Index: src/CodeGen/CodeGenerator.cc
===================================================================
--- src/CodeGen/CodeGenerator.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/CodeGen/CodeGenerator.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -443,11 +443,11 @@
 	void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
 		extension( untypedExpr );
-		if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
+		if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
 			OperatorInfo opInfo;
-			if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
-				std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
+			if ( operatorLookup( nameExpr->name, opInfo ) ) {
+				std::list< Expression* >::iterator arg = untypedExpr->args.begin();
 				switch ( opInfo.type ) {
 				  case OT_INDEX:
-					assert( untypedExpr->get_args().size() == 2 );
+					assert( untypedExpr->args.size() == 2 );
 					(*arg++)->accept( *visitor );
 					output << "[";
@@ -461,5 +461,5 @@
 				  case OT_CTOR:
 				  case OT_DTOR:
-					if ( untypedExpr->get_args().size() == 1 ) {
+					if ( untypedExpr->args.size() == 1 ) {
 						// the expression fed into a single parameter constructor or destructor may contain side
 						// effects, so must still output this expression
@@ -480,5 +480,5 @@
 						(*arg++)->accept( *visitor );
 						output << opInfo.symbol << "{ ";
-						genCommaList( arg, untypedExpr->get_args().end() );
+						genCommaList( arg, untypedExpr->args.end() );
 						output << "}) /* " << opInfo.inputName << " */";
 					} // if
@@ -488,5 +488,5 @@
 				  case OT_PREFIXASSIGN:
 				  case OT_LABELADDRESS:
-					assert( untypedExpr->get_args().size() == 1 );
+					assert( untypedExpr->args.size() == 1 );
 					output << "(";
 					output << opInfo.symbol;
@@ -497,5 +497,5 @@
 				  case OT_POSTFIX:
 				  case OT_POSTFIXASSIGN:
-					assert( untypedExpr->get_args().size() == 1 );
+					assert( untypedExpr->args.size() == 1 );
 					(*arg)->accept( *visitor );
 					output << opInfo.symbol;
@@ -504,5 +504,5 @@
 				  case OT_INFIX:
 				  case OT_INFIXASSIGN:
-					assert( untypedExpr->get_args().size() == 2 );
+					assert( untypedExpr->args.size() == 2 );
 					output << "(";
 					(*arg++)->accept( *visitor );
@@ -517,20 +517,14 @@
 				} // switch
 			} else {
-				if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
-					assert( untypedExpr->get_args().size() == 2 );
-					(*untypedExpr->get_args().begin())->accept( *visitor );
-					output << " ... ";
-					(*--untypedExpr->get_args().end())->accept( *visitor );
-				} else {								// builtin routines
-					nameExpr->accept( *visitor );
-					output << "(";
-					genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
-					output << ")";
-				} // if
+				// builtin routines
+				nameExpr->accept( *visitor );
+				output << "(";
+				genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
+				output << ")";
 			} // if
 		} else {
-			untypedExpr->get_function()->accept( *visitor );
+			untypedExpr->function->accept( *visitor );
 			output << "(";
-			genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+			genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
 			output << ")";
 		} // if
@@ -538,7 +532,7 @@
 
 	void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
-		rangeExpr->get_low()->accept( *visitor );
+		rangeExpr->low->accept( *visitor );
 		output << " ... ";
-		rangeExpr->get_high()->accept( *visitor );
+		rangeExpr->high->accept( *visitor );
 	}
 
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/InitTweak/FixInit.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -58,5 +58,4 @@
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
-#include "Tuples/Tuples.h"             // for isTtype
 
 bool ctordtorp = false; // print all debug
@@ -339,5 +338,5 @@
 				} else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
 					FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
-					assert( ftype );
+					assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
 					if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
 						Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
@@ -368,7 +367,5 @@
 		}
 
-		bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
-			return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
-		}
+		bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
 
 		Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
@@ -819,7 +816,9 @@
 					assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
 					Statement * dtor = ctorInit->get_dtor();
+					// don't need to call intrinsic dtor, because it does nothing, but
+					// non-intrinsic dtors must be called
 					if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
-						// don't need to call intrinsic dtor, because it does nothing, but
-						// non-intrinsic dtors must be called
+						// set dtor location to the object's location for error messages
+						ctorInit->dtor->location = objDecl->location;
 						reverseDeclOrder.front().push_front( objDecl );
 					} // if
@@ -1012,4 +1011,6 @@
 					// skip non-DWT members
 					if ( ! field ) continue;
+					// skip non-constructable members
+					if ( ! tryConstruct( field ) ) continue;
 					// skip handled members
 					if ( ! unhandled.count( field ) ) continue;
Index: src/InitTweak/GenInit.cc
===================================================================
--- src/InitTweak/GenInit.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/InitTweak/GenInit.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -62,5 +62,5 @@
 	};
 
-	struct CtorDtor : public WithGuards, public WithShortCircuiting  {
+	struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
 		/// create constructor and destructor statements for object declarations.
 		/// the actual call statements will be added in after the resolver has run
@@ -75,10 +75,7 @@
 		// that need to be constructed or destructed
 		void previsit( StructDecl *aggregateDecl );
-		void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
-		void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
-		void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
-		void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
-		void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
-		void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
+		void previsit( AggregateDecl * ) { visit_children = false; }
+		void previsit( NamedTypeDecl * ) { visit_children = false; }
+		void previsit( FunctionType * ) { visit_children = false; }
 
 		void previsit( CompoundStmt * compoundStmt );
@@ -96,8 +93,5 @@
 	};
 
-	class HoistArrayDimension final : public GenPoly::DeclMutator {
-	  public:
-		typedef GenPoly::DeclMutator Parent;
-
+	struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
 		/// hoist dimension from array types in object declaration so that it uses a single
 		/// const variable of type size_t, so that side effecting array dimensions are only
@@ -105,19 +99,12 @@
 		static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
 
-	  private:
-		using Parent::mutate;
-
-		virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
-		virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+		void premutate( ObjectDecl * objectDecl );
+		DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+		void premutate( FunctionDecl *functionDecl );
 		// should not traverse into any of these declarations to find objects
 		// that need to be constructed or destructed
-		virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
-		virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
-		virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
-		virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
-		virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
-		virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
-
-		virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
+		void premutate( AggregateDecl * ) { visit_children = false; }
+		void premutate( NamedTypeDecl * ) { visit_children = false; }
+		void premutate( FunctionType * ) { visit_children = false; }
 
 		void hoist( Type * type );
@@ -128,10 +115,10 @@
 
 	void genInit( std::list< Declaration * > & translationUnit ) {
-		ReturnFixer::makeReturnTemp( translationUnit );
+		fixReturnStatements( translationUnit );
 		HoistArrayDimension::hoistArrayDimension( translationUnit );
 		CtorDtor::generateCtorDtor( translationUnit );
 	}
 
-	void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
+	void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
 		PassVisitor<ReturnFixer> fixer;
 		mutateAll( translationUnit, fixer );
@@ -143,5 +130,5 @@
 		// hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
 		// is being returned
-		if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
+		if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
 			// explicitly construct the return value using the return expression and the retVal object
 			assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
@@ -158,6 +145,6 @@
 		GuardValue( funcName );
 
-		ftype = functionDecl->get_functionType();
-		funcName = functionDecl->get_name();
+		ftype = functionDecl->type;
+		funcName = functionDecl->name;
 	}
 
@@ -165,13 +152,16 @@
 	// which would be incorrect if it is a side-effecting computation.
 	void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-		HoistArrayDimension hoister;
-		hoister.mutateDeclarationList( translationUnit );
-	}
-
-	DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+		PassVisitor<HoistArrayDimension> hoister;
+		mutateAll( translationUnit, hoister );
+	}
+
+	void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
+		GuardValue( storageClasses );
 		storageClasses = objectDecl->get_storageClasses();
-		DeclarationWithType * temp = Parent::mutate( objectDecl );
+	}
+
+	DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
 		hoist( objectDecl->get_type() );
-		return temp;
+		return objectDecl;
 	}
 
@@ -194,5 +184,5 @@
 
 			arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-			addDeclaration( arrayDimension );
+			declsToAddBefore.push_back( arrayDimension );
 
 			hoist( arrayType->get_base() );
@@ -201,9 +191,6 @@
 	}
 
-	DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-		ValueGuard< bool > oldInFunc( inFunction );
-		inFunction = true;
-		DeclarationWithType * decl = Parent::mutate( functionDecl );
-		return decl;
+	void HoistArrayDimension::premutate( FunctionDecl * ) {
+		GuardValue( inFunction );
 	}
 
@@ -214,5 +201,5 @@
 
 	bool CtorDtor::isManaged( Type * type ) const {
-		// at least for now, references are never constructed
+		// references are never constructed
 		if ( dynamic_cast< ReferenceType * >( type ) ) return false;
 		// need to clear and reset qualifiers when determining if a type is managed
@@ -221,5 +208,5 @@
 		if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
 			// tuple is also managed if any of its components are managed
-			if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
+			if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
 				return true;
 			}
@@ -305,4 +292,5 @@
 
 	void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+		visit_children = false;  // do not try and construct parameters or forall parameters
 		GuardValue( inFunction );
 		inFunction = true;
@@ -318,8 +306,5 @@
 		}
 
-		PassVisitor<CtorDtor> newCtorDtor;
-		newCtorDtor.pass = *this;
-		maybeAccept( functionDecl->get_statements(), newCtorDtor );
-		visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+		maybeAccept( functionDecl->get_statements(), *visitor );
 	}
 
@@ -340,5 +325,5 @@
 	}
 
-	void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
+	void CtorDtor::previsit( CompoundStmt * ) {
 		GuardScope( managedTypes );
 	}
Index: src/InitTweak/GenInit.h
===================================================================
--- src/InitTweak/GenInit.h	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/InitTweak/GenInit.h	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -25,6 +25,9 @@
 	void genInit( std::list< Declaration * > & translationUnit );
 
-  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
-  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+	/// Converts return statements into copy constructor calls on the hidden return variable
+	void fixReturnStatements( std::list< Declaration * > & translationUnit );
+
+	/// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+	ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
 
 	/// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/InitTweak/InitTweak.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -1,3 +1,2 @@
-#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
@@ -23,4 +22,5 @@
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
+#include "Tuples/Tuples.h"         // for Tuples::isTtype
 
 class UntypedValofExpr;
@@ -184,5 +184,5 @@
 			callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-			*out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+			*out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
 
 			UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
@@ -250,18 +250,18 @@
 	// To accomplish this, generate switch statement, consuming all of expander's elements
 	Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
-		if ( ! init ) return NULL;
+		if ( ! init ) return nullptr;
 		CompoundStmt * block = new CompoundStmt( noLabels );
 		build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
 		if ( block->get_kids().empty() ) {
 			delete block;
-			return NULL;
+			return nullptr;
 		} else {
-			init = NULL; // init was consumed in creating the list init
+			init = nullptr; // init was consumed in creating the list init
 			return block;
 		}
 	}
 
-	Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
-		return NULL;
+	Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+		return nullptr;
 	}
 
@@ -270,9 +270,16 @@
 	}
 
-	bool tryConstruct( ObjectDecl * objDecl ) {
+	bool tryConstruct( DeclarationWithType * dwt ) {
+		ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
+		if ( ! objDecl ) return false;
 		return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
-			(objDecl->get_init() == NULL ||
-				( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
-			&& ! objDecl->get_storageClasses().is_extern;
+			(objDecl->get_init() == nullptr ||
+				( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
+			&& ! objDecl->get_storageClasses().is_extern
+			&& isConstructable( objDecl->type );
+	}
+
+	bool isConstructable( Type * type ) {
+		return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
 	}
 
@@ -314,5 +321,5 @@
 		collectCtorDtorCalls( stmt, matches );
 		assert( matches.size() <= 1 );
-		return matches.size() == 1 ? matches.front() : NULL;
+		return matches.size() == 1 ? matches.front() : nullptr;
 	}
 
@@ -359,10 +366,10 @@
 	ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
 		ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
-		if ( ! appExpr ) return NULL;
+		if ( ! appExpr ) return nullptr;
 		DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
 		assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
 		// check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
 		// will call all member dtors, and some members may have a user defined dtor.
-		return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
+		return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
 	}
 
@@ -482,5 +489,5 @@
 			return refType->get_base();
 		} else {
-			return NULL;
+			return nullptr;
 		}
 	}
@@ -488,5 +495,5 @@
 	Type * isPointerType( Type * type ) {
 		if ( getPointerBase( type ) ) return type;
-		else return NULL;
+		else return nullptr;
 	}
 
Index: src/InitTweak/InitTweak.h
===================================================================
--- src/InitTweak/InitTweak.h	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/InitTweak/InitTweak.h	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -33,6 +33,9 @@
 	std::list< Expression * > makeInitList( Initializer * init );
 
-	/// True if the resolver should try to construct objDecl
-	bool tryConstruct( ObjectDecl * objDecl );
+	/// True if the resolver should try to construct dwt
+	bool tryConstruct( DeclarationWithType * dwt );
+
+	/// True if the type can have a user-defined constructor
+	bool isConstructable( Type * t );
 
 	/// True if the Initializer contains designations
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/ResolvExpr/Resolver.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -95,4 +95,9 @@
 		PassVisitor<Resolver> resolver;
 		acceptAll( translationUnit, resolver );
+	}
+
+	void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+		PassVisitor<Resolver> resolver( indexer );
+		maybeAccept( decl, resolver );
 	}
 
Index: src/ResolvExpr/Resolver.h
===================================================================
--- src/ResolvExpr/Resolver.h	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/ResolvExpr/Resolver.h	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -29,6 +29,7 @@
 	/// Checks types and binds syntactic constructs to typed representations
 	void resolve( std::list< Declaration * > translationUnit );
-	Expression * resolveInVoidContext( Expression *expr   , const SymTab::Indexer &indexer );
-	Expression * findVoidExpression  ( Expression *untyped, const SymTab::Indexer &indexer );
+	void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
+	Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
+	Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
 	Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
 	void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
Index: src/ResolvExpr/TypeEnvironment.cc
===================================================================
--- src/ResolvExpr/TypeEnvironment.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/ResolvExpr/TypeEnvironment.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -123,13 +123,13 @@
 		for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
 			for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
-///       std::cout << "adding " << *theVar;
+///       std::cerr << "adding " << *theVar;
 				if ( theClass->type ) {
-///         std::cout << " bound to ";
-///         theClass->type->print( std::cout );
-///         std::cout << std::endl;
+///         std::cerr << " bound to ";
+///         theClass->type->print( std::cerr );
+///         std::cerr << std::endl;
 					sub.add( *theVar, theClass->type );
 				} else if ( theVar != theClass->vars.begin() ) {
 					TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
-///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
+///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
 					sub.add( *theVar, newTypeInst );
 					delete newTypeInst;
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/Autogen.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -16,5 +16,4 @@
 #include "Autogen.h"
 
-#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
@@ -27,8 +26,11 @@
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
+#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
 #include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
+#include "InitTweak/GenInit.h"     // for fixReturnStatements
+#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
@@ -53,35 +55,21 @@
 	};
 
-	class AutogenerateRoutines final : public Visitor {
-	    template< typename Visitor >
-	    friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
-	    template< typename Visitor >
-	    friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
-	  public:
-		std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
-
-		typedef Visitor Parent;
-		using Parent::visit;
-
+	struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
 		AutogenerateRoutines();
 
-		virtual void visit( EnumDecl *enumDecl );
-		virtual void visit( StructDecl *structDecl );
-		virtual void visit( UnionDecl *structDecl );
-		virtual void visit( TypeDecl *typeDecl );
-		virtual void visit( TraitDecl *ctxDecl );
-		virtual void visit( FunctionDecl *functionDecl );
-
-		virtual void visit( FunctionType *ftype );
-		virtual void visit( PointerType *ftype );
-
-		virtual void visit( CompoundStmt *compoundStmt );
-		virtual void visit( SwitchStmt *switchStmt );
+		void previsit( EnumDecl * enumDecl );
+		void previsit( StructDecl * structDecl );
+		void previsit( UnionDecl * structDecl );
+		void previsit( TypeDecl * typeDecl );
+		void previsit( TraitDecl * traitDecl );
+		void previsit( FunctionDecl * functionDecl );
+
+		void previsit( FunctionType * ftype );
+		void previsit( PointerType * ptype );
+
+		void previsit( CompoundStmt * compoundStmt );
 
 	  private:
-		template< typename StmtClass > void visitStatement( StmtClass *stmt );
-
-		std::list< Declaration * > declsToAdd, declsToAddAfter;
-		std::set< std::string > structsDone;
+		GenPoly::ScopedSet< std::string > structsDone;
 		unsigned int functionNesting = 0;     // current level of nested functions
 		/// Note: the following maps could be ScopedSets, but it should be easier to work
@@ -112,6 +100,6 @@
 
 	void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-		AutogenerateRoutines generator;
-		acceptAndAdd( translationUnit, generator );
+		PassVisitor<AutogenerateRoutines> generator;
+		acceptAll( translationUnit, generator );
 
 		// needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
@@ -121,5 +109,5 @@
 
 	bool isUnnamedBitfield( ObjectDecl * obj ) {
-		return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
+		return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
 	}
 
@@ -128,5 +116,5 @@
 		FunctionDecl * decl = functionDecl->clone();
 		delete decl->get_statements();
-		decl->set_statements( NULL );
+		decl->set_statements( nullptr );
 		declsToAdd.push_back( decl );
 		decl->fixUniqueId();
@@ -339,5 +327,5 @@
 				assert( ! func->get_functionType()->get_parameters().empty() );
 				ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
-				ObjectDecl * srcParam = NULL;
+				ObjectDecl * srcParam = nullptr;
 				if ( func->get_functionType()->get_parameters().size() == 2 ) {
 					srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
@@ -346,5 +334,5 @@
 				assert( dstParam );
 
-				Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
+				Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
 				makeStructMemberOp( dstParam, srcselect, field, func, forward );
 			} // if
@@ -385,5 +373,5 @@
 				} else {
 					// no matching parameter, initialize field with default ctor
-					makeStructMemberOp( dstParam, NULL, field, func );
+					makeStructMemberOp( dstParam, nullptr, field, func );
 				}
 			}
@@ -401,11 +389,10 @@
 	void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
 		// Builtins do not use autogeneration.
-		if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
-			 aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
+		if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
 			return;
 		}
 
 		// Make function polymorphic in same parameters as generic struct, if applicable
-		const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+		const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
 
 		// generate each of the functions based on the supplied FuncData objects
@@ -572,11 +559,12 @@
 		// the order here determines the order that these functions are generated.
 		// assignment should come last since it uses copy constructor in return.
-		data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
-		data.push_back( FuncData( "?{}", genCopyType, copyable ) );
-		data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
-		data.push_back( FuncData( "?=?", genAssignType, assignable ) );
-	}
-
-	void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
+		data.emplace_back( "?{}", genDefaultType, constructable );
+		data.emplace_back( "?{}", genCopyType, copyable );
+		data.emplace_back( "^?{}", genDefaultType, destructable );
+		data.emplace_back( "?=?", genAssignType, assignable );
+	}
+
+	void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
+		visit_children = false;
 		if ( ! enumDecl->get_members().empty() ) {
 			EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -586,19 +574,21 @@
 	}
 
-	void AutogenerateRoutines::visit( StructDecl *structDecl ) {
-		if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
-			StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
-			for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
+	void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
+		visit_children = false;
+		if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
+			StructInstType structInst( Type::Qualifiers(), structDecl->name );
+			for ( TypeDecl * typeDecl : structDecl->parameters ) {
 				// need to visit assertions so that they are added to the appropriate maps
-				acceptAll( typeDecl->get_assertions(), *this );
-				structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
+				acceptAll( typeDecl->assertions, *visitor );
+				structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
 			}
 			structInst.set_baseStruct( structDecl );
 			makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
-			structsDone.insert( structDecl->get_name() );
+			structsDone.insert( structDecl->name );
 		} // if
 	}
 
-	void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
+	void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
+		visit_children = false;
 		if ( ! unionDecl->get_members().empty() ) {
 			UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
@@ -619,5 +609,6 @@
 
 	// generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
-	void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
+	void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+		visit_children = false;
 		if ( ! typeDecl->base ) return;
 
@@ -664,31 +655,21 @@
 	}
 
-	void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
-		for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
-			statements.insert( i, new DeclStmt( noLabels, *decl ) );
-		} // for
-		declsToAdd.clear();
-	}
-
-	void AutogenerateRoutines::visit( FunctionType *) {
+	void AutogenerateRoutines::previsit( FunctionType *) {
 		// ensure that we don't add assignment ops for types defined as part of the function
-	}
-
-	void AutogenerateRoutines::visit( PointerType *) {
+		visit_children = false;
+	}
+
+	void AutogenerateRoutines::previsit( PointerType *) {
 		// ensure that we don't add assignment ops for types defined as part of the pointer
-	}
-
-	void AutogenerateRoutines::visit( TraitDecl *) {
+		visit_children = false;
+	}
+
+	void AutogenerateRoutines::previsit( TraitDecl * ) {
 		// ensure that we don't add assignment ops for types defined as part of the trait
-	}
-
-	template< typename StmtClass >
-	inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
-		std::set< std::string > oldStructs = structsDone;
-		addVisit( stmt, *this );
-		structsDone = oldStructs;
-	}
-
-	void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
+		visit_children = false;
+	}
+
+	void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+		visit_children = false;
 		// record the existence of this function as appropriate
 		insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
@@ -697,24 +678,16 @@
 		insert( functionDecl, destructable, InitTweak::isDestructor );
 
-		maybeAccept( functionDecl->get_functionType(), *this );
+		maybeAccept( functionDecl->type, *visitor );
 		functionNesting += 1;
-		maybeAccept( functionDecl->get_statements(), *this );
+		maybeAccept( functionDecl->statements, *visitor );
 		functionNesting -= 1;
 	}
 
-	void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
-		constructable.beginScope();
-		assignable.beginScope();
-		copyable.beginScope();
-		destructable.beginScope();
-		visitStatement( compoundStmt );
-		constructable.endScope();
-		assignable.endScope();
-		copyable.endScope();
-		destructable.endScope();
-	}
-
-	void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
-		visitStatement( switchStmt );
+	void AutogenerateRoutines::previsit( CompoundStmt * ) {
+		GuardScope( constructable );
+		GuardScope( assignable );
+		GuardScope( copyable );
+		GuardScope( destructable );
+		GuardScope( structsDone );
 	}
 
Index: src/SymTab/FixFunction.cc
===================================================================
--- src/SymTab/FixFunction.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/FixFunction.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -27,8 +27,8 @@
 
 	DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
+		// can't delete function type because it may contain assertions, so transfer ownership to new object
 		ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
 		functionDecl->get_attributes().clear();
-		// can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
-		functionDecl->set_type( functionDecl->get_type()->clone() );
+		functionDecl->type = nullptr;
 		delete functionDecl;
 		return pointer;
Index: src/SymTab/Indexer.cc
===================================================================
--- src/SymTab/Indexer.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/Indexer.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -40,17 +40,4 @@
 
 namespace SymTab {
-	struct NewScope {
-		NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
-		~NewScope() { indexer.leaveScope(); }
-		SymTab::Indexer & indexer;
-	};
-
-	template< typename TreeType, typename VisitorType >
-	inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
-		visitor.enterScope();
-		maybeAccept( tree, visitor );
-		visitor.leaveScope();
-	}
-
 	typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
 	typedef std::unordered_map< std::string, MangleTable > IdTable;
@@ -198,9 +185,9 @@
 	}
 
-	Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
-
-	Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
-
-	Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
+	Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
+
+	Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
+
+	Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
 		that.tables = 0;
 	}
Index: src/SymTab/Indexer.h
===================================================================
--- src/SymTab/Indexer.h	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/Indexer.h	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -26,5 +26,5 @@
 	class Indexer {
 	  public:
-		explicit Indexer( bool useDebug = false );
+		explicit Indexer();
 
 		Indexer( const Indexer &that );
@@ -76,4 +76,5 @@
 		void addTrait( TraitDecl *decl );
 
+		bool doDebug = false; ///< Display debugging trace?
 	  private:
 		struct Impl;
@@ -81,5 +82,4 @@
 		Impl *tables;         ///< Copy-on-write instance of table data structure
 		unsigned long scope;  ///< Scope index of this pointer
-		bool doDebug;         ///< Display debugging trace?
 
 		/// Takes a new ref to a table (returns null if null)
Index: src/SymTab/Mangler.cc
===================================================================
--- src/SymTab/Mangler.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/Mangler.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -31,5 +31,5 @@
 
 namespace SymTab {
-	std::string Mangler::mangleType( Type *ty ) {
+	std::string Mangler::mangleType( Type * ty ) {
 		Mangler mangler( false, true );
 		maybeAccept( ty, mangler );
@@ -48,5 +48,5 @@
 	}
 
-	void Mangler::mangleDecl( DeclarationWithType *declaration ) {
+	void Mangler::mangleDecl( DeclarationWithType * declaration ) {
 		bool wasTopLevel = isTopLevel;
 		if ( isTopLevel ) {
@@ -79,18 +79,18 @@
 	}
 
-	void Mangler::visit( ObjectDecl *declaration ) {
+	void Mangler::visit( ObjectDecl * declaration ) {
 		mangleDecl( declaration );
 	}
 
-	void Mangler::visit( FunctionDecl *declaration ) {
+	void Mangler::visit( FunctionDecl * declaration ) {
 		mangleDecl( declaration );
 	}
 
-	void Mangler::visit( VoidType *voidType ) {
+	void Mangler::visit( VoidType * voidType ) {
 		printQualifiers( voidType );
 		mangleName << "v";
 	}
 
-	void Mangler::visit( BasicType *basicType ) {
+	void Mangler::visit( BasicType * basicType ) {
 		static const char *btLetter[] = {
 			"b",	// Bool
@@ -121,5 +121,5 @@
 	}
 
-	void Mangler::visit( PointerType *pointerType ) {
+	void Mangler::visit( PointerType * pointerType ) {
 		printQualifiers( pointerType );
 		mangleName << "P";
@@ -127,5 +127,5 @@
 	}
 
-	void Mangler::visit( ArrayType *arrayType ) {
+	void Mangler::visit( ArrayType * arrayType ) {
 		// TODO: encode dimension
 		printQualifiers( arrayType );
@@ -134,5 +134,5 @@
 	}
 
-	void Mangler::visit( ReferenceType *refType ) {
+	void Mangler::visit( ReferenceType * refType ) {
 		printQualifiers( refType );
 		mangleName << "R";
@@ -149,5 +149,5 @@
 	}
 
-	void Mangler::visit( FunctionType *functionType ) {
+	void Mangler::visit( FunctionType * functionType ) {
 		printQualifiers( functionType );
 		mangleName << "F";
@@ -160,5 +160,5 @@
 	}
 
-	void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
+	void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
 		printQualifiers( refType );
 
@@ -166,5 +166,5 @@
 	}
 
-	void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
+	void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
 		printQualifiers( refType );
 
@@ -189,19 +189,19 @@
 	}
 
-	void Mangler::visit( StructInstType *aggregateUseType ) {
+	void Mangler::visit( StructInstType * aggregateUseType ) {
 		if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
 		else mangleRef( aggregateUseType, "s" );
 	}
 
-	void Mangler::visit( UnionInstType *aggregateUseType ) {
+	void Mangler::visit( UnionInstType * aggregateUseType ) {
 		if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
 		else mangleRef( aggregateUseType, "u" );
 	}
 
-	void Mangler::visit( EnumInstType *aggregateUseType ) {
+	void Mangler::visit( EnumInstType * aggregateUseType ) {
 		mangleRef( aggregateUseType, "e" );
 	}
 
-	void Mangler::visit( TypeInstType *typeInst ) {
+	void Mangler::visit( TypeInstType * typeInst ) {
 		VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
 		if ( varNum == varNums.end() ) {
@@ -231,27 +231,27 @@
 	}
 
-	void Mangler::visit( TupleType *tupleType ) {
+	void Mangler::visit( TupleType * tupleType ) {
 		printQualifiers( tupleType );
 		mangleName << "T";
-		acceptAll( tupleType->get_types(), *this );
+		acceptAll( tupleType->types, *this );
 		mangleName << "_";
 	}
 
-	void Mangler::visit( VarArgsType *varArgsType ) {
+	void Mangler::visit( VarArgsType * varArgsType ) {
 		printQualifiers( varArgsType );
 		mangleName << "VARGS";
 	}
 
-	void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
+	void Mangler::visit( ZeroType * ) {
 		mangleName << "Z";
 	}
 
-	void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
+	void Mangler::visit( OneType * ) {
 		mangleName << "O";
 	}
 
-	void Mangler::visit( TypeDecl *decl ) {
+	void Mangler::visit( TypeDecl * decl ) {
 		static const char *typePrefix[] = { "BT", "BD", "BF" };
-		mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
+		mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
 	}
 
@@ -262,5 +262,5 @@
 	}
 
-	void Mangler::printQualifiers( Type *type ) {
+	void Mangler::printQualifiers( Type * type ) {
 		// skip if not including qualifiers
 		if ( typeMode ) return;
@@ -270,5 +270,5 @@
 			int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
 			mangleName << "A";
-			for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+			for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
 				switch ( (*i)->get_kind() ) {
 				  case TypeDecl::Any:
@@ -287,6 +287,6 @@
 					assert( false );
 				} // switch
-				varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
-				for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
+				varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+				for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
 					Mangler sub_mangler( mangleOverridable, typeMode );
 					sub_mangler.nextVarNum = nextVarNum;
@@ -315,6 +315,7 @@
 //		} // if
 		if ( type->get_lvalue() ) {
+			// mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
 			mangleName << "L";
-		} // if
+		}
 		if ( type->get_atomic() ) {
 			mangleName << "A";
Index: src/SymTab/Validate.cc
===================================================================
--- src/SymTab/Validate.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SymTab/Validate.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -56,4 +56,5 @@
 #include "FixFunction.h"               // for FixFunction
 #include "Indexer.h"                   // for Indexer
+#include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
 #include "Parser/LinkageSpec.h"        // for C
@@ -150,6 +151,6 @@
 	/// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
 	struct ForallPointerDecay final {
-		void previsit( ObjectDecl *object );
-		void previsit( FunctionDecl *func );
+		void previsit( ObjectDecl * object );
+		void previsit( FunctionDecl * func );
 	};
 
@@ -579,6 +580,6 @@
 
 	/// Fix up assertions - flattens assertion lists, removing all trait instances
-	void forallFixer( Type * func ) {
-		for ( TypeDecl * type : func->get_forall() ) {
+	void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
+		for ( TypeDecl * type : forall ) {
 			std::list< DeclarationWithType * > asserts;
 			asserts.splice( asserts.end(), type->assertions );
@@ -599,5 +600,5 @@
 				assertion = assertion->acceptMutator( fixer );
 				if ( fixer.get_isVoid() ) {
-					throw SemanticError( "invalid type void in assertion of function ", func );
+					throw SemanticError( "invalid type void in assertion of function ", node );
 				} // if
 			} // for
@@ -607,7 +608,7 @@
 
 	void ForallPointerDecay::previsit( ObjectDecl *object ) {
-		forallFixer( object->get_type() );
-		if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
-			forallFixer( pointer->get_base() );
+		forallFixer( object->type->forall, object );
+		if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
+			forallFixer( pointer->base->forall, object );
 		} // if
 		object->fixUniqueId();
@@ -615,5 +616,5 @@
 
 	void ForallPointerDecay::previsit( FunctionDecl *func ) {
-		forallFixer( func->get_type() );
+		forallFixer( func->type->forall, func );
 		func->fixUniqueId();
 	}
Index: src/SynTree/Visitor.h
===================================================================
--- src/SynTree/Visitor.h	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/SynTree/Visitor.h	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -25,5 +25,5 @@
   public:
 	// visit: Default implementation of all functions visits the children
-    // of the given syntax node, but performs no other action.
+	// of the given syntax node, but performs no other action.
 
 	virtual void visit( ObjectDecl *objectDecl );
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 596bc0ad00de94eb1ed399785d9f92cb36c5b520)
+++ src/main.cc	(revision f265042c897846bca67d9bccada8b87b9ad4daf8)
@@ -239,7 +239,4 @@
 		} // if
 
-		// OPTPRINT( "Concurrency" )
-		// Concurrency::applyKeywords( translationUnit );
-
 		// add the assignment statement after the initialization of a type parameter
 		OPTPRINT( "validate" )