Index: libcfa/src/bits/queue.hfa
===================================================================
--- libcfa/src/bits/queue.hfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ libcfa/src/bits/queue.hfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -33,8 +33,10 @@
 		}
 
-		T * succ( Queue(T) & q, T * n ) with( q ) {		// pre: *n in *q
-			#ifdef __CFA_DEBUG__
+		T * succ( Queue(T) & q, T * n ) {					// pre: *n in *q
+		  #ifdef __CFA_DEBUG__
 			if ( ! listed( n ) ) abort( "(Queue &)%p.succ( %p ) : Node is not on a list.", &q, n );
-			#endif // __CFA_DEBUG__
+		  #else
+			(void) q;
+		  #endif // __CFA_DEBUG__
 			return (Next( n ) == n) ? 0p : Next( n );
 		} // post: n == tail() & succ(n) == 0 | n != tail() & *succ(n) in *q
Index: libcfa/src/concurrency/mutex_stmt.hfa
===================================================================
--- libcfa/src/concurrency/mutex_stmt.hfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ libcfa/src/concurrency/mutex_stmt.hfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -30,5 +30,5 @@
 forall(L & | is_lock(L)) {
     static inline void * __get_mutexstmt_lock_ptr( L & this ) { return &this; }
-    static inline L __get_mutexstmt_lock_type( L & this ) {}
-    static inline L __get_mutexstmt_lock_type( L * this ) {}
+    static inline L __get_mutexstmt_lock_type( L & ) {}
+    static inline L __get_mutexstmt_lock_type( L * ) {}
 }
Index: tests/Makefile.am
===================================================================
--- tests/Makefile.am	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/Makefile.am	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -61,8 +61,6 @@
 # Tests that need investigation from the CFA team about why they require lax wflags.  Goal is to eliminate this list.
 WFLGAS_OPT_LAX_TO_INVESTIGATE = \
-	alloc \
 	attributes \
 	collections/atomic_mpsc \
-	collections/multi_list \
 	collections/queue \
 	collections/sequence \
@@ -78,7 +76,4 @@
 	concurrency/actors/static \
 	concurrency/actors/types \
-	concurrency/barrier/generation \
-	concurrency/barrier/last \
-	concurrency/barrier/order \
 	concurrency/channels/big_elems \
 	concurrency/channels/churn \
@@ -89,36 +84,19 @@
 	concurrency/channels/pub_sub \
 	concurrency/channels/zero_size \
-	concurrency/cluster \
 	concurrency/cofor \
-	concurrency/coroutineYield \
-	concurrency/examples/boundedBufferEXT \
-	concurrency/examples/boundedBufferINT \
 	concurrency/futures/multi \
 	concurrency/futures/select_future \
 	concurrency/futures/typed \
 	concurrency/futures/wait_any \
-	concurrency/join \
 	concurrency/lockfree_stack \
-	concurrency/migrate \
-	concurrency/monitor \
-	concurrency/multi-monitor \
 	concurrency/mutexstmt/locks \
-	concurrency/mutexstmt/monitors \
 	concurrency/mutexstmt/tuple \
 	concurrency/once \
-	concurrency/preempt \
 	concurrency/pthread/bounded_buffer \
 	concurrency/pthread/pthread_attr_test \
-	concurrency/pthread/pthread_cond_test \
 	concurrency/pthread/pthread_demo_create_join \
 	concurrency/pthread/pthread_demo_lock \
 	concurrency/pthread/pthread_key_test \
 	concurrency/pthread/pthread_once_test \
-	concurrency/readyQ/leader_spin \
-	concurrency/signal/block \
-	concurrency/signal/disjoint \
-	concurrency/signal/wait \
-	concurrency/sleep \
-	concurrency/suspend_then \
 	concurrency/thread \
 	concurrency/unified_locking/block_spin_lock \
@@ -134,7 +112,4 @@
 	concurrency/unified_locking/spin_queue_lock \
 	concurrency/unified_locking/timeout_lock \
-	concurrency/waitfor/barge \
-	concurrency/waitfor/statment \
-	concurrency/waitfor/when \
 	concurrency/waituntil/all_types \
 	concurrency/waituntil/basic_else \
@@ -147,23 +122,11 @@
 	concurrency/waituntil/repeat_close \
 	concurrency/waituntil/timeout \
-	configs/parsebools \
-	configs/parsenums \
 	configs/usage \
-	coroutine/raii \
-	ctrl-flow/goto \
-	ctrl-flow/ifwhileCtl \
 	ctrl-flow/labelledExit \
 	ctrl-flow/loop_else \
 	designations \
-	enum \
-	enum_tests/inc-dec \
-	enum_tests/planet \
-	enum_tests/structEnum \
 	exceptions/cardgame \
 	exceptions/defaults \
 	exceptions/defaults-threads \
-	exceptions/hotpotato \
-	exceptions/hotpotato_checked \
-	exceptions/pingpong_nonlocal \
 	exceptions/polymorphic \
 	exceptions/try-leave-catch \
@@ -181,49 +144,24 @@
 	io/comp_basic \
 	io/comp_fair \
-	io/io-acquire \
-	io/io-acquire2 \
-	io/io-acquire-in \
-	io/io-acquire-no-io \
-	io/io-acquire-out \
 	io/manipulatorsInput \
 	io/manipulatorsInput-uchunk \
 	io/many_read \
-	linking/io-acquire \
-	linking/mangling/anon \
-		linking/mangling/lib.o \
-		linking/mangling/main.o \
-	linkonce \
-		link-once/% \
-	malloc \
 	math \
-	mathX \
-	maybe \
 	minmax \
 	operators \
-	poly-d-cycle \
 	poly-many-arsz \
-	poly-member \
 	polymorphism \
 	poly-o-cycle \
-	PRNG \
-	quotedKeyword \
 	raii/boxed-types \
 	raii/ctor-autogen \
 	raii/dtor-early-exit \
 	raii/init_once \
-	raii/partial \
 	references \
-	result \
 	shortCircuit \
-	sizeof \
 	smart-pointers \
 	sum \
 	switch \
-	tuple/tupleAssign \
 	tuple/tupleCast \
 	tuple/tupleMember \
-	tuple/tuplePolymorphism \
-	tuple/tupleVariadic \
-	typeof \
 	userLiterals \
 	vector
Index: tests/PRNG.cfa
===================================================================
--- tests/PRNG.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/PRNG.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -86,5 +86,5 @@
 
 thread T3 {};
-void main( T3 & th ) {
+void main( T3 & ) {
 	size_t * buckets = calloc( BUCKETS );				// too big for task stack
 	for ( TRIALS / 5 ) {
Index: tests/alloc.cfa
===================================================================
--- tests/alloc.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/alloc.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -21,7 +21,7 @@
 #include <stdlib.hfa>									// access C malloc, realloc
 
-int * foo( int * p, int c ) { return p; }
-int * bar( int * p, int c ) { return p; }
-int * baz( int * p, int c ) { return p; }
+int * foo( int * p, int ) { return p; }
+int * bar( int * p, int ) { return p; }
+int * baz( int * p, int ) { return p; }
 
 int main( void ) {
@@ -217,5 +217,5 @@
 		const_count++;
 	}
-	void ^?{}( Struct & a ) { dest_count++; }			// destruct
+	void ^?{}( Struct & ) { dest_count++; }			// destruct
 	Struct st, st1, sta[dim], sta1[dim], * stp, * stp1;
 
Index: tests/concurrency/channels/ping_pong.cfa
===================================================================
--- tests/concurrency/channels/ping_pong.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ 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++ ) {
Index: tests/configs/parsebools.cfa
===================================================================
--- tests/configs/parsebools.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/configs/parsebools.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -22,5 +22,6 @@
 
 int main( int argc, char * argv[] ) {
-	check_main(argv[0]);
+	if ( argc == 0 ) abort( "Test requires a command-line argument" );
+	check_main( argv[0] );
 
 	bool YN = false;
Index: tests/configs/parsenums.cfa
===================================================================
--- tests/configs/parsenums.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/configs/parsenums.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -35,5 +35,6 @@
 
 int main( int argc, char * argv[]) {
-	check_main( argv[0]);
+	if ( argc == 0 ) abort( "Test requires a command-line argument" );
+	check_main( argv[0] );
 
 	int i = -3;
Index: tests/coroutine/raii.cfa
===================================================================
--- tests/coroutine/raii.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/coroutine/raii.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -32,9 +32,9 @@
 coroutine Cor {};
 
-void ?{}( Cor & this ) {
+void ?{}( Cor & ) {
 	sout | "Coroutine Ctor";
 }
 
-void main( Cor & this ) {
+void main( Cor & ) {
 	Raii raii = { "Coroutine" };
 	sout | "Before Suspend";
@@ -43,5 +43,5 @@
 }
 
-void ^?{}( Cor & this ) {
+void ^?{}( Cor & ) {
 	sout | "Coroutine Dtor";
 }
Index: tests/ctrl-flow/goto.cfa
===================================================================
--- tests/ctrl-flow/goto.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/ctrl-flow/goto.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -16,5 +16,5 @@
 }
 
-int main(int argc, char * argv[]) {
+int main() {
 	sout | nlOff;
 
Index: tests/ctrl-flow/ifwhileCtl.cfa
===================================================================
--- tests/ctrl-flow/ifwhileCtl.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/ctrl-flow/ifwhileCtl.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -19,5 +19,5 @@
 
 int main( void ) {
-	int x = 4, y = 3;
+	int x = 4, y = 3;		(void) x; (void) y;
 
 	if ( int x = 1 ) {
@@ -42,8 +42,8 @@
 
 	if ( struct S { int i; } s = { 3 }; s.i < 4 ) {
-		S s1;
+		S s1;	(void) s1;
 		sout | "s.i < 4 correct";
 	} else {
-		S s1;
+		S s1;	(void) s1;
 		sout | "s.i >= 4 incorrect";
 	} // if
@@ -64,5 +64,5 @@
 
 	while ( struct S { int i; } s = { 3 }; s.i < 4 ) {
-		S s1;
+		S s1;	(void) s1;
 		sout | "s.i < 4 correct";
 		break;
Index: tests/enum.cfa
===================================================================
--- tests/enum.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/enum.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -19,7 +19,7 @@
 		Pear,
 		Mango
-	} fruit = Mango;
-	enum Fruits f1;
-	Fruits f2;
+	} fruit = Mango;	(void) fruit;
+	enum Fruits f1;		(void) f1;
+	Fruits f2;			(void) f2;
 }
 
@@ -41,5 +41,5 @@
 
 //Dummy main
-int main(int argc, char const *argv[]) {
+int main() {
 	printf( "done\n" );				// non-empty .expect file
 }
Index: tests/enum_tests/inc-dec.cfa
===================================================================
--- tests/enum_tests/inc-dec.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/enum_tests/inc-dec.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -4,5 +4,5 @@
 enum() Number { One, Two, Three };
 
-int main(int argc, char * argv[]) {
+int main() {
 	Number a = One;
 
Index: tests/enum_tests/planet.cfa
===================================================================
--- tests/enum_tests/planet.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/enum_tests/planet.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -28,5 +28,5 @@
 }
 
-int main( int argc, char * argv[] ) {
+int main() {
 //	if ( argc != 2 ) exit | "Usage: " | argv[0] | "earth-weight"; // terminate program
 //	double earthWeight = convert( argv[1] );
Index: tests/enum_tests/structEnum.cfa
===================================================================
--- tests/enum_tests/structEnum.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/enum_tests/structEnum.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -26,6 +26,6 @@
 
 int main() {
-     PointEnum vals = second;
-     PointEnum val2;
+     PointEnum vals = second;      (void) vals;
+     PointEnum val2;               (void) val2;
      // The failing line: assignment
      // val2 = vals;
Index: tests/exceptions/hotpotato.cfa
===================================================================
--- tests/exceptions/hotpotato.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/exceptions/hotpotato.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -129,5 +129,4 @@
 	intmax_t seed = 42;									// random-number seed
 	bool playersSet = false;
-	char * nosummary = getenv( "NOSUMMARY" );			// print extra output
 
 	try {
Index: tests/exceptions/hotpotato_checked.cfa
===================================================================
--- tests/exceptions/hotpotato_checked.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/exceptions/hotpotato_checked.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -150,5 +150,4 @@
 	intmax_t seed = 42;									// random-number seed
 	bool playersSet = false;
-	char * nosummary = getenv( "NOSUMMARY" );			// print extra output
 
 	try {
Index: tests/io/io-acquire-no-io.cfa
===================================================================
--- tests/io/io-acquire-no-io.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/io/io-acquire-no-io.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -55,5 +55,4 @@
 	// above output used as input to parallel threads 
 
-	int a, b, c, d, e, f, g, h, i;
 	for ( 100 ) {										// expression protection
 		mutex(sinLock) doWork();
Index: tests/link-once/main.cfa
===================================================================
--- tests/link-once/main.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/link-once/main.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -9,5 +9,5 @@
 }
 
-int main(int argc, char * argv[]) {
+int main() {
 	printformat(example, example);
 }
Index: tests/linking/mangling/main.cfa
===================================================================
--- tests/linking/mangling/main.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/linking/mangling/main.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -12,4 +12,6 @@
 	a_typedefed_global.a_float = 9.0f;
 
+	(void) test;
+
 	sout | "Done!";
 }
Index: tests/malloc.cfa
===================================================================
--- tests/malloc.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/malloc.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -51,5 +51,4 @@
 	size_t elemSize = sizeof(int);
 	size_t size = dim * elemSize;
-	char fill = '\xde';
 	int * ip;
 	T1 * tp;
Index: tests/mathX.cfa
===================================================================
--- tests/mathX.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/mathX.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -29,8 +29,4 @@
 	unsigned long long int ulli, ullir1, ullir2, ullir3;
 
-	float f;
-	double d;
-	long double l;
-
 	//---------------------- Nearest Integer ----------------------
 
Index: tests/maybe.cfa
===================================================================
--- tests/maybe.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/maybe.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -60,5 +60,5 @@
 }
 
-int main(int argc, char * argv[]) {
+int main() {
 	checkPredicates();
 	checkGetter();
Index: tests/poly-d-cycle.cfa
===================================================================
--- tests/poly-d-cycle.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/poly-d-cycle.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -20,5 +20,5 @@
 func_table(int) an_instance = { func };
 
-int main(int argc, char * argv[]) {
+int main() {
 	object(int) x = { 0p };
 	an_instance.object_func( &x );
Index: tests/poly-member.cfa
===================================================================
--- tests/poly-member.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/poly-member.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -15,4 +15,5 @@
 		MonoCell thing1;
 		Proxy(int) & thing2 = thing1.data;
+		(void) thing2;
 	}
 
@@ -20,4 +21,5 @@
 		PolyCell(int) thing1;
 		Proxy(int) & thing2 = thing1.data;
+		(void) thing2;
 	}
 
Index: tests/poly-o-cycle.cfa
===================================================================
--- tests/poly-o-cycle.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/poly-o-cycle.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -20,5 +20,5 @@
 func_table(int) an_instance = { func };
 
-int main(int argc, char * argv[]) {
+int main() {
 	object(int) x = { 0p };
 	an_instance.object_func( &x );
Index: tests/quotedKeyword.cfa
===================================================================
--- tests/quotedKeyword.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/quotedKeyword.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -15,4 +15,6 @@
 
 #include <fstream.hfa>
+
+#pragma GCC diagnostic ignored "-Wunused-variable"
 
 static struct {
Index: tests/raii/partial.cfa
===================================================================
--- tests/raii/partial.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/raii/partial.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -12,5 +12,5 @@
     // Declaring your own empty ctor leaves an autogen dtor usable
     struct thing1 {};
-    void ?{}( thing1 & this ) {  printf( "custom ctor\n"); }
+    void ?{}( thing1 & ) {  printf( "custom ctor\n"); }
     void test1() {
         printf("test1\n");
@@ -20,6 +20,6 @@
     // Declaring your own empty ctor and dtor leaves an autogen copy ctor usable
     struct thing2 {};
-    void  ?{}( thing2 & this ) {  printf( "custom ctor\n"); }
-    void ^?{}( thing2 & this ) {  printf( "custom dtor\n"); }
+    void  ?{}( thing2 & ) {  printf( "custom ctor\n"); }
+    void ^?{}( thing2 & ) {  printf( "custom dtor\n"); }
     void test2() {
         printf("test2\n");
@@ -37,8 +37,8 @@
 
     struct thing456 {};
-    void    ?{}( thing456 & this ) {  printf( "custom ctor\n"); }
+    void    ?{}( thing456 & ) {  printf( "custom ctor\n"); }
     void    ?{}( thing456 &, thing456 ) = void;
     thing456 & ?=?( thing456 &, thing456 ) = void;
-    void   ^?{}( thing456 & this ) {  printf( "custom dtor\n"); }
+    void   ^?{}( thing456 & ) {  printf( "custom dtor\n"); }
 
     struct wrapper1 { thing456 x; };
@@ -80,5 +80,5 @@
 // Declaring your own empty ctor leaves an autogen dtor usable
 struct thing1 {};
-void ?{}( thing1 & this ) {  printf( "custom ctor\n"); }
+void ?{}( thing1 & ) {  printf( "custom ctor\n"); }
 void test1() {
     printf("test1\n");
@@ -88,6 +88,6 @@
 // Declaring your own empty ctor and dtor leaves an autogen copy ctor usable
 struct thing2 {};
-void  ?{}( thing2 & this ) {  printf( "custom ctor\n"); }
-void ^?{}( thing2 & this ) {  printf( "custom dtor\n"); }
+void  ?{}( thing2 & ) {  printf( "custom ctor\n"); }
+void ^?{}( thing2 & ) {  printf( "custom dtor\n"); }
 void test2() {
     printf("test2\n");
@@ -105,8 +105,8 @@
 
 struct thing456 {};
-void    ?{}( thing456 & this ) {  printf( "custom ctor\n"); }
+void    ?{}( thing456 & ) {  printf( "custom ctor\n"); }
 void    ?{}( thing456 &, thing456 ) = void;
 thing456 & ?=?( thing456 &, thing456 ) = void;
-void   ^?{}( thing456 & this ) {  printf( "custom dtor\n"); }
+void   ^?{}( thing456 & ) {  printf( "custom dtor\n"); }
 
 struct wrapper1 { thing456 x; };
Index: tests/result.cfa
===================================================================
--- tests/result.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/result.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -61,5 +61,5 @@
 }
 
-int main(int argc, char * argv[]) {
+int main() {
 	checkPredicates();
 	//checkNamedConstructors();
Index: tests/sizeof.cfa
===================================================================
--- tests/sizeof.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/sizeof.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -3,5 +3,5 @@
 #include <fstream.hfa>
 
-int main(int argc, char * argv[]) {
+int main() {
 	char val = 'c';
 	char & ref = val;
@@ -9,3 +9,7 @@
 	sout | "char  : " | sizeof(val) | alignof(val);
 	sout | "char &: " | sizeof(ref) | alignof(ref);
+
+	// FIX ME: work around Trac #300
+	(void) val;
+	(void) ref;
 }
Index: tests/smart-pointers.cfa
===================================================================
--- tests/smart-pointers.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/smart-pointers.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -65,5 +65,5 @@
 }
 
-int main(int argc, char * argv[]) {
+int main() {
 	counter_test();
 	unique_test();
Index: tests/tuple/tupleAssign.cfa
===================================================================
--- tests/tuple/tupleAssign.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/tuple/tupleAssign.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -48,5 +48,5 @@
 			int z;
 		} x;
-		X ?=?(X & x, double d) { return x; }
+		X ?=?(X & x, double) { return x; }
 		[int, double, int] t;
 
Index: tests/tuple/tuplePolymorphism.cfa
===================================================================
--- tests/tuple/tuplePolymorphism.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/tuple/tuplePolymorphism.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -66,4 +66,5 @@
 forall(T)
 [T, T] foo([T, T] y) {
+	(void) y;
 	[T, T] x;
 	return x;
Index: tests/tuple/tupleVariadic.cfa
===================================================================
--- tests/tuple/tupleVariadic.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/tuple/tupleVariadic.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -98,5 +98,5 @@
 }
 
-forall(T... | { void foo(T); }) void bar(T x) {}
+forall(T... | { void foo(T); }) void bar( T ) {}
 void foo(int) {}
 
@@ -126,5 +126,5 @@
 	{
 		// T = [const int] -- this ensures that void(*)(int) satisfies void(*)(const int)
-		const int x;
+		const int x = 42;
 		bar(x);
 	}
Index: tests/typeof.cfa
===================================================================
--- tests/typeof.cfa	(revision 70670e7e2966ac22d6c398e8b0ef6335d8e023f2)
+++ tests/typeof.cfa	(revision 10b5970650e2ff3d8e757dd5c91889d466e44fe0)
@@ -10,3 +10,12 @@
 	(typeof(v1)) v2; // cast with typeof
 	printf( "done\n" );				// non-empty .expect file
+
+	// FIX ME: work around Trac #300
+	(void) v1;
+	(void) v3;
+	(void) v4;
+	(void) v5;
+	(void) v6;
+	(void) v7;
+	(void) v8;
 }