Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/InitTweak/FixInit.cc	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -534,5 +534,5 @@
 			} else {
 				// expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-				unqExpr->set_object( new ObjectDecl( toString("_unq_expr_", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+				unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
 				unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
 			}
@@ -764,8 +764,17 @@
 						}
 					} else {
-						stmtsToAddAfter.push_back( ctor );
+						ImplicitCtorDtorStmt * implicit = safe_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
+						ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+						ApplicationExpr * ctorCall = nullptr;
+						if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+							// clean up intrinsic copy constructor calls by making them into SingleInits
+							objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
+							ctorCall->get_args().pop_back();
+						} else {
+							stmtsToAddAfter.push_back( ctor );
+							objDecl->set_init( NULL );
+							ctorInit->set_ctor( NULL );
+						}
 					} // if
-					objDecl->set_init( NULL );
-					ctorInit->set_ctor( NULL );
 				} else if ( Initializer * init = ctorInit->get_init() ) {
 					objDecl->set_init( init );
Index: src/Parser/ExpressionNode.cc
===================================================================
--- src/Parser/ExpressionNode.cc	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/Parser/ExpressionNode.cc	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -163,5 +163,5 @@
 ConstantExpr *build_constantStr( const std::string & str ) {
 	// string should probably be a primitive type
-	ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( emptyQualifiers, BasicType::Char ),
+	ArrayType *at = new ArrayType( emptyQualifiers, new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
 				new ConstantExpr( Constant( new BasicType( emptyQualifiers, BasicType::UnsignedInt ),
 											toString( str.size()+1-2 ) ) ),  // +1 for '\0' and -2 for '"'
Index: src/SynTree/Type.h
===================================================================
--- src/SynTree/Type.h	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/SynTree/Type.h	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -157,4 +157,5 @@
 	virtual Type * getComponent( unsigned i ) { assertf( size() == 1 && i == 0, "Type::getComponent was called with size %d and index %d\n", size(), i ); return this; }
 
+	/// return type without outer pointers and arrays
 	Type *stripDeclarator();
 
Index: src/Tuples/TupleExpansion.cc
===================================================================
--- src/Tuples/TupleExpansion.cc	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/Tuples/TupleExpansion.cc	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -194,5 +194,5 @@
 			}
 			BasicType * boolType = new BasicType( Type::Qualifiers(), BasicType::Bool );
-			ObjectDecl * finished = new ObjectDecl( toString( "_unq_expr_finished_", id ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
+			ObjectDecl * finished = new ObjectDecl( toString( "_unq", id, "_finished_" ), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new BasicType( Type::Qualifiers(), BasicType::Bool ), new SingleInit( new ConstantExpr( Constant( boolType->clone(), "0" ) ), noDesignators ) );
 			addDeclaration( finished );
 			// (finished ? _unq_expr_N : (_unq_expr_N = <unqExpr->get_expr()>, finished = 1, _unq_expr_N))
@@ -225,5 +225,5 @@
 		if ( ! typeMap.count( tupleSize ) ) {
 			// generate struct type to replace tuple type based on the number of components in the tuple
-			StructDecl * decl = new StructDecl( toString( "_tuple_type_", tupleSize  ) );
+			StructDecl * decl = new StructDecl( toString( "_tuple", tupleSize, "_" ) );
 			decl->set_body( true );
 			for ( size_t i = 0; i < tupleSize; ++i ) {
Index: src/libcfa/iostream.c
===================================================================
--- src/libcfa/iostream.c	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/libcfa/iostream.c	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -203,4 +203,5 @@
 	os | arg | ", ";
 	os | rest;
+	return os;
 } // ?|?
 
Index: src/tests/avltree/avl.h
===================================================================
--- src/tests/avltree/avl.h	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/tests/avltree/avl.h	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -61,5 +61,5 @@
 void ?{}(tree(K, V) *t, K key, V value);
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t);
 
Index: src/tests/avltree/avl1.c
===================================================================
--- src/tests/avltree/avl1.c	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/tests/avltree/avl1.c	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -12,5 +12,5 @@
 }
 
-forall(otype K | Comparable(K), otype V)
+forall(otype K, otype V)
 void ^?{}(tree(K, V) * t){
   delete(t->left);
Index: src/tests/avltree/avl_test.c
===================================================================
--- src/tests/avltree/avl_test.c	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/tests/avltree/avl_test.c	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -25,5 +25,5 @@
 
   // int -> char *
-  tree(int, char *) * smap = create(-1, "baz");
+  tree(int, const char *) * smap = create(-1, "baz");
   insert(&smap, 12, "bar");
   insert(&smap, 2, "foo");
@@ -35,17 +35,17 @@
   delete(smap);
 
-  // char* -> char*
-  struct c_str { char *str; };  // wraps a C string
-  int ?<?(c_str a, c_str b) {
-    return strcmp(a.str,b.str) < 0;
+  // const char* -> const char*
+  int ?<?(const char * a, const char * b) {
+    return strcmp(a, b) < 0;
   }
-  tree(c_str, char *) * ssmap = create((c_str){"queso"}, "cheese");
-  insert(&ssmap, (c_str){"foo"}, "bar");
-  insert(&ssmap, (c_str){"hello"}, "world");
+
+  tree(const char *, const char *) * ssmap = create("queso", "cheese");
+  insert(&ssmap, "foo", "bar");
+  insert(&ssmap, "hello", "world");
   assert( height(ssmap) == 2 );
 
-  printf("%s %s %s\n", *find(ssmap, (c_str){"hello"}), *find(ssmap, (c_str){"foo"}), *find(ssmap, (c_str){"queso"}));
+  printf("%s %s %s\n", *find(ssmap, "hello"), *find(ssmap, "foo"), *find(ssmap, "queso"));
 
-  remove(&ssmap, (c_str){"foo"});
+  remove(&ssmap, "foo");
   delete(ssmap);
 }
Index: src/tests/completeTypeError.c
===================================================================
--- src/tests/completeTypeError.c	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/tests/completeTypeError.c	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -62,5 +62,5 @@
 
 forall(dtype T | sized(T))
-void qux(T * z) {
+void quux(T * z) {
 	// okay
 	bar(z);
Index: src/tests/dtor-early-exit.c
===================================================================
--- src/tests/dtor-early-exit.c	(revision 9c313496292e447189530c6d9e91a7b120e46cc2)
+++ src/tests/dtor-early-exit.c	(revision da6d45668cc1ab6e16f1f312125f192fc673feac)
@@ -28,6 +28,6 @@
 // don't want these called
 void ?{}(A * a) { assert( false ); }
-void ?{}(A * a, char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
-void ?{}(A * a, char * name, int * ptr) { assert( false ); }
+void ?{}(A * a, const char * name) { a->name = name; sout | "construct " | name | endl; a->x = (int*)malloc(); }
+void ?{}(A * a, const char * name, int * ptr) { assert( false ); }
 
 A ?=?(A * a, A a) {  sout | "assign " | a->name | " " | a.name; return a; }