Index: src/tests/avltree/avl.h
===================================================================
--- src/tests/avltree/avl.h	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/avltree/avl.h	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -61,5 +61,5 @@
 void ?{}(tree(K, V) *t, K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t);
 
Index: src/tests/avltree/avl1.c
===================================================================
--- src/tests/avltree/avl1.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/avltree/avl1.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -12,5 +12,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t){
   delete(t->left);
Index: src/tests/avltree/avl_test.c
===================================================================
--- src/tests/avltree/avl_test.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/avltree/avl_test.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -25,5 +25,5 @@
 
   // int -> char *
-  tree(int, char *) * smap = create(-1, "baz");
+  tree(int, const char *) * smap = create(-1, "baz");
   insert(&smap, 12, "bar");
   insert(&smap, 2, "foo");
@@ -35,17 +35,17 @@
   delete(smap);
 
-  // char* -> char*
-  struct c_str { char *str; };  // wraps a C string
-  int ?<?(c_str a, c_str b) {
-    return strcmp(a.str,b.str) < 0;
+  // const char* -> const char*
+  int ?<?(const char * a, const char * b) {
+    return strcmp(a, b) < 0;
   }
-  tree(c_str, char *) * ssmap = create((c_str){"queso"}, "cheese");
-  insert(&ssmap, (c_str){"foo"}, "bar");
-  insert(&ssmap, (c_str){"hello"}, "world");
+
+  tree(const char *, const char *) * ssmap = create("queso", "cheese");
+  insert(&ssmap, "foo", "bar");
+  insert(&ssmap, "hello", "world");
   assert( height(ssmap) == 2 );
 
-  printf("%s %s %s\n", *find(ssmap, (c_str){"hello"}), *find(ssmap, (c_str){"foo"}), *find(ssmap, (c_str){"queso"}));
+  printf("%s %s %s\n", *find(ssmap, "hello"), *find(ssmap, "foo"), *find(ssmap, "queso"));
 
-  remove(&ssmap, (c_str){"foo"});
+  remove(&ssmap, "foo");
   delete(ssmap);
 }
Index: src/tests/completeTypeError.c
===================================================================
--- src/tests/completeTypeError.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/completeTypeError.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -62,5 +62,5 @@
 
 forall(dtype T | sized(T))
-void qux(T * z) {
+void quux(T * z) {
 	// okay
 	bar(z);
Index: src/tests/coroutine.c
===================================================================
--- src/tests/coroutine.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/coroutine.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -2,7 +2,6 @@
 #include <coroutine>
 
-struct Fibonacci {
+coroutine Fibonacci {
       int fn; // used for communication
-      coroutine_desc c;
 };
 
@@ -11,13 +10,5 @@
 }
 
-coroutine_desc* get_coroutine(Fibonacci* this) {
-      return &this->c;
-}
-
 void main(Fibonacci* this) {
-#ifdef MORE_DEBUG
-      sout | "Starting main of coroutine " | this | endl;
-      sout | "Started from " | this->c.last | endl;
-#endif
       int fn1, fn2; 		// retained between resumes
       this->fn = 0;
@@ -45,17 +36,4 @@
 int main() {
       Fibonacci f1, f2;
-#ifdef MORE_DEBUG      
-      Fibonacci *pf1 = &f1, *pf2 = &f2;
-      coroutine_desc *cf1 = &f1.c, *cf2 = &f2.c;
-      covptr_t  *vf1 = vtable(pf1), *vf2 = vtable(pf2);
-      coroutine_desc *cv1 = get_coroutine(vf1), *cv2 = get_coroutine(vf2);
-      Fibonacci *ov1 = (Fibonacci *)get_object(vf1), *ov2 = (Fibonacci *)get_object(vf2);
-
-      sout | "User coroutines : " | pf1 | ' ' | pf2 | endl;
-      sout | "Coroutine data  : " | cf1 | ' ' | cf2 | endl;
-      sout | "Vptr address    : " | vf1 | ' ' | vf2 | endl;
-      sout | "Vptr obj data   : " | ov1 | ' ' | ov2 | endl;
-      sout | "Vptr cor data   : " | cv1 | ' ' | cv2 | endl;
-#endif
       for ( int i = 1; i <= 10; i += 1 ) {
             sout | next(&f1) | ' ' | next(&f2) | endl;
Index: src/tests/dtor-early-exit.c
===================================================================
--- src/tests/dtor-early-exit.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/dtor-early-exit.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -28,6 +28,6 @@
 // don't want these called
 void ?{}(A * a) { assert( false ); }
-void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
-void ?{}(A * a, char * name, int * ptr) { assert( false ); }
+void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
+void ?{}(A * a, const char * name, int * ptr) { assert( false ); }
 
 A ?=?(A * a, A a) {  sout | "assign " | a->name | " " | a.name; return a; }
Index: src/tests/monitor.c
===================================================================
--- src/tests/monitor.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/monitor.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -13,26 +13,31 @@
 }
 
+monitor_desc * get_monitor( global_t * this ) {
+	return &this->m;
+}
+
 static global_t global;
 
-void increment( /*mutex*/ global_t * this ) {
-	monitor_desc * mon = &this->m;
-	monitor_guard_t g1 = { &mon };
-	{
-		monitor_guard_t g2 = { &mon };
-		{
-			monitor_guard_t g3 = { &mon };
-			this->value += 1;
-		}
-	}
+void increment3( global_t * mutex this ) {
+	this->value += 1;
 }
 
-struct MyThread { thread_desc t; };
+void increment2( global_t * mutex this ) {
+	increment3( this );
+}
+
+void increment( global_t * mutex this ) {
+	increment2( this );
+}
+
+struct MyThread { thread_desc __thrd; };
 
 DECL_THREAD(MyThread);
 
 void ?{}( MyThread * this ) {}
+void ^?{}( MyThread * mutex this ) {}
 
 void main( MyThread* this ) {
-	for(int i = 0; i < 1000000; i++) {
+	for(int i = 0; i < 1_000_000; i++) {
 		increment( &global );
 	}
Index: src/tests/multi-monitor.c
===================================================================
--- src/tests/multi-monitor.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/multi-monitor.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -6,14 +6,20 @@
 static int global12, global23, global13;
 
-static monitor_desc m1, m2, m3;
+struct monitor_t {
+	monitor_desc m;
+};
 
-void increment( /*mutex*/ monitor_desc * p1, /*mutex*/ monitor_desc * p2, int * value ) {
-	monitor_desc * mons[] = { p1, p2 };
-	monitor_guard_t g = { mons, 2 };
+monitor_desc * get_monitor( monitor_t * this ) {
+	return &this->m;
+}
+
+static monitor_t m1, m2, m3;
+
+void increment( monitor_t * mutex p1, monitor_t * mutex p2, int * value ) {
 	*value += 1;
 }
 
 struct MyThread { 
-	thread_desc t; 
+	thread_desc __thrd; 
 	int target;
 };
@@ -24,4 +30,6 @@
 	this->target = target;
 }
+
+void ^?{}( MyThread * mutex this ) {}
 
 void main( MyThread* this ) {
Index: src/tests/thread.c
===================================================================
--- src/tests/thread.c	(revision 829c907247aaf3211ea7e8c3d290193a6f2d15d5)
+++ src/tests/thread.c	(revision 87d13cd6f0b6eede5621fb0f5bd5b06911c656fe)
@@ -4,6 +4,6 @@
 #include <thread>
 
-struct First { thread_desc t; signal_once* lock; };
-struct Second { thread_desc t; signal_once* lock; };
+struct First { thread_desc __thrd; signal_once* lock; };
+struct Second { thread_desc __thrd; signal_once* lock; };
 
 DECL_THREAD(First);
@@ -12,4 +12,7 @@
 void ?{}( First * this, signal_once* lock ) { this->lock = lock; }
 void ?{}( Second * this, signal_once* lock ) { this->lock = lock; }
+
+void ^?{}( First  * mutex this ) {}
+void ^?{}( Second * mutex this ) {}
 
 void main(First* this) {