Index: tests/zombies/ArrayN.c
===================================================================
--- tests/zombies/ArrayN.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/ArrayN.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -6,5 +6,5 @@
 // }
 
-forall(otype index_t)
+forall(index_t)
 index_t offset_to_index(unsigned offset, index_t size) {
     return [offset / size.0, offset % size.1];
Index: tests/zombies/Members.c
===================================================================
--- tests/zombies/Members.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/Members.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -2,6 +2,6 @@
 int ?=?( int*, int );
 float ?=?( float*, float );
-forall( dtype DT ) DT * ?=?( DT**, DT* );
-forall(otype T) lvalue T *?( T* );
+forall( DT & ) DT * ?=?( DT**, DT* );
+forall(T) lvalue T *?( T* );
 char *__builtin_memcpy();
 
Index: tests/zombies/Rank2.c
===================================================================
--- tests/zombies/Rank2.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/Rank2.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,8 +1,8 @@
 int ?=?( int &, int );
-forall(dtype DT) DT * ?=?( DT *&, DT * );
+forall(DT &) DT * ?=?( DT *&, DT * );
 
 void a() {
-	forall( otype T ) void f( T );
-	void g( forall( otype U ) void p( U ) );
+	forall( T ) void f( T );
+	void g( forall( U ) void p( U ) );
 	g( f );
 }
@@ -10,5 +10,5 @@
 void g() {
 	void h( int *null );
-	forall( otype T ) T id( T );
+	forall( T ) T id( T );
 //	forall( dtype T ) T *0;
 //	int 0;
Index: tests/zombies/abstype.c
===================================================================
--- tests/zombies/abstype.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/abstype.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -21,8 +21,8 @@
 }
 
-forall( otype T ) T *?( T * );
+forall( T ) T *?( T * );
 int ?++( int * );
 int ?=?( int *, int );
-forall( dtype DT ) DT * ?=?( DT **, DT * );
+forall( DT & ) DT * ?=?( DT **, DT * );
 
 otype U = int *;
Index: tests/zombies/context.cfa
===================================================================
--- tests/zombies/context.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/context.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,10 +1,10 @@
 // trait declaration
 
-trait has_q( otype T ) {
+trait has_q( T ) {
 	T q( T );
 };
 
-forall( otype z | has_q( z ) ) void f() {
-	trait has_r( otype T, otype U ) {
+forall( z | has_q( z ) ) void f() {
+	trait has_r( T, U ) {
 		T r( T, T (T,U) );
 	};
Index: tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/blockers/explicit_cast.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -9,5 +9,5 @@
 };
 
-forall(otype T)
+forall(T)
 struct gcpointer
 {
@@ -15,5 +15,5 @@
 };
 
-forall(otype T)
+forall(T)
 static inline gcpointer(T) gcmalloc()
 {
Index: tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/blockers/recursive_realloc.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -3,10 +3,10 @@
 #include <stdlib.hfa>
 
-trait allocator_c(otype T, otype allocator_t)
+trait allocator_c(T, allocator_t)
 {
 	void realloc(allocator_t* const, size_t);
 };
 
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
@@ -15,5 +15,5 @@
 };
 
-forall(otype T)
+forall(T)
 inline void realloc(heap_allocator(T) *const this, size_t size)
 {
Index: tests/zombies/gc_no_raii/bug-repro/deref.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/deref.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/deref.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,3 +1,3 @@
-    forall(otype T)
+    forall(T)
     struct wrap
     {
@@ -5,5 +5,5 @@
     };
 
-    forall(otype T)
+    forall(T)
     T *? (wrap(T) rhs)
     {
Index: tests/zombies/gc_no_raii/bug-repro/field.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/field.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/field.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -8,5 +8,5 @@
 //------------------------------------------------------------------------------
 //Declaration
-trait allocator_c(otype T, otype allocator_t)
+trait allocator_c(T, allocator_t)
 {
 	void ctor(allocator_t* const);
@@ -16,5 +16,5 @@
 };
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 struct vector
 {
Index: tests/zombies/gc_no_raii/bug-repro/malloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/malloc.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/malloc.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrapper
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 void ctor(wrapper(T)* this)
 {
@@ -11,5 +11,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T) gcmalloc()
 {
@@ -19,5 +19,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T)* ?=? (wrapper(T)* lhs, wrapper(T)* rhs)
 {
Index: tests/zombies/gc_no_raii/bug-repro/oddtype.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/oddtype.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/oddtype.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,10 +1,10 @@
-forall(dtype T)
+forall(T &)
 struct wrap {
 	int i;
 };
 
-forall(otype T) void ?{}(wrap(T)* this) {}
-forall(otype T) void ?=?(wrap(T)* this) {}
-forall(otype T) void ^?{}(wrap(T)* this) {}
+forall(T) void ?{}(wrap(T)* this) {}
+forall(T) void ?=?(wrap(T)* this) {}
+forall(T) void ^?{}(wrap(T)* this) {}
 
 struct List_t {
Index: tests/zombies/gc_no_raii/bug-repro/push_back.h
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/push_back.h	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/push_back.h	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,5 +1,5 @@
 //------------------------------------------------------------------------------
 //Declaration
-trait allocator_c(otype T, otype allocator_t) {
+trait allocator_c(T, allocator_t) {
 	void ctor(allocator_t* const);
 	void dtor(allocator_t* const);
@@ -8,5 +8,5 @@
 };
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 struct vector
 {
@@ -17,13 +17,13 @@
 //------------------------------------------------------------------------------
 //Initialization
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void vector_ctor(vector(T, allocator_t) *const this);
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void dtor(vector(T, allocator_t) *const this);
 
 //------------------------------------------------------------------------------
 //Allocator
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
@@ -32,14 +32,14 @@
 };
 
-forall(otype T)
+forall(T)
 void ctor(heap_allocator(T) *const this);
 
-forall(otype T)
+forall(T)
 void dtor(heap_allocator(T) *const this);
 
-forall(otype T)
+forall(T)
 void realloc(heap_allocator(T) *const this, size_t size);
 
-forall(otype T)
+forall(T)
 inline T* data(heap_allocator(T) *const this)
 {
@@ -49,5 +49,5 @@
 //------------------------------------------------------------------------------
 //Capacity
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline bool empty(vector(T, allocator_t) *const this)
 {
@@ -55,5 +55,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline bool size(vector(T, allocator_t) *const this)
 {
@@ -61,5 +61,5 @@
 }
 
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 inline void reserve(vector(T, allocator_t) *const this, size_t size)
 {
@@ -69,4 +69,4 @@
 //------------------------------------------------------------------------------
 //Modifiers
-forall(otype T, otype allocator_t | allocator_c(T, allocator_t))
+forall(T, allocator_t | allocator_c(T, allocator_t))
 void push_back(vector(T, allocator_t) *const this, T value);
Index: tests/zombies/gc_no_raii/bug-repro/realloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/realloc.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/realloc.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,5 +1,5 @@
 void* realloc(void*, unsigned long int);
 
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -7,5 +7,5 @@
 };
 
-forall(otype T)
+forall(T)
 static inline void realloc(wrap(T) *const this, unsigned long int size)
 {
Index: tests/zombies/gc_no_raii/bug-repro/return.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/return.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/return.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrapper
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 wrapper(T) create()
 {
@@ -12,5 +12,5 @@
 }
 
-forall(otype T)
+forall(T)
 wrapper(T)* ?=?(wrapper(T)* lhs, wrapper(T)* rhs)
 {
Index: tests/zombies/gc_no_raii/bug-repro/return_template.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/return_template.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/return_template.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -5,10 +5,10 @@
 };
 
-forall(otype T) void ?{}(wrap(T)* this);
-forall(otype T) void ?{}(wrap(T)* this, wrap(T)* rhs);
-forall(otype T) void ^?{}(wrap(T)* this);
-forall(otype T) void ?=?(wrap(T)* this, wrap(T)* rhs);
+forall(T) void ?{}(wrap(T)* this);
+forall(T) void ?{}(wrap(T)* this, wrap(T)* rhs);
+forall(T) void ^?{}(wrap(T)* this);
+forall(T) void ?=?(wrap(T)* this, wrap(T)* rhs);
 
-forall(otype T)
+forall(T)
 wrap(T) test()
 {
Index: tests/zombies/gc_no_raii/bug-repro/slow_malloc.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/slow_malloc.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/slow_malloc.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,5 +1,5 @@
 #include <stdlib.hfa>
 
-forall(otype T)
+forall(T)
 struct heap_allocator
 {
Index: tests/zombies/gc_no_raii/bug-repro/zero.c
===================================================================
--- tests/zombies/gc_no_raii/bug-repro/zero.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/bug-repro/zero.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,3 +1,3 @@
-forall(otype T)
+forall(T)
 struct wrap
 {
@@ -5,5 +5,5 @@
 };
 
-forall(otype T)
+forall(T)
 int ?==? (wrap(T) lhs, wrap(T) rhs)
 {
@@ -14,5 +14,5 @@
 struct wrap(int) 0;
 /*/
-forall(otype T)
+forall(T)
 struct wrap(T) 0;
 //*/
Index: tests/zombies/gc_no_raii/src/gc.h
===================================================================
--- tests/zombies/gc_no_raii/src/gc.h	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/src/gc.h	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -13,5 +13,5 @@
 // }
 
-forall(otype T)
+forall(T)
 static inline void gcmalloc(gcpointer(T)* ptr)
 {
Index: tests/zombies/gc_no_raii/src/gcpointers.c
===================================================================
--- tests/zombies/gc_no_raii/src/gcpointers.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/src/gcpointers.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -113,21 +113,21 @@
 #endif
 
-forall(otype T) void ?{}(gcpointer(T)* this) {
+forall(T) void ?{}(gcpointer(T)* this) {
 	(&this->internal) {};
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, void* address) {
+forall(T) void ?{}(gcpointer(T)* this, void* address) {
 	(&this->internal) { address };
 }
 
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
+forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other) {
 	(&this->internal) { other.internal };
 }
 
-forall(otype T) void ^?{}(gcpointer(T)* this) {
+forall(T) void ^?{}(gcpointer(T)* this) {
 	^?{}(&this->internal);
 }
 
-forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
+forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs) {
 	this->internal = rhs.internal;
 	return *this;
@@ -136,10 +136,10 @@
 // forall(otype T) T *?(gcpointer(T) this);
 
-forall(otype T) T* get(gcpointer(T)* this) {
+forall(T) T* get(gcpointer(T)* this) {
 	return (T*)this->internal.ptr;
 }
 //
 // //Logical operators
-forall(otype T) int ?!=?(gcpointer(T) this, int zero) {
+forall(T) int ?!=?(gcpointer(T) this, int zero) {
 	return this.internal.ptr != 0;
 }
Index: tests/zombies/gc_no_raii/src/gcpointers.h
===================================================================
--- tests/zombies/gc_no_raii/src/gcpointers.h	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/src/gcpointers.h	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -4,5 +4,5 @@
 #include <stdint.h>
 
-forall(dtype T)
+forall(T &)
 struct gcpointer;
 
@@ -29,5 +29,5 @@
 #endif
 
-forall(dtype T)
+forall(T &)
 struct gcpointer
 {
@@ -36,16 +36,16 @@
 
 //
-forall(otype T) void ?{}(gcpointer(T)* this);
-forall(otype T) void ?{}(gcpointer(T)* this, void* address);
-forall(otype T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
-forall(otype T) void ^?{}(gcpointer(T)* this);
-forall(otype T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
+forall(T) void ?{}(gcpointer(T)* this);
+forall(T) void ?{}(gcpointer(T)* this, void* address);
+forall(T) void ?{}(gcpointer(T)* this, gcpointer(T) other);
+forall(T) void ^?{}(gcpointer(T)* this);
+forall(T) gcpointer(T) ?=?(gcpointer(T)* this, gcpointer(T) rhs);
 
 
 // forall(otype T) T *?(gcpointer(T) this);
-forall(otype T) T* get(gcpointer(T)* this);
+forall(T) T* get(gcpointer(T)* this);
 
 //Logical operators
-forall(otype T) int ?!=?(gcpointer(T) this, int zero);
-forall(otype T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
-forall(otype T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
+forall(T) int ?!=?(gcpointer(T) this, int zero);
+forall(T) int ?!=?(gcpointer(T) this, gcpointer(T) rhs);
+forall(T) int ?==?(gcpointer(T) this, gcpointer(T) rhs);
Index: tests/zombies/gc_no_raii/src/tools.h
===================================================================
--- tests/zombies/gc_no_raii/src/tools.h	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/gc_no_raii/src/tools.h	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -12,10 +12,10 @@
 // }
 
-trait has_equal(otype T)
+trait has_equal(T)
 {
 	signed int ?==?(T a, T b);
 };
 
-trait InputIterator_t(otype T, otype InputIterator)
+trait InputIterator_t(T, InputIterator)
 {
 	signed int ?==?(InputIterator a, InputIterator b);
@@ -26,5 +26,5 @@
 };
 
-forall(otype T | has_equal(T), otype InputIterator | InputIterator_t(T, InputIterator))
+forall(T | has_equal(T), InputIterator | InputIterator_t(T, InputIterator))
 static inline InputIterator find( InputIterator first, const InputIterator* const last, T val)
 {
Index: tests/zombies/hashtable.cfa
===================================================================
--- tests/zombies/hashtable.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/hashtable.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -14,14 +14,14 @@
 
 
-trait has_hash( otype K ) {
+trait has_hash( K ) {
     size_t hash(K);
     int ?==?( K, K );
 };
 
-trait hkey( otype K, dtype tN | has_hash(K) ) {
+trait hkey( K, tN & | has_hash(K) ) {
     K key(tN &);
 };
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) {
 
     struct hashtable {
@@ -39,5 +39,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
 
     void ?{}( hashtable(K, tN, tE) & this, size_t n_buckets, dlist(tN, tE) *buckets ) {
@@ -57,5 +57,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) ) {
 
     float fill_frac( hashtable(K, tN, tE) & this ) with(this) {
@@ -124,5 +124,5 @@
 
 
-trait heaped(dtype T) {
+trait heaped(T &) {
     T * alloc( size_t );
     void free( void * ); 
@@ -133,5 +133,5 @@
 }
 
-forall( otype K, dtype tN, dtype tE | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) {
+forall( K, tN &, tE & | $dlistable(tN, tE) | hkey(K, tN) | heaped( dlist(tN, tE) ) ) {
 
     struct hashtable_dynamic { 
Index: tests/zombies/hashtable2.cfa
===================================================================
--- tests/zombies/hashtable2.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/hashtable2.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -69,9 +69,9 @@
 
 
-trait pretendsToMatter( dtype TTT ) {
+trait pretendsToMatter( TTT & ) {
     void actsmart(TTT &);
 };
 
-forall( dtype TTTx )
+forall( TTTx & )
 void actsmart(TTTx &) {}
 
@@ -86,5 +86,5 @@
 //   2. shows up in -CFA output as hashtable_rbs(), which is bad C; expecting hashtable_rbs*
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) ) {
 
     // hashtable of request by source
@@ -104,5 +104,5 @@
 }
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) | { void defaultResumptionHandler(ht_fill_limit_crossed &); } ) {
 
     void ?{}( hashtable_rbs(Tt_unused) & this, size_t n_buckets, dlist(request_in_ht_by_src, request) *buckets,
@@ -135,5 +135,5 @@
 void defaultResumptionHandler( ht_auto_resize_pending & ex );
 
-forall( otype Tt_unused | pretendsToMatter(Tt_unused) ) {
+forall( Tt_unused | pretendsToMatter(Tt_unused) ) {
 
     float fill_frac( hashtable_rbs(Tt_unused) & this ) with(this) {
@@ -221,5 +221,5 @@
 
 
-trait heaped(dtype T) {
+trait heaped(T &) {
     T * alloc( size_t );
     void free( void * ); 
@@ -228,5 +228,5 @@
 void __dynamic_defaultResumptionHandler(ht_fill_limit_crossed &);
 
-forall( otype Tt_unused ) {
+forall( Tt_unused ) {
 
     struct hashtable_rbs_dynamic { 
@@ -263,5 +263,5 @@
 
 
-forall( otype Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) {
+forall( Tt_unused | heaped( dlist(request_in_ht_by_src, request) ) ) {
 
     void ?{}( hashtable_rbs_dynamic(Tt_unused).resize_policy & this, size_t nbuckets_floor ) {
@@ -325,5 +325,5 @@
 }
 
-forall( otype Tt_unused ) {
+forall( Tt_unused ) {
     void rehashToLarger_STEP( hashtable_rbs_dynamic(Tt_unused) & this, size_t new_n_buckets ) with (this) {
         rehashToLarger( this, new_n_buckets );
Index: tests/zombies/huge.c
===================================================================
--- tests/zombies/huge.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/huge.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -14,5 +14,5 @@
 //
 
-int huge( int n, forall( otype T ) T (*f)( T ) ) {
+int huge( int n, forall( T ) T (*f)( T ) ) {
 	if ( n <= 0 )
 		return f( 0 );
Index: tests/zombies/it_out.c
===================================================================
--- tests/zombies/it_out.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/it_out.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -16,18 +16,18 @@
 typedef unsigned long streamsize_type;
 
-trait ostream( dtype os_type ) {
+trait ostream( os_type & ) {
 	os_type *write( os_type *, const char *, streamsize_type );
 	int fail( os_type * );
 };
 
-trait writeable( otype T ) {
-	forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, T );
+trait writeable( T ) {
+	forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, T );
 };
 
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, char );
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, int );
-forall( dtype os_type | ostream( os_type ) ) os_type * ?<<?( os_type *, const char * );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, char );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, int );
+forall( os_type & | ostream( os_type ) ) os_type * ?<<?( os_type *, const char * );
 
-trait istream( dtype is_type ) {
+trait istream( is_type & ) {
 	is_type *read( is_type *, char *, streamsize_type );
 	is_type *unread( is_type *, char );
@@ -36,12 +36,12 @@
 };
 
-trait readable( otype T ) {
-	forall( dtype is_type | istream( is_type ) ) is_type * ?<<?( is_type *, T );
+trait readable( T ) {
+	forall( is_type & | istream( is_type ) ) is_type * ?<<?( is_type *, T );
 };
 
-forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, char* );
-forall( dtype is_type | istream( is_type ) ) is_type * ?>>?( is_type *, int* );
+forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, char* );
+forall( is_type & | istream( is_type ) ) is_type * ?>>?( is_type *, int* );
 
-trait iterator( otype iterator_type, otype elt_type ) {
+trait iterator( iterator_type, elt_type ) {
 	iterator_type ?++( iterator_type* );
 	iterator_type ++?( iterator_type* );
@@ -52,12 +52,12 @@
 };
 
-forall( otype elt_type | writeable( elt_type ),
-		otype iterator_type | iterator( iterator_type, elt_type ),
-		dtype os_type | ostream( os_type ) )
+forall( elt_type | writeable( elt_type ),
+		iterator_type | iterator( iterator_type, elt_type ),
+		os_type & | ostream( os_type ) )
 void write_all( iterator_type begin, iterator_type end, os_type *os );
 
-forall( otype elt_type | writeable( elt_type ),
-		otype iterator_type | iterator( iterator_type, elt_type ),
-		dtype os_type | ostream( os_type ) )
+forall( elt_type | writeable( elt_type ),
+		iterator_type | iterator( iterator_type, elt_type ),
+		os_type & | ostream( os_type ) )
 void write_all( elt_type begin, iterator_type end, os_type *os ) {
 	os << begin;
Index: tests/zombies/new.c
===================================================================
--- tests/zombies/new.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/new.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T )
+forall( T )
 void f( T *t ) {
 	t--;
Index: tests/zombies/occursError.cfa
===================================================================
--- tests/zombies/occursError.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/occursError.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,5 +1,5 @@
-forall( otype T ) void f( void (*)( T, T * ) );
-forall( otype U ) void g( U,  U * );
-forall( otype U ) void h( U *, U );
+forall( T ) void f( void (*)( T, T * ) );
+forall( U ) void g( U,  U * );
+forall( U ) void h( U *, U );
 
 void test() {
Index: tests/zombies/prolog.c
===================================================================
--- tests/zombies/prolog.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/prolog.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -25,13 +25,13 @@
 void is_integer( int x ) {}
 
-trait ArithmeticType( otype T ) {
+trait ArithmeticType( T ) {
 	void is_arithmetic( T );
 };
 
-trait IntegralType( otype T | ArithmeticType( T ) ) {
+trait IntegralType( T | ArithmeticType( T ) ) {
 	void is_integer( T );
 };
 
-forall( otype T | IntegralType( T ) | { void printResult( T ); } )
+forall( T | IntegralType( T ) | { void printResult( T ); } )
 void hornclause( T param ) {
 	printResult( param );
Index: tests/zombies/quad.c
===================================================================
--- tests/zombies/quad.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/quad.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -16,10 +16,10 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?*?( T, T ); } )
+forall( T | { T ?*?( T, T ); } )
 T square( T t ) {
 	return t * t;
 }
 
-forall( otype U | { U square( U ); } )
+forall( U | { U square( U ); } )
 U quad( U u ) {
 	return square( square( u ) );
Index: tests/zombies/scope.cfa
===================================================================
--- tests/zombies/scope.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/scope.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -20,9 +20,9 @@
 y p;
 
-trait has_u( otype z ) {
+trait has_u( z ) {
 	z u(z);
 };
 
-forall( otype t | has_u( t ) )
+forall( t | has_u( t ) )
 y q( t the_t ) {
 	t y = u( the_t );
Index: tests/zombies/simplePoly.c
===================================================================
--- tests/zombies/simplePoly.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/simplePoly.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T, otype U | { T f( T, U ); } )
+forall( T, U | { T f( T, U ); } )
 T q( T t, U u ) {
 	return f( t, u );
Index: tests/zombies/simpler.c
===================================================================
--- tests/zombies/simpler.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/simpler.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -14,5 +14,5 @@
 //
 
-forall( otype T ) T id( T, T );
+forall( T ) T id( T, T );
 
 int main() {
Index: tests/zombies/specialize.c
===================================================================
--- tests/zombies/specialize.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/specialize.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -39,5 +39,5 @@
 }
 
-forall( otype T ) T f( T t )
+forall( T ) T f( T t )
 {
 	printf( "in f; sizeof T is %d\n", sizeof( T ) );
Index: tests/zombies/square.c
===================================================================
--- tests/zombies/square.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/square.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -16,5 +16,5 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?*?( T, T ); } )
+forall( T | { T ?*?( T, T ); } )
 T square( T t ) {
 	return t * t;
Index: tests/zombies/structMember.cfa
===================================================================
--- tests/zombies/structMember.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/structMember.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -66,5 +66,5 @@
 	S.T;
 	.S.T;
-	forall( otype S, otype T ) struct W {
+	forall( S, T ) struct W {
 		struct X {};
 	};
Index: tests/zombies/subrange.cfa
===================================================================
--- tests/zombies/subrange.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/subrange.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,5 +1,5 @@
 // A small context defining the notion of an ordered otype.  (The standard
 // library should probably contain a context for this purpose.)
-trait ordered(otype T) {
+trait ordered(T) {
     int ?<?(T, T), ?<=?(T, T);
 };
@@ -7,5 +7,5 @@
 // A subrange otype resembling an Ada subotype with a base otype and a range
 // constraint.
-otype subrange(otype base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
+otype subrange(base_t | ordered(base_t), base_t low = 0, base_t high = 8) = base_t;
 
 // Note that subrange() can be applied to floating-point and pointer otypes, not
@@ -28,10 +28,10 @@
 
 // Convenient access to subrange bounds, for instance for iteration:
-forall (otype T, T low, T high)
+forall (T, T low, T high)
 T lbound( subrange(T, low, high) v) {
     return low;
 }
 
-forall (otype T, T low, T high)
+forall (T, T low, T high)
 T hbound( subrange(T, low, high) v) {
     return high;
@@ -44,5 +44,5 @@
 // of exception handling here.  Inlining allows the compiler to eliminate
 // bounds checks.
-forall (otype T | ordered(T), T low, T high)
+forall (T | ordered(T), T low, T high)
 inline subrange(T, low, high) ?=?(subrange(T, low, high)* target, T source) {
     if (low <= source && source <= high) *((T*)target) = source;
@@ -54,5 +54,5 @@
 // compares range bounds so that the compiler can optimize checks away when the
 // ranges are known to overlap.
-forall (otype T | ordered(T), T t_low, T t_high, T s_low, T s_high)
+forall (T | ordered(T), T t_low, T t_high, T s_low, T s_high)
 inline subrange(T, t_low, t_high) ?=?(subrange(T, t_low, t_high)* target,
 				      subrange(T, s_low, s_high) source) {
Index: tests/zombies/twice.c
===================================================================
--- tests/zombies/twice.c	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/twice.c	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -16,5 +16,5 @@
 #include <fstream.hfa>
 
-forall( otype T | { T ?+?( T, T ); } )
+forall( T | { T ?+?( T, T ); } )
 T twice( const T t ) {
 	return t + t;
Index: tests/zombies/typeGenerator.cfa
===================================================================
--- tests/zombies/typeGenerator.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/typeGenerator.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -1,8 +1,8 @@
-context addable( otype T ) {
+context addable( T ) {
 	T ?+?( T,T );
 	T ?=?( T*, T);
 };
 
-otype List1( otype T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
+otype List1( T | addable( T ) ) = struct { T data; List1( T ) *next; } *;
 typedef List1( int ) ListOfIntegers;
 //List1( int ) li;
@@ -11,11 +11,11 @@
 [int] h( * List1( int ) p );							// new declaration syntax
 
-struct( otype T ) S2 { T i; };							// actual definition
+struct( T ) S2 { T i; };							// actual definition
 struct( int ) S3 v1, *p;								// expansion and instantiation
-struct( otype T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
-struct( otype T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
+struct( T )( int ) S24 { T i; } v2;				// actual definition, expansion and instantiation
+struct( T )( int ) { T i; } v2;					// anonymous actual definition, expansion and instantiation
 
-struct( otype T | addable( T ) ) node { T data; struct( T ) node *next; };
-otype List( otype T ) = struct( T ) node *;
+struct( T | addable( T ) ) node { T data; struct( T ) node *next; };
+otype List( T ) = struct( T ) node *;
 List( int ) my_list;
 
Index: tests/zombies/withStatement.cfa
===================================================================
--- tests/zombies/withStatement.cfa	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/withStatement.cfa	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -54,10 +54,10 @@
 }
 
-forall( otype T )
+forall( T )
 struct Box {
 	T x;
 };
 
-forall( otype T )
+forall( T )
 void ?{}( Box(T) & this ) with( this ) { // with clause in polymorphic function
 	x{};
@@ -66,5 +66,5 @@
 void print( int i ) { sout | i; }
 
-forall( otype T | { void print( T ); })
+forall( T | { void print( T ); })
 void foo( T t ) {
 	Box( T ) b = { t };
Index: tests/zombies/wrapper/src/pointer.h
===================================================================
--- tests/zombies/wrapper/src/pointer.h	(revision f0d67e5abea7221dccd4183dd58ccc6cdbee32fc)
+++ tests/zombies/wrapper/src/pointer.h	(revision 3d67f83c7f1cf71e4c8b9fe50394c8cd4480d87a)
@@ -8,5 +8,5 @@
 // type safe malloc / free
 
-forall(otype T)
+forall(T)
 T* new()
 {
@@ -16,5 +16,5 @@
 }
 
-forall(otype T)
+forall(T)
 void delete(T* p)
 {