Index: tests/concurrency/waituntil/all_types.cfa
===================================================================
--- tests/concurrency/waituntil/all_types.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/all_types.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -33,6 +33,6 @@
 
 thread Server1 {};
-void main( Server1 & this ) {
-    long long int a, b, c, i = 0, myTotal = 0;
+void main( Server1 & ) {
+    long long int a, c, i = 0, myTotal = 0;
     for( ;;i++ ) {
         when( i % 2 == 0 ) waituntil( a << A ) { myTotal += a; }
@@ -46,6 +46,6 @@
 
 thread Drainer {}; // ensures that the changing when states of Server1 don't result in a deadlock
-void main( Drainer & this ) {
-    long long int a, b, c, myTotal = 0;
+void main( Drainer & ) {
+    long long int a, c, myTotal = 0;
     for( ;; ) {
         waituntil( F ) { myTotal += get(F); reset( F ); }
@@ -59,5 +59,5 @@
 
 thread Churner {}; // performs non-waituntil try insert/remove operations to add churn/interference
-void main( Churner & this ) {
+void main( Churner & ) {
     long long int out, myTotal = 0;
     bool success;
Index: tests/concurrency/waituntil/channel_close.cfa
===================================================================
--- tests/concurrency/waituntil/channel_close.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/channel_close.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -9,5 +9,5 @@
 
 thread Producer {};
-void main( Producer & this ) {
+void main( Producer & ) {
     try {
         for( size_t i; 0~@ ) {
@@ -15,10 +15,10 @@
             and waituntil( B << i ) { inserts++; }
         }
-    } catch ( channel_closed * e ) {} 
+    } catch ( channel_closed * e ) {}
 }
 
 bool useAnd = false;
 thread Consumer {}; // ensures that the changing when states of Server1 don't result in a deadlock
-void main( Consumer & this ) {
+void main( Consumer & ) {
     ssize_t in, in2, A_removes = 0, B_removes = 0;
 
@@ -34,5 +34,5 @@
         }
     } catchResume ( channel_closed * e ) {				// continue to remove until would block
-	} catch ( channel_closed * e ) {} 
+	} catch ( channel_closed * e ) {}
 
     try {
@@ -40,5 +40,5 @@
             waituntil( (in << A) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( A_removes == in ); A_removes++; removes++; }
     } catchResume ( channel_closed * e ) {				// continue to remove until would block
-	} catch ( channel_closed * e ) {} 
+	} catch ( channel_closed * e ) {}
 
     try {
@@ -46,5 +46,5 @@
             waituntil( (in << B) ) { __atomic_thread_fence( __ATOMIC_SEQ_CST ); assert( B_removes == in ); B_removes++; removes++; }
     } catchResume ( channel_closed * e ) {				// continue to remove until would block
-	} catch ( channel_closed * e ) {} 
+	} catch ( channel_closed * e ) {}
 }
 
Index: tests/concurrency/waituntil/channels.cfa
===================================================================
--- tests/concurrency/waituntil/channels.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/channels.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -9,5 +9,5 @@
 
 thread Server1 {};
-void main( Server1 & this ) {
+void main( Server1 & ) {
     long long int a, b, c, i = 0, myTotal = 0;
     for( ;;i++ ) {
@@ -21,5 +21,5 @@
 
 thread Drainer {}; // ensures that the changing when states of Server1 don't result in a deadlock
-void main( Drainer & this ) {
+void main( Drainer & ) {
     long long int a, b, c, myTotal = 0;
     for( ;; ) {
@@ -33,5 +33,5 @@
 
 thread Churner {}; // performs non-waituntil try insert/remove operations to add churn/interference
-void main( Churner & this ) {
+void main( Churner & ) {
     long long int out, myTotal = 0;
     bool success;
Index: tests/concurrency/waituntil/futures.cfa
===================================================================
--- tests/concurrency/waituntil/futures.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/futures.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -8,5 +8,5 @@
 
 thread Server1 {};
-void main( Server1 & this ) {
+void main( Server1 & ) {
     fulfil(B, 3);
     P( s );
@@ -16,5 +16,5 @@
 
 thread Server2 {};
-void main( Server2 & this ) {
+void main( Server2 & ) {
     fulfil(B, 6);
     fulfil(A, 5);
Index: tests/concurrency/waituntil/locks.cfa
===================================================================
--- tests/concurrency/waituntil/locks.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/locks.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -12,5 +12,5 @@
 
 thread Server1 {};
-void main( Server1 & this ) {
+void main( Server1 & ) {
     while( !done ) {
         lock(A);
@@ -44,5 +44,5 @@
                 )
                 and when( i < 4 ) waituntil( C ) { c++; }
-                
+
                 when( i % 2 == 0 ) waituntil( A ) { a++; }
                 and when( i % 4 < 2 ) waituntil( B ) { b++; }
Index: tests/concurrency/waituntil/repeat_close.cfa
===================================================================
--- tests/concurrency/waituntil/repeat_close.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
+++ tests/concurrency/waituntil/repeat_close.cfa	(revision 4be01174e416453134c91b2bd79737cea7f5d3f7)
@@ -10,6 +10,5 @@
 
 thread Producer {};
-void main( Producer & this ) {
-    long long int my_inserts = 0;
+void main( Producer & ) {
     long long int A_i = 0, B_i = 0, C_i = 0, D_i = 0, E_i = 0, F_i = 0;
     try {
@@ -22,10 +21,10 @@
             and waituntil( F << i ) { F_i++; }
         }
-    } catch ( channel_closed * e ) {} 
+    } catch ( channel_closed * e ) {}
     __atomic_fetch_add( &inserts, A_i + B_i + C_i + D_i + E_i + F_i, __ATOMIC_SEQ_CST );
 }
 
 thread Consumer {};
-void main( Consumer & this ) {
+void main( Consumer & ) {
     long long int in, A_removes = 0, B_removes = 0, C_removes = 0, D_removes = 0, E_removes = 0, F_removes = 0;
     try {
@@ -83,5 +82,5 @@
     printf("Start\n");
     for ( i; num_times ) {
-        printf("%lu\n", i);
+        printf("%zu\n", i);
         A{chan_size};
         B{chan_size};