Index: src/CodeGen/CodeGeneratorNew.cpp
===================================================================
--- src/CodeGen/CodeGeneratorNew.cpp	(revision 61efa421be36a355b304d2e9b9e14e493947d332)
+++ src/CodeGen/CodeGeneratorNew.cpp	(revision 8d182b1ed853a31c8c46021c2f2a6be9c45ea31d)
@@ -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.
Index: src/CodeGen/CodeGeneratorNew.hpp
===================================================================
--- src/CodeGen/CodeGeneratorNew.hpp	(revision 61efa421be36a355b304d2e9b9e14e493947d332)
+++ src/CodeGen/CodeGeneratorNew.hpp	(revision 8d182b1ed853a31c8c46021c2f2a6be9c45ea31d)
@@ -25,10 +25,9 @@
 namespace CodeGen {
 
-#warning Remove the _new when old version is removed.
-struct CodeGenerator_new :
+struct CodeGenerator final :
 		public ast::WithGuards,
 		public ast::WithShortCircuiting,
-		public ast::WithVisitorRef<CodeGenerator_new> {
-	CodeGenerator_new( std::ostream & out, Options const & options );
+		public ast::WithVisitorRef<CodeGenerator> {
+	CodeGenerator( std::ostream & out, Options const & options );
 
 	// Turn off visit_children for all nodes.
@@ -119,6 +118,6 @@
 	/// Custom local implementation of endl that updates print location.
 	struct LineEnder {
-		CodeGenerator_new & cg;
-		LineEnder( CodeGenerator_new & cg ) : cg( cg ) {}
+		CodeGenerator & cg;
+		LineEnder( CodeGenerator & cg ) : cg( cg ) {}
 		std::ostream & operator()( std::ostream & ) const;
 	};
@@ -129,8 +128,8 @@
 	/// Wrapper class to help print vectors of Labels.
 	struct LabelPrinter {
-		LabelPrinter( CodeGenerator_new & cg ) : cg( cg ), labels( nullptr ) {}
+		LabelPrinter( CodeGenerator & cg ) : cg( cg ), labels( nullptr ) {}
 		LabelPrinter & operator()( std::vector<ast::Label> const & l );
 		std::ostream & operator()( std::ostream & ) const;
-		CodeGenerator_new & cg;
+		CodeGenerator & cg;
 		std::vector<ast::Label> const * labels;
 	};
Index: src/CodeGen/GenType.cc
===================================================================
--- src/CodeGen/GenType.cc	(revision 61efa421be36a355b304d2e9b9e14e493947d332)
+++ src/CodeGen/GenType.cc	(revision 8d182b1ed853a31c8c46021c2f2a6be9c45ea31d)
@@ -21,5 +21,5 @@
 #include "AST/Print.hpp"          // for print
 #include "AST/Vector.hpp"         // for vector
-#include "CodeGeneratorNew.hpp"   // for CodeGenerator_new
+#include "CodeGeneratorNew.hpp"   // for CodeGenerator
 #include "Common/UniqueName.h"    // for UniqueName
 
@@ -28,10 +28,9 @@
 namespace {
 
-#warning Remove the _new when old version is removed.
-struct GenType_new :
+struct GenType final :
 		public ast::WithShortCircuiting,
-		public ast::WithVisitorRef<GenType_new> {
+		public ast::WithVisitorRef<GenType> {
 	std::string result;
-	GenType_new( const std::string &typeString, const Options &options );
+	GenType( const std::string &typeString, const Options &options );
 
 	void previsit( ast::Node const * );
@@ -67,7 +66,7 @@
 };
 
-GenType_new::GenType_new( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {}
-
-void GenType_new::previsit( ast::Node const * ) {
+GenType::GenType( const std::string &typeString, const Options &options ) : result( typeString ), options( options ) {}
+
+void GenType::previsit( ast::Node const * ) {
 	// Turn off automatic recursion for all nodes, to allow each visitor to
 	// precisely control the order in which its children are visited.
@@ -75,5 +74,5 @@
 }
 
-void GenType_new::postvisit( ast::Node const * node ) {
+void GenType::postvisit( ast::Node const * node ) {
 	std::stringstream ss;
 	ast::print( ss, node );
@@ -81,10 +80,10 @@
 }
 
-void GenType_new::postvisit( ast::VoidType const * type ) {
+void GenType::postvisit( ast::VoidType const * type ) {
 	result = "void " + result;
 	handleQualifiers( type );
 }
 
-void GenType_new::postvisit( ast::BasicType const * type ) {
+void GenType::postvisit( ast::BasicType const * type ) {
 	ast::BasicType::Kind kind = type->kind;
 	assert( 0 <= kind && kind < ast::BasicType::NUMBER_OF_BASIC_TYPES );
@@ -93,5 +92,5 @@
 }
 
-void GenType_new::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) {
+void GenType::genArray( const ast::CV::Qualifiers & qualifiers, ast::Type const * base, ast::Expr const *dimension, bool isVarLen, bool isStatic ) {
 	std::ostringstream os;
 	if ( result != "" ) {
@@ -119,5 +118,5 @@
 	}
 	if ( dimension != 0 ) {
-		ast::Pass<CodeGenerator_new>::read( dimension, os, options );
+		ast::Pass<CodeGenerator>::read( dimension, os, options );
 	} else if ( isVarLen ) {
 		// no dimension expression on a VLA means it came in with the * token
@@ -131,5 +130,5 @@
 }
 
-void GenType_new::postvisit( ast::PointerType const * type ) {
+void GenType::postvisit( ast::PointerType const * type ) {
 	if ( type->isStatic || type->isVarLen || type->dimension ) {
 		genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
@@ -145,9 +144,9 @@
 }
 
-void GenType_new::postvisit( ast::ArrayType const * type ) {
+void GenType::postvisit( ast::ArrayType const * type ) {
 	genArray( type->qualifiers, type->base, type->dimension, type->isVarLen, type->isStatic );
 }
 
-void GenType_new::postvisit( ast::ReferenceType const * type ) {
+void GenType::postvisit( ast::ReferenceType const * type ) {
 	assertf( !options.genC, "Reference types should not reach code generation." );
 	handleQualifiers( type );
@@ -156,5 +155,5 @@
 }
 
-void GenType_new::postvisit( ast::FunctionType const * type ) {
+void GenType::postvisit( ast::FunctionType const * type ) {
 	std::ostringstream os;
 
@@ -196,5 +195,5 @@
 		//assertf( !options.genC, "FunctionDecl type parameters should not reach code generation." );
 		std::ostringstream os;
-		ast::Pass<CodeGenerator_new> cg( os, options );
+		ast::Pass<CodeGenerator> cg( os, options );
 		os << "forall(";
 		cg.core.genCommaList( type->forall );
@@ -204,8 +203,8 @@
 }
 
-std::string GenType_new::handleGeneric( ast::BaseInstType const * type ) {
+std::string GenType::handleGeneric( ast::BaseInstType const * type ) {
 	if ( !type->params.empty() ) {
 		std::ostringstream os;
-		ast::Pass<CodeGenerator_new> cg( os, options );
+		ast::Pass<CodeGenerator> cg( os, options );
 		os << "(";
 		cg.core.genCommaList( type->params );
@@ -216,5 +215,5 @@
 }
 
-void GenType_new::postvisit( ast::StructInstType const * type )  {
+void GenType::postvisit( ast::StructInstType const * type )  {
 	result = type->name + handleGeneric( type ) + " " + result;
 	if ( options.genC ) result = "struct " + result;
@@ -222,5 +221,5 @@
 }
 
-void GenType_new::postvisit( ast::UnionInstType const * type ) {
+void GenType::postvisit( ast::UnionInstType const * type ) {
 	result = type->name + handleGeneric( type ) + " " + result;
 	if ( options.genC ) result = "union " + result;
@@ -228,5 +227,5 @@
 }
 
-void GenType_new::postvisit( ast::EnumInstType const * type ) {
+void GenType::postvisit( ast::EnumInstType const * type ) {
 	if ( type->base && type->base->base ) {
 		result = genType( type->base->base, result, options );
@@ -240,5 +239,5 @@
 }
 
-void GenType_new::postvisit( ast::TypeInstType const * type ) {
+void GenType::postvisit( ast::TypeInstType const * type ) {
 	assertf( !options.genC, "TypeInstType should not reach code generation." );
 	result = type->name + " " + result;
@@ -246,5 +245,5 @@
 }
 
-void GenType_new::postvisit( ast::TupleType const * type ) {
+void GenType::postvisit( ast::TupleType const * type ) {
 	assertf( !options.genC, "TupleType should not reach code generation." );
 	unsigned int i = 0;
@@ -259,10 +258,10 @@
 }
 
-void GenType_new::postvisit( ast::VarArgsType const * type ) {
+void GenType::postvisit( ast::VarArgsType const * type ) {
 	result = "__builtin_va_list " + result;
 	handleQualifiers( type );
 }
 
-void GenType_new::postvisit( ast::ZeroType const * type ) {
+void GenType::postvisit( ast::ZeroType const * type ) {
 	// Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
 	result = (options.pretty ? "zero_t " : "long int ") + result;
@@ -270,5 +269,5 @@
 }
 
-void GenType_new::postvisit( ast::OneType const * type ) {
+void GenType::postvisit( ast::OneType const * type ) {
 	// Ideally these wouldn't hit codegen at all, but should be safe to make them ints.
 	result = (options.pretty ? "one_t " : "long int ") + result;
@@ -276,10 +275,10 @@
 }
 
-void GenType_new::postvisit( ast::GlobalScopeType const * type ) {
+void GenType::postvisit( ast::GlobalScopeType const * type ) {
 	assertf( !options.genC, "GlobalScopeType should not reach code generation." );
 	handleQualifiers( type );
 }
 
-void GenType_new::postvisit( ast::TraitInstType const * type ) {
+void GenType::postvisit( ast::TraitInstType const * type ) {
 	assertf( !options.genC, "TraitInstType should not reach code generation." );
 	result = type->name + " " + result;
@@ -287,8 +286,8 @@
 }
 
-void GenType_new::postvisit( ast::TypeofType const * type ) {
+void GenType::postvisit( ast::TypeofType const * type ) {
 	std::ostringstream os;
 	os << "typeof(";
-	ast::Pass<CodeGenerator_new>::read( type, os, options );
+	ast::Pass<CodeGenerator>::read( type, os, options );
 	os << ") " << result;
 	result = os.str();
@@ -296,5 +295,5 @@
 }
 
-void GenType_new::postvisit( ast::VTableType const * type ) {
+void GenType::postvisit( ast::VTableType const * type ) {
 	assertf( !options.genC, "Virtual table types should not reach code generation." );
 	std::ostringstream os;
@@ -304,5 +303,5 @@
 }
 
-void GenType_new::postvisit( ast::QualifiedType const * type ) {
+void GenType::postvisit( ast::QualifiedType const * type ) {
 	assertf( !options.genC, "QualifiedType should not reach code generation." );
 	std::ostringstream os;
@@ -312,5 +311,5 @@
 }
 
-void GenType_new::handleQualifiers( ast::Type const * type ) {
+void GenType::handleQualifiers( ast::Type const * type ) {
 	if ( type->is_const() ) {
 		result = "const " + result;
@@ -327,5 +326,5 @@
 }
 
-std::string GenType_new::genParamList( const ast::vector<ast::Type> & range ) {
+std::string GenType::genParamList( const ast::vector<ast::Type> & range ) {
 	auto cur = range.begin();
 	auto end = range.end();
@@ -346,13 +345,13 @@
 	std::ostringstream os;
 	if ( !type->attributes.empty() ) {
-		ast::Pass<CodeGenerator_new> cg( os, options );
+		ast::Pass<CodeGenerator> cg( os, options );
 		cg.core.genAttributes( type->attributes );
 	}
 
-	return os.str() + ast::Pass<GenType_new>::read( type, base, options );
+	return os.str() + ast::Pass<GenType>::read( type, base, options );
 }
 
 std::string genTypeNoAttr( ast::Type const * type, const std::string & base, const Options & options ) {
-	return ast::Pass<GenType_new>::read( type, base, options );
+	return ast::Pass<GenType>::read( type, base, options );
 }
 
Index: src/CodeGen/Generate.cc
===================================================================
--- src/CodeGen/Generate.cc	(revision 61efa421be36a355b304d2e9b9e14e493947d332)
+++ src/CodeGen/Generate.cc	(revision 8d182b1ed853a31c8c46021c2f2a6be9c45ea31d)
@@ -19,5 +19,5 @@
 #include <string>                    // for operator<<
 
-#include "CodeGeneratorNew.hpp"      // for CodeGenerator_new, doSemicolon, ...
+#include "CodeGeneratorNew.hpp"      // for CodeGenerator, doSemicolon, ...
 #include "GenType.h"                 // for genPrettyType
 
@@ -32,5 +32,5 @@
 
 	/// Removes various nodes that should not exist in CodeGen.
-	struct TreeCleaner_new {
+	struct TreeCleaner final {
 		ast::CompoundStmt const * previsit( ast::CompoundStmt const * stmt ) {
 			auto mutStmt = ast::mutate( stmt );
@@ -51,7 +51,7 @@
 		bool pretty, bool generateC, bool lineMarks, bool printExprTypes ) {
 	erase_if( translationUnit.decls, shouldClean );
-	ast::Pass<TreeCleaner_new>::run( translationUnit );
+	ast::Pass<TreeCleaner>::run( translationUnit );
 
-	ast::Pass<CodeGenerator_new> cgv( os,
+	ast::Pass<CodeGenerator> cgv( os,
 			Options( pretty, generateC, lineMarks, printExprTypes ) );
 	for ( auto & decl : translationUnit.decls ) {
Index: src/CodeGen/Generate.h
===================================================================
--- src/CodeGen/Generate.h	(revision 61efa421be36a355b304d2e9b9e14e493947d332)
+++ src/CodeGen/Generate.h	(revision 8d182b1ed853a31c8c46021c2f2a6be9c45ea31d)
@@ -17,8 +17,4 @@
 
 #include <iostream>  // for ostream
-#include <list>      // for list
-
-class BaseSyntaxNode;
-class Declaration;
 
 namespace ast {