Index: src/AST/Decl.hpp
===================================================================
--- src/AST/Decl.hpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/AST/Decl.hpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -108,5 +108,5 @@
 	ObjectDecl( const CodeLocation & loc, const std::string & name, const Type * type,
 		const Init * init = nullptr, Storage::Classes storage = {},
-		Linkage::Spec linkage = Linkage::C, const Expr * bitWd = nullptr,
+		Linkage::Spec linkage = Linkage::Cforall, const Expr * bitWd = nullptr,
 		std::vector< ptr<Attribute> > && attrs = {}, Function::Specs fs = {} )
 	: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
@@ -143,5 +143,5 @@
 	FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
 		std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
-		CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
+		CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
 		std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
@@ -149,5 +149,5 @@
 		std::vector<ptr<TypeDecl>>&& forall, std::vector<ptr<DeclWithType>>&& assertions,
 		std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
-		CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
+		CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::Cforall,
 		std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
 
Index: src/AST/Pass.impl.hpp
===================================================================
--- src/AST/Pass.impl.hpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/AST/Pass.impl.hpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -597,4 +597,5 @@
 			guard_symtab guard { *this };
 			// implicit add __func__ identifier as specified in the C manual 6.4.2.2
+			// This is a C name and so has C linkage.
 			static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{
 				CodeLocation{}, "__func__",
@@ -602,5 +603,8 @@
 					new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
 					nullptr, VariableLen, DynamicDim
-				}
+				},
+				nullptr,
+				ast::Storage::Classes(),
+				ast::Linkage::C,
 			} };
 			__pass::symtab::addId( core, 0, func );
Index: src/Concurrency/KeywordsNew.cpp
===================================================================
--- src/Concurrency/KeywordsNew.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/Concurrency/KeywordsNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -398,7 +398,5 @@
 			new ast::ReferenceType( vtable_object->type, ast::CV::Const ),
 			new ast::SingleInit( location,
-				new ast::VariableExpr( location, vtable_object ) ),
-			ast::Storage::Classes(),
-			ast::Linkage::Cforall
+				new ast::VariableExpr( location, vtable_object ) )
 		)
 	);
@@ -471,8 +469,5 @@
 		location,
 		"this",
-		new ast::ReferenceType( new ast::StructInstType( decl ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::ReferenceType( new ast::StructInstType( decl ) )
 	);
 
@@ -480,8 +475,5 @@
 		location,
 		"ret",
-		new ast::PointerType( new ast::StructInstType( type_decl ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::PointerType( new ast::StructInstType( type_decl ) )
 	);
 
@@ -530,8 +522,5 @@
 		location,
 		field_name,
-		new ast::StructInstType( type_decl ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::StructInstType( type_decl )
 	);
 
@@ -577,8 +566,5 @@
 		location,
 		"this",
-		new ast::ReferenceType( new ast::StructInstType( decl ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::ReferenceType( new ast::StructInstType( decl ) )
 	);
 
@@ -1077,7 +1063,5 @@
 				) }
 			)
-		),
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		)
 	);
 
@@ -1107,7 +1091,5 @@
 				{},
 				ast::MaybeConstruct
-			),
-			ast::Storage::Classes(),
-			ast::Linkage::Cforall
+			)
 		))
 	);
@@ -1161,7 +1143,5 @@
 				}
 			)
-		),
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		)
 	);
 
@@ -1190,7 +1170,5 @@
 				{},
 				ast::MaybeConstruct
-			),
-			ast::Storage::Classes(),
-			ast::Linkage::Cforall
+			)
 		))
 	);
@@ -1296,7 +1274,5 @@
 				}
 			)
-		),
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		)
 	);
 
@@ -1370,7 +1346,5 @@
 					{},
 					ast::MaybeConstruct
-				),
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
+				)
 			)
 		)
@@ -1513,7 +1487,5 @@
 				{},
 				ast::MaybeConstruct
-			),
-			ast::Storage::Classes(),
-			ast::Linkage::Cforall
+			)
 		)
 	));
Index: src/ControlStruct/ExceptDeclNew.cpp
===================================================================
--- src/ControlStruct/ExceptDeclNew.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/ControlStruct/ExceptDeclNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -110,8 +110,5 @@
 		"parent",
 		new ast::PointerType(
-			new ast::StructInstType( "__cfavir_type_info", ast::CV::Const ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+			new ast::StructInstType( "__cfavir_type_info", ast::CV::Const ) )
 	) );
 	decl->body = true;
@@ -166,40 +163,25 @@
 		location,
 		"__cfavir_typeid",
-		new ast::PointerType( typeIdType ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::PointerType( typeIdType )
 	);
 	ast::ObjectDecl * size = new ast::ObjectDecl(
 		location,
 		"size",
-		new ast::TypeInstType( "size_t", ast::TypeDecl::Dtype ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::TypeInstType( "size_t", ast::TypeDecl::Dtype )
 	);
 	ast::ObjectDecl * copy = new ast::ObjectDecl(
 		location,
 		"copy",
-		new ast::PointerType( createCopyFuncType( exceptionName, params ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::PointerType( createCopyFuncType( exceptionName, params ) )
 	);
 	ast::ObjectDecl * dtor = new ast::ObjectDecl(
 		location,
 		"^?{}",
-		new ast::PointerType( createDtorFuncType( exceptionName, params ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::PointerType( createDtorFuncType( exceptionName, params ) )
 	);
 	ast::ObjectDecl * msg = new ast::ObjectDecl(
 		location,
 		"msg",
-		new ast::PointerType( createMsgFuncType( exceptionName, params ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::PointerType( createMsgFuncType( exceptionName, params ) )
 	);
 	ast::StructDecl * decl = new ast::StructDecl(
@@ -229,8 +211,5 @@
 		"virtual_table",
 		new ast::PointerType(
-			createVTableInstType( exceptionName, params ) ),
-		nullptr,
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+			createVTableInstType( exceptionName, params ) )
 	) );
 	for ( ast::ptr<ast::Decl> const & member : members ) {
@@ -289,8 +268,5 @@
 				"this",
 				new ast::PointerType(
-					createExceptionInstType( exceptionName, params ) ),
-				nullptr,
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
+					createExceptionInstType( exceptionName, params ) )
 			),
 			new ast::ObjectDecl(
@@ -298,19 +274,9 @@
 				"that",
 				new ast::PointerType(
-					createExceptionInstType( exceptionName, params ) ),
-				nullptr,
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
+					createExceptionInstType( exceptionName, params ) )
 			),
 		},
 		{
-			new ast::ObjectDecl(
-				location,
-				"",
-				new ast::VoidType(),
-				nullptr,
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
-			),
+			new ast::ObjectDecl( location, "", new ast::VoidType() ),
 		},
 		new ast::CompoundStmt( location, {
@@ -366,8 +332,5 @@
 				"this",
 				new ast::PointerType(
-					createExceptionInstType( exceptionName, params ) ),
-				nullptr,
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
+					createExceptionInstType( exceptionName, params ) )
 			),
 		},
@@ -377,8 +340,5 @@
 				"",
 				new ast::PointerType(
-					new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) ),
-				nullptr,
-				ast::Storage::Classes(),
-				ast::Linkage::Cforall
+					new ast::BasicType( ast::BasicType::Char, ast::CV::Const ) )
 			),
 		},
@@ -432,7 +392,5 @@
 		tableName,
 		createVTableInstType( exceptionName, params ),
-		new ast::ListInit( location, std::move( inits ), std::move( dsigs ) ),
-		ast::Storage::Classes(),
-		ast::Linkage::Cforall
+		new ast::ListInit( location, std::move( inits ), std::move( dsigs ) )
 	);
 }
Index: src/ControlStruct/ExceptTranslateNew.cpp
===================================================================
--- src/ControlStruct/ExceptTranslateNew.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/ControlStruct/ExceptTranslateNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -190,8 +190,5 @@
 		location,
 		"__handler_index",
-		new ast::BasicType(ast::BasicType::SignedInt),
-		nullptr, //init
-		ast::Storage::Classes{},
-		ast::Linkage::Cforall
+		new ast::BasicType( ast::BasicType::SignedInt )
 		);
 }
@@ -203,10 +200,5 @@
 		location,
 		"__exception_inst",
-		new ast::PointerType(
-			new ast::StructInstType( except_decl )
-			),
-		nullptr, //init
-		ast::Storage::Classes{},
-		ast::Linkage::Cforall
+		new ast::PointerType( new ast::StructInstType( except_decl ) )
 		);
 }
Index: src/GenPoly/Specialize.h
===================================================================
--- src/GenPoly/Specialize.h	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/GenPoly/Specialize.h	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// Specialize.h -- 
+// Specialize.h -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Richard C. Bilson
@@ -17,7 +17,9 @@
 
 #include <list>  // for list
-#include "AST/TranslationUnit.hpp"
 
 class Declaration;
+namespace ast {
+	class TranslationUnit;
+}
 
 namespace GenPoly {
Index: src/GenPoly/SpecializeNew.cpp
===================================================================
--- src/GenPoly/SpecializeNew.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/GenPoly/SpecializeNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -5,5 +5,5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// SpecializeNew.cpp --
+// SpecializeNew.cpp -- Generate thunks to specialize polymorphic functions.
 //
 // Author           : Andrew Beach
@@ -201,9 +201,4 @@
 			*formal, *actual, getInferredParams( expr ) );
 	}
-	//for ( auto pair : group_iterate( formal->params, mut->args ) ) {
-	//	const ast::ptr<ast::Type> & formal = std::get<0>( pair );
-	//	ast::ptr<ast::Expr> & actual = std::get<1>( pair );
-	//	*actual = doSpecialization( (*actual)->location, *formal, *actual, getInferredParams( expr ) );
-	//}
 	return mut;
 }
@@ -227,27 +222,11 @@
 }
 
-// Restructures the arguments to match the structure of the formal parameters
-// of the actual function. [begin, end) are the exploded arguments.
-template<typename Iterator, typename OutIterator>
-void structureArg( const CodeLocation & location, const ast::Type * type,
-		Iterator & begin, Iterator end, OutIterator out ) {
-	if ( auto tuple = dynamic_cast<const ast::TupleType *>( type ) ) {
-		std::vector<ast::ptr<ast::Expr>> exprs;
-		for ( const ast::Type * t : *tuple ) {
-			structureArg( location, t, begin, end, std::back_inserter( exprs ) );
-		}
-		*out++ = new ast::TupleExpr( location, std::move( exprs ) );
-	} else {
-		assertf( begin != end, "reached the end of the arguments while structuring" );
-		*out++ = *begin++;
-	}
-}
-
-#if 0
+// Restructures arguments to match the structure of the formal parameters
+// of the actual function. Returns the next structured argument.
 template<typename Iterator>
 const ast::Expr * structureArg(
 		const CodeLocation& location, const ast::ptr<ast::Type> & type,
 		Iterator & begin, const Iterator & end ) {
-	if ( auto tuple = type->as<ast::TupleType>() ) {
+	if ( auto tuple = type.as<ast::TupleType>() ) {
 		std::vector<ast::ptr<ast::Expr>> exprs;
 		for ( const ast::Type * t : *tuple ) {
@@ -260,5 +239,4 @@
 	}
 }
-#endif
 
 namespace {
@@ -291,6 +269,4 @@
 		// Must replace only occurrences of type variables
 		// that occure free in the thunk's type.
-		//ast::TypeSubstitution::ApplyResult<ast::FunctionType>
-		//	typeSubs->applyFree( newType );
 		auto result = typeSubs->applyFree( newType );
 		newType = result.node.release();
@@ -300,21 +276,14 @@
 	using DeclVector = std::vector<ast::ptr<ast::TypeDecl>>;
 
-	//const std::string & thunkName = thunkNamer.newName();
-	//UniqueName paramNamer(thunkName + "Param");
 	UniqueName paramNamer( paramPrefix );
 
-	//auto toParamDecl = [&location, &paramNamer]( const ast::Type * type ) {
-	//	return new ast::ObjectDecl(
-	//		location, paramNamer.newName(), ast::deepCopy( type ) );
-	//};
-
 	// Create new thunk with same signature as formal type.
-
-	// std::map<const ast::TypeDecl *, std::pair<int, int>> typeMap;
 	ast::Pass<TypeInstFixer> fixer;
 	for (const auto & kv : newType->forall) {
 		if (fixer.core.typeMap.count(kv->base)) {
-			std::cerr << location << ' ' << kv->base->name << ' ' << kv->expr_id << '_' << kv->formal_usage << ',' 
-			<< fixer.core.typeMap[kv->base].first << '_' << fixer.core.typeMap[kv->base].second << std::endl;
+			std::cerr << location << ' ' << kv->base->name
+				<< ' ' << kv->expr_id << '_' << kv->formal_usage
+				<< ',' << fixer.core.typeMap[kv->base].first
+				<< '_' << fixer.core.typeMap[kv->base].second << std::endl;
 			assertf(false, "multiple formals in specialize");
 		}
@@ -322,5 +291,5 @@
 			fixer.core.typeMap[kv->base] = std::make_pair(kv->expr_id, kv->formal_usage);
 		}
-	} 
+	}
 
 	ast::CompoundStmt * thunkBody = new ast::CompoundStmt( location );
@@ -345,8 +314,5 @@
 		);
 
-	// thunkFunc->accept(fixer);
 	thunkFunc->fixUniqueId();
-
-
 
 	// Thunks may be generated and not used, avoid them.
@@ -375,8 +341,5 @@
 		// Name each thunk parameter and explode it.
 		// These are then threaded back into the actual function call.
-		//param->name = paramNamer.newName();
 		ast::DeclWithType * mutParam = ast::mutate( param.get() );
-		// - Should be renamed earlier. -
-		//mutParam->name = paramNamer.newName();
 		explodeSimple( location, new ast::VariableExpr( location, mutParam ),
 			std::back_inserter( args ) );
@@ -388,6 +351,6 @@
 		argBegin = args.begin(), argEnd = args.end();
 	for ( const auto & actualArg : actualType->params ) {
-		structureArg( location, actualArg.get(), argBegin, argEnd,
-			std::back_inserter( app->args ) );
+		app->args.push_back(
+			structureArg( location, actualArg.get(), argBegin, argEnd ) );
 	}
 	assertf( argBegin == argEnd, "Did not structure all arguments." );
@@ -469,10 +432,9 @@
 	// Create thunks for the inferred parameters.
 	// This is not needed for intrinsic calls, because they aren't
-	// actually passed
-	//
-	// need to handle explicit params before inferred params so that
-	// explicit params do not recieve a changed set of inferParams (and
-	// change them again) alternatively, if order starts to matter then
-	// copy appExpr's inferParams and pass them to handleExplicitParams.
+	// actually passed to the function. It needs to handle explicit params
+	// before inferred params so that explicit params do not recieve a
+	// changed set of inferParams (and change them again).
+	// Alternatively, if order starts to matter then copy expr's inferParams
+	// and pass them to handleExplicitParams.
 	ast::ApplicationExpr * mut = handleExplicitParams( expr );
 	if ( !mut->inferred.hasParams() ) {
Index: src/InitTweak/FixInitNew.cpp
===================================================================
--- src/InitTweak/FixInitNew.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/InitTweak/FixInitNew.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -595,5 +595,4 @@
 		if ( arg && isIntrinsicCallExpr( dtor ) ) {
 			return new ast::CommaExpr(loc, arg, new ast::VariableExpr(loc, ret ) );
-			// return;
 		}
 
@@ -654,5 +653,4 @@
 		if ( ! result->isVoid() ) {
 			static UniqueName retNamer("_tmp_cp_ret");
-			// result = result->clone();
 			auto subResult = env->apply( result ).node;
 			auto ret = new ast::ObjectDecl(loc, retNamer.newName(), subResult, nullptr );
@@ -833,6 +831,4 @@
 			}
 
-			// stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
-			// stmtsToAddAfter.splice( stmtsToAddAfter.end(), fixer.pass.stmtsToAddAfter );
 			unqMap[mutExpr->id] = mutExpr;
 		} else {
@@ -1349,5 +1345,4 @@
 		auto tmp = new ast::ObjectDecl(loc, tempNamer.newName(), callExpr->args.front()->result );
 		declsToAddBefore.push_back( tmp );
-		// delete ctorExpr;
 
 		// build assignment and replace constructor's first argument with new temporary
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/ResolvExpr/Resolver.cc	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -1542,5 +1542,4 @@
 	}
 
-
 	const ast::StaticAssertDecl * Resolver_new::previsit(
 		const ast::StaticAssertDecl * assertDecl
@@ -1554,11 +1553,9 @@
 	const PtrType * handlePtrType( const PtrType * type, const ResolveContext & context ) {
 		if ( type->dimension ) {
-			ast::ptr< ast::Type > sizeType = context.global.sizeType;
+			const ast::Type * sizeType = context.global.sizeType.get();
 			ast::ptr< ast::Expr > dimension = findSingleExpression( type->dimension, sizeType, context );
 			assertf(dimension->env->empty(), "array dimension expr has nonempty env");
 			dimension.get_and_mutate()->env = nullptr;
-			ast::mutate_field(
-				type, &PtrType::dimension,
-				dimension);
+			ast::mutate_field( type, &PtrType::dimension, dimension );
 		}
 		return type;
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/SymTab/Autogen.cc	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -258,10 +258,10 @@
 	}
 
-	/// 
+	/// Given type T, generate type of default ctor/dtor, i.e. function type void (*) (T &).
 	ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
 		std::vector<ast::ptr<ast::TypeDecl>> typeParams;
 		if (maybePolymorphic) typeParams = getGenericParams(paramType);
 		auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
-		return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc));
+		return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc), {}, ast::Linkage::Cforall);
 	}
 
Index: src/Validate/Autogen.cpp
===================================================================
--- src/Validate/Autogen.cpp	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/Validate/Autogen.cpp	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -370,12 +370,10 @@
 ast::ObjectDecl * FuncGenerator::dstParam() const {
 	return new ast::ObjectDecl( getLocation(), "_dst",
-		new ast::ReferenceType( ast::deepCopy( type ) ),
-		nullptr, {}, ast::Linkage::Cforall );
+		new ast::ReferenceType( ast::deepCopy( type ) ) );
 }
 
 ast::ObjectDecl * FuncGenerator::srcParam() const {
 	return new ast::ObjectDecl( getLocation(), "_src",
-		ast::deepCopy( type ),
-		nullptr, {}, ast::Linkage::Cforall );
+		ast::deepCopy( type ) );
 }
 
@@ -429,5 +427,4 @@
 		ast::ObjectDecl * param = new ast::ObjectDecl(
 			getLocation(), member->name, paramType );
-		param->linkage = ast::Linkage::Cforall;
 		for ( auto & attr : member->attributes ) {
 			if ( attr->isValidOnFuncParam() ) {
Index: src/main.cc
===================================================================
--- src/main.cc	(revision 4c48be0244175628306b8fa1224cf2acb1666dab)
+++ src/main.cc	(revision dd33c1f4ee8e23b2956d02571e0614fdf0a438d4)
@@ -439,6 +439,7 @@
 			PASS( "Translate Tries", ControlStruct::translateTries( transUnit ) );
 			PASS( "Gen Waitfor", Concurrency::generateWaitFor( transUnit ) );
-			PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) ); // needs to happen before tuple types are expanded
-
+
+			// Needs to happen before tuple types are expanded.
+			PASS( "Convert Specializations",  GenPoly::convertSpecializations( transUnit ) );
 
 			translationUnit = convert( move( transUnit ) );
@@ -516,9 +517,5 @@
 			PASS( "Gen Waitfor", Concurrency::generateWaitFor( translationUnit ) );
 			PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
-
 		}
-
-
-		// PASS( "Convert Specializations",  GenPoly::convertSpecializations( translationUnit ) ); // needs to happen before tuple types are expanded
 
 		PASS( "Expand Tuples", Tuples::expandTuples( translationUnit ) ); // xxx - is this the right place for this?