Index: src/CodeGen/CodeGeneratorNew.cpp
===================================================================
--- src/CodeGen/CodeGeneratorNew.cpp	(revision 6e7ed0aae5c3d162fadc30a2aad792abe6f1a8a7)
+++ src/CodeGen/CodeGeneratorNew.cpp	(revision decd4a66c8a6f47e3f77469ec710400b3f0038c4)
@@ -24,5 +24,5 @@
 namespace CodeGen {
 
-int CodeGenerator_new::tabsize = 4;
+int CodeGenerator::tabsize = 4;
 
 // The kinds of statements that should be followed by whitespace.
@@ -35,13 +35,13 @@
 }
 
-void CodeGenerator_new::extension( ast::Expr const * expr ) {
+void CodeGenerator::extension( ast::Expr const * expr ) {
 	if ( expr->extension ) output << "__extension__ ";
 }
 
-void CodeGenerator_new::extension( ast::Decl const * decl ) {
+void CodeGenerator::extension( ast::Decl const * decl ) {
 	if ( decl->extension ) output << "__extension__ ";
 }
 
-void CodeGenerator_new::asmName( ast::DeclWithType const * decl ) {
+void CodeGenerator::asmName( ast::DeclWithType const * decl ) {
 	if ( auto asmName = decl->asmName.as<ast::ConstantExpr>() ) {
 		output << " asm ( " << asmName->rep << " )";
@@ -49,5 +49,5 @@
 }
 
-CodeGenerator_new::LabelPrinter & CodeGenerator_new::LabelPrinter::operator()(
+CodeGenerator::LabelPrinter & CodeGenerator::LabelPrinter::operator()(
 		std::vector<ast::Label> const & l ) {
 	labels = &l;
@@ -55,5 +55,5 @@
 }
 
-std::ostream & CodeGenerator_new::LabelPrinter::operator()( std::ostream & output ) const {
+std::ostream & CodeGenerator::LabelPrinter::operator()( std::ostream & output ) const {
 	const std::vector<ast::Label> & labels = *this->labels;
 	for ( const ast::Label & label : labels ) {
@@ -66,5 +66,5 @@
 // Using updateLocation at the beginning of a node and endl within a node
 // should become the method of formating.
-void CodeGenerator_new::updateLocation( CodeLocation const & to ) {
+void CodeGenerator::updateLocation( CodeLocation const & to ) {
 	// Skip if linemarks shouldn't appear or if location is unset.
 	if ( !options.lineMarks || to.isUnset() ) return;
@@ -86,9 +86,9 @@
 }
 
-void CodeGenerator_new::updateLocation( ast::ParseNode const * to ) {
+void CodeGenerator::updateLocation( ast::ParseNode const * to ) {
 	updateLocation( to->location );
 }
 
-std::ostream & CodeGenerator_new::LineEnder::operator()( std::ostream & os ) const {
+std::ostream & CodeGenerator::LineEnder::operator()( std::ostream & os ) const {
 	os << "\n" << std::flush;
 	cg.currentLocation.first_line++;
@@ -96,10 +96,10 @@
 }
 
-CodeGenerator_new::CodeGenerator_new( std::ostream & os, const Options & options ) :
-		indent( 0, CodeGenerator_new::tabsize ), output( os ),
+CodeGenerator::CodeGenerator( std::ostream & os, const Options & options ) :
+		indent( 0, CodeGenerator::tabsize ), output( os ),
 		options( options ), printLabels( *this ), endl( *this )
 {}
 
-std::string CodeGenerator_new::mangleName( ast::DeclWithType const * decl ) {
+std::string CodeGenerator::mangleName( ast::DeclWithType const * decl ) {
 	// GCC builtins should always be printed unmangled.
 	if ( options.pretty || decl->linkage.is_gcc_builtin ) {
@@ -112,5 +112,5 @@
 }
 
-void CodeGenerator_new::genAttributes(
+void CodeGenerator::genAttributes(
 		const std::vector<ast::ptr<ast::Attribute>> & attributes ) {
 	if ( attributes.empty() ) return;
@@ -129,5 +129,5 @@
 }
 
-void CodeGenerator_new::previsit( ast::Node const * ) {
+void CodeGenerator::previsit( ast::Node const * ) {
 	// All traversal is manual.
 	// TODO: Which means the ast::Pass is just providing a default no visit?
@@ -135,10 +135,10 @@
 }
 
-void CodeGenerator_new::previsit( ast::ParseNode const * node ) {
+void CodeGenerator::previsit( ast::ParseNode const * node ) {
 	previsit( (ast::Node const *)node );
 	updateLocation( node );
 }
 
-void CodeGenerator_new::postvisit( ast::Node const * node ) {
+void CodeGenerator::postvisit( ast::Node const * node ) {
 	std::stringstream ss;
 	ast::print( ss, node );
@@ -146,5 +146,5 @@
 }
 
-void CodeGenerator_new::previsit( ast::Expr const * expr ) {
+void CodeGenerator::previsit( ast::Expr const * expr ) {
 	previsit( (ast::ParseNode const *)expr );
 	GuardAction( [this, expr](){
@@ -155,5 +155,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::FunctionDecl const * decl ) {
+void CodeGenerator::postvisit( ast::FunctionDecl const * decl ) {
 	// Deleted decls should never be used, so don't print them in C.
 	if ( decl->isDeleted && options.genC ) return;
@@ -168,5 +168,5 @@
 
 	std::ostringstream acc;
-	ast::Pass<CodeGenerator_new> subCG( acc, subOptions );
+	ast::Pass<CodeGenerator> subCG( acc, subOptions );
 	// Add the forall clause.
 	// TODO: These probably should be removed by now and the assert used.
@@ -213,6 +213,5 @@
 }
 
-//void CodeGenerator_new::postvisit( ast::ObjectDecl const * decl_ ) {
-ast::ObjectDecl const * CodeGenerator_new::postvisit(
+ast::ObjectDecl const * CodeGenerator::postvisit(
 		ast::ObjectDecl const * decl ) {
 	// Deleted decls should never be used, so don't print them in C.
@@ -262,5 +261,5 @@
 }
 
-void CodeGenerator_new::handleStorageClass( ast::DeclWithType const * decl ) {
+void CodeGenerator::handleStorageClass( ast::DeclWithType const * decl ) {
 	if ( decl->storage.any() ) {
 		ast::print( output, decl->storage );
@@ -268,5 +267,5 @@
 }
 
-void CodeGenerator_new::handleAggregate(
+void CodeGenerator::handleAggregate(
 		ast::AggregateDecl const * decl, std::string const & kind ) {
 	if ( !decl->params.empty() && !options.genC ) {
@@ -296,10 +295,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::StructDecl const * decl ) {
+void CodeGenerator::postvisit( ast::StructDecl const * decl ) {
 	extension( decl );
 	handleAggregate( decl, "struct " );
 }
 
-void CodeGenerator_new::postvisit( ast::UnionDecl const * decl ) {
+void CodeGenerator::postvisit( ast::UnionDecl const * decl ) {
 	extension( decl );
 	handleAggregate( decl, "union " );
@@ -332,5 +331,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::EnumDecl const * decl ) {
+void CodeGenerator::postvisit( ast::EnumDecl const * decl ) {
 	extension( decl );
 	auto members = decl->members;
@@ -370,5 +369,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TraitDecl const * decl ) {
+void CodeGenerator::postvisit( ast::TraitDecl const * decl ) {
 	assertf( !options.genC, "TraitDecls should not reach code generation." );
 	extension( decl );
@@ -376,10 +375,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TypedefDecl const * decl ) {
+void CodeGenerator::postvisit( ast::TypedefDecl const * decl ) {
 	assertf( !options.genC, "Typedefs should not reach code generation." );
 	output << "typedef " << genType( decl->base, decl->name, options ) << endl;
 }
 
-void CodeGenerator_new::postvisit( ast::TypeDecl const * decl ) {
+void CodeGenerator::postvisit( ast::TypeDecl const * decl ) {
 	assertf( !options.genC, "TypeDecls should not reach code generation." );
 	output << decl->genTypeString() << " " << decl->name;
@@ -397,5 +396,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::StaticAssertDecl const * decl ) {
+void CodeGenerator::postvisit( ast::StaticAssertDecl const * decl ) {
 	output << "_Static_assert(";
 	decl->cond->accept( *visitor );
@@ -405,5 +404,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::Designation const * designation ) {
+void CodeGenerator::postvisit( ast::Designation const * designation ) {
 	auto designators = designation->designators;
 	if ( 0 == designators.size() ) return;
@@ -423,9 +422,9 @@
 }
 
-void CodeGenerator_new::postvisit( ast::SingleInit const * init ) {
+void CodeGenerator::postvisit( ast::SingleInit const * init ) {
 	init->value->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::ListInit const * init ) {
+void CodeGenerator::postvisit( ast::ListInit const * init ) {
 	auto initBegin = init->initializers.begin();
 	auto initEnd = init->initializers.end();
@@ -446,5 +445,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ConstructorInit const * init ) {
+void CodeGenerator::postvisit( ast::ConstructorInit const * init ) {
 	assertf( !options.genC, "ConstructorInit nodes should not reach code generation." );
 	// This isn't actual code, but labels the constructor/destructor pairs.
@@ -456,5 +455,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ApplicationExpr const * expr ) {
+void CodeGenerator::postvisit( ast::ApplicationExpr const * expr ) {
 	extension( expr );
 	if ( auto var = expr->func.as<ast::VariableExpr>() ) {
@@ -550,5 +549,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::UntypedExpr const * expr ) {
+void CodeGenerator::postvisit( ast::UntypedExpr const * expr ) {
 	extension( expr );
 	if ( auto name = expr->func.as<ast::NameExpr>() ) {
@@ -638,5 +637,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::RangeExpr const * expr ) {
+void CodeGenerator::postvisit( ast::RangeExpr const * expr ) {
 	expr->low->accept( *visitor );
 	output << " ... ";
@@ -644,5 +643,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::NameExpr const * expr ) {
+void CodeGenerator::postvisit( ast::NameExpr const * expr ) {
 	extension( expr );
 	if ( const OperatorInfo * opInfo = operatorLookup( expr->name ) ) {
@@ -657,10 +656,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::DimensionExpr const * expr ) {
+void CodeGenerator::postvisit( ast::DimensionExpr const * expr ) {
 	extension( expr );
 	output << "/*non-type*/" << expr->name;
 }
 
-void CodeGenerator_new::postvisit( ast::AddressExpr const * expr ) {
+void CodeGenerator::postvisit( ast::AddressExpr const * expr ) {
 	extension( expr );
 	output << "(&";
@@ -669,10 +668,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::LabelAddressExpr const * expr ) {
+void CodeGenerator::postvisit( ast::LabelAddressExpr const * expr ) {
 	extension( expr );
 	output << "(&&" << expr->arg << ")";
 }
 
-void CodeGenerator_new::postvisit( ast::CastExpr const * expr ) {
+void CodeGenerator::postvisit( ast::CastExpr const * expr ) {
 	extension( expr );
 	output << "(";
@@ -688,5 +687,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::KeywordCastExpr const * expr ) {
+void CodeGenerator::postvisit( ast::KeywordCastExpr const * expr ) {
 	assertf( !options.genC, "KeywordCastExpr should not reach code generation." );
 	extension( expr );
@@ -696,5 +695,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::VirtualCastExpr const * expr ) {
+void CodeGenerator::postvisit( ast::VirtualCastExpr const * expr ) {
 	assertf( !options.genC, "VirtualCastExpr should not reach code generation." );
 	extension( expr );
@@ -705,5 +704,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::UntypedMemberExpr const * expr ) {
+void CodeGenerator::postvisit( ast::UntypedMemberExpr const * expr ) {
 	assertf( !options.genC, "UntypedMemberExpr should not reach code generation." );
 	extension( expr );
@@ -713,5 +712,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::MemberExpr const * expr ) {
+void CodeGenerator::postvisit( ast::MemberExpr const * expr ) {
 	extension( expr );
 	expr->aggregate->accept( *visitor );
@@ -719,5 +718,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::VariableExpr const * expr ) {
+void CodeGenerator::postvisit( ast::VariableExpr const * expr ) {
 	extension( expr );
 	const OperatorInfo * opInfo;
@@ -733,10 +732,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ConstantExpr const * expr ) {
+void CodeGenerator::postvisit( ast::ConstantExpr const * expr ) {
 	extension( expr );
 	output << expr->rep;
 }
 
-void CodeGenerator_new::postvisit( ast::SizeofExpr const * expr ) {
+void CodeGenerator::postvisit( ast::SizeofExpr const * expr ) {
 	extension( expr );
 	output << "sizeof(";
@@ -749,5 +748,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::AlignofExpr const * expr ) {
+void CodeGenerator::postvisit( ast::AlignofExpr const * expr ) {
 	// Using the GCC extension to avoid changing the std to C11.
 	extension( expr );
@@ -761,5 +760,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::UntypedOffsetofExpr const * expr ) {
+void CodeGenerator::postvisit( ast::UntypedOffsetofExpr const * expr ) {
 	assertf( !options.genC, "UntypedOffsetofExpr should not reach code generation." );
 	output << "offsetof(";
@@ -769,5 +768,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::OffsetofExpr const * expr ) {
+void CodeGenerator::postvisit( ast::OffsetofExpr const * expr ) {
 	// Use GCC builtin
 	output << "__builtin_offsetof(";
@@ -777,10 +776,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::OffsetPackExpr const * expr ) {
+void CodeGenerator::postvisit( ast::OffsetPackExpr const * expr ) {
 	assertf( !options.genC, "OffsetPackExpr should not reach code generation." );
 	output << "__CFA_offsetpack(" << genType( expr->type, "", options ) << ")";
 }
 
-void CodeGenerator_new::postvisit( ast::LogicalExpr const * expr ) {
+void CodeGenerator::postvisit( ast::LogicalExpr const * expr ) {
 	extension( expr );
 	output << "(";
@@ -791,5 +790,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ConditionalExpr const * expr ) {
+void CodeGenerator::postvisit( ast::ConditionalExpr const * expr ) {
 	extension( expr );
 	output << "(";
@@ -802,5 +801,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::CommaExpr const * expr ) {
+void CodeGenerator::postvisit( ast::CommaExpr const * expr ) {
 	extension( expr );
 	output << "(";
@@ -818,10 +817,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TupleAssignExpr const * expr ) {
+void CodeGenerator::postvisit( ast::TupleAssignExpr const * expr ) {
 	assertf( !options.genC, "TupleAssignExpr should not reach code generation." );
 	expr->stmtExpr->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::UntypedTupleExpr const * expr ) {
+void CodeGenerator::postvisit( ast::UntypedTupleExpr const * expr ) {
 	assertf( !options.genC, "UntypedTupleExpr should not reach code generation." );
 	extension( expr );
@@ -831,5 +830,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TupleExpr const * expr ) {
+void CodeGenerator::postvisit( ast::TupleExpr const * expr ) {
 	assertf( !options.genC, "TupleExpr should not reach code generation." );
 	extension( expr );
@@ -839,5 +838,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TupleIndexExpr const * expr ) {
+void CodeGenerator::postvisit( ast::TupleIndexExpr const * expr ) {
 	assertf( !options.genC, "TupleIndexExpr should not reach code generation." );
 	extension( expr );
@@ -846,5 +845,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::TypeExpr const * expr ) {
+void CodeGenerator::postvisit( ast::TypeExpr const * expr ) {
 	// TODO: Should there be an assertion there?
 	if ( !options.genC ) {
@@ -853,5 +852,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::AsmExpr const * expr ) {
+void CodeGenerator::postvisit( ast::AsmExpr const * expr ) {
 	if ( !expr->inout.empty() ) {
 		output << "[ " << expr->inout << " ] ";
@@ -863,5 +862,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::CompoundLiteralExpr const * expr ) {
+void CodeGenerator::postvisit( ast::CompoundLiteralExpr const * expr ) {
 	//assert( expr->result && dynamic_cast<ast::ListInit const *>( expr->init ) );
 	assert( expr->result && expr->init.as<ast::ListInit>() );
@@ -870,5 +869,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::UniqueExpr const * expr ) {
+void CodeGenerator::postvisit( ast::UniqueExpr const * expr ) {
 	assertf( !options.genC, "UniqueExpr should not reach code generation." );
 	output << "unq<" << expr->id << ">{ ";
@@ -877,5 +876,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::StmtExpr const * expr ) {
+void CodeGenerator::postvisit( ast::StmtExpr const * expr ) {
 	auto stmts = expr->stmts->kids;
 	output << "({" << endl;
@@ -905,20 +904,20 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ConstructorExpr const * expr ) {
+void CodeGenerator::postvisit( ast::ConstructorExpr const * expr ) {
 	assertf( !options.genC, "ConstructorExpr should not reach code generation." );
 	expr->callExpr->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::DeletedExpr const * expr ) {
+void CodeGenerator::postvisit( ast::DeletedExpr const * expr ) {
 	assertf( !options.genC, "DeletedExpr should not reach code generation." );
 	expr->expr->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::DefaultArgExpr const * expr ) {
+void CodeGenerator::postvisit( ast::DefaultArgExpr const * expr ) {
 	assertf( !options.genC, "DefaultArgExpr should not reach code generation." );
 	expr->expr->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::GenericExpr const * expr ) {
+void CodeGenerator::postvisit( ast::GenericExpr const * expr ) {
 	assertf( !options.genC, "GenericExpr should not reach code generation." );
 	output << "_Generic(";
@@ -940,5 +939,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::CompoundStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::CompoundStmt const * stmt ) {
 	output << "{" << endl;
 
@@ -955,5 +954,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ExprStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::ExprStmt const * stmt ) {
 	assert( stmt );
 	// Cast the top-level expression to void to reduce gcc warnings.
@@ -967,5 +966,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::AsmStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::AsmStmt const * stmt ) {
 	output << "asm ";
 	if ( stmt->isVolatile ) output << "volatile ";
@@ -991,5 +990,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::AsmDecl const * decl ) {
+void CodeGenerator::postvisit( ast::AsmDecl const * decl ) {
 	output << "asm ";
 	ast::AsmStmt const * stmt = decl->stmt;
@@ -999,15 +998,15 @@
 }
 
-void CodeGenerator_new::postvisit( ast::DirectiveDecl const * decl ) {
+void CodeGenerator::postvisit( ast::DirectiveDecl const * decl ) {
 	// endl prevents spaces before the directive.
 	output << endl << decl->stmt->directive;
 }
 
-void CodeGenerator_new::postvisit( ast::DirectiveStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::DirectiveStmt const * stmt ) {
 	// endl prevents spaces before the directive.
 	output << endl << stmt->directive;
 }
 
-void CodeGenerator_new::postvisit( ast::IfStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::IfStmt const * stmt ) {
 	output << "if ( ";
 	stmt->cond->accept( *visitor );
@@ -1022,5 +1021,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::SwitchStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::SwitchStmt const * stmt ) {
 	output << "switch ( ";
 	stmt->cond->accept( *visitor );
@@ -1036,5 +1035,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::CaseClause const * clause ) {
+void CodeGenerator::postvisit( ast::CaseClause const * clause ) {
 	updateLocation( clause );
 	output << indent;
@@ -1056,5 +1055,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::BranchStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::BranchStmt const * stmt ) {
 	switch ( stmt->kind ) {
 	case ast::BranchStmt::Goto:
@@ -1091,5 +1090,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ReturnStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::ReturnStmt const * stmt ) {
 	output << "return ";
 	if ( stmt->expr ) stmt->expr->accept( *visitor );
@@ -1097,5 +1096,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ThrowStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::ThrowStmt const * stmt ) {
 	assertf( !options.genC, "ThrowStmt should not reach code generation." );
 
@@ -1112,5 +1111,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::CatchClause const * stmt ) {
+void CodeGenerator::postvisit( ast::CatchClause const * stmt ) {
 	assertf( !options.genC, "CatchClause should not reach code generation." );
 
@@ -1126,5 +1125,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::WaitForStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::WaitForStmt const * stmt ) {
 	assertf( !options.genC, "WaitforStmt should not reach code generation." );
 
@@ -1172,5 +1171,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::WithStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::WithStmt const * stmt ) {
 	assertf( !options.genC, "WithStmt should not reach code generation." );
 
@@ -1181,5 +1180,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::WhileDoStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::WhileDoStmt const * stmt ) {
 	if ( stmt->isDoWhile ) {
 		output << "do";
@@ -1191,5 +1190,5 @@
 	output << " ";
 
-	output << CodeGenerator_new::printLabels( stmt->body->labels );
+	output << CodeGenerator::printLabels( stmt->body->labels );
 	stmt->body->accept( *visitor );
 
@@ -1203,5 +1202,5 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ForStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::ForStmt const * stmt ) {
 	// Initializer is always hoised so don't generate it.
 	// TODO: Do an assertion check?
@@ -1226,9 +1225,9 @@
 }
 
-void CodeGenerator_new::postvisit( ast::NullStmt const * ) {
+void CodeGenerator::postvisit( ast::NullStmt const * ) {
 	output << "/* null statement */ ;";
 }
 
-void CodeGenerator_new::postvisit( ast::DeclStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::DeclStmt const * stmt ) {
 	stmt->decl->accept( *visitor );
 
@@ -1236,10 +1235,10 @@
 }
 
-void CodeGenerator_new::postvisit( ast::ImplicitCtorDtorStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::ImplicitCtorDtorStmt const * stmt ) {
 	assertf( !options.genC, "ImplicitCtorCtorStmt should not reach code generation." );
 	stmt->callStmt->accept( *visitor );
 }
 
-void CodeGenerator_new::postvisit( ast::MutexStmt const * stmt ) {
+void CodeGenerator::postvisit( ast::MutexStmt const * stmt ) {
 	assertf( !options.genC, "MutexStmt should not reach code generation." );
 	// TODO: But this isn't what a mutex statement looks like.
