Index: src/SynTree/CompoundStmt.cc
===================================================================
--- src/SynTree/CompoundStmt.cc	(revision 487845d74b2dd4093ae3056d0dc4bc6c42748969)
+++ src/SynTree/CompoundStmt.cc	(revision 12d2dc8fad3691528e0f541fe5bd38046cdc9877)
@@ -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 487845d74b2dd4093ae3056d0dc4bc6c42748969)
+++ src/SynTree/DeclStmt.cc	(revision 12d2dc8fad3691528e0f541fe5bd38046cdc9877)
@@ -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 487845d74b2dd4093ae3056d0dc4bc6c42748969)
+++ src/SynTree/Statement.cc	(revision 12d2dc8fad3691528e0f541fe5bd38046cdc9877)
@@ -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 487845d74b2dd4093ae3056d0dc4bc6c42748969)
+++ src/SynTree/Statement.h	(revision 12d2dc8fad3691528e0f541fe5bd38046cdc9877)
@@ -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 487845d74b2dd4093ae3056d0dc4bc6c42748969)
+++ src/SynTree/TupleExpr.cc	(revision 12d2dc8fad3691528e0f541fe5bd38046cdc9877)
@@ -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 );
 }