Index: libcfa/src/concurrency/future.hfa
===================================================================
--- libcfa/src/concurrency/future.hfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ libcfa/src/concurrency/future.hfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -176,5 +176,5 @@
         }
 
-        bool on_selected( future(T) & this, select_node & node ) { return true; }
+        bool on_selected( future(T) &, select_node & ) { return true; }
 	}
 }
@@ -204,5 +204,5 @@
 		// Mark the future as abandoned, meaning it will be deleted by the server
 		// This doesn't work beause of the potential need for a destructor
-		void abandon( single_future(T) & this );
+		// void abandon( single_future(T) & this );
 
 		// Fulfil the future, returns whether or not someone was unblocked
Index: src/Concurrency/Waituntil.cpp
===================================================================
--- src/Concurrency/Waituntil.cpp	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ src/Concurrency/Waituntil.cpp	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -720,5 +720,5 @@
 				                )
 				            ),
-				            new BranchStmt( cLoc, BranchStmt::Kind::Break, Label( cLoc, switchLabel ) )
+				            new BranchStmt( cLoc, BranchStmt::Goto, Label( cLoc, switchLabel ) )
 				        }
 				    )
@@ -733,4 +733,10 @@
 			new NameExpr( loc, idxName ),
 			std::move( switchCases ),
+			{}
+		)
+	);
+
+	ifBody->push_back(
+		new NullStmt( loc,
 			{ Label( loc, switchLabel ) }
 		)
@@ -790,9 +796,12 @@
 				                { new NameExpr( loc, clauseData.at(0)->statusName ) }
 				            ),
-				            new BranchStmt( loc, BranchStmt::Kind::Break, Label( loc, forLabel ) )
+				            new BranchStmt( loc, BranchStmt::Goto, Label( loc, forLabel ) )
 				        ),
 				        ifSwitch
 				    }
 				),   // body
+				{}
+			),
+			new NullStmt( loc,
 				{ Label( loc, forLabel ) }
 			)
Index: tests/Makefile.am
===================================================================
--- tests/Makefile.am	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/Makefile.am	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -52,4 +52,5 @@
 WFLAGS_OPT_LAX = \
 	${WFLAGS_OPT_LAX_EXPECT_WARN} \
+	${WFLAGS_OPT_LAX_WAITING_ON_303} \
 	${WFLAGS_OPT_LAX_TO_INVESTIGATE}
 
@@ -60,6 +61,7 @@
 	warnings/self-assignment
 
-# Tests that need investigation from the CFA team about why they require lax wflags.  Goal is to eliminate this list.
-WFLAGS_OPT_LAX_TO_INVESTIGATE = \
+# These are failing because of trac #303; it is not likely to be fixed soon.
+# It only shows up on some configurations and machines.
+WFLAGS_OPT_LAX_WAITING_ON_303 = \
 	concurrency/actors/dynamic \
 	concurrency/actors/executor \
@@ -70,27 +72,8 @@
 	concurrency/actors/poison \
 	concurrency/actors/static \
-	concurrency/actors/types \
-	concurrency/channels/churn \
-	concurrency/channels/contend \
-	concurrency/channels/daisy_chain \
-	concurrency/channels/hot_potato \
-	concurrency/channels/pub_sub \
-	concurrency/futures/multi \
-	concurrency/futures/select_future \
-	concurrency/futures/typed \
-	concurrency/lockfree_stack \
-	concurrency/pthread/bounded_buffer \
-	concurrency/pthread/pthread_attr_test \
-	concurrency/pthread/pthread_demo_create_join \
-	concurrency/pthread/pthread_demo_lock \
-	concurrency/pthread/pthread_key_test \
-	concurrency/waituntil/all_types \
-	concurrency/waituntil/basic_else \
-	concurrency/waituntil/channel_close \
-	concurrency/waituntil/channels \
-	concurrency/waituntil/futures \
-	concurrency/waituntil/locks \
-	concurrency/waituntil/repeat_close \
-	concurrency/waituntil/timeout \
+	concurrency/actors/types
+
+# Tests that need investigation from the CFA team about why they require lax wflags.  Goal is to eliminate this list.
+WFLAGS_OPT_LAX_TO_INVESTIGATE = \
 	exceptions/cardgame \
 	exceptions/defaults \
Index: tests/concurrency/actors/executor.cfa
===================================================================
--- tests/concurrency/actors/executor.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/actors/executor.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -24,5 +24,5 @@
 struct d_msg { inline message; } shared_msg;
 
-allocation receive( d_actor & this, d_msg & msg ) with( this ) {
+allocation receive( d_actor & this, d_msg & ) with( this ) {
 	if ( recs == rounds ) return Finished;
 	if ( recs % Batch == 0 ) {
@@ -43,4 +43,5 @@
 			if ( BufSize < 0 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 6:
 		if ( strcmp( argv[5], "d" ) != 0 ) {			// default ?
@@ -48,4 +49,5 @@
 			if ( Batch < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 5:
 		if ( strcmp( argv[4], "d" ) != 0 ) {			// default ?
@@ -53,4 +55,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 4:
 		if ( strcmp( argv[3], "d" ) != 0 ) {			// default ?
@@ -58,4 +61,5 @@
 			if ( Rounds < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 3:
 		if ( strcmp( argv[2], "d" ) != 0 ) {			// default ?
@@ -63,4 +67,5 @@
 			if ( Set < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -68,4 +73,5 @@
 			if ( Actors < 1 || Actors <= Set || Actors % Set != 0 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/actors/matrixMultiply.cfa
===================================================================
--- tests/concurrency/actors/matrixMultiply.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/actors/matrixMultiply.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -24,5 +24,5 @@
 }
 
-allocation receive( derived_actor & receiver, derived_msg & msg ) {
+allocation receive( derived_actor &, derived_msg & msg ) {
 	for ( i; yc ) {										// multiply X_row by Y_col and sum products
 		msg.Z[i] = 0;
@@ -41,4 +41,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+        fallthrough;
 	  case 4:
 		if ( strcmp( argv[3], "d" ) != 0 ) {			// default ?
@@ -46,4 +47,5 @@
 			if ( xr < 1 ) fallthrough default;
 		} // if
+        fallthrough;
 	  case 3:
 		if ( strcmp( argv[2], "d" ) != 0 ) {			// default ?
@@ -51,4 +53,5 @@
 			if ( xc < 1 ) fallthrough default;
 		} // if
+        fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -56,4 +59,5 @@
 			if ( yc < 1 ) fallthrough default;
 		} // if
+        fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/channels/churn.cfa
===================================================================
--- tests/concurrency/channels/churn.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/channels/churn.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -30,5 +30,5 @@
 }
 
-void main(Consumer & this) {
+void main(Consumer &) {
     size_t i = 0;
     size_t runs = 0;
@@ -53,5 +53,5 @@
             }
         } catchResume ( channel_closed * e ) {} // continue to remove until would block
-        catch ( channel_closed * e ) {} 
+        catch ( channel_closed * e ) {}
     }
 
@@ -65,5 +65,5 @@
 thread Producer {};
 
-void main(Producer & this) {
+void main(Producer &) {
     size_t i = 0;
     size_t runs = 0;
@@ -77,5 +77,5 @@
             runs++;
         }
-    } catch ( channel_closed * e ) {} 
+    } catch ( channel_closed * e ) {}
     lock(o);
     total_operations += runs;
@@ -93,4 +93,5 @@
 			if ( ChannelSize < 1 ) fallthrough default;
 		} // if
+		fallthrough;
       case 3:
 		if ( strcmp( argv[2], "d" ) != 0 ) {			// default ?
@@ -98,4 +99,5 @@
 			if ( Channels < 1 ) fallthrough default;
 		} // if
+		fallthrough;
       case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -103,4 +105,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
@@ -121,5 +124,5 @@
 
     sout | "start";
-    {   
+    {
         Consumer c[Consumers];
         {
Index: tests/concurrency/channels/contend.cfa
===================================================================
--- tests/concurrency/channels/contend.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/channels/contend.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -130,4 +130,5 @@
 			if ( ChannelSize < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -135,4 +136,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/channels/daisy_chain.cfa
===================================================================
--- tests/concurrency/channels/daisy_chain.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/channels/daisy_chain.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -17,5 +17,5 @@
 
 thread Task {};
-void main(Task & this) {
+void main(Task &) {
     size_t runs = 0;
     int token = 0;
@@ -40,4 +40,5 @@
             if ( Tasks < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -45,4 +46,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/channels/hot_potato.cfa
===================================================================
--- tests/concurrency/channels/hot_potato.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/channels/hot_potato.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -45,4 +45,5 @@
             if ( Tasks < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -50,4 +51,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/channels/pub_sub.cfa
===================================================================
--- tests/concurrency/channels/pub_sub.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/channels/pub_sub.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -90,4 +90,5 @@
             if ( Tasks < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 2:
 		if ( strcmp( argv[1], "d" ) != 0 ) {			// default ?
@@ -95,4 +96,5 @@
 			if ( Processors < 1 ) fallthrough default;
 		} // if
+		fallthrough;
 	  case 1:											// use defaults
 		break;
Index: tests/concurrency/lockfree_stack.cfa
===================================================================
--- tests/concurrency/lockfree_stack.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/lockfree_stack.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// lockfree_stack.cfa -- 
+// lockfree_stack.cfa --
 //
 // Author           : Peter A. Buhr
@@ -12,5 +12,5 @@
 // Last Modified On : Fri Jun  9 14:01:07 2023
 // Update Count     : 68
-// 
+//
 
 #include <thread.hfa>
@@ -42,5 +42,5 @@
 	n.next = stack;										// atomic assignment unnecessary
 	for () {											// busy wait
-		Link temp{ &n, n.next.count + 1 };
+		Link temp{ { &n, n.next.count + 1 } };
 		if ( CASV( s.stack.atom, n.next.atom, temp.atom ) ) break; // attempt to update top node
 	}
@@ -51,5 +51,5 @@
 	for () {											// busy wait
 		if ( t.top == NULL ) return NULL;				// empty stack ?
-		Link temp{ t.top->next.top, t.count };
+		Link temp{ { t.top->next.top, t.count } };
 		if ( CASV( stack.atom, t.atom, temp.atom ) ) return t.top; // attempt to update top node
 	}
@@ -62,5 +62,5 @@
 
 thread Worker {};
-void main( Worker & w ) {
+void main( Worker & ) {
 	for ( i; Times ) {
 		Node & n = *pop( stack );						// pop any node
Index: tests/concurrency/pthread/pthread_attr_test.cfa
===================================================================
--- tests/concurrency/pthread/pthread_attr_test.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/pthread/pthread_attr_test.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -4,8 +4,11 @@
 #include <thread.hfa>
 
-void* foo(void* _attr){
+void* foo(void*){
+    pthread_t self = pthread_self();
+    pthread_attr_t self_attr;
+    pthread_getattr_np(self, &self_attr);
+
     size_t size;
-    pthread_attr_t* attr = (pthread_attr_t*)_attr;
-    int status = pthread_attr_getstacksize(attr, &size);
+    int status = pthread_attr_getstacksize(&self_attr, &size);
     if (status != 0){
         sout | "error return code";
@@ -16,5 +19,5 @@
 }
 
-int main(int argc, char const *argv[])
+int main()
 {
     pthread_attr_t attr;
@@ -23,5 +26,5 @@
     pthread_t thr;
     void* res;
-    pthread_create(&thr, &attr, foo, (void*)&attr);
+    pthread_create(&thr, &attr, foo, (void*)0);
     pthread_join(thr, &res);
     pthread_attr_destroy(&attr);
Index: tests/concurrency/pthread/pthread_demo_create_join.cfa
===================================================================
--- tests/concurrency/pthread/pthread_demo_create_join.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/pthread/pthread_demo_create_join.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -3,8 +3,8 @@
 /* test pthread create/join/exit */
 
-int arr[20];
+size_t arr[20];
 
 void* fetch(void* idx){
-    int res = arr[(uint64_t)idx];
+    size_t res = arr[(size_t)idx];
     pthread_exit((void*)res);
     sout | "it should not be here";
@@ -19,10 +19,10 @@
 }
 
-int main(int argc, char const *argv[])
+int main()
 {
     pthread_t threads[20];
     arr_init();
     int status;
-    for (int i = 0; i < 20; i++){
+    for (size_t i = 0; i < 20; i++){
         status = pthread_create(&threads[i], NULL, fetch, (void*)i);
         if (status != 0) exit(1);
@@ -30,9 +30,9 @@
     int res = 0;
     for (int i = 0; i < 20; i++){
-        void* _res = NULL;
-        status = pthread_join(threads[i], &_res);
+        void* res_i = NULL;
+        status = pthread_join(threads[i], &res_i);
         if (status != 0) exit(2);
-        if (((uint64_t)_res) != i) exit(3);
-        res += (uint64_t)_res;
+        if (((size_t)res_i) != i) exit(3);
+        res += (size_t)res_i;
     }
     sout | "final res is" | res;
Index: tests/concurrency/pthread/pthread_key_test.cfa
===================================================================
--- tests/concurrency/pthread/pthread_key_test.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/pthread/pthread_key_test.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -16,5 +16,6 @@
     #define BUFFSZ  48
     pthread_key_t   key;
-    volatile int total_value,total_value_getspec;
+    volatile size_t total_value;
+    volatile size_t total_value_getspec;
     pthread_mutex_t value_mutex;
 
@@ -26,5 +27,4 @@
         int       *tnum;
         void      *getvalue;
-        char       Buffer[BUFFSZ];
 
         tnum = (int*)parm;
@@ -32,5 +32,5 @@
 
         //printf("Thread %d executing\n", threadnum);
-        value = (void *)(rand()%100);
+        value = (void *)(size_t)(rand()%100);
         status = pthread_setspecific(key, (void *) value);
         if ( status !=  0) {
@@ -40,10 +40,10 @@
         }
         pthread_mutex_lock(&value_mutex);
-        total_value_getspec += (int)value;
-        total_value += (int)pthread_getspecific(key);
+        total_value_getspec += (size_t)value;
+        total_value += (size_t)pthread_getspecific(key);
         pthread_mutex_unlock(&value_mutex);
 
 
-        if (!(value = malloc(sizeof(Buffer))))
+        if (!(value = malloc(BUFFSZ)))
             printf("Thread %d could not allocate storage, errno = %d\n",
                                                         threadnum, errno);
@@ -60,5 +60,5 @@
 
         if (getvalue != value) {
-        printf("getvalue not valid, getvalue=%d", (u_int64_t)getvalue);
+            printf("getvalue not valid, getvalue=%p", getvalue);
             return (void*)68;
         }
@@ -76,5 +76,4 @@
 
     int main() {
-        int          getvalue;
         int          status;
         int          i;
@@ -116,9 +115,9 @@
 
             if (thread_stat[i] != 0)   {
-                printf("bad thread status, thread %d, status=%d\n", i+1,
-                                                        (u_int64_t)thread_stat[i]);
+                printf("bad thread status, thread %d, status=%zd\n", i+1,
+                                                        (size_t)thread_stat[i]);
             }
         }
-        printf("total value is %d, total value by pthread_getspecific is %d\n", total_value, total_value_getspec);
+        printf("total value is %zd, total value by pthread_getspecific is %zd\n", total_value, total_value_getspec);
         exit(0);
     }   // main
Index: tests/concurrency/waituntil/all_types.cfa
===================================================================
--- tests/concurrency/waituntil/all_types.cfa	(revision 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/all_types.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/channel_close.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/channels.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/futures.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/locks.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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 3e5fea2e8e80a245642d87ae8b4d88b702fb3e57)
+++ tests/concurrency/waituntil/repeat_close.cfa	(revision d923fca679790b81e32b6a12debf586d34a17e72)
@@ -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};