Index: tests/concurrency/channels/ping_pong.cfa
===================================================================
--- tests/concurrency/channels/ping_pong.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/channels/ping_pong.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -16,5 +16,5 @@
 
 thread Pong {};
-void main(Pong & this) {
+void main(Pong &) {
     try {
         for ( ;; ) {
@@ -27,5 +27,5 @@
 
 thread Ping {};
-void main(Ping & this) {
+void main(Ping &) {
     try {
         for ( ;; ) {
@@ -39,5 +39,5 @@
 
 
-int main( int argc, char * argv[] ) {
+int main() {
     sout | "start";
     processor proc[1];
Index: tests/concurrency/cluster.cfa
===================================================================
--- tests/concurrency/cluster.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/cluster.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -9,5 +9,5 @@
 }
 
-void main( MyThread & this ) {
+void main( MyThread & ) {
 	for(50) {
 		yield();
Index: tests/concurrency/coroutineYield.cfa
===================================================================
--- tests/concurrency/coroutineYield.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/coroutineYield.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -24,5 +24,5 @@
 coroutine Coroutine {};
 
-void main(Coroutine& this) {
+void main( Coroutine & ) {
 	while(true) {
 		#if !defined(TEST_FOREVER)
@@ -39,5 +39,5 @@
 
 Coroutine c;
-int main(int argc, char* argv[]) {
+int main() {
 	for(int i = 0; TEST(i < N); i++) {
 		#if !defined(TEST_FOREVER)
Index: tests/concurrency/examples/boundedBufferEXT.cfa
===================================================================
--- tests/concurrency/examples/boundedBufferEXT.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/examples/boundedBufferEXT.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -94,5 +94,4 @@
 	Buffer(int) buffer;
 	int sums[Cons];
-	int i;
 	processor p;
 
Index: tests/concurrency/examples/boundedBufferINT.cfa
===================================================================
--- tests/concurrency/examples/boundedBufferINT.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/examples/boundedBufferINT.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -94,5 +94,4 @@
 	Consumer * cons[Cons];
 	int sums[Cons];
-	int i;
 	processor p;
 
Index: tests/concurrency/futures/wait_any.cfa
===================================================================
--- tests/concurrency/futures/wait_any.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/futures/wait_any.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -32,5 +32,5 @@
 
 thread Waiter {};
-void main( Waiter & this ) {
+void main( Waiter & ) {
     for (numtimes) {
         wait_any(futures, num_futures);
@@ -42,5 +42,5 @@
 
 thread Deliverer {};
-void main( Deliverer & this ) {
+void main( Deliverer & ) {
     while (!done) {
         size_t num_satisfy = random(1,num_futures);
Index: tests/concurrency/join.cfa
===================================================================
--- tests/concurrency/join.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/join.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -28,5 +28,5 @@
 
 
-int main(int argc, char* argv[]) {
+int main() {
 	{
 		Worker workers[17];
Index: tests/concurrency/migrate.cfa
===================================================================
--- tests/concurrency/migrate.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/migrate.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -47,6 +47,4 @@
 	}
 
-	struct cluster_wrapper * curr = (struct cluster_wrapper *)&the_clusters[0];
-
 	for(100) {
 		unsigned idx = prng( this, cluster_cnt );
Index: tests/concurrency/monitor.cfa
===================================================================
--- tests/concurrency/monitor.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/monitor.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -28,5 +28,5 @@
 thread MyThread {};
 
-void main( MyThread & this ) {
+void main( MyThread & ) {
 	for(int i = 0; i < 750_000; i++) {
 		increment( global );
@@ -34,5 +34,5 @@
 }
 
-int main(int argc, char* argv[]) {
+int main() {
 	assert( global.__mon.entry_queue.tail != NULL );
 	processor p;
Index: tests/concurrency/multi-monitor.cfa
===================================================================
--- tests/concurrency/multi-monitor.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/multi-monitor.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -44,5 +44,5 @@
 }
 
-int main(int argc, char* argv[]) {
+int main() {
 	processor p;
 	{
Index: tests/concurrency/mutexstmt/locks.cfa
===================================================================
--- tests/concurrency/mutexstmt/locks.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/mutexstmt/locks.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -12,5 +12,5 @@
 int count = 0;
 
-void main( T_Mutex & this ) {
+void main( T_Mutex & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		mutex ( m1 ) count++;
@@ -35,5 +35,5 @@
 thread T_Multi {};
 
-void main( T_Multi & this ) {
+void main( T_Multi & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		refTest( m1 );
@@ -81,5 +81,5 @@
 thread T_Multi_Poly {};
 
-void main( T_Multi_Poly & this ) {
+void main( T_Multi_Poly & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		refTest( l1 );
Index: tests/concurrency/mutexstmt/monitors.cfa
===================================================================
--- tests/concurrency/mutexstmt/monitors.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/mutexstmt/monitors.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -16,5 +16,5 @@
 bool startFlag = false;
 
-void main( T_Mutex & this ) {
+void main( T_Mutex & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		mutex ( m1 ) count++;
@@ -30,5 +30,5 @@
 thread T_Multi {};
 
-void main( T_Multi & this ) {
+void main( T_Multi & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		mutex ( m1 ) {
Index: tests/concurrency/preempt.cfa
===================================================================
--- tests/concurrency/preempt.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/preempt.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -71,5 +71,5 @@
 }
 
-int main(int argc, char* argv[]) {
+int main() {
 	processor p;
 	globals.counter = 0;
Index: tests/concurrency/pthread/pthread_cond_test.cfa
===================================================================
--- tests/concurrency/pthread/pthread_cond_test.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/pthread/pthread_cond_test.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -9,6 +9,6 @@
 pthread_cond_t cond;
 
-extern "C"{
-    void* S1(void* arg){
+extern "C" {
+    void* S1( void * ) {
         pthread_mutex_lock(&_mutex);
         for (int i = 0; i < 1000; i++) sout | "S1 done " | i;
@@ -19,5 +19,5 @@
     }
 
-    void* S2(void* arg){
+    void* S2( void * ) {
         pthread_mutex_lock(&_mutex);
         if (!done_flag) pthread_cond_wait(&cond, &_mutex);
@@ -30,7 +30,5 @@
 
 
-int main(int argc, char const *argv[])
-{
-    /* code */
+int main() {
     pthread_mutex_init(&_mutex, NULL);
     pthread_cond_init(&cond, NULL);
Index: tests/concurrency/pthread/pthread_once_test.cfa
===================================================================
--- tests/concurrency/pthread/pthread_once_test.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/pthread/pthread_once_test.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -90,5 +90,5 @@
 
 
-int main(int argc, char const *argv[])
+int main()
 {
     test();
Index: tests/concurrency/readyQ/leader_spin.cfa
===================================================================
--- tests/concurrency/readyQ/leader_spin.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/readyQ/leader_spin.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -97,5 +97,5 @@
 
 // ==================================================
-int main(int argc, char * argv[]) {
+int main() {
 	lead_idx = 0;
 	leader = prng( lead_rng, nthreads );
Index: tests/concurrency/signal/block.cfa
===================================================================
--- tests/concurrency/signal/block.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/signal/block.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -51,5 +51,5 @@
 
 //------------------------------------------------------------------------------
-void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned i ) {
+void wait_op( global_data_t & mutex a, global_data_t & mutex b, unsigned ) {
     wait( cond, (uintptr_t)active_thread() );
 
@@ -67,5 +67,5 @@
 
 thread Waiter {};
-void main( Waiter & this ) {
+void main( Waiter & ) {
 	for( int i = 0; TEST(i < N); i++ ) {
 		wait_op( globalA, globalB, i );
@@ -100,5 +100,5 @@
 
 thread Signaller {};
-void main( Signaller & this ) {
+void main( Signaller & ) {
 	while( !done ) {
 		signal_op( globalA, globalB );
@@ -112,5 +112,5 @@
 
 thread Barger {};
-void main( Barger & this ) {
+void main( Barger & ) {
 	for( unsigned i = 0; !done; i++ ) {
 		//Choose some monitor to barge into with some irregular pattern
@@ -123,5 +123,5 @@
 //------------------------------------------------------------------------------
 
-int main(int argc, char* argv[]) {
+int main() {
 	srandom( time( NULL ) );
 	done = false;
Index: tests/concurrency/signal/disjoint.cfa
===================================================================
--- tests/concurrency/signal/disjoint.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/signal/disjoint.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -65,5 +65,5 @@
 }
 
-void main( Barger & this ) {
+void main( Barger & ) {
 	while( !all_done ) {
 		barge( globals.data );
@@ -93,5 +93,5 @@
 }
 
-void main( Waiter & this ) {
+void main( Waiter & ) {
 	while( wait( globals.mut, globals.data ) ) { KICK_WATCHDOG; yield(); }
 }
@@ -122,5 +122,5 @@
 }
 
-void main( Signaller & this ) {
+void main( Signaller & ) {
 	while( !all_done ) {
 		logic( globals.mut );
@@ -131,5 +131,5 @@
 //------------------------------------------------------------------------------
 // Main loop
-int main(int argc, char* argv[]) {
+int main() {
 	srandom( time( NULL ) );
 	all_done = false;
Index: tests/concurrency/signal/wait.cfa
===================================================================
--- tests/concurrency/signal/wait.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/signal/wait.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -65,5 +65,5 @@
 //----------------------------------------------------------------------------------------------------
 // Signaler
-void main( Signaler & this ) {
+void main( Signaler & ) {
 
 	while( waiter_left != 0 ) {
@@ -92,5 +92,5 @@
 //----------------------------------------------------------------------------------------------------
 // Waiter ABC
-void main( WaiterABC & this ) {
+void main( WaiterABC & ) {
 	for( int i = 0; TEST(i < N); i++ ) {
 		wait( condABC, globalA, globalB, globalC );
@@ -103,5 +103,5 @@
 //----------------------------------------------------------------------------------------------------
 // Waiter AB
-void main( WaiterAB & this ) {
+void main( WaiterAB & ) {
 	for( int i = 0; TEST(i < N); i++ ) {
 		wait( condAB , globalA, globalB );
@@ -114,5 +114,5 @@
 //----------------------------------------------------------------------------------------------------
 // Waiter AC
-void main( WaiterAC & this ) {
+void main( WaiterAC & ) {
 	for( int i = 0; TEST(i < N); i++ ) {
 		wait( condAC , globalA, globalC );
@@ -125,5 +125,5 @@
 //----------------------------------------------------------------------------------------------------
 // Waiter BC
-void main( WaiterBC & this ) {
+void main( WaiterBC & ) {
 	for( int i = 0; TEST(i < N); i++ ) {
 		wait( condBC , globalB, globalC );
@@ -136,5 +136,5 @@
 //----------------------------------------------------------------------------------------------------
 // Main
-int main(int argc, char* argv[]) {
+int main() {
 	srandom( time( NULL ) );
 	waiter_left = 4;
Index: tests/concurrency/suspend_then.cfa
===================================================================
--- tests/concurrency/suspend_then.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/suspend_then.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -64,5 +64,5 @@
 
 thread Thread {};
-void main(Thread & this) {
+void main( Thread & ) {
 	Coroutine * mine = 0p;
 	while(!done) {
@@ -78,5 +78,5 @@
 
 
-int main(int argc, char* argv[]) {
+int main() {
 	processor p[2];
 	Coroutine c;
Index: tests/concurrency/thread.cfa
===================================================================
--- tests/concurrency/thread.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/thread.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -28,5 +28,5 @@
 
 
-int main(int argc, char* argv[]) {
+int main() {
 	semaphore lock = { 0 };
 	sout | "User main begin";
Index: tests/concurrency/unified_locking/locks.cfa
===================================================================
--- tests/concurrency/unified_locking/locks.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/unified_locking/locks.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -23,5 +23,5 @@
 thread T_C_M_WS1 {};
 
-void main( T_C_M_WS1 & this ) {
+void main( T_C_M_WS1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(m);
@@ -37,5 +37,5 @@
 thread T_C_M_WB1 {};
 
-void main( T_C_M_WB1 & this ) {
+void main( T_C_M_WB1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(m);
@@ -51,5 +51,5 @@
 thread T_C_S_WS1 {};
 
-void main( T_C_S_WS1 & this ) {
+void main( T_C_S_WS1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(s);
@@ -65,5 +65,5 @@
 thread T_C_S_WB1 {};
 
-void main( T_C_S_WB1 & this ) {
+void main( T_C_S_WB1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(s);
@@ -79,5 +79,5 @@
 thread T_C_L_WS1 {};
 
-void main( T_C_L_WS1 & this ) {
+void main( T_C_L_WS1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -93,5 +93,5 @@
 thread T_C_L_WB1 {};
 
-void main( T_C_L_WB1 & this ) {
+void main( T_C_L_WB1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -107,5 +107,5 @@
 thread T_F_C_F_WS1 {};
 
-void main( T_F_C_F_WS1 & this ) {
+void main( T_F_C_F_WS1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(f);
@@ -121,5 +121,5 @@
 thread T_C_O_WS1 {};
 
-void main( T_C_O_WS1 & this ) {
+void main( T_C_O_WS1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(o);
@@ -135,5 +135,5 @@
 thread T_C_O_WB1 {};
 
-void main( T_C_O_WB1 & this ) {
+void main( T_C_O_WB1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(o);
@@ -149,5 +149,5 @@
 thread T_C_M_WS2 {};
 
-void main( T_C_M_WS2 & this ) {
+void main( T_C_M_WS2 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(m);
@@ -167,5 +167,5 @@
 thread T_C_O_WS2 {};
 
-void main( T_C_O_WS2 & this ) {
+void main( T_C_O_WS2 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(o);
@@ -185,5 +185,5 @@
 thread T_C_NLW {};
 
-void main( T_C_NLW & this ) {
+void main( T_C_NLW & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		wait(c_o);
@@ -193,5 +193,5 @@
 thread T_C_NLS {};
 
-void main( T_C_NLS & this ) {
+void main( T_C_NLS & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		while (empty(c_o)) { }
@@ -202,5 +202,5 @@
 thread T_C_S_WNF {};
 
-void main( T_C_S_WNF & this ) {
+void main( T_C_S_WNF & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(s);
@@ -219,5 +219,5 @@
 thread T_C_NLWD {};
 
-void main( T_C_NLWD & this ) {
+void main( T_C_NLWD & ) {
 	done = false;
 	for (unsigned int i = 0; i < num_times/5; i++) {
@@ -230,5 +230,5 @@
 thread T_C_WDS {};
 
-void main( T_C_WDS & this ) {
+void main( T_C_WDS & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		while (empty(c_s) && !done) { }
@@ -241,5 +241,5 @@
 thread T_C_LWD {};
 
-void main( T_C_LWD & this ) {
+void main( T_C_LWD & ) {
 	done = false;
 	for (unsigned int i = 0; i < num_times/5; i++) {
@@ -254,5 +254,5 @@
 thread T_C_LWDS {};
 
-void main( T_C_LWDS & this ) {
+void main( T_C_LWDS & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		while (empty(c_s) && !done) { }
Index: tests/concurrency/unified_locking/pthread_locks.cfa
===================================================================
--- tests/concurrency/unified_locking/pthread_locks.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/unified_locking/pthread_locks.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -18,5 +18,5 @@
 thread Wait_Signal_1 {};
 
-void main( Wait_Signal_1 & this ) {
+void main( Wait_Signal_1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -32,5 +32,5 @@
 thread Wait_3_Signal_3 {};
 
-void main( Wait_3_Signal_3 & this ) {
+void main( Wait_3_Signal_3 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -48,5 +48,5 @@
 thread Rec_Lock_Wait_Signal_1 {};
 
-void main( Rec_Lock_Wait_Signal_1 & this ) {
+void main( Rec_Lock_Wait_Signal_1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -66,5 +66,5 @@
 thread Wait_Time_Signal_1 {};
 
-void main( Wait_Time_Signal_1 & this ) {
+void main( Wait_Time_Signal_1 & ) {
 	for (unsigned int i = 0; i < num_times; i++) {
 		lock(l);
@@ -74,4 +74,5 @@
 			timespec waitTime{0,1};
 			bool woken = wait(c,l, t + waitTime);
+			(void) woken;
 		}else{
 			notify_one(c);
Index: tests/concurrency/waitfor/barge.cfa
===================================================================
--- tests/concurrency/waitfor/barge.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/waitfor/barge.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -30,5 +30,5 @@
 }
 
-void ^?{} ( global_t & mutex this ) {}
+void ^?{} ( global_t & mutex ) {}
 
 global_t global;
@@ -40,5 +40,5 @@
 
 thread barger_t {};
-void main( barger_t & this ) {
+void main( barger_t & ) {
 	yield();
 	while( barge( global ) ) { yield(random( 10 )); }
@@ -56,5 +56,5 @@
 
 thread caller_t {};
-void main( caller_t & this ) {
+void main( caller_t & ) {
 	while( do_call(global) ) { yield(random( 10 )); }
 }
@@ -78,5 +78,5 @@
 
 thread waiter_t{};
-void main( waiter_t & this ) {
+void main( waiter_t & ) {
 	do_wait(global);
 }
Index: tests/concurrency/waitfor/statment.cfa
===================================================================
--- tests/concurrency/waitfor/statment.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/waitfor/statment.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -89,5 +89,5 @@
 }
 
-void main( caller & this ) {
+void main( caller & ) {
 	int index = get_index( m );
 	while( !start ) yield();
@@ -122,5 +122,5 @@
 thread waiter{};
 
-void main( waiter & this ) {
+void main( waiter & ) {
 	do_wait( m );
 }
Index: tests/concurrency/waitfor/when.cfa
===================================================================
--- tests/concurrency/waitfor/when.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/waitfor/when.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -39,5 +39,5 @@
 
 thread caller_t{};
-void main( caller_t & this ) {
+void main( caller_t & ) {
 	while( true ) {
 		rand_yield();
@@ -76,5 +76,5 @@
 
 thread arbiter_t{};
-void main( arbiter_t & this ) {
+void main( arbiter_t & ) {
 	arbiter( global );
 }
Index: tests/concurrency/waituntil/channel_zero_size.cfa
===================================================================
--- tests/concurrency/waituntil/channel_zero_size.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/waituntil/channel_zero_size.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -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++ ) {
Index: tests/concurrency/waituntil/one_chan.cfa
===================================================================
--- tests/concurrency/waituntil/one_chan.cfa	(revision 2853d6fb02befcb65b90aa2717750f5b7e57ad95)
+++ tests/concurrency/waituntil/one_chan.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -9,5 +9,5 @@
 
 thread Server1 {};
-void main( Server1 & this ) {
+void main( Server1 & ) {
     long long int c, i = 0, myTotal = 0;
     for( ;;i++ ) {