Index: src/CodeGen/FixNames.cc
===================================================================
--- src/CodeGen/FixNames.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/CodeGen/FixNames.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -121,5 +121,5 @@
 				throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
 			}
-			functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) );
+			functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
 			CodeGen::FixMain::registerMain( functionDecl );
 		}
Index: src/Common/PassVisitor.impl.h
===================================================================
--- src/Common/PassVisitor.impl.h	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/Common/PassVisitor.impl.h	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -55,5 +55,5 @@
 		it,
 		[](Declaration * decl) -> auto {
-			return new DeclStmt( noLabels, decl );
+			return new DeclStmt( decl );
 		}
 	);
@@ -251,5 +251,5 @@
 	    || ( empty( beforeDecls ) && empty( afterDecls )) );
 
-	CompoundStmt *compound = new CompoundStmt( noLabels );
+	CompoundStmt *compound = new CompoundStmt();
 	if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
 	if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
Index: src/Concurrency/Keywords.cc
===================================================================
--- src/Concurrency/Keywords.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/Concurrency/Keywords.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -38,12 +38,4 @@
 
 namespace Concurrency {
-
-	namespace {
-		const std::list<Label> noLabels;
-		const std::list< Attribute * > noAttributes;
-		Type::StorageClasses noStorage;
-		Type::Qualifiers noQualifiers;
-	}
-
 	//=============================================================================================
 	// Pass declarations
@@ -296,5 +288,5 @@
 		ObjectDecl * this_decl = new ObjectDecl(
 			"this",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -313,5 +305,5 @@
 			new ObjectDecl(
 				"ret",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -346,5 +338,5 @@
 			main_decl = new FunctionDecl(
 				"main",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				main_type,
@@ -363,5 +355,5 @@
 		ObjectDecl * field = new ObjectDecl(
 			field_name,
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -379,8 +371,7 @@
 
 	void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
-		CompoundStmt * statement = new CompoundStmt( noLabels );
+		CompoundStmt * statement = new CompoundStmt();
 		statement->push_back(
 			new ReturnStmt(
-				noLabels,
 				new AddressExpr(
 					new MemberExpr(
@@ -488,5 +479,5 @@
 		ObjectDecl * monitors = new ObjectDecl(
 			"__monitor",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -509,7 +500,7 @@
 		// monitor_guard_t __guard = { __monitors, #, func };
 		body->push_front(
-			new DeclStmt( noLabels, new ObjectDecl(
+			new DeclStmt( new ObjectDecl(
 				"__guard",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -530,5 +521,5 @@
 
 		//monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-		body->push_front( new DeclStmt( noLabels, monitors) );
+		body->push_front( new DeclStmt( monitors) );
 	}
 
@@ -536,5 +527,5 @@
 		ObjectDecl * monitors = new ObjectDecl(
 			"__monitors",
-			noStorage,
+			noStorageClasses,
 			LinkageSpec::Cforall,
 			nullptr,
@@ -569,7 +560,7 @@
 		// monitor_guard_t __guard = { __monitors, #, func };
 		body->push_front(
-			new DeclStmt( noLabels, new ObjectDecl(
+			new DeclStmt( new ObjectDecl(
 				"__guard",
-				noStorage,
+				noStorageClasses,
 				LinkageSpec::Cforall,
 				nullptr,
@@ -591,5 +582,5 @@
 
 		//monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-		body->push_front( new DeclStmt( noLabels, monitors) );
+		body->push_front( new DeclStmt( monitors) );
 	}
 
@@ -631,5 +622,4 @@
 		stmt->push_back(
 			new ExprStmt(
-				noLabels,
 				new UntypedExpr(
 					new NameExpr( "__thrd_start" ),
Index: src/Concurrency/Waitfor.cc
===================================================================
--- src/Concurrency/Waitfor.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/Concurrency/Waitfor.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -100,12 +100,4 @@
 
 namespace Concurrency {
-
-	namespace {
-		const std::list<Label> noLabels;
-		const std::list< Attribute * > noAttributes;
-		Type::StorageClasses noStorage;
-		Type::Qualifiers noQualifiers;
-	}
-
 	//=============================================================================================
 	// Pass declarations
@@ -203,5 +195,5 @@
 			ResolvExpr::findVoidExpression( expr, indexer );
 
-			return new ExprStmt( noLabels, expr );
+			return new ExprStmt( expr );
 		}
 
@@ -259,5 +251,5 @@
 		if( !decl_monitor || !decl_acceptable || !decl_mask ) throw SemanticError( "waitfor keyword requires monitors to be in scope, add #include <monitor>", waitfor );
 
-		CompoundStmt * stmt = new CompoundStmt( noLabels );
+		CompoundStmt * stmt = new CompoundStmt();
 
 		ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
@@ -281,7 +273,6 @@
 		);
 
-		CompoundStmt * compound = new CompoundStmt( noLabels );
+		CompoundStmt * compound = new CompoundStmt();
 		stmt->push_back( new IfStmt(
-			noLabels,
 			safeCond( new VariableExpr( flag ) ),
 			compound,
@@ -313,5 +304,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, acceptables) );
+		stmt->push_back( new DeclStmt( acceptables) );
 
 		Expression * set = new UntypedExpr(
@@ -326,5 +317,5 @@
 		ResolvExpr::findVoidExpression( set, indexer );
 
-		stmt->push_back( new ExprStmt( noLabels, set ) );
+		stmt->push_back( new ExprStmt( set ) );
 
 		return acceptables;
@@ -341,5 +332,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, flag) );
+		stmt->push_back( new DeclStmt( flag) );
 
 		return flag;
@@ -357,5 +348,5 @@
 		ResolvExpr::findVoidExpression( expr, indexer );
 
-		return new ExprStmt( noLabels, expr );
+		return new ExprStmt( expr );
 	}
 
@@ -399,5 +390,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, mon) );
+		stmt->push_back( new DeclStmt( mon) );
 
 		return mon;
@@ -411,5 +402,4 @@
 
 		stmt->push_back( new IfStmt(
-			noLabels,
 			safeCond( clause.condition ),
 			new CompoundStmt({
@@ -447,13 +437,11 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, timeout ) );
+		stmt->push_back( new DeclStmt( timeout ) );
 
 		if( time ) {
 			stmt->push_back( new IfStmt(
-				noLabels,
 				safeCond( time_cond ),
 				new CompoundStmt({
 					new ExprStmt(
-						noLabels,
 						makeOpAssign(
 							new VariableExpr( timeout ),
@@ -471,9 +459,7 @@
 		if( has_else ) {
 			stmt->push_back( new IfStmt(
-				noLabels,
 				safeCond( else_cond ),
 				new CompoundStmt({
 					new ExprStmt(
-						noLabels,
 						makeOpAssign(
 							new VariableExpr( timeout ),
@@ -511,5 +497,5 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, index ) );
+		stmt->push_back( new DeclStmt( index ) );
 
 		ObjectDecl * mask = ObjectDecl::newObject(
@@ -526,8 +512,7 @@
 		);
 
-		stmt->push_back( new DeclStmt( noLabels, mask ) );
+		stmt->push_back( new DeclStmt( mask ) );
 
 		stmt->push_back( new ExprStmt(
-			noLabels,
 			new ApplicationExpr(
 				VariableExpr::functionPointer( decl_waitfor ),
@@ -557,5 +542,4 @@
 	) {
 		SwitchStmt * swtch = new SwitchStmt(
-			noLabels,
 			result,
 			std::list<Statement *>()
@@ -566,10 +550,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_ulong( i++ ) ),
 					{
 						clause.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
@@ -583,10 +565,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_int( -2 ) ),
 					{
 						waitfor->timeout.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
@@ -600,10 +580,8 @@
 			swtch->statements.push_back(
 				new CaseStmt(
-					noLabels,
 					new ConstantExpr( Constant::from_int( -1 ) ),
 					{
 						waitfor->orelse.statement,
 						new BranchStmt(
-							noLabels,
 							"",
 							BranchStmt::Break
Index: src/ControlStruct/ExceptTranslate.cc
===================================================================
--- src/ControlStruct/ExceptTranslate.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/ControlStruct/ExceptTranslate.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -30,5 +30,5 @@
 #include "SynTree/Expression.h"       // for UntypedExpr, ConstantExpr, Name...
 #include "SynTree/Initializer.h"      // for SingleInit, ListInit
-#include "SynTree/Label.h"            // for Label, noLabels
+#include "SynTree/Label.h"            // for Label
 #include "SynTree/Mutator.h"          // for mutateAll
 #include "SynTree/Statement.h"        // for CompoundStmt, CatchStmt, ThrowStmt
@@ -57,5 +57,5 @@
 
 	void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
-		block->push_back(new DeclStmt(noLabels, item));
+		block->push_back(new DeclStmt(item));
 	}
 
@@ -205,5 +205,5 @@
 		throwStmt->set_expr( nullptr );
 		delete throwStmt;
-		return new ExprStmt( noLabels, call );
+		return new ExprStmt( call );
 	}
 
@@ -220,6 +220,7 @@
 		assert( handler_except_decl );
 
-		CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
-		result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
+		CompoundStmt * result = new CompoundStmt();
+		result->labels =  throwStmt->labels;
+		result->push_back( new ExprStmt( UntypedExpr::createAssign(
 			nameOf( handler_except_decl ),
 			new ConstantExpr( Constant::null(
@@ -231,5 +232,4 @@
 			) ) );
 		result->push_back( new ExprStmt(
-			noLabels,
 			new UntypedExpr( new NameExpr( "__cfaehm__rethrow_terminate" ) )
 			) );
@@ -248,7 +248,7 @@
 		// return false;
 		Statement * result = new ReturnStmt(
-			throwStmt->get_labels(),
 			new ConstantExpr( Constant::from_bool( false ) )
 			);
+		result->labels = throwStmt->labels;
 		delete throwStmt;
 		return result;
@@ -291,5 +291,5 @@
 			// }
 			// return;
-			CompoundStmt * block = new CompoundStmt( noLabels );
+			CompoundStmt * block = new CompoundStmt();
 
 			// Just copy the exception value. (Post Validation)
@@ -304,5 +304,5 @@
 					) })
 				);
-			block->push_back( new DeclStmt( noLabels, local_except ) );
+			block->push_back( new DeclStmt( local_except ) );
 
 			// Add the cleanup attribute.
@@ -324,7 +324,6 @@
 
 			std::list<Statement *> caseBody
-					{ block, new ReturnStmt( noLabels, nullptr ) };
+					{ block, new ReturnStmt( nullptr ) };
 			handler_wrappers.push_back( new CaseStmt(
-				noLabels,
 				new ConstantExpr( Constant::from_int( index ) ),
 				caseBody
@@ -340,9 +339,8 @@
 
 		SwitchStmt * handler_lookup = new SwitchStmt(
-			noLabels,
 			nameOf( index_obj ),
 			stmt_handlers
 			);
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 		body->push_back( handler_lookup );
 
@@ -363,5 +361,5 @@
 		// }
 
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 
 		// Local Declaration
@@ -369,5 +367,5 @@
 			dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
 		assert( local_except );
-		block->push_back( new DeclStmt( noLabels, local_except ) );
+		block->push_back( new DeclStmt( local_except ) );
 
 		// Check for type match.
@@ -381,5 +379,5 @@
 		}
 		// Construct the match condition.
-		block->push_back( new IfStmt( noLabels,
+		block->push_back( new IfStmt(
 			cond, modded_handler->get_body(), nullptr ) );
 
@@ -397,5 +395,5 @@
 		// }
 
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		FunctionType * func_type = match_func_t.clone();
@@ -413,5 +411,5 @@
 
 			// Create new body.
-			handler->set_body( new ReturnStmt( noLabels,
+			handler->set_body( new ReturnStmt(
 				new ConstantExpr( Constant::from_int( index ) ) ) );
 
@@ -421,5 +419,5 @@
 		}
 
-		body->push_back( new ReturnStmt( noLabels,
+		body->push_back( new ReturnStmt(
 			new ConstantExpr( Constant::from_int( 0 ) ) ) );
 
@@ -441,6 +439,6 @@
 		args.push_back( nameOf( terminate_match ) );
 
-		CompoundStmt * callStmt = new CompoundStmt( noLabels );
-		callStmt->push_back( new ExprStmt( noLabels, caller ) );
+		CompoundStmt * callStmt = new CompoundStmt();
+		callStmt->push_back( new ExprStmt( caller ) );
 		return callStmt;
 	}
@@ -451,5 +449,5 @@
 		//     HANDLER WRAPPERS { `hander->body`; return true; }
 		// }
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		FunctionType * func_type = handle_func_t.clone();
@@ -464,8 +462,8 @@
 				dynamic_cast<CompoundStmt*>( handler->get_body() );
 			if ( ! handling_code ) {
-				handling_code = new CompoundStmt( noLabels );
+				handling_code = new CompoundStmt();
 				handling_code->push_back( handler->get_body() );
 			}
-			handling_code->push_back( new ReturnStmt( noLabels,
+			handling_code->push_back( new ReturnStmt(
 				new ConstantExpr( Constant::from_bool( true ) ) ) );
 			handler->set_body( handling_code );
@@ -476,5 +474,5 @@
 		}
 
-		body->push_back( new ReturnStmt( noLabels,
+		body->push_back( new ReturnStmt(
 			new ConstantExpr( Constant::from_bool( false ) ) ) );
 
@@ -486,5 +484,5 @@
 			Statement * wraps,
 			FunctionDecl * resume_handler ) {
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 
 		// struct __try_resume_node __resume_node
@@ -521,5 +519,5 @@
 		setup->get_args().push_back( nameOf( resume_handler ) );
 
-		body->push_back( new ExprStmt( noLabels, setup ) );
+		body->push_back( new ExprStmt( setup ) );
 
 		body->push_back( wraps );
@@ -646,5 +644,5 @@
 		// Generate a prefix for the function names?
 
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 		CompoundStmt * inner = take_try_block( tryStmt );
 
Index: src/ControlStruct/ForExprMutator.cc
===================================================================
--- src/ControlStruct/ForExprMutator.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/ControlStruct/ForExprMutator.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -29,5 +29,5 @@
 		// Create compound statement, move initializers outside,
 		// the resut of the original stays as is.
-		CompoundStmt *block = new CompoundStmt( std::list< Label >() );
+		CompoundStmt *block = new CompoundStmt();
 		std::list<Statement *> &stmts = block->get_kids();
 		stmts.splice( stmts.end(), init );
Index: src/ControlStruct/MLEMutator.cc
===================================================================
--- src/ControlStruct/MLEMutator.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/ControlStruct/MLEMutator.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -149,6 +149,7 @@
 
 			if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
-				std::list<Label> temp; temp.push_back( brkLabel );
-				c->get_statements().push_back( new BranchStmt( temp, Label("brkLabel"), BranchStmt::Break ) );
+				Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
+				stmt->labels.push_back( brkLabel );
+				c->get_statements().push_back( stmt );
 			} else assert(0); // as of this point, all statements of a switch are still CaseStmts
 		} // if
@@ -232,5 +233,5 @@
 		// transform break/continue statements into goto to simplify later handling of branches
 		delete branchStmt;
-		return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
+		return new BranchStmt( exitLabel, BranchStmt::Goto );
 	}
 
@@ -239,5 +240,5 @@
 		CompoundStmt *newBody;
 		if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
-			newBody = new CompoundStmt( std::list< Label >() );
+			newBody = new CompoundStmt();
 			newBody->get_kids().push_back( bodyLoop );
 		} // if
Index: src/GenPoly/Box.cc
===================================================================
--- src/GenPoly/Box.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/GenPoly/Box.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -49,5 +49,5 @@
 #include "SynTree/Expression.h"          // for ApplicationExpr, UntypedExpr
 #include "SynTree/Initializer.h"         // for SingleInit, Initializer, Lis...
-#include "SynTree/Label.h"               // for Label, noLabels
+#include "SynTree/Label.h"               // for Label
 #include "SynTree/Mutator.h"             // for maybeMutate, Mutator, mutateAll
 #include "SynTree/Statement.h"           // for ExprStmt, DeclStmt, ReturnStmt
@@ -293,5 +293,5 @@
 		FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
 													 functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
-													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
+													 LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
 													 std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		layoutDecl->fixUniqueId();
@@ -321,5 +321,5 @@
 	/// makes an if-statement with a single-expression if-block and no then block
 	Statement *makeCond( Expression *cond, Expression *ifPart ) {
-		return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 );
+		return new IfStmt( cond, new ExprStmt( ifPart ), 0 );
 	}
 
@@ -340,5 +340,5 @@
 	/// adds an expression to a compound statement
 	void addExpr( CompoundStmt *stmts, Expression *expr ) {
-		stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
+		stmts->get_kids().push_back( new ExprStmt( expr ) );
 	}
 
@@ -629,5 +629,5 @@
 		ObjectDecl *Pass1::makeTemporary( Type *type ) {
 			ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
-			stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+			stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 			return newObj;
 		}
@@ -740,9 +740,9 @@
 				ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
 				newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 				UntypedExpr *assign = new UntypedExpr( new NameExpr( "?=?" ) ); // TODO: why doesn't this just use initialization syntax?
 				assign->get_args().push_back( new VariableExpr( newObj ) );
 				assign->get_args().push_back( arg );
-				stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
+				stmtsToAddBefore.push_back( new ExprStmt( assign ) );
 				arg = new AddressExpr( new VariableExpr( newObj ) );
 			} // if
@@ -888,5 +888,5 @@
 				// void return
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-				bodyStmt = new ExprStmt( noLabels, adapteeApp );
+				bodyStmt = new ExprStmt( adapteeApp );
 			} else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
 				// return type T
@@ -900,11 +900,11 @@
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
 				assign->get_args().push_back( adapteeApp );
-				bodyStmt = new ExprStmt( noLabels, assign );
+				bodyStmt = new ExprStmt( assign );
 			} else {
 				// adapter for a function that returns a monomorphic value
 				addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-				bodyStmt = new ReturnStmt( noLabels, adapteeApp );
+				bodyStmt = new ReturnStmt( adapteeApp );
 			} // if
-			CompoundStmt *adapterBody = new CompoundStmt( noLabels );
+			CompoundStmt *adapterBody = new CompoundStmt();
 			adapterBody->get_kids().push_back( bodyStmt );
 			std::string adapterName = makeAdapterName( mangleName );
@@ -952,5 +952,5 @@
 						std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
 						adapter = answer.first;
-						stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
+						stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
 					} // if
 					assert( adapter != adapters.end() );
@@ -1279,5 +1279,5 @@
 						retval->set_name( "_retval" );
 					}
-					functionDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, retval ) );
+					functionDecl->get_statements()->get_kids().push_front( new DeclStmt( retval ) );
 					DeclarationWithType * newRet = retval->clone(); // for ownership purposes
 					ftype->get_returnVals().front() = newRet;
@@ -1519,5 +1519,5 @@
 					// (alloca was previously used, but can't be safely used in loops)
 					ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
+					stmtsToAddBefore.push_back( new DeclStmt( newBuf ) );
 
 					delete objectDecl->get_init();
@@ -1598,5 +1598,5 @@
 		ObjectDecl *PolyGenericCalculator::makeVar( const std::string &name, Type *type, Initializer *init ) {
 			ObjectDecl *newObj = new ObjectDecl( name, Type::StorageClasses(), LinkageSpec::C, 0, type, init );
-			stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+			stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
 			return newObj;
 		}
@@ -1677,5 +1677,5 @@
 					addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-					stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+					stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
 				}
 
@@ -1703,5 +1703,5 @@
 				addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-				stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
+				stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
 
 				return true;
Index: src/GenPoly/InstantiateGeneric.cc
===================================================================
--- src/GenPoly/InstantiateGeneric.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/GenPoly/InstantiateGeneric.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -526,5 +526,5 @@
 					Expression * init = new CastExpr( new AddressExpr( memberExpr ), new PointerType( Type::Qualifiers(), concType->clone() ) );
 					ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), new ReferenceType( Type::Qualifiers(), concType ), new SingleInit( init ) );
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, tmp ) );
+					stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
 					return new VariableExpr( tmp );
 				} else {
Index: src/GenPoly/Specialize.cc
===================================================================
--- src/GenPoly/Specialize.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/GenPoly/Specialize.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -35,5 +35,5 @@
 #include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...
 #include "SynTree/Expression.h"          // for ApplicationExpr, Expression
-#include "SynTree/Label.h"               // for Label, noLabels
+#include "SynTree/Label.h"               // for Label
 #include "SynTree/Mutator.h"             // for mutateAll
 #include "SynTree/Statement.h"           // for CompoundStmt, DeclStmt, Expr...
@@ -234,5 +234,5 @@
 		} // if
 		// create new thunk with same signature as formal type (C linkage, empty body)
-		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
+		FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt() );
 		thunkFunc->fixUniqueId();
 
@@ -287,12 +287,12 @@
 		Statement *appStmt;
 		if ( funType->returnVals.empty() ) {
-			appStmt = new ExprStmt( noLabels, appExpr );
-		} else {
-			appStmt = new ReturnStmt( noLabels, appExpr );
+			appStmt = new ExprStmt( appExpr );
+		} else {
+			appStmt = new ReturnStmt( appExpr );
 		} // if
 		thunkFunc->statements->kids.push_back( appStmt );
 
 		// add thunk definition to queue of statements to add
-		stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
+		stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
 		// return address of thunk function as replacement expression
 		return new AddressExpr( new VariableExpr( thunkFunc ) );
Index: src/InitTweak/FixGlobalInit.cc
===================================================================
--- src/InitTweak/FixGlobalInit.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/InitTweak/FixGlobalInit.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -29,5 +29,5 @@
 #include "SynTree/Expression.h"    // for ConstantExpr, Expression (ptr only)
 #include "SynTree/Initializer.h"   // for ConstructorInit, Initializer
-#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Label.h"         // for Label
 #include "SynTree/Statement.h"     // for CompoundStmt, Statement (ptr only)
 #include "SynTree/Type.h"          // for Type, Type::StorageClasses, Functi...
@@ -92,7 +92,7 @@
 			dtorParameters.push_back( new ConstantExpr( Constant::from_int( 102 ) ) );
 		}
-		initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 		initFunction->get_attributes().push_back( new Attribute( "constructor", ctorParameters ) );
-		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+		destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 		destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
 	}
Index: src/InitTweak/FixInit.cc
===================================================================
--- src/InitTweak/FixInit.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/InitTweak/FixInit.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -49,5 +49,5 @@
 #include "SynTree/Expression.h"        // for UniqueExpr, VariableExpr, Unty...
 #include "SynTree/Initializer.h"       // for ConstructorInit, SingleInit
-#include "SynTree/Label.h"             // for Label, noLabels, operator<
+#include "SynTree/Label.h"             // for Label, operator<
 #include "SynTree/Mutator.h"           // for mutateAll, Mutator, maybeMutate
 #include "SynTree/Statement.h"         // for ExprStmt, CompoundStmt, Branch...
@@ -544,13 +544,13 @@
 			// add all temporary declarations and their constructors
 			for ( ObjectDecl * obj : tempDecls ) {
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 			} // for
 			for ( ObjectDecl * obj : returnDecls ) {
-				stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+				stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 			} // for
 
 			// add destructors after current statement
 			for ( Expression * dtor : dtors ) {
-				stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+				stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
 			} // for
 
@@ -598,14 +598,14 @@
 			if ( ! result->isVoid() ) {
 				for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-					stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+					stmtsToAddBefore.push_back( new DeclStmt( obj ) );
 				} // for
 				// add destructors after current statement
 				for ( Expression * dtor : stmtExpr->get_dtors() ) {
-					stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
+					stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
 				} // for
 				// must have a non-empty body, otherwise it wouldn't have a result
 				assert( ! stmts.empty() );
 				assert( ! stmtExpr->get_returnDecls().empty() );
-				stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+				stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
 				stmtExpr->get_returnDecls().clear();
 				stmtExpr->get_dtors().clear();
@@ -685,12 +685,12 @@
 
 						// generate body of if
-						CompoundStmt * initStmts = new CompoundStmt( noLabels );
+						CompoundStmt * initStmts = new CompoundStmt();
 						std::list< Statement * > & body = initStmts->get_kids();
 						body.push_back( ctor );
-						body.push_back( new ExprStmt( noLabels, setTrue ) );
+						body.push_back( new ExprStmt( setTrue ) );
 
 						// put it all together
-						IfStmt * ifStmt = new IfStmt( noLabels, new VariableExpr( isUninitializedVar ), initStmts, 0 );
-						stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) );
+						IfStmt * ifStmt = new IfStmt( new VariableExpr( isUninitializedVar ), initStmts, 0 );
+						stmtsToAddAfter.push_back( new DeclStmt( isUninitializedVar ) );
 						stmtsToAddAfter.push_back( ifStmt );
 
@@ -707,5 +707,5 @@
 
 							// void __objName_dtor_atexitN(...) {...}
-							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
+							FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt() );
 							dtorCaller->fixUniqueId();
 							dtorCaller->get_statements()->push_back( dtorStmt );
@@ -715,5 +715,5 @@
 							callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
 
-							body.push_back( new ExprStmt( noLabels, callAtexit ) );
+							body.push_back( new ExprStmt( callAtexit ) );
 
 							// hoist variable and dtor caller decls to list of decls that will be added into global scope
Index: src/InitTweak/InitTweak.cc
===================================================================
--- src/InitTweak/InitTweak.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/InitTweak/InitTweak.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -19,5 +19,5 @@
 #include "SynTree/Expression.h"    // for Expression, UntypedExpr, Applicati...
 #include "SynTree/Initializer.h"   // for Initializer, ListInit, Designation
-#include "SynTree/Label.h"         // for Label, noLabels
+#include "SynTree/Label.h"         // for Label
 #include "SynTree/Statement.h"     // for CompoundStmt, ExprStmt, BranchStmt
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
@@ -195,9 +195,9 @@
 			callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-			*out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
+			*out++ = new IfStmt( cond, new ExprStmt( callExpr ), nullptr );
 
 			UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
 			increment->get_args().push_back( index->clone() );
-			*out++ = new ExprStmt( noLabels, increment );
+			*out++ = new ExprStmt( increment );
 		}
 
@@ -244,10 +244,10 @@
 					std::list< Statement * > stmts;
 					build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
-					stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) );
-					CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
+					stmts.push_back( new BranchStmt( switchLabel, BranchStmt::Break ) );
+					CaseStmt * caseStmt = new CaseStmt( condition, stmts );
 					branches.push_back( caseStmt );
 				}
-				*out++ = new SwitchStmt( noLabels, index->clone(), branches );
-				*out++ = new NullStmt( std::list<Label>{ switchLabel } );
+				*out++ = new SwitchStmt( index->clone(), branches );
+				*out++ = new NullStmt( { switchLabel } );
 			}
 		}
@@ -262,5 +262,5 @@
 	Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
 		if ( ! init ) return nullptr;
-		CompoundStmt * block = new CompoundStmt( noLabels );
+		CompoundStmt * block = new CompoundStmt();
 		build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
 		if ( block->get_kids().empty() ) {
Index: src/MakeLibCfa.cc
===================================================================
--- src/MakeLibCfa.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/MakeLibCfa.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -116,5 +116,5 @@
 			} // for
 
-			funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
+			funcDecl->set_statements( new CompoundStmt() );
 			newDecls.push_back( funcDecl );
 
@@ -130,10 +130,10 @@
 			  case CodeGen::OT_INFIXASSIGN:
 					// return the recursive call
-					stmt = new ReturnStmt( noLabels, newExpr );
+					stmt = new ReturnStmt( newExpr );
 					break;
 			  case CodeGen::OT_CTOR:
 			  case CodeGen::OT_DTOR:
 					// execute the recursive call
-					stmt = new ExprStmt( noLabels, newExpr );
+					stmt = new ExprStmt( newExpr );
 					break;
 			  case CodeGen::OT_CONSTANT:
Index: src/Parser/StatementNode.cc
===================================================================
--- src/Parser/StatementNode.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/Parser/StatementNode.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -37,5 +37,5 @@
 	DeclarationNode *agg = decl->extractAggregate();
 	if ( agg ) {
-		StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
+		StatementNode *nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
 		set_next( nextStmt );
 		if ( decl->get_next() ) {
@@ -50,5 +50,5 @@
 		agg = decl;
 	} // if
-	stmt.reset( new DeclStmt( noLabels, maybeMoveBuild< Declaration >(agg) ) );
+	stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
 } // StatementNode::StatementNode
 
@@ -75,7 +75,7 @@
 
 	if ( e )
-		return new ExprStmt( noLabels, e );
+		return new ExprStmt( e );
 	else
-		return new NullStmt( noLabels );
+		return new NullStmt();
 }
 
@@ -113,5 +113,5 @@
 	}
 	delete ctl;
-	return new IfStmt( noLabels, cond, thenb, elseb, init );
+	return new IfStmt( cond, thenb, elseb, init );
 }
 
@@ -120,13 +120,13 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	// branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
-	return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+	return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
 	std::list< Statement * > branches;
-	return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
+	return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
 	std::list< Statement * > branches;
-	return new CaseStmt( noLabels, nullptr, branches, true );
+	return new CaseStmt( nullptr, branches, true );
 }
 
@@ -135,5 +135,5 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
+	return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
@@ -157,18 +157,18 @@
 
 	delete forctl;
-	return new ForStmt( noLabels, init, cond, incr, branches.front() );
+	return new ForStmt( init, cond, incr, branches.front() );
 }
 
 Statement *build_branch( BranchStmt::Type kind ) {
-	Statement * ret = new BranchStmt( noLabels, "", kind );
+	Statement * ret = new BranchStmt( "", kind );
 	return ret;
 }
 Statement *build_branch( std::string *identifier, BranchStmt::Type kind ) {
-	Statement * ret = new BranchStmt( noLabels, *identifier, kind );
+	Statement * ret = new BranchStmt( *identifier, kind );
 	delete identifier; 									// allocated by lexer
 	return ret;
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-	return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+	return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
@@ -176,5 +176,5 @@
 	std::list< Expression * > exps;
 	buildMoveList( ctl, exps );
-	return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
+	return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
 }
 
@@ -183,5 +183,5 @@
 	buildMoveList( ctl, exps );
 	assertf( exps.size() < 2, "This means we are leaking memory");
-	return new ThrowStmt( noLabels, ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+	return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -190,5 +190,5 @@
 	buildMoveList( ctl, exps );
 	assertf( exps.size() < 2, "This means we are leaking memory");
-	return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+	return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -204,5 +204,5 @@
 	CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
 	FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
-	return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
+	return new TryStmt( tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body ) {
@@ -210,5 +210,5 @@
 	buildMoveList< Statement, StatementNode >( body, branches );
 	assert( branches.size() == 1 );
-	return new CatchStmt( noLabels, kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
+	return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
 }
 Statement *build_finally( StatementNode *stmt ) {
@@ -216,5 +216,5 @@
 	buildMoveList< Statement, StatementNode >( stmt, branches );
 	assert( branches.size() == 1 );
-	return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
+	return new FinallyStmt( dynamic_cast< CompoundStmt * >( branches.front() ) );
 }
 
@@ -289,5 +289,5 @@
 
 Statement *build_compound( StatementNode *first ) {
-	CompoundStmt *cs = new CompoundStmt( noLabels );
+	CompoundStmt *cs = new CompoundStmt();
 	buildMoveList( first, cs->get_kids() );
 	return cs;
@@ -301,5 +301,5 @@
 	buildMoveList( input, in );
 	buildMoveList( clobber, clob );
-	return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+	return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }
 
Index: src/SymTab/AddVisit.h
===================================================================
--- src/SymTab/AddVisit.h	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SymTab/AddVisit.h	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -24,5 +24,5 @@
 			// add any new declarations after the previous statement
 			for ( std::list< Declaration* >::iterator decl = visitor.declsToAddAfter.begin(); decl != visitor.declsToAddAfter.end(); ++decl ) {
-				DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
+				DeclStmt *declStmt = new DeclStmt( *decl );
 				stmts.insert( stmt, declStmt );
 			}
@@ -36,5 +36,5 @@
 			// add any new declarations before the statement
 			for ( std::list< Declaration* >::iterator decl = visitor.declsToAdd.begin(); decl != visitor.declsToAdd.end(); ++decl ) {
-				DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
+				DeclStmt *declStmt = new DeclStmt( *decl );
 				stmts.insert( stmt, declStmt );
 			}
Index: src/SymTab/Autogen.cc
===================================================================
--- src/SymTab/Autogen.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SymTab/Autogen.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -264,5 +264,5 @@
 		Type::StorageClasses scs = functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static );
 		LinkageSpec::Spec spec = isIntrinsic ? LinkageSpec::Intrinsic : LinkageSpec::AutoGen;
-		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
+		FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt(),
 												std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
 		decl->fixUniqueId();
@@ -299,5 +299,5 @@
 				assert( assignType->returnVals.size() == 1 );
 				ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() );
-				dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) );
+				dcl->statements->push_back( new ReturnStmt( new VariableExpr( dstParam ) ) );
 			}
 			resolve( dcl );
@@ -468,5 +468,5 @@
 		copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
 		copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
-		*out++ = new ExprStmt( noLabels, copy );
+		*out++ = new ExprStmt( copy );
 	}
 
@@ -544,5 +544,5 @@
 			callExpr->get_args().push_back( new VariableExpr( dstParam ) );
 			callExpr->get_args().push_back( new VariableExpr( srcParam ) );
-			funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) );
+			funcDecl->statements->push_back( new ExprStmt( callExpr ) );
 		} else {
 			// default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
@@ -569,5 +569,5 @@
 		expr->args.push_back( new CastExpr( new VariableExpr( dst ), new ReferenceType( Type::Qualifiers(), typeDecl->base->clone() ) ) );
 		if ( src ) expr->args.push_back( new CastExpr( new VariableExpr( src ), typeDecl->base->clone() ) );
-		dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
+		dcl->statements->kids.push_back( new ExprStmt( expr ) );
 	};
 
@@ -664,6 +664,6 @@
 			untyped->get_args().push_back( new VariableExpr( ftype->get_parameters().back() ) );
 		}
-		function->get_statements()->get_kids().push_back( new ExprStmt( noLabels, untyped ) );
-		function->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
+		function->get_statements()->get_kids().push_back( new ExprStmt( untyped ) );
+		function->get_statements()->get_kids().push_back( new ReturnStmt( UntypedExpr::createDeref( new VariableExpr( ftype->get_parameters().front() ) ) ) );
 	}
 
Index: src/SymTab/Autogen.h
===================================================================
--- src/SymTab/Autogen.h	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SymTab/Autogen.h	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -104,5 +104,5 @@
 		fExpr->args.splice( fExpr->args.end(), args );
 
-		*out++ = new ExprStmt( noLabels, fExpr );
+		*out++ = new ExprStmt( fExpr );
 
 		srcParam.clearArrayIndices();
@@ -162,13 +162,13 @@
 
 		// for stmt's body, eventually containing call
-		CompoundStmt * body = new CompoundStmt( noLabels );
+		CompoundStmt * body = new CompoundStmt();
 		Statement * listInit = genCall( srcParam, dstParam, fname, back_inserter( body->kids ), array->base, addCast, forward );
 
 		// block containing for stmt and index variable
 		std::list<Statement *> initList;
-		CompoundStmt * block = new CompoundStmt( noLabels );
-		block->push_back( new DeclStmt( noLabels, index ) );
+		CompoundStmt * block = new CompoundStmt();
+		block->push_back( new DeclStmt( index ) );
 		if ( listInit ) block->get_kids().push_back( listInit );
-		block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
+		block->push_back( new ForStmt( initList, cond, inc, body ) );
 
 		*out++ = block;
Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SynTree/CompoundStmt.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -28,8 +28,8 @@
 using std::endl;
 
-CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
+CompoundStmt::CompoundStmt() : Statement() {
 }
 
-CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement(), kids( stmts ) {
 }
 
Index: src/SynTree/DeclStmt.cc
===================================================================
--- src/SynTree/DeclStmt.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SynTree/DeclStmt.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -23,5 +23,5 @@
 #include "SynTree/Label.h"   // for Label
 
-DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl ) : Statement( labels ), decl( decl ) {
+DeclStmt::DeclStmt( Declaration *decl ) : Statement(), decl( decl ) {
 }
 
Index: src/SynTree/Statement.cc
===================================================================
--- src/SynTree/Statement.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SynTree/Statement.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -32,5 +32,5 @@
 using std::endl;
 
-Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
+Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
 
 void Statement::print( std::ostream & os, Indenter ) const {
@@ -46,5 +46,5 @@
 Statement::~Statement() {}
 
-ExprStmt::ExprStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -60,5 +60,5 @@
 
 
-AsmStmt::AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement( labels ), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
+AsmStmt::AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels ) : Statement(), voltile( voltile ), instruction( instruction ), output( output ), input( input ), clobber( clobber ), gotolabels( gotolabels ) {}
 
 AsmStmt::AsmStmt( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -96,6 +96,6 @@
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
-BranchStmt::BranchStmt( std::list<Label> labels, Label target, Type type ) throw ( SemanticError ) :
-	Statement( labels ), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
+BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticError ) :
+	Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
 	//actually this is a syntactic error signaled by the parser
 	if ( type == BranchStmt::Goto && target.empty() ) {
@@ -104,6 +104,6 @@
 }
 
-BranchStmt::BranchStmt( std::list<Label> labels, Expression *computedTarget, Type type ) throw ( SemanticError ) :
-	Statement( labels ), computedTarget( computedTarget ), type( type ) {
+BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticError ) :
+	Statement(), computedTarget( computedTarget ), type( type ) {
 	if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
 		throw SemanticError("Computed target not valid in branch statement");
@@ -118,5 +118,5 @@
 }
 
-ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
+ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
 
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -135,6 +135,6 @@
 }
 
-IfStmt::IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
-	Statement( labels ), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
+IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
+	Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
 
 IfStmt::IfStmt( const IfStmt & other ) :
@@ -176,6 +176,6 @@
 }
 
-SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
-	Statement( labels ), condition( condition ), statements( statements ) {
+SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
+	Statement(), condition( condition ), statements( statements ) {
 }
 
@@ -201,6 +201,6 @@
 }
 
-CaseStmt::CaseStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
-	Statement( labels ), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
+	Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
 	if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
 }
@@ -216,6 +216,8 @@
 }
 
-CaseStmt * CaseStmt::makeDefault( std::list<Label> labels, std::list<Statement *> stmts ) {
-	return new CaseStmt( labels, 0, stmts, true );
+CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
+	CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
+	stmt->labels = labels;
+	return stmt;
 }
 
@@ -233,6 +235,6 @@
 }
 
-WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition, Statement *body, bool isDoWhile ):
-	Statement( labels ), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
+	Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
 }
 
@@ -255,6 +257,6 @@
 }
 
-ForStmt::ForStmt( std::list<Label> labels, std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
-	Statement( labels ), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
+	Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
 }
 
@@ -302,6 +304,6 @@
 }
 
-ThrowStmt::ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target ) :
-		Statement( labels ), kind(kind), expr(expr), target(target)	{
+ThrowStmt::ThrowStmt( Kind kind, Expression * expr, Expression * target ) :
+		Statement(), kind(kind), expr(expr), target(target)	{
 	assertf(Resume == kind || nullptr == target, "Non-local termination throw is not accepted." );
 }
@@ -326,6 +328,6 @@
 }
 
-TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
-	Statement( labels ), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
+TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
+	Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
 
@@ -359,6 +361,6 @@
 }
 
-CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
-	Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
+	Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
 		assertf( decl, "Catch clause must have a declaration." );
 }
@@ -391,6 +393,5 @@
 
 
-FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *block ) : Statement( labels ), block( block ) {
-	assert( labels.empty() ); // finally statement cannot be labeled
+FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
 }
 
@@ -408,5 +409,5 @@
 }
 
-WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
+WaitForStmt::WaitForStmt() : Statement() {
 	timeout.time      = nullptr;
 	timeout.statement = nullptr;
@@ -455,6 +456,6 @@
 }
 
-NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
-NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
+NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
+}
 
 void NullStmt::print( std::ostream &os, Indenter ) const {
@@ -462,5 +463,5 @@
 }
 
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement(), callStmt( callStmt ) {
 	assert( callStmt );
 }
Index: src/SynTree/Statement.h
===================================================================
--- src/SynTree/Statement.h	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SynTree/Statement.h	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -37,5 +37,5 @@
 	std::list<Label> labels;
 
-	Statement( std::list<Label> labels );
+	Statement( const std::list<Label> & labels = {} );
 	virtual ~Statement();
 
@@ -53,5 +53,5 @@
 	std::list<Statement*> kids;
 
-	CompoundStmt( std::list<Label> labels );
+	CompoundStmt();
 	CompoundStmt( std::list<Statement *> stmts );
 	CompoundStmt( const CompoundStmt &other );
@@ -70,6 +70,5 @@
 class NullStmt : public Statement {
   public:
-	NullStmt();
-	NullStmt( std::list<Label> labels );
+	NullStmt( const std::list<Label> & labels = {} );
 
 	virtual NullStmt *clone() const override { return new NullStmt( *this ); }
@@ -83,5 +82,5 @@
 	Expression *expr;
 
-	ExprStmt( std::list<Label> labels, Expression *expr );
+	ExprStmt( Expression *expr );
 	ExprStmt( const ExprStmt &other );
 	virtual ~ExprStmt();
@@ -104,5 +103,5 @@
 	std::list<Label> gotolabels;
 
-	AsmStmt( std::list<Label> labels, bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
+	AsmStmt( bool voltile, Expression *instruction, std::list<Expression *> output, std::list<Expression *> input, std::list<ConstantExpr *> clobber, std::list<Label> gotolabels );
 	AsmStmt( const AsmStmt &other );
 	virtual ~AsmStmt();
@@ -134,5 +133,5 @@
 	std::list<Statement *> initialization;
 
-	IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart,
+	IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
 			std::list<Statement *> initialization = std::list<Statement *>() );
 	IfStmt( const IfStmt &other );
@@ -158,5 +157,5 @@
 	std::list<Statement *> statements;
 
-	SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
+	SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
 	SwitchStmt( const SwitchStmt &other );
 	virtual ~SwitchStmt();
@@ -180,9 +179,9 @@
 	std::list<Statement *> stmts;
 
-	CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+	CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
 	CaseStmt( const CaseStmt &other );
 	virtual ~CaseStmt();
 
-	static CaseStmt * makeDefault( std::list<Label> labels = std::list<Label>(), std::list<Statement *> stmts = std::list<Statement *>() );
+	static CaseStmt * makeDefault( const std::list<Label> & labels = {}, std::list<Statement *> stmts = std::list<Statement *>() );
 
 	bool isDefault() const { return _isDefault; }
@@ -210,5 +209,5 @@
 	bool isDoWhile;
 
-	WhileStmt( std::list<Label> labels, Expression *condition,
+	WhileStmt( Expression *condition,
 	       Statement *body, bool isDoWhile = false );
 	WhileStmt( const WhileStmt &other );
@@ -235,5 +234,5 @@
 	Statement *body;
 
-	ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
+	ForStmt( std::list<Statement *> initialization,
 	     Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
 	ForStmt( const ForStmt &other );
@@ -264,6 +263,6 @@
 	Type type;
 
-	BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
-	BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
+	BranchStmt( Label target, Type ) throw (SemanticError);
+	BranchStmt( Expression *computedTarget, Type ) throw (SemanticError);
 
 	Label get_originalTarget() { return originalTarget; }
@@ -289,5 +288,5 @@
 	Expression *expr;
 
-	ReturnStmt( std::list<Label> labels, Expression *expr );
+	ReturnStmt( Expression *expr );
 	ReturnStmt( const ReturnStmt &other );
 	virtual ~ReturnStmt();
@@ -310,5 +309,5 @@
 	Expression * target;
 
-	ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
+	ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
 	ThrowStmt( const ThrowStmt &other );
 	virtual ~ThrowStmt();
@@ -332,5 +331,5 @@
 	FinallyStmt * finallyBlock;
 
-	TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
+	TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
 	TryStmt( const TryStmt &other );
 	virtual ~TryStmt();
@@ -358,5 +357,5 @@
 	Statement *body;
 
-	CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
+	CatchStmt( Kind kind, Declaration *decl,
 	           Expression *cond, Statement *body );
 	CatchStmt( const CatchStmt &other );
@@ -381,5 +380,5 @@
 	CompoundStmt *block;
 
-	FinallyStmt( std::list<Label> labels, CompoundStmt *block );
+	FinallyStmt( CompoundStmt *block );
 	FinallyStmt( const FinallyStmt &other );
 	virtual ~FinallyStmt();
@@ -408,5 +407,5 @@
 	};
 
-	WaitForStmt( std::list<Label> labels = noLabels );
+	WaitForStmt();
 	WaitForStmt( const WaitForStmt & );
 	virtual ~WaitForStmt();
@@ -438,5 +437,5 @@
 	Declaration *decl;
 
-	DeclStmt( std::list<Label> labels, Declaration *decl );
+	DeclStmt( Declaration *decl );
 	DeclStmt( const DeclStmt &other );
 	virtual ~DeclStmt();
Index: src/SynTree/TupleExpr.cc
===================================================================
--- src/SynTree/TupleExpr.cc	(revision 4429b04ca946276c0b8ac84a2f2188572c29d66c)
+++ src/SynTree/TupleExpr.cc	(revision ba3706fcc236a2f6c927dc1a9da14313751a7aa4)
@@ -23,5 +23,5 @@
 #include "Declaration.h"        // for ObjectDecl
 #include "Expression.h"         // for Expression, TupleExpr, TupleIndexExpr
-#include "SynTree/Label.h"      // for Label, noLabels
+#include "SynTree/Label.h"      // for Label
 #include "SynTree/Statement.h"  // for CompoundStmt, DeclStmt, ExprStmt, Sta...
 #include "Tuples/Tuples.h"      // for makeTupleType
@@ -89,12 +89,12 @@
 	// convert internally into a StmtExpr which contains the declarations and produces the tuple of the assignments
 	set_result( Tuples::makeTupleType( assigns ) );
-	CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
+	CompoundStmt * compoundStmt = new CompoundStmt();
 	std::list< Statement * > & stmts = compoundStmt->get_kids();
 	for ( ObjectDecl * obj : tempDecls ) {
-		stmts.push_back( new DeclStmt( noLabels, obj ) );
+		stmts.push_back( new DeclStmt( obj ) );
 	}
 	TupleExpr * tupleExpr = new TupleExpr( assigns );
 	assert( tupleExpr->get_result() );
-	stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
+	stmts.push_back( new ExprStmt( tupleExpr ) );
 	stmtExpr = new StmtExpr( compoundStmt );
 }