Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/InitTweak/FixInit.cc	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -393,7 +393,7 @@
 			if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
 
-			// type may involve type variables, so apply type substitution to get temporary variable's actual type.
+			// type may involve type variables, so apply type substitution to get temporary variable's actual type,
+			// since result type may not be substituted (e.g., if the type does not appear in the parameter list)
 			// Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
-			result = result->clone();
 			env->applyFree( result );
 			ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
@@ -570,11 +570,5 @@
 
 			if ( returnDecl ) {
-				UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
-				assign->get_args().push_back( new VariableExpr( returnDecl ) );
-				assign->get_args().push_back( callExpr );
-				// know the result type of the assignment is the type of the LHS (minus the pointer), so
-				// add that onto the assignment expression so that later steps have the necessary information
-				assign->set_result( returnDecl->get_type()->clone() );
-
+				ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
 				Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
 				// move env from callExpr to retExpr
@@ -1146,8 +1140,4 @@
 			assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
-			// xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-			ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
-			declsToAddBefore.push_back( tmp );
-
 			// xxx - this can be TupleAssignExpr now. Need to properly handle this case.
 			ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
@@ -1155,4 +1145,8 @@
 			ctorExpr->set_callExpr( nullptr );
 			ctorExpr->set_env( nullptr );
+
+			// xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
+			ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
+			declsToAddBefore.push_back( tmp );
 			delete ctorExpr;
 
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/InitTweak/InitTweak.cc	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -12,4 +12,5 @@
 #include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SynTree/Attribute.h"     // for Attribute
@@ -524,4 +525,23 @@
 	}
 
+	ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
+		static FunctionDecl * assign = nullptr;
+		if ( ! assign ) {
+			// temporary? Generate a fake assignment operator to represent bitwise assignments.
+			// This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
+			TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
+			assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
+		}
+		if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
+			dst = new AddressExpr( dst );
+		} else {
+			dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
+		}
+		if ( dynamic_cast< ReferenceType * >( src->result ) ) {
+			src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
+		}
+		return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
+	}
+
 	class ConstExprChecker : public Visitor {
 	public:
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/InitTweak/InitTweak.h	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -35,4 +35,7 @@
 	/// returns the first parameter of a constructor/destructor/assignment function
 	ObjectDecl * getParamThis( FunctionType * ftype );
+
+	/// generate a bitwise assignment operation.
+	ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
 
 	/// transform Initializer into an argument list that can be passed to a call expression
Index: src/ResolvExpr/PtrsAssignable.cc
===================================================================
--- src/ResolvExpr/PtrsAssignable.cc	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/ResolvExpr/PtrsAssignable.cc	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -68,9 +68,6 @@
 
 	void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
-		if ( ! dynamic_cast< FunctionType* >( dest ) ) {
-			// T * = void * is safe for any T that is not a function type.
-			// xxx - this should be unsafe...
-			result = 1;
-		} // if
+		// T * = void * is disallowed - this is a change from C, where any
+		// void * can be assigned or passed to a non-void pointer without a cast.
 	}
 
Index: src/libcfa/concurrency/kernel
===================================================================
--- src/libcfa/concurrency/kernel	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/libcfa/concurrency/kernel	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -120,5 +120,5 @@
 #ifdef __CFA_DEBUG__
 	// Last function to enable preemption on this processor
-	char * last_enable;
+	const char * last_enable;
 #endif
 };
Index: src/libcfa/concurrency/monitor.c
===================================================================
--- src/libcfa/concurrency/monitor.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/libcfa/concurrency/monitor.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -823,5 +823,5 @@
 		this.monitor_count = thrd->monitors.size;
 
-		this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+		this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
 		for( int i = 0; i < this.monitor_count; i++ ) {
 			this.monitors[i] = thrd->monitors.list[i];
Index: src/libcfa/stdhdr/stddef.h
===================================================================
--- src/libcfa/stdhdr/stddef.h	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/libcfa/stdhdr/stddef.h	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -4,7 +4,7 @@
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// stddef.h -- 
-// 
+//
+// stddef.h --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Jul  4 23:25:26 2016
@@ -12,8 +12,10 @@
 // Last Modified On : Tue Jul  5 20:40:01 2016
 // Update Count     : 12
-// 
+//
 
 extern "C" {
-#include_next <stddef.h>								// has internal check for multiple expansion
+#include_next <stddef.h>                // has internal check for multiple expansion
+#undef NULL
+#define NULL 0                          // define NULL as 0 rather than (void*)0 to take advantage of zero_t
 } // extern "C"
 
Index: src/libcfa/stdlib
===================================================================
--- src/libcfa/stdlib	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/libcfa/stdlib	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -77,5 +77,5 @@
 	//printf( "X8\n" );
 	T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );	// C malloc
-    return memset( ptr, (int)fill, sizeof(T) );			// initial with fill value
+    return (T *)memset( ptr, (int)fill, sizeof(T) );			// initial with fill value
 } // alloc
 
@@ -87,10 +87,10 @@
 	//printf( "X10\n" );
 	T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-    return memset( ptr, (int)fill, dim * sizeof(T) );
+    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
 } // alloc
 
 static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
 	//printf( "X11\n" );
-	return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+	return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
 } // alloc
 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
@@ -103,5 +103,5 @@
 	//printf( "X14\n" );
     T * ptr = (T *)memalign( align, sizeof(T) );
-    return memset( ptr, (int)fill, sizeof(T) );
+    return (T *)memset( ptr, (int)fill, sizeof(T) );
 } // align_alloc
 
@@ -113,5 +113,5 @@
 	//printf( "X16\n" );
     T * ptr = (T *)memalign( align, dim * sizeof(T) );
-    return memset( ptr, (int)fill, dim * sizeof(T) );
+    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
 } // align_alloc
 
@@ -120,10 +120,10 @@
 static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
 	//printf( "X17\n" );
-	return memset( dest, c, sizeof(T) );
+	return (T *)memset( dest, c, sizeof(T) );
 } // memset
 extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
 static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
 	//printf( "X18\n" );
-	return memcpy( dest, src, sizeof(T) );
+	return (T *)memcpy( dest, src, sizeof(T) );
 } // memcpy
 
@@ -131,9 +131,9 @@
 static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
 	//printf( "X19\n" );
-	return (void *)memset( dest, c, dim * sizeof(T) );	// C memset
+	return (T *)(void *)memset( dest, c, dim * sizeof(T) );	// C memset
 } // memset
 static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
 	//printf( "X20\n" );
-	return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
+	return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
 } // memcpy
 
Index: src/prelude/prelude.cf
===================================================================
--- src/prelude/prelude.cf	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/prelude/prelude.cf	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -403,24 +403,4 @@
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile	DT * );
 
-forall( dtype DT ) DT *			?=?(		     DT *	   &,			void * );
-forall( dtype DT ) DT *			?=?(		     DT * volatile &,			void * );
-forall( dtype DT ) const DT *		?=?( const	     DT *	   &,			void * );
-forall( dtype DT ) const DT *		?=?( const	     DT * volatile &,			void * );
-forall( dtype DT ) const DT *		?=?( const	     DT *	   &, const		void * );
-forall( dtype DT ) const DT *		?=?( const	     DT * volatile &, const		void * );
-forall( dtype DT ) volatile DT *	?=?(	   volatile  DT *	   &,			void * );
-forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile &,			void * );
-forall( dtype DT ) volatile DT *	?=?(	   volatile  DT *	   &,	    volatile	void * );
-forall( dtype DT ) volatile DT *	?=?(	   volatile  DT * volatile &,	    volatile	void * );
-
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   &,			void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile &,			void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   &, const		void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile &, const		void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   &,	    volatile	void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile &,	    volatile	void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT *	   &, const volatile	void * );
-forall( dtype DT ) const volatile DT *	?=?( const volatile  DT * volatile &, const volatile	void * );
-
 forall( dtype DT ) void *		 ?=?(		     void *	     &,			DT * );
 forall( dtype DT ) void *		 ?=?(		     void * volatile &,			DT * );
@@ -441,23 +421,4 @@
 forall( dtype DT ) const volatile void * ?=?( const volatile void *	     &, const volatile	DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile	DT * );
-
-void *			?=?(		    void *	    &,		      void * );
-void *			?=?(		    void * volatile &,		      void * );
-const void *		?=?( const	    void *	    &,		      void * );
-const void *		?=?( const	    void * volatile &,		      void * );
-const void *		?=?( const	    void *	    &, const	      void * );
-const void *		?=?( const	    void * volatile &, const	      void * );
-volatile void *		?=?(	   volatile void *	    &,		      void * );
-volatile void *		?=?(	   volatile void * volatile &,		      void * );
-volatile void *		?=?(	   volatile void *	    &,	     volatile void * );
-volatile void *		?=?(	   volatile void * volatile &,	     volatile void * );
-const volatile void *	?=?( const volatile void *	    &,		      void * );
-const volatile void *	?=?( const volatile void * volatile &,		      void * );
-const volatile void *	?=?( const volatile void *	    &, const	      void * );
-const volatile void *	?=?( const volatile void * volatile &, const	      void * );
-const volatile void *	?=?( const volatile void *	    &,	     volatile void * );
-const volatile void *	?=?( const volatile void * volatile &,	     volatile void * );
-const volatile void *	?=?( const volatile void *	    &, const volatile void * );
-const volatile void *	?=?( const volatile void * volatile &, const volatile void * );
 
 //forall( dtype DT ) DT *			?=?(		    DT *	  &, zero_t );
@@ -781,15 +742,4 @@
 forall( dtype DT ) void ?{}( const volatile  DT *	   &, const volatile	DT * );
 
-forall( dtype DT ) void ?{}(		     DT *	   &,			void * );
-forall( dtype DT ) void ?{}( const	     DT *	   &,			void * );
-forall( dtype DT ) void ?{}( const	     DT *	   &, const		void * );
-forall( dtype DT ) void ?{}(	   volatile  DT *	   &,			void * );
-forall( dtype DT ) void ?{}(	   volatile  DT *	   &,	    volatile	void * );
-
-forall( dtype DT ) void ?{}( const volatile  DT *	   &,			void * );
-forall( dtype DT ) void ?{}( const volatile  DT *	   &, const		void * );
-forall( dtype DT ) void ?{}( const volatile  DT *	   &,	    volatile	void * );
-forall( dtype DT ) void ?{}( const volatile  DT *	   &, const volatile	void * );
-
 forall( dtype DT ) void ?{}(		     void *	     &,			DT * );
 forall( dtype DT ) void ?{}( const	     void *	     &,			DT * );
@@ -802,14 +752,4 @@
 forall( dtype DT ) void ?{}( const volatile void *	     &, const volatile	DT * );
 
-void 	?{}(		    void *	    &,		      void * );
-void 	?{}( const	    void *	    &,		      void * );
-void 	?{}( const	    void *	    &, const	      void * );
-void 	?{}(	   volatile void *	    &,		      void * );
-void 	?{}(	   volatile void *	    &,	     volatile void * );
-void 	?{}( const volatile void *	    &,		      void * );
-void 	?{}( const volatile void *	    &, const	      void * );
-void 	?{}( const volatile void *	    &,	     volatile void * );
-void 	?{}( const volatile void *	    &, const volatile void * );
-
 //forall( dtype DT ) void ?{}(		    DT *	  &, zero_t );
 //forall( dtype DT ) void ?{}(		    DT * volatile &, zero_t );
Index: src/tests/.expect/alloc-ERROR.txt
===================================================================
--- src/tests/.expect/alloc-ERROR.txt	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
+++ src/tests/.expect/alloc-ERROR.txt	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -0,0 +1,44 @@
+alloc.c:259:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: ?=?
+...to: 
+  Name: p
+  Applying untyped: 
+    Name: alloc
+  ...to: 
+    Name: stp
+    Applying untyped: 
+      Name: ?*?
+    ...to: 
+      Name: dim
+      Sizeof Expression on: Applying untyped: 
+          Name: *?
+        ...to: 
+          Name: stp
+
+
+
+
+alloc.c:260:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: ?=?
+...to: 
+  Name: p
+  Applying untyped: 
+    Name: memset
+  ...to: 
+    Name: stp
+    constant expression (10 10: signed int)
+
+
+alloc.c:261:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: ?=?
+...to: 
+  Name: p
+  Applying untyped: 
+    Name: memcpy
+  ...to: 
+    Address of:
+      Name: st1
+    Address of:
+      Name: st
+
+
Index: src/tests/.expect/completeTypeError.txt
===================================================================
--- src/tests/.expect/completeTypeError.txt	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/.expect/completeTypeError.txt	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -1,7 +1,16 @@
-completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped: 
+completeTypeError.c:33:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: *?
 ...to: 
   Name: v
 
+completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: *?
+...to: 
+  Name: y
+
+completeTypeError.c:35:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: foo
+...to: 
+  Name: v
 
 completeTypeError.c:36:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -10,10 +19,8 @@
   Name: v
 
-
 completeTypeError.c:37:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: quux
 ...to: 
   Name: v
-
 
 completeTypeError.c:58:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -22,10 +29,8 @@
   Name: y
 
-
 completeTypeError.c:59:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: quux
 ...to: 
   Name: y
-
 
 completeTypeError.c:60:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -34,5 +39,4 @@
   Name: y
 
-
 completeTypeError.c:72:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: baz
@@ -40,3 +44,2 @@
   Name: z
 
-
Index: src/tests/Makefile.am
===================================================================
--- src/tests/Makefile.am	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/Makefile.am	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -141,2 +141,5 @@
 typedefRedef-ERR1: typedefRedef.c @CFA_BINDIR@/@CFA_NAME@
 	${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
+	${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
Index: src/tests/Makefile.in
===================================================================
--- src/tests/Makefile.in	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/Makefile.in	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -895,4 +895,7 @@
 	${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 
+alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
+	${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.
Index: src/tests/alloc.c
===================================================================
--- src/tests/alloc.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/alloc.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -32,5 +32,5 @@
 	// allocation, non-array types
 
-	p = (void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
+	p = (int *)(void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
 	*p = 0xdeadbeef;
 	printf( "C   malloc %#x\n", *p );
@@ -54,5 +54,5 @@
 	printf( "\n" );
 
-	p = calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
+	p = (int *)calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
 	printf( "C   array calloc, fill 0\n" );
 	for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
@@ -83,5 +83,5 @@
 	printf( "\n" );
 
-	p = (void *)realloc( p, dim * sizeof(*p) );         // C realloc
+	p = (int *)(void *)realloc( p, dim * sizeof(*p) );         // C realloc
 	for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
 	printf( "C   realloc\n" );
@@ -256,7 +256,9 @@
 	stp = malloc();
 	printf( "\nSHOULD FAIL\n" );
+#ifdef ERR1
 	p = alloc( stp, dim * sizeof(*stp) );
 	p = memset( stp, 10 );
 	p = memcpy( &st1, &st );
+#endif
 } // main
 
Index: src/tests/completeTypeError.c
===================================================================
--- src/tests/completeTypeError.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/completeTypeError.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -12,13 +12,13 @@
 	void *v;
 
-	// A * x;
-	// A * y;
-	// B * x;
-	// B * z;
+	A * x;
+	A * y;
+	B * x;
+	B * z;
 
 	// okay
 	*i;
-	// *x; // picks B
-	// *z;
+	*x; // picks B
+	*z;
 	foo(i);
 	bar(i);
@@ -29,9 +29,9 @@
 	bar(v);
 	qux(v);
-	foo(v); // questionable, but works at the moment for C compatibility
 
 	// bad
 	*v;
-	// *y;
+	*y;
+	foo(v);
 	baz(v);
 	quux(v);
Index: src/tests/dtor-early-exit.c
===================================================================
--- src/tests/dtor-early-exit.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/dtor-early-exit.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -22,5 +22,5 @@
 
 struct A {
-	char * name;
+	const char * name;
 	int * x;
 };
Index: src/tests/init_once.c
===================================================================
--- src/tests/init_once.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/init_once.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -72,5 +72,5 @@
 	insert( &constructed, &x );
 
-	x.x = malloc(sizeof(int));
+	x.x = (int *)malloc(sizeof(int));
 }
 
Index: src/tests/multiDimension.c
===================================================================
--- src/tests/multiDimension.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/multiDimension.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -7,5 +7,5 @@
   printf("default constructing\n");
   (this.a){ 123 };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 
@@ -13,5 +13,5 @@
   printf("copy constructing\n");
   (this.a){ other.a };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 
@@ -19,5 +19,5 @@
   printf("constructing with %d\n", a);
   (this.a){ a };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 
Index: src/tests/tupleVariadic.c
===================================================================
--- src/tests/tupleVariadic.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/tupleVariadic.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -73,5 +73,5 @@
 	[a0, a1, a2, a3] = args;
 	a.size = 4;
-	a.data = malloc(sizeof(int)*a.size);
+	a.data = (int *)malloc(sizeof(int)*a.size);
 	a.data[0] = a0;
 	a.data[1] = a1;
Index: src/tests/vector/vector_int.c
===================================================================
--- src/tests/vector/vector_int.c	(revision f203a7a1eb56be0df147abdb42ec52c9a2c51be4)
+++ src/tests/vector/vector_int.c	(revision 1ba5803c90674cf77489dd4409a2afd3b782551e)
@@ -27,5 +27,5 @@
 	vec.last = -1;
 	vec.capacity = reserve;
-	vec.data = malloc( sizeof( int ) * reserve );
+	vec.data = (int *)malloc( sizeof( int ) * reserve );
 }
 
@@ -33,5 +33,5 @@
 	vec.last = other.last;
 	vec.capacity = other.capacity;
-	vec.data = malloc( sizeof( int ) * other.capacity );
+	vec.data = (int *)malloc( sizeof( int ) * other.capacity );
 	for (int i = 0; i < vec.last; i++) {
 		vec.data[i] = other.data[i];
@@ -45,5 +45,5 @@
 void reserve( vector_int *vec, int reserve ) {
 	if ( reserve > vec->capacity ) {
-		vec->data = realloc( vec->data, sizeof( int ) * reserve );
+		vec->data = (int *)realloc( vec->data, sizeof( int ) * reserve );
 		vec->capacity = reserve;
 	}
@@ -54,5 +54,5 @@
 	if ( vec->last == vec->capacity ) {
 		vec->capacity *= 2;
-		vec->data = realloc( vec->data, sizeof( int ) * vec->capacity );
+		vec->data = (int *)realloc( vec->data, sizeof( int ) * vec->capacity );
 	}
 	vec->data[ vec->last ] = element;