Changes in / [5da9d6a:3d560060]

Location:

src

Files:

• CodeGen/FixNames.cc (modified) (5 diffs)
• CodeGen/FixNames.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (4 diffs)
• Concurrency/Keywords.cc (modified) (13 diffs)
• Concurrency/Waitfor.cc (modified) (18 diffs)
• ControlStruct/ExceptTranslate.cc (modified) (23 diffs)
• ControlStruct/ForExprMutator.cc (modified) (1 diff)
• ControlStruct/LabelFixer.cc (modified) (3 diffs)
• ControlStruct/LabelFixer.h (modified) (3 diffs)
• ControlStruct/MLEMutator.cc (modified) (3 diffs)
• ControlStruct/Mutate.cc (modified) (2 diffs)
• GenPoly/Box.cc (modified) (14 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (3 diffs)
• InitTweak/FixGlobalInit.cc (modified) (6 diffs)
• InitTweak/FixInit.cc (modified) (6 diffs)
• InitTweak/InitTweak.cc (modified) (12 diffs)
• MakeLibCfa.cc (modified) (2 diffs)
• Makefile.in (modified) (5 diffs)
• Parser/StatementNode.cc (modified) (15 diffs)
• SymTab/AddVisit.h (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (6 diffs)
• SymTab/Autogen.h (modified) (2 diffs)
• SymTab/ImplementationType.cc (added)
• SymTab/ImplementationType.h (added)
• SymTab/TypeEquality.cc (added)
• SymTab/TypeEquality.h (added)
• SymTab/Validate.cc (modified) (3 diffs)
• SymTab/module.mk (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (1 diff)
• SynTree/DeclStmt.cc (modified) (1 diff)
• SynTree/Statement.cc (modified) (19 diffs)
• SynTree/Statement.h (modified) (18 diffs)
• SynTree/TupleExpr.cc (modified) (2 diffs)
• Tuples/TupleAssignment.cc (modified) (16 diffs)
• Tuples/TupleExpansion.cc (modified) (3 diffs)
• tests/except-mac.h (modified) (3 diffs)

src/CodeGen/FixNames.cc

@@ -19 +19 @@
 #include <string>                  // for string, operator!=, operator==
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "FixMain.h"               // for FixMain
@@ -33 +32 @@
 
 namespace CodeGen {
-        class FixNames : public WithGuards {
+        class FixNames : public Visitor {
           public:
-                void postvisit( ObjectDecl *objectDecl );
-                void postvisit( FunctionDecl *functionDecl );
+                virtual void visit( ObjectDecl *objectDecl );
+                virtual void visit( FunctionDecl *functionDecl );
 
-                void previsit( CompoundStmt *compoundStmt );
+                virtual void visit( CompoundStmt *compoundStmt );
           private:
                 int scopeLevel = 1;
@@ -94 +93 @@
         }
 
-        void fixNames( std::list< Declaration* > & translationUnit ) {
-                PassVisitor<FixNames> fixer;
+        void fixNames( std::list< Declaration* > translationUnit ) {
+                FixNames fixer;
                 acceptAll( translationUnit, fixer );
         }
 
-        void FixNames::fixDWT( DeclarationWithType * dwt ) {
+        void FixNames::fixDWT( DeclarationWithType *dwt ) {
                 if ( dwt->get_name() != "" ) {
                         if ( LinkageSpec::isMangled( dwt->get_linkage() ) ) {
@@ -108 +107 @@
         }
 
-        void FixNames::postvisit( ObjectDecl * objectDecl ) {
+        void FixNames::visit( ObjectDecl *objectDecl ) {
+                Visitor::visit( objectDecl );
                 fixDWT( objectDecl );
         }
 
-        void FixNames::postvisit( FunctionDecl * functionDecl ) {
+        void FixNames::visit( FunctionDecl *functionDecl ) {
+                Visitor::visit( functionDecl );
                 fixDWT( functionDecl );
 
@@ -120 +121 @@
                                 throw SemanticError("Main expected to have 0, 2 or 3 arguments\n", functionDecl);
                         }
-                        functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( new ConstantExpr( Constant::from_int( 0 ) ) ) );
+                        functionDecl->get_statements()->get_kids().push_back( new ReturnStmt( noLabels, new ConstantExpr( Constant::from_int( 0 ) ) ) );
                         CodeGen::FixMain::registerMain( functionDecl );
                 }
         }
 
-        void FixNames::previsit( CompoundStmt * ) {
+        void FixNames::visit( CompoundStmt *compoundStmt ) {
                 scopeLevel++;
-                GuardAction( [this](){ scopeLevel--; } );
+                Visitor::visit( compoundStmt );
+                scopeLevel--;
         }
 } // namespace CodeGen

src/CodeGen/FixNames.h

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixNames.h --
+// FixNames.h -- 
 //
 // Author           : Richard C. Bilson
@@ -22 +22 @@
 namespace CodeGen {
         /// mangles object and function names
-        void fixNames( std::list< Declaration* > & translationUnit );
+        void fixNames( std::list< Declaration* > translationUnit );
 } // namespace CodeGen
 

src/Common/PassVisitor.impl.h

@@ -55 +55 @@
                 it,
                 [](Declaration * decl) -> auto {
-                        return new DeclStmt( decl );
+                        return new DeclStmt( noLabels, decl );
                 }
         );
@@ -251 +251 @@
             || ( empty( beforeDecls ) && empty( afterDecls )) );
 
-        CompoundStmt *compound = new CompoundStmt();
+        CompoundStmt *compound = new CompoundStmt( noLabels );
         if( !empty(beforeDecls) ) { splice( std::back_inserter( compound->get_kids() ), beforeDecls ); }
         if( !empty(beforeStmts) ) { compound->get_kids().splice( compound->get_kids().end(), *beforeStmts ); }
@@ -400 +400 @@
         {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                static ObjectDecl func(
-                        "__func__", noStorageClasses, LinkageSpec::C, nullptr,
-                        new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
-                        nullptr
-                );
-                indexerAddId( &func );
                 maybeAccept_impl( node->type, *this );
                 maybeAccept_impl( node->statements, *this );
@@ -425 +418 @@
         {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                static ObjectDecl func(
-                        "__func__", noStorageClasses, LinkageSpec::C, nullptr,
-                        new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ), nullptr, true, false ),
-                        nullptr
-                );
-                indexerAddId( &func );
                 maybeMutate_impl( node->type, *this );
                 maybeMutate_impl( node->statements, *this );

src/Concurrency/Keywords.cc

@@ -38 +38 @@
 
 namespace Concurrency {
+
+        namespace {
+                const std::list<Label> noLabels;
+                const std::list< Attribute * > noAttributes;
+                Type::StorageClasses noStorage;
+                Type::Qualifiers noQualifiers;
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -288 +296 @@
                 ObjectDecl * this_decl = new ObjectDecl(
                         "this",
-                        noStorageClasses,
+                        noStorage,
                         LinkageSpec::Cforall,
                         nullptr,
@@ -305 +313 @@
                         new ObjectDecl(
                                 "ret",
-                                noStorageClasses,
+                                noStorage,
                                 LinkageSpec::Cforall,
                                 nullptr,
@@ -338 +346 @@
                         main_decl = new FunctionDecl(
                                 "main",
-                                noStorageClasses,
+                                noStorage,
                                 LinkageSpec::Cforall,
                                 main_type,
@@ -355 +363 @@
                 ObjectDecl * field = new ObjectDecl(
                         field_name,
-                        noStorageClasses,
+                        noStorage,
                         LinkageSpec::Cforall,
                         nullptr,
@@ -371 +379 @@
 
         void ConcurrentSueKeyword::addRoutines( ObjectDecl * field, FunctionDecl * func ) {
-                CompoundStmt * statement = new CompoundStmt();
+                CompoundStmt * statement = new CompoundStmt( noLabels );
                 statement->push_back(
                         new ReturnStmt(
+                                noLabels,
                                 new AddressExpr(
                                         new MemberExpr(
@@ -479 +488 @@
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitor",
-                        noStorageClasses,
+                        noStorage,
                         LinkageSpec::Cforall,
                         nullptr,
@@ -500 +509 @@
                 // monitor_guard_t __guard = { __monitors, #, func };
                 body->push_front(
-                        new DeclStmt( new ObjectDecl(
+                        new DeclStmt( noLabels, new ObjectDecl(
                                 "__guard",
-                                noStorageClasses,
+                                noStorage,
                                 LinkageSpec::Cforall,
                                 nullptr,
@@ -521 +530 @@
 
                 //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-                body->push_front( new DeclStmt( monitors) );
+                body->push_front( new DeclStmt( noLabels, monitors) );
         }
 
@@ -527 +536 @@
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
-                        noStorageClasses,
+                        noStorage,
                         LinkageSpec::Cforall,
                         nullptr,
@@ -560 +569 @@
                 // monitor_guard_t __guard = { __monitors, #, func };
                 body->push_front(
-                        new DeclStmt( new ObjectDecl(
+                        new DeclStmt( noLabels, new ObjectDecl(
                                 "__guard",
-                                noStorageClasses,
+                                noStorage,
                                 LinkageSpec::Cforall,
                                 nullptr,
@@ -582 +591 @@
 
                 //monitor_desc * __monitors[] = { get_monitor(a), get_monitor(b) };
-                body->push_front( new DeclStmt( monitors) );
+                body->push_front( new DeclStmt( noLabels, monitors) );
         }
 
@@ -622 +631 @@
                 stmt->push_back(
                         new ExprStmt(
+                                noLabels,
                                 new UntypedExpr(
                                         new NameExpr( "__thrd_start" ),

src/Concurrency/Waitfor.cc

@@ -100 +100 @@
 
 namespace Concurrency {
+
+        namespace {
+                const std::list<Label> noLabels;
+                const std::list< Attribute * > noAttributes;
+                Type::StorageClasses noStorage;
+                Type::Qualifiers noQualifiers;
+        }
+
         //=============================================================================================
         // Pass declarations
@@ -195 +203 @@
                         ResolvExpr::findVoidExpression( expr, indexer );
 
-                        return new ExprStmt( expr );
+                        return new ExprStmt( noLabels, expr );
                 }
 
@@ -251 +259 @@
                 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();
+                CompoundStmt * stmt = new CompoundStmt( noLabels );
 
                 ObjectDecl * acceptables = declare( waitfor->clauses.size(), stmt );
@@ -273 +281 @@
                 );
 
-                CompoundStmt * compound = new CompoundStmt();
+                CompoundStmt * compound = new CompoundStmt( noLabels );
                 stmt->push_back( new IfStmt(
+                        noLabels,
                         safeCond( new VariableExpr( flag ) ),
                         compound,
@@ -304 +313 @@
                 );
 
-                stmt->push_back( new DeclStmt( acceptables) );
+                stmt->push_back( new DeclStmt( noLabels, acceptables) );
 
                 Expression * set = new UntypedExpr(
@@ -317 +326 @@
                 ResolvExpr::findVoidExpression( set, indexer );
 
-                stmt->push_back( new ExprStmt( set ) );
+                stmt->push_back( new ExprStmt( noLabels, set ) );
 
                 return acceptables;
@@ -332 +341 @@
                 );
 
-                stmt->push_back( new DeclStmt( flag) );
+                stmt->push_back( new DeclStmt( noLabels, flag) );
 
                 return flag;
@@ -348 +357 @@
                 ResolvExpr::findVoidExpression( expr, indexer );
 
-                return new ExprStmt( expr );
+                return new ExprStmt( noLabels, expr );
         }
 
@@ -390 +399 @@
                 );
 
-                stmt->push_back( new DeclStmt( mon) );
+                stmt->push_back( new DeclStmt( noLabels, mon) );
 
                 return mon;
@@ -402 +411 @@
 
                 stmt->push_back( new IfStmt(
+                        noLabels,
                         safeCond( clause.condition ),
                         new CompoundStmt({
@@ -437 +447 @@
                 );
 
-                stmt->push_back( new DeclStmt( timeout ) );
+                stmt->push_back( new DeclStmt( noLabels, timeout ) );
 
                 if( time ) {
                         stmt->push_back( new IfStmt(
+                                noLabels,
                                 safeCond( time_cond ),
                                 new CompoundStmt({
                                         new ExprStmt(
+                                                noLabels,
                                                 makeOpAssign(
                                                         new VariableExpr( timeout ),
@@ -459 +471 @@
                 if( has_else ) {
                         stmt->push_back( new IfStmt(
+                                noLabels,
                                 safeCond( else_cond ),
                                 new CompoundStmt({
                                         new ExprStmt(
+                                                noLabels,
                                                 makeOpAssign(
                                                         new VariableExpr( timeout ),
@@ -497 +511 @@
                 );
 
-                stmt->push_back( new DeclStmt( index ) );
+                stmt->push_back( new DeclStmt( noLabels, index ) );
 
                 ObjectDecl * mask = ObjectDecl::newObject(
@@ -512 +526 @@
                 );
 
-                stmt->push_back( new DeclStmt( mask ) );
+                stmt->push_back( new DeclStmt( noLabels, mask ) );
 
                 stmt->push_back( new ExprStmt(
+                        noLabels,
                         new ApplicationExpr(
                                 VariableExpr::functionPointer( decl_waitfor ),
@@ -542 +557 @@
         ) {
                 SwitchStmt * swtch = new SwitchStmt(
+                        noLabels,
                         result,
                         std::list<Statement *>()
@@ -550 +566 @@
                         swtch->statements.push_back(
                                 new CaseStmt(
+                                        noLabels,
                                         new ConstantExpr( Constant::from_ulong( i++ ) ),
                                         {
                                                 clause.statement,
                                                 new BranchStmt(
+                                                        noLabels,
                                                         "",
                                                         BranchStmt::Break
@@ -565 +583 @@
                         swtch->statements.push_back(
                                 new CaseStmt(
+                                        noLabels,
                                         new ConstantExpr( Constant::from_int( -2 ) ),
                                         {
                                                 waitfor->timeout.statement,
                                                 new BranchStmt(
+                                                        noLabels,
                                                         "",
                                                         BranchStmt::Break
@@ -580 +600 @@
                         swtch->statements.push_back(
                                 new CaseStmt(
+                                        noLabels,
                                         new ConstantExpr( Constant::from_int( -1 ) ),
                                         {
                                                 waitfor->orelse.statement,
                                                 new BranchStmt(
+                                                        noLabels,
                                                         "",
                                                         BranchStmt::Break

src/ControlStruct/ExceptTranslate.cc

@@ -30 +30 @@
 #include "SynTree/Expression.h"       // for UntypedExpr, ConstantExpr, Name...
 #include "SynTree/Initializer.h"      // for SingleInit, ListInit
-#include "SynTree/Label.h"            // for Label
+#include "SynTree/Label.h"            // for Label, noLabels
 #include "SynTree/Mutator.h"          // for mutateAll
 #include "SynTree/Statement.h"        // for CompoundStmt, CatchStmt, ThrowStmt
@@ -57 +57 @@
 
         void appendDeclStmt( CompoundStmt * block, Declaration * item ) {
-                block->push_back(new DeclStmt(item));
+                block->push_back(new DeclStmt(noLabels, item));
         }
 
@@ -205 +205 @@
                 throwStmt->set_expr( nullptr );
                 delete throwStmt;
-                return new ExprStmt( call );
+                return new ExprStmt( noLabels, call );
         }
 
@@ -220 +220 @@
                 assert( handler_except_decl );
 
-                CompoundStmt * result = new CompoundStmt();
-                result->labels =  throwStmt->labels;
-                result->push_back( new ExprStmt( UntypedExpr::createAssign(
+                CompoundStmt * result = new CompoundStmt( throwStmt->get_labels() );
+                result->push_back( new ExprStmt( noLabels, UntypedExpr::createAssign(
                         nameOf( handler_except_decl ),
                         new ConstantExpr( Constant::null(
@@ -232 +231 @@
                         ) ) );
                 result->push_back( new ExprStmt(
+                        noLabels,
                         new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
                         ) );
@@ -248 +248 @@
                 // return false;
                 Statement * result = new ReturnStmt(
+                        throwStmt->get_labels(),
                         new ConstantExpr( Constant::from_bool( false ) )
                         );
-                result->labels = throwStmt->labels;
                 delete throwStmt;
                 return result;
@@ -291 +291 @@
                         // }
                         // return;
-                        CompoundStmt * block = new CompoundStmt();
+                        CompoundStmt * block = new CompoundStmt( noLabels );
 
                         // Just copy the exception value. (Post Validation)
@@ -304 +304 @@
                                         ) })
                                 );
-                        block->push_back( new DeclStmt( local_except ) );
+                        block->push_back( new DeclStmt( noLabels, local_except ) );
 
                         // Add the cleanup attribute.
@@ -324 +324 @@
 
                         std::list<Statement *> caseBody
-                                        { block, new ReturnStmt( nullptr ) };
+                                        { block, new ReturnStmt( noLabels, nullptr ) };
                         handler_wrappers.push_back( new CaseStmt(
+                                noLabels,
                                 new ConstantExpr( Constant::from_int( index ) ),
                                 caseBody
@@ -339 +340 @@
 
                 SwitchStmt * handler_lookup = new SwitchStmt(
+                        noLabels,
                         nameOf( index_obj ),
                         stmt_handlers
                         );
-                CompoundStmt * body = new CompoundStmt();
+                CompoundStmt * body = new CompoundStmt( noLabels );
                 body->push_back( handler_lookup );
 
@@ -361 +363 @@
                 // }
 
-                CompoundStmt * block = new CompoundStmt();
+                CompoundStmt * block = new CompoundStmt( noLabels );
 
                 // Local Declaration
@@ -367 +369 @@
                         dynamic_cast<ObjectDecl *>( modded_handler->get_decl() );
                 assert( local_except );
-                block->push_back( new DeclStmt( local_except ) );
+                block->push_back( new DeclStmt( noLabels, local_except ) );
 
                 // Check for type match.
@@ -379 +381 @@
                 }
                 // Construct the match condition.
-                block->push_back( new IfStmt(
+                block->push_back( new IfStmt( noLabels,
                         cond, modded_handler->get_body(), nullptr ) );
 
@@ -395 +397 @@
                 // }
 
-                CompoundStmt * body = new CompoundStmt();
+                CompoundStmt * body = new CompoundStmt( noLabels );
 
                 FunctionType * func_type = match_func_t.clone();
@@ -411 +413 @@
 
                         // Create new body.
-                        handler->set_body( new ReturnStmt(
+                        handler->set_body( new ReturnStmt( noLabels,
                                 new ConstantExpr( Constant::from_int( index ) ) ) );
 
@@ -419 +421 @@
                 }
 
-                body->push_back( new ReturnStmt(
+                body->push_back( new ReturnStmt( noLabels,
                         new ConstantExpr( Constant::from_int( 0 ) ) ) );
 
@@ -439 +441 @@
                 args.push_back( nameOf( terminate_match ) );
 
-                CompoundStmt * callStmt = new CompoundStmt();
-                callStmt->push_back( new ExprStmt( caller ) );
+                CompoundStmt * callStmt = new CompoundStmt( noLabels );
+                callStmt->push_back( new ExprStmt( noLabels, caller ) );
                 return callStmt;
         }
@@ -449 +451 @@
                 //     HANDLER WRAPPERS { `hander->body`; return true; }
                 // }
-                CompoundStmt * body = new CompoundStmt();
+                CompoundStmt * body = new CompoundStmt( noLabels );
 
                 FunctionType * func_type = handle_func_t.clone();
@@ -462 +464 @@
                                 dynamic_cast<CompoundStmt*>( handler->get_body() );
                         if ( ! handling_code ) {
-                                handling_code = new CompoundStmt();
+                                handling_code = new CompoundStmt( noLabels );
                                 handling_code->push_back( handler->get_body() );
                         }
-                        handling_code->push_back( new ReturnStmt(
+                        handling_code->push_back( new ReturnStmt( noLabels,
                                 new ConstantExpr( Constant::from_bool( true ) ) ) );
                         handler->set_body( handling_code );
@@ -474 +476 @@
                 }
 
-                body->push_back( new ReturnStmt(
+                body->push_back( new ReturnStmt( noLabels,
                         new ConstantExpr( Constant::from_bool( false ) ) ) );
 
@@ -484 +486 @@
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
-                CompoundStmt * body = new CompoundStmt();
+                CompoundStmt * body = new CompoundStmt( noLabels );
 
                 // struct __try_resume_node __resume_node
@@ -519 +521 @@
                 setup->get_args().push_back( nameOf( resume_handler ) );
 
-                body->push_back( new ExprStmt( setup ) );
+                body->push_back( new ExprStmt( noLabels, setup ) );
 
                 body->push_back( wraps );
@@ -644 +646 @@
                 // Generate a prefix for the function names?
 
-                CompoundStmt * block = new CompoundStmt();
+                CompoundStmt * block = new CompoundStmt( noLabels );
                 CompoundStmt * inner = take_try_block( tryStmt );
 

src/ControlStruct/ForExprMutator.cc

@@ -29 +29 @@
                 // Create compound statement, move initializers outside,
                 // the resut of the original stays as is.
-                CompoundStmt *block = new CompoundStmt();
+                CompoundStmt *block = new CompoundStmt( std::list< Label >() );
                 std::list<Statement *> &stmts = block->get_kids();
                 stmts.splice( stmts.end(), init );

src/ControlStruct/LabelFixer.cc

@@ -37 +37 @@
         }
 
-        void LabelFixer::previsit( FunctionDecl * ) {
+        void LabelFixer::visit( FunctionDecl *functionDecl ) {
                 // need to go into a nested function in a fresh state
-                GuardValue( labelTable );
+                std::map < Label, Entry *> oldLabelTable = labelTable;
                 labelTable.clear();
-        }
 
-        void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
+                maybeAccept( functionDecl->get_statements(), *this );
+
                 MLEMutator mlemut( resolveJumps(), generator );
                 functionDecl->acceptMutator( mlemut );
+
+                // and remember the outer function's labels when
+                // returning to it
+                labelTable = oldLabelTable;
         }
 
         // prune to at most one label definition for each statement
-        void LabelFixer::previsit( Statement *stmt ) {
+        void LabelFixer::visit( Statement *stmt ) {
                 std::list< Label > &labels = stmt->get_labels();
 
@@ -58 +62 @@
         }
 
-        void LabelFixer::previsit( BranchStmt *branchStmt ) {
-                previsit( ( Statement *)branchStmt );
+        void LabelFixer::visit( BranchStmt *branchStmt ) {
+                visit ( ( Statement * )branchStmt );
 
                 // for labeled branches, add an entry to the label table
@@ -68 +72 @@
         }
 
-        void LabelFixer::previsit( LabelAddressExpr * addrExpr ) {
-                Label & target = addrExpr->arg;
-                assert( target != "" );
-                setLabelsUsg( target, addrExpr );
+        void LabelFixer::visit( UntypedExpr *untyped ) {
+                if ( NameExpr * func = dynamic_cast< NameExpr * >( untyped->get_function() ) ) {
+                        if ( func->get_name() == "&&" ) {
+                                NameExpr * arg = dynamic_cast< NameExpr * >( untyped->get_args().front() );
+                                Label target = arg->get_name();
+                                assert( target != "" );
+                                setLabelsUsg( target, untyped );
+                        } else {
+                                Visitor::visit( untyped );
+                        }
+                }
         }
 

src/ControlStruct/LabelFixer.h

@@ -19 +19 @@
 #include <map>                     // for map
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "SynTree/Label.h"         // for Label
@@ -27 +26 @@
 namespace ControlStruct {
         /// normalizes label definitions and generates multi-level exit labels
-        class LabelGenerator;
+class LabelGenerator;
 
-        class LabelFixer final : public WithGuards {
+        class LabelFixer final : public Visitor {
+                typedef Visitor Parent;
           public:
                 LabelFixer( LabelGenerator *gen = 0 );
@@ -35 +35 @@
                 std::map < Label, Statement * > *resolveJumps() throw ( SemanticError );
 
+                using Visitor::visit;
+
                 // Declarations
-                void previsit( FunctionDecl *functionDecl );
-                void postvisit( FunctionDecl *functionDecl );
+                virtual void visit( FunctionDecl *functionDecl ) override;
 
                 // Statements
-                void previsit( Statement *stmt );
-                void previsit( BranchStmt *branchStmt );
+                void visit( Statement *stmt );
 
-                // Expressions
-                void previsit( LabelAddressExpr *addrExpr );
+                virtual void visit( CompoundStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( NullStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ExprStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( IfStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( WhileStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ForStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( SwitchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( CaseStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( ReturnStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( TryStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( CatchStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( DeclStmt *stmt ) override { visit( (Statement *)stmt ); return Parent::visit( stmt ); }
+                virtual void visit( BranchStmt *branchStmt ) override;
+                virtual void visit( UntypedExpr *untyped ) override;
 
                 Label setLabelsDef( std::list< Label > &, Statement *definition );

src/ControlStruct/MLEMutator.cc

@@ -149 +149 @@
 
                         if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
-                                Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
-                                stmt->labels.push_back( brkLabel );
-                                c->get_statements().push_back( stmt );
+                                std::list<Label> temp; temp.push_back( brkLabel );
+                                c->get_statements().push_back( new BranchStmt( temp, Label("brkLabel"), BranchStmt::Break ) );
                         } else assert(0); // as of this point, all statements of a switch are still CaseStmts
                 } // if
@@ -233 +232 @@
                 // transform break/continue statements into goto to simplify later handling of branches
                 delete branchStmt;
-                return new BranchStmt( exitLabel, BranchStmt::Goto );
+                return new BranchStmt( std::list<Label>(), exitLabel, BranchStmt::Goto );
         }
 
@@ -240 +239 @@
                 CompoundStmt *newBody;
                 if ( ! (newBody = dynamic_cast<CompoundStmt *>( bodyLoop )) ) {
-                        newBody = new CompoundStmt();
+                        newBody = new CompoundStmt( std::list< Label >() );
                         newBody->get_kids().push_back( bodyLoop );
                 } // if

src/ControlStruct/Mutate.cc

@@ -24 +24 @@
 #include "SynTree/Declaration.h"   // for Declaration
 #include "SynTree/Mutator.h"       // for mutateAll
+//#include "ExceptMutator.h"
 
 #include "Common/PassVisitor.h"    // for PassVisitor
@@ -36 +37 @@
 
                 // normalizes label definitions and generates multi-level exit labels
-                PassVisitor<LabelFixer> lfix;
+                LabelFixer lfix;
+
+                //ExceptMutator exc;
 
                 mutateAll( translationUnit, formut );
                 acceptAll( translationUnit, lfix );
+                //mutateAll( translationUnit, exc );
         }
 } // namespace CodeGen

src/GenPoly/Box.cc

@@ -49 +49 @@
 #include "SynTree/Expression.h"          // for ApplicationExpr, UntypedExpr
 #include "SynTree/Initializer.h"         // for SingleInit, Initializer, Lis...
-#include "SynTree/Label.h"               // for Label
+#include "SynTree/Label.h"               // for Label, noLabels
 #include "SynTree/Mutator.h"             // for maybeMutate, Mutator, mutateAll
 #include "SynTree/Statement.h"           // for ExprStmt, DeclStmt, ReturnStmt
@@ -293 +293 @@
                 FunctionDecl *layoutDecl = new FunctionDecl( layoutofName( typeDecl ),
                                                                                                          functionNesting > 0 ? Type::StorageClasses() : Type::StorageClasses( Type::Static ),
-                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt(),
+                                                                                                         LinkageSpec::AutoGen, layoutFnType, new CompoundStmt( noLabels ),
                                                                                                          std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 layoutDecl->fixUniqueId();
@@ -321 +321 @@
         /// makes an if-statement with a single-expression if-block and no then block
         Statement *makeCond( Expression *cond, Expression *ifPart ) {
-                return new IfStmt( cond, new ExprStmt( ifPart ), 0 );
+                return new IfStmt( noLabels, cond, new ExprStmt( noLabels, ifPart ), 0 );
         }
 
@@ -340 +340 @@
         /// adds an expression to a compound statement
         void addExpr( CompoundStmt *stmts, Expression *expr ) {
-                stmts->get_kids().push_back( new ExprStmt( expr ) );
+                stmts->get_kids().push_back( new ExprStmt( noLabels, expr ) );
         }
 
@@ -629 +629 @@
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
-                        stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -740 +740 @@
                                 ObjectDecl *newObj = ObjectDecl::newObject( tempNamer.newName(), newType, nullptr );
                                 newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-                                stmtsToAddBefore.push_back( new DeclStmt( newObj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, 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( assign ) );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, assign ) );
                                 arg = new AddressExpr( new VariableExpr( newObj ) );
                         } // if
@@ -888 +888 @@
                                 // void return
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-                                bodyStmt = new ExprStmt( adapteeApp );
+                                bodyStmt = new ExprStmt( noLabels, adapteeApp );
                         } else if ( isDynType( adaptee->get_returnVals().front()->get_type(), tyVars ) ) {
                                 // return type T
@@ -900 +900 @@
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
                                 assign->get_args().push_back( adapteeApp );
-                                bodyStmt = new ExprStmt( assign );
+                                bodyStmt = new ExprStmt( noLabels, assign );
                         } else {
                                 // adapter for a function that returns a monomorphic value
                                 addAdapterParams( adapteeApp, arg, param, adapterType->get_parameters().end(), realParam, tyVars );
-                                bodyStmt = new ReturnStmt( adapteeApp );
+                                bodyStmt = new ReturnStmt( noLabels, adapteeApp );
                         } // if
-                        CompoundStmt *adapterBody = new CompoundStmt();
+                        CompoundStmt *adapterBody = new CompoundStmt( noLabels );
                         adapterBody->get_kids().push_back( bodyStmt );
                         std::string adapterName = makeAdapterName( mangleName );
@@ -952 +952 @@
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
-                                                stmtsToAddBefore.push_back( new DeclStmt( newAdapter ) );
+                                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
                                         assert( adapter != adapters.end() );
@@ -1279 +1279 @@
                                                 retval->set_name( "_retval" );
                                         }
-                                        functionDecl->get_statements()->get_kids().push_front( new DeclStmt( retval ) );
+                                        functionDecl->get_statements()->get_kids().push_front( new DeclStmt( noLabels, retval ) );
                                         DeclarationWithType * newRet = retval->clone(); // for ownership purposes
                                         ftype->get_returnVals().front() = newRet;
@@ -1519 +1519 @@
                                         // (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( newBuf ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
 
                                         delete objectDecl->get_init();
@@ -1598 +1598 @@
                 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( newObj ) );
+                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -1677 +1677 @@
                                         addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                        stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
+                                        stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
                                 }
 
@@ -1703 +1703 @@
                                 addOtypeParamsToLayoutCall( layoutCall, otypeParams );
 
-                                stmtsToAddBefore.push_back( new ExprStmt( layoutCall ) );
+                                stmtsToAddBefore.push_back( new ExprStmt( noLabels, layoutCall ) );
 
                                 return true;

src/GenPoly/InstantiateGeneric.cc

@@ -526 +526 @@
                                         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( tmp ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, tmp ) );
                                         return new VariableExpr( tmp );
                                 } else {

src/GenPoly/Specialize.cc

@@ -35 +35 @@
 #include "SynTree/Declaration.h"         // for FunctionDecl, DeclarationWit...
 #include "SynTree/Expression.h"          // for ApplicationExpr, Expression
-#include "SynTree/Label.h"               // for Label
+#include "SynTree/Label.h"               // for Label, noLabels
 #include "SynTree/Mutator.h"             // for mutateAll
 #include "SynTree/Statement.h"           // for CompoundStmt, DeclStmt, Expr...
@@ -234 +234 @@
                 } // 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() );
+                FunctionDecl *thunkFunc = new FunctionDecl( thunkNamer.newName(), Type::StorageClasses(), LinkageSpec::C, newType, new CompoundStmt( noLabels ) );
                 thunkFunc->fixUniqueId();
 
@@ -287 +287 @@
                 Statement *appStmt;
                 if ( funType->returnVals.empty() ) {
-                        appStmt = new ExprStmt( appExpr );
-                } else {
-                        appStmt = new ReturnStmt( appExpr );
+                        appStmt = new ExprStmt( noLabels, appExpr );
+                } else {
+                        appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
                 thunkFunc->statements->kids.push_back( appStmt );
 
                 // add thunk definition to queue of statements to add
-                stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
+                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );

src/InitTweak/FixGlobalInit.cc

@@ -20 +20 @@
 #include <algorithm>               // for replace_if
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
@@ -30 +29 @@
 #include "SynTree/Expression.h"    // for ConstantExpr, Expression (ptr only)
 #include "SynTree/Initializer.h"   // for ConstructorInit, Initializer
-#include "SynTree/Label.h"         // for Label
+#include "SynTree/Label.h"         // for Label, noLabels
 #include "SynTree/Statement.h"     // for CompoundStmt, Statement (ptr only)
 #include "SynTree/Type.h"          // for Type, Type::StorageClasses, Functi...
@@ -36 +35 @@
 
 namespace InitTweak {
-        class GlobalFixer : public WithShortCircuiting {
+        class GlobalFixer : public Visitor {
           public:
                 GlobalFixer( const std::string & name, bool inLibrary );
 
-                void previsit( ObjectDecl *objDecl );
-                void previsit( FunctionDecl *functionDecl );
-                void previsit( StructDecl *aggregateDecl );
-                void previsit( UnionDecl *aggregateDecl );
-                void previsit( EnumDecl *aggregateDecl );
-                void previsit( TraitDecl *aggregateDecl );
-                void previsit( TypeDecl *typeDecl );
+                virtual void visit( ObjectDecl *objDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+                virtual void visit( StructDecl *aggregateDecl );
+                virtual void visit( UnionDecl *aggregateDecl );
+                virtual void visit( EnumDecl *aggregateDecl );
+                virtual void visit( TraitDecl *aggregateDecl );
+                virtual void visit( TypeDecl *typeDecl );
 
                 UniqueName tempNamer;
@@ -54 +53 @@
 
         void fixGlobalInit( std::list< Declaration * > & translationUnit, const std::string & name, bool inLibrary ) {
-                PassVisitor<GlobalFixer> visitor( name, inLibrary );
-                acceptAll( translationUnit, visitor );
-                GlobalFixer & fixer = visitor.pass;
+                GlobalFixer fixer( name, inLibrary );
+                acceptAll( translationUnit, fixer );
                 // don't need to include function if it's empty
                 if ( fixer.initFunction->get_statements()->get_kids().empty() ) {
@@ -94 +92 @@
                         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() );
+                initFunction = new FunctionDecl( "_init_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 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() );
+                destroyFunction = new FunctionDecl( "_destroy_" + fixedName, Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                 destroyFunction->get_attributes().push_back( new Attribute( "destructor", dtorParameters ) );
         }
 
-        void GlobalFixer::previsit( ObjectDecl *objDecl ) {
+        void GlobalFixer::visit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
                 std::list< Statement * > & destroyStatements = destroyFunction->get_statements()->get_kids();
@@ -136 +134 @@
 
         // only modify global variables
-        void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( StructDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( UnionDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( EnumDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( TraitDecl * ) { visit_children = false; }
-        void GlobalFixer::previsit( TypeDecl * ) { visit_children = false; }
+        void GlobalFixer::visit( __attribute__((unused)) FunctionDecl *functionDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) StructDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) UnionDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) EnumDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TraitDecl *aggregateDecl ) {}
+        void GlobalFixer::visit( __attribute__((unused)) TypeDecl *typeDecl ) {}
 
 } // namespace InitTweak

src/InitTweak/FixInit.cc

@@ -49 +49 @@
 #include "SynTree/Expression.h"        // for UniqueExpr, VariableExpr, Unty...
 #include "SynTree/Initializer.h"       // for ConstructorInit, SingleInit
-#include "SynTree/Label.h"             // for Label, operator<
+#include "SynTree/Label.h"             // for Label, noLabels, operator<
 #include "SynTree/Mutator.h"           // for mutateAll, Mutator, maybeMutate
 #include "SynTree/Statement.h"         // for ExprStmt, CompoundStmt, Branch...
@@ -544 +544 @@
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 
                         // add destructors after current statement
                         for ( Expression * dtor : dtors ) {
-                                stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
+                                stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
                         } // for
 
@@ -598 +598 @@
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAddBefore.push_back( new DeclStmt( obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
                                 for ( Expression * dtor : stmtExpr->get_dtors() ) {
-                                        stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
+                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, 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( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
@@ -685 +685 @@
 
                                                 // generate body of if
-                                                CompoundStmt * initStmts = new CompoundStmt();
+                                                CompoundStmt * initStmts = new CompoundStmt( noLabels );
                                                 std::list< Statement * > & body = initStmts->get_kids();
                                                 body.push_back( ctor );
-                                                body.push_back( new ExprStmt( setTrue ) );
+                                                body.push_back( new ExprStmt( noLabels, setTrue ) );
 
                                                 // put it all together
-                                                IfStmt * ifStmt = new IfStmt( new VariableExpr( isUninitializedVar ), initStmts, 0 );
-                                                stmtsToAddAfter.push_back( new DeclStmt( isUninitializedVar ) );
+                                                IfStmt * ifStmt = new IfStmt( noLabels, new VariableExpr( isUninitializedVar ), initStmts, 0 );
+                                                stmtsToAddAfter.push_back( new DeclStmt( noLabels, isUninitializedVar ) );
                                                 stmtsToAddAfter.push_back( ifStmt );
 
@@ -707 +707 @@
 
                                                         // 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() );
+                                                        FunctionDecl * dtorCaller = new FunctionDecl( objDecl->get_mangleName() + dtorCallerNamer.newName(), Type::StorageClasses( Type::Static ), LinkageSpec::C, new FunctionType( Type::Qualifiers(), false ), new CompoundStmt( noLabels ) );
                                                         dtorCaller->fixUniqueId();
                                                         dtorCaller->get_statements()->push_back( dtorStmt );
@@ -715 +715 @@
                                                         callAtexit->get_args().push_back( new VariableExpr( dtorCaller ) );
 
-                                                        body.push_back( new ExprStmt( callAtexit ) );
+                                                        body.push_back( new ExprStmt( noLabels, callAtexit ) );
 
                                                         // hoist variable and dtor caller decls to list of decls that will be added into global scope

src/InitTweak/InitTweak.cc

@@ -5 +5 @@
 #include <memory>                  // for __shared_ptr
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/UniqueName.h"     // for UniqueName
@@ -20 +19 @@
 #include "SynTree/Expression.h"    // for Expression, UntypedExpr, Applicati...
 #include "SynTree/Initializer.h"   // for Initializer, ListInit, Designation
-#include "SynTree/Label.h"         // for Label
+#include "SynTree/Label.h"         // for Label, noLabels
 #include "SynTree/Statement.h"     // for CompoundStmt, ExprStmt, BranchStmt
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
@@ -30 +29 @@
 namespace InitTweak {
         namespace {
-                struct HasDesignations : public WithShortCircuiting {
+                class HasDesignations : public Visitor {
+                public:
                         bool hasDesignations = false;
-
-                        void previsit( BaseSyntaxNode * ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
-                        }
-
-                        void previsit( Designation * des ) {
-                                // short circuit if we already know there are designations
-                                if ( hasDesignations ) visit_children = false;
-                                else if ( ! des->get_designators().empty() ) {
-                                        hasDesignations = true;
-                                        visit_children = false;
-                                }
+                        virtual void visit( Designation * des ) {
+                                if ( ! des->get_designators().empty() ) hasDesignations = true;
+                                else Visitor::visit( des );
                         }
                 };
 
-                struct InitDepthChecker : public WithGuards {
+                class InitDepthChecker : public Visitor {
+                public:
                         bool depthOkay = true;
                         Type * type;
@@ -60 +51 @@
                                 maxDepth++;
                         }
-                        void previsit( ListInit * ) {
+                        virtual void visit( ListInit * listInit ) {
                                 curDepth++;
-                                GuardAction( [this]() { curDepth--; } );
                                 if ( curDepth > maxDepth ) depthOkay = false;
+                                Visitor::visit( listInit );
+                                curDepth--;
                         }
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
-                        void previsit( SingleInit * singleInit ) {
-                                visit_children = false;
-                                argList.push_back( singleInit->value->clone() );
-                        }
+                class InitFlattener : public Visitor {
+                        public:
+                        virtual void visit( SingleInit * singleInit );
+                        virtual void visit( ListInit * listInit );
                         std::list< Expression * > argList;
                 };
 
+                void InitFlattener::visit( SingleInit * singleInit ) {
+                        argList.push_back( singleInit->get_value()->clone() );
+                }
+
+                void InitFlattener::visit( ListInit * listInit ) {
+                        // flatten nested list inits
+                        std::list<Initializer*>::iterator it = listInit->begin();
+                        for ( ; it != listInit->end(); ++it ) {
+                                (*it)->accept( *this );
+                        }
+                }
         }
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                InitFlattener flattener;
                 maybeAccept( init, flattener );
-                return flattener.pass.argList;
+                return flattener.argList;
         }
 
         bool isDesignated( Initializer * init ) {
-                PassVisitor<HasDesignations> finder;
+                HasDesignations finder;
                 maybeAccept( init, finder );
-                return finder.pass.hasDesignations;
+                return finder.hasDesignations;
         }
 
         bool checkInitDepth( ObjectDecl * objDecl ) {
-                PassVisitor<InitDepthChecker> checker( objDecl->type );
-                maybeAccept( objDecl->init, checker );
-                return checker.pass.depthOkay;
+                InitDepthChecker checker( objDecl->get_type() );
+                maybeAccept( objDecl->get_init(), checker );
+                return checker.depthOkay;
         }
 
@@ -193 +195 @@
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-                        *out++ = new IfStmt( cond, new ExprStmt( callExpr ), nullptr );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
 
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
                         increment->get_args().push_back( index->clone() );
-                        *out++ = new ExprStmt( increment );
+                        *out++ = new ExprStmt( noLabels, increment );
                 }
 
@@ -242 +244 @@
                                         std::list< Statement * > stmts;
                                         build( callExpr, idx, idxEnd, init, back_inserter( stmts ) );
-                                        stmts.push_back( new BranchStmt( switchLabel, BranchStmt::Break ) );
-                                        CaseStmt * caseStmt = new CaseStmt( condition, stmts );
+                                        stmts.push_back( new BranchStmt( noLabels, switchLabel, BranchStmt::Break ) );
+                                        CaseStmt * caseStmt = new CaseStmt( noLabels, condition, stmts );
                                         branches.push_back( caseStmt );
                                 }
-                                *out++ = new SwitchStmt( index->clone(), branches );
-                                *out++ = new NullStmt( { switchLabel } );
+                                *out++ = new SwitchStmt( noLabels, index->clone(), branches );
+                                *out++ = new NullStmt( std::list<Label>{ switchLabel } );
                         }
                 }
@@ -260 +262 @@
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
-                CompoundStmt * block = new CompoundStmt();
+                CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
@@ -307 +309 @@
         }
 
-        struct CallFinder {
+        class CallFinder : public Visitor {
+        public:
+                typedef Visitor Parent;
                 CallFinder( const std::list< std::string > & names ) : names( names ) {}
 
-                void postvisit( ApplicationExpr * appExpr ) {
+                virtual void visit( ApplicationExpr * appExpr ) {
                         handleCallExpr( appExpr );
                 }
 
-                void postvisit( UntypedExpr * untypedExpr ) {
+                virtual void visit( UntypedExpr * untypedExpr ) {
                         handleCallExpr( untypedExpr );
                 }
@@ -324 +328 @@
                 template< typename CallExpr >
                 void handleCallExpr( CallExpr * expr ) {
+                        Parent::visit( expr );
                         std::string fname = getFunctionName( expr );
                         if ( std::find( names.begin(), names.end(), fname ) != names.end() ) {
@@ -332 +337 @@
 
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches ) {
-                static PassVisitor<CallFinder> finder( std::list< std::string >{ "?{}", "^?{}" } );
-                finder.pass.matches = &matches;
+                static CallFinder finder( std::list< std::string >{ "?{}", "^?{}" } );
+                finder.matches = &matches;
                 maybeAccept( stmt, finder );
         }
@@ -539 +544 @@
         }
 
-        struct ConstExprChecker : public WithShortCircuiting {
-                // most expressions are not const expr
-                void previsit( Expression * ) { isConstExpr = false; visit_children = false; }
-
-                void previsit( AddressExpr *addressExpr ) {
-                        visit_children = false;
-
+        class ConstExprChecker : public Visitor {
+        public:
+                ConstExprChecker() : isConstExpr( true ) {}
+
+                using Visitor::visit;
+
+                virtual void visit( ApplicationExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedExpr * ) { isConstExpr = false; }
+                virtual void visit( NameExpr * ) { isConstExpr = false; }
+                // virtual void visit( CastExpr *castExpr ) { isConstExpr = false; }
+                virtual void visit( AddressExpr *addressExpr ) {
                         // address of a variable or member expression is constexpr
                         Expression * arg = addressExpr->get_arg();
                         if ( ! dynamic_cast< NameExpr * >( arg) && ! dynamic_cast< VariableExpr * >( arg ) && ! dynamic_cast< MemberExpr * >( arg ) && ! dynamic_cast< UntypedMemberExpr * >( arg ) ) isConstExpr = false;
                 }
-
-                // these expressions may be const expr, depending on their children
-                void previsit( SizeofExpr * ) {}
-                void previsit( AlignofExpr * ) {}
-                void previsit( UntypedOffsetofExpr * ) {}
-                void previsit( OffsetofExpr * ) {}
-                void previsit( OffsetPackExpr * ) {}
-                void previsit( AttrExpr * ) {}
-                void previsit( CommaExpr * ) {}
-                void previsit( LogicalExpr * ) {}
-                void previsit( ConditionalExpr * ) {}
-                void previsit( CastExpr * ) {}
-                void previsit( ConstantExpr * ) {}
-
-                bool isConstExpr = true;
+                virtual void visit( UntypedMemberExpr * ) { isConstExpr = false; }
+                virtual void visit( MemberExpr * ) { isConstExpr = false; }
+                virtual void visit( VariableExpr * ) { isConstExpr = false; }
+                // these might be okay?
+                // virtual void visit( SizeofExpr *sizeofExpr );
+                // virtual void visit( AlignofExpr *alignofExpr );
+                // virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetofExpr *offsetofExpr );
+                // virtual void visit( OffsetPackExpr *offsetPackExpr );
+                // virtual void visit( AttrExpr *attrExpr );
+                // virtual void visit( CommaExpr *commaExpr );
+                // virtual void visit( LogicalExpr *logicalExpr );
+                // virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( TypeExpr * ) { isConstExpr = false; }
+                virtual void visit( AsmExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedValofExpr * ) { isConstExpr = false; }
+                virtual void visit( CompoundLiteralExpr * ) { isConstExpr = false; }
+                virtual void visit( UntypedTupleExpr * ) { isConstExpr = false; }
+                virtual void visit( TupleExpr * ) { isConstExpr = false; }
+                virtual void visit( TupleAssignExpr * ) { isConstExpr = false; }
+
+                bool isConstExpr;
         };
 
         bool isConstExpr( Expression * expr ) {
                 if ( expr ) {
-                        PassVisitor<ConstExprChecker> checker;
+                        ConstExprChecker checker;
                         expr->accept( checker );
-                        return checker.pass.isConstExpr;
+                        return checker.isConstExpr;
                 }
                 return true;
@@ -578 +594 @@
         bool isConstExpr( Initializer * init ) {
                 if ( init ) {
-                        PassVisitor<ConstExprChecker> checker;
+                        ConstExprChecker checker;
                         init->accept( checker );
-                        return checker.pass.isConstExpr;
+                        return checker.isConstExpr;
                 } // if
                 // for all intents and purposes, no initializer means const expr

src/MakeLibCfa.cc

@@ -116 +116 @@
                         } // for
 
-                        funcDecl->set_statements( new CompoundStmt() );
+                        funcDecl->set_statements( new CompoundStmt( std::list< Label >() ) );
                         newDecls.push_back( funcDecl );
 
@@ -130 +130 @@
                           case CodeGen::OT_INFIXASSIGN:
                                         // return the recursive call
-                                        stmt = new ReturnStmt( newExpr );
+                                        stmt = new ReturnStmt( noLabels, newExpr );
                                         break;
                           case CodeGen::OT_CTOR:
                           case CodeGen::OT_DTOR:
                                         // execute the recursive call
-                                        stmt = new ExprStmt( newExpr );
+                                        stmt = new ExprStmt( noLabels, newExpr );
                                         break;
                           case CodeGen::OT_CONSTANT:

src/Makefile.in

@@ -215 +215 @@
         SymTab/driver_cfa_cpp-Validate.$(OBJEXT) \
         SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT) \
+        SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT) \
+        SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Autogen.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Type.$(OBJEXT) \
@@ -512 +514 @@
         ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
         SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
-        SymTab/FixFunction.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
         SynTree/VoidType.cc SynTree/BasicType.cc \
         SynTree/PointerType.cc SynTree/ArrayType.cc \
@@ -841 +844 @@
 SymTab/driver_cfa_cpp-FixFunction.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/driver_cfa_cpp-ImplementationType.$(OBJEXT):  \
+        SymTab/$(am__dirstamp) SymTab/$(DEPDIR)/$(am__dirstamp)
+SymTab/driver_cfa_cpp-TypeEquality.$(OBJEXT): SymTab/$(am__dirstamp) \
+        SymTab/$(DEPDIR)/$(am__dirstamp)
 SymTab/driver_cfa_cpp-Autogen.$(OBJEXT): SymTab/$(am__dirstamp) \
         SymTab/$(DEPDIR)/$(am__dirstamp)
@@ -1033 +1040 @@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Autogen.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-FixFunction.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Mangler.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SymTab/$(DEPDIR)/driver_cfa_cpp-Validate.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
@@ -2030 +2039 @@
 @AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-FixFunction.obj `if test -f 'SymTab/FixFunction.cc'; then $(CYGPATH_W) 'SymTab/FixFunction.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/FixFunction.cc'; fi`
+
+SymTab/driver_cfa_cpp-ImplementationType.o: SymTab/ImplementationType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-ImplementationType.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo -c -o SymTab/driver_cfa_cpp-ImplementationType.o `test -f 'SymTab/ImplementationType.cc' || echo '$(srcdir)/'`SymTab/ImplementationType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/ImplementationType.cc' object='SymTab/driver_cfa_cpp-ImplementationType.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-ImplementationType.o `test -f 'SymTab/ImplementationType.cc' || echo '$(srcdir)/'`SymTab/ImplementationType.cc
+
+SymTab/driver_cfa_cpp-ImplementationType.obj: SymTab/ImplementationType.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-ImplementationType.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo -c -o SymTab/driver_cfa_cpp-ImplementationType.obj `if test -f 'SymTab/ImplementationType.cc'; then $(CYGPATH_W) 'SymTab/ImplementationType.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/ImplementationType.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-ImplementationType.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/ImplementationType.cc' object='SymTab/driver_cfa_cpp-ImplementationType.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-ImplementationType.obj `if test -f 'SymTab/ImplementationType.cc'; then $(CYGPATH_W) 'SymTab/ImplementationType.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/ImplementationType.cc'; fi`
+
+SymTab/driver_cfa_cpp-TypeEquality.o: SymTab/TypeEquality.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TypeEquality.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo -c -o SymTab/driver_cfa_cpp-TypeEquality.o `test -f 'SymTab/TypeEquality.cc' || echo '$(srcdir)/'`SymTab/TypeEquality.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TypeEquality.cc' object='SymTab/driver_cfa_cpp-TypeEquality.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TypeEquality.o `test -f 'SymTab/TypeEquality.cc' || echo '$(srcdir)/'`SymTab/TypeEquality.cc
+
+SymTab/driver_cfa_cpp-TypeEquality.obj: SymTab/TypeEquality.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-TypeEquality.obj -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo -c -o SymTab/driver_cfa_cpp-TypeEquality.obj `if test -f 'SymTab/TypeEquality.cc'; then $(CYGPATH_W) 'SymTab/TypeEquality.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TypeEquality.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Tpo SymTab/$(DEPDIR)/driver_cfa_cpp-TypeEquality.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SymTab/TypeEquality.cc' object='SymTab/driver_cfa_cpp-TypeEquality.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o SymTab/driver_cfa_cpp-TypeEquality.obj `if test -f 'SymTab/TypeEquality.cc'; then $(CYGPATH_W) 'SymTab/TypeEquality.cc'; else $(CYGPATH_W) '$(srcdir)/SymTab/TypeEquality.cc'; fi`
 
 SymTab/driver_cfa_cpp-Autogen.o: SymTab/Autogen.cc

src/Parser/StatementNode.cc

@@ -37 +37 @@
         DeclarationNode *agg = decl->extractAggregate();
         if ( agg ) {
-                StatementNode *nextStmt = new StatementNode( new DeclStmt( maybeBuild< Declaration >( decl ) ) );
+                StatementNode *nextStmt = new StatementNode( new DeclStmt( noLabels, maybeBuild< Declaration >( decl ) ) );
                 set_next( nextStmt );
                 if ( decl->get_next() ) {
@@ -50 +50 @@
                 agg = decl;
         } // if
-        stmt.reset( new DeclStmt( maybeMoveBuild< Declaration >(agg) ) );
+        stmt.reset( new DeclStmt( noLabels, maybeMoveBuild< Declaration >(agg) ) );
 } // StatementNode::StatementNode
 
@@ -75 +75 @@
 
         if ( e )
-                return new ExprStmt( e );
+                return new ExprStmt( noLabels, e );
         else
-                return new NullStmt();
+                return new NullStmt( noLabels );
 }
 
@@ -113 +113 @@
         }
         delete ctl;
-        return new IfStmt( cond, thenb, elseb, init );
+        return new IfStmt( noLabels, cond, thenb, elseb, init );
 }
 
@@ -120 +120 @@
         buildMoveList< Statement, StatementNode >( stmt, branches );
         // branches.size() == 0 for switch (...) {}, i.e., no declaration or statements
-        return new SwitchStmt( maybeMoveBuild< Expression >(ctl), branches );
+        return new SwitchStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_case( ExpressionNode *ctl ) {
         std::list< Statement * > branches;
-        return new CaseStmt( maybeMoveBuild< Expression >(ctl), branches );
+        return new CaseStmt( noLabels, maybeMoveBuild< Expression >(ctl), branches );
 }
 Statement *build_default() {
         std::list< Statement * > branches;
-        return new CaseStmt( nullptr, branches, true );
+        return new CaseStmt( noLabels, nullptr, branches, true );
 }
 
@@ -135 +135 @@
         buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new WhileStmt( notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
+        return new WhileStmt( noLabels, notZeroExpr( maybeMoveBuild< Expression >(ctl) ), branches.front(), kind );
 }
 
@@ -157 +157 @@
 
         delete forctl;
-        return new ForStmt( init, cond, incr, branches.front() );
+        return new ForStmt( noLabels, init, cond, incr, branches.front() );
 }
 
 Statement *build_branch( BranchStmt::Type kind ) {
-        Statement * ret = new BranchStmt( "", kind );
+        Statement * ret = new BranchStmt( noLabels, "", kind );
         return ret;
 }
 Statement *build_branch( std::string *identifier, BranchStmt::Type kind ) {
-        Statement * ret = new BranchStmt( *identifier, kind );
+        Statement * ret = new BranchStmt( noLabels, *identifier, kind );
         delete identifier;                                                                      // allocated by lexer
         return ret;
 }
 Statement *build_computedgoto( ExpressionNode *ctl ) {
-        return new BranchStmt( maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
+        return new BranchStmt( noLabels, maybeMoveBuild< Expression >(ctl), BranchStmt::Goto );
 }
 
@@ -176 +176 @@
         std::list< Expression * > exps;
         buildMoveList( ctl, exps );
-        return new ReturnStmt( exps.size() > 0 ? exps.back() : nullptr );
+        return new ReturnStmt( noLabels, exps.size() > 0 ? exps.back() : nullptr );
 }
 
@@ -183 +183 @@
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "This means we are leaking memory");
-        return new ThrowStmt( ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
+        return new ThrowStmt( noLabels, ThrowStmt::Terminate, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -190 +190 @@
         buildMoveList( ctl, exps );
         assertf( exps.size() < 2, "This means we are leaking memory");
-        return new ThrowStmt( ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
+        return new ThrowStmt( noLabels, ThrowStmt::Resume, !exps.empty() ? exps.back() : nullptr );
 }
 
@@ -204 +204 @@
         CompoundStmt *tryBlock = strict_dynamic_cast< CompoundStmt * >(maybeMoveBuild< Statement >(try_stmt));
         FinallyStmt *finallyBlock = dynamic_cast< FinallyStmt * >(maybeMoveBuild< Statement >(finally_stmt) );
-        return new TryStmt( tryBlock, branches, finallyBlock );
+        return new TryStmt( noLabels, tryBlock, branches, finallyBlock );
 }
 Statement *build_catch( CatchStmt::Kind kind, DeclarationNode *decl, ExpressionNode *cond, StatementNode *body ) {
@@ -210 +210 @@
         buildMoveList< Statement, StatementNode >( body, branches );
         assert( branches.size() == 1 );
-        return new CatchStmt( kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
+        return new CatchStmt( noLabels, kind, maybeMoveBuild< Declaration >(decl), maybeMoveBuild< Expression >(cond), branches.front() );
 }
 Statement *build_finally( StatementNode *stmt ) {
@@ -216 +216 @@
         buildMoveList< Statement, StatementNode >( stmt, branches );
         assert( branches.size() == 1 );
-        return new FinallyStmt( dynamic_cast< CompoundStmt * >( branches.front() ) );
+        return new FinallyStmt( noLabels, dynamic_cast< CompoundStmt * >( branches.front() ) );
 }
 
@@ -289 +289 @@
 
 Statement *build_compound( StatementNode *first ) {
-        CompoundStmt *cs = new CompoundStmt();
+        CompoundStmt *cs = new CompoundStmt( noLabels );
         buildMoveList( first, cs->get_kids() );
         return cs;
@@ -301 +301 @@
         buildMoveList( input, in );
         buildMoveList( clobber, clob );
-        return new AsmStmt( voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
+        return new AsmStmt( noLabels, voltile, instruction, out, in, clob, gotolabels ? gotolabels->labels : noLabels );
 }
 

src/SymTab/AddVisit.h

@@ -24 +24 @@
                         // 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( *decl );
+                                DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
                                 stmts.insert( stmt, declStmt );
                         }
@@ -36 +36 @@
                         // 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( *decl );
+                                DeclStmt *declStmt = new DeclStmt( noLabels, *decl );
                                 stmts.insert( stmt, declStmt );
                         }

src/SymTab/Autogen.cc

@@ -264 +264 @@
                 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(),
+                FunctionDecl * decl = new FunctionDecl( fname, scs, spec, ftype, new CompoundStmt( noLabels ),
                                                                                                 std::list< Attribute * >(), Type::FuncSpecifiers( Type::Inline ) );
                 decl->fixUniqueId();
@@ -299 +299 @@
                                 assert( assignType->returnVals.size() == 1 );
                                 ObjectDecl * dstParam = strict_dynamic_cast< ObjectDecl * >( assignType->parameters.front() );
-                                dcl->statements->push_back( new ReturnStmt( new VariableExpr( dstParam ) ) );
+                                dcl->statements->push_back( new ReturnStmt( noLabels, new VariableExpr( dstParam ) ) );
                         }
                         resolve( dcl );
@@ -468 +468 @@
                 copy->args.push_back( new AddressExpr( new VariableExpr( srcParam ) ) );
                 copy->args.push_back( new SizeofExpr( srcParam->get_type()->clone() ) );
-                *out++ = new ExprStmt( copy );
+                *out++ = new ExprStmt( noLabels, copy );
         }
 
@@ -544 +544 @@
                         callExpr->get_args().push_back( new VariableExpr( dstParam ) );
                         callExpr->get_args().push_back( new VariableExpr( srcParam ) );
-                        funcDecl->statements->push_back( new ExprStmt( callExpr ) );
+                        funcDecl->statements->push_back( new ExprStmt( noLabels, callExpr ) );
                 } else {
                         // default ctor/dtor body is empty - add unused attribute to parameter to silence warnings
@@ -569 +569 @@
                 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( expr ) );
+                dcl->statements->kids.push_back( new ExprStmt( noLabels, expr ) );
         };
 
@@ -664 +664 @@
                         untyped->get_args().push_back( new VariableExpr( ftype->get_parameters().back() ) );
                 }
-                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() ) ) ) );
+                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() ) ) ) );
         }
 

src/SymTab/Autogen.h

@@ -104 +104 @@
                 fExpr->args.splice( fExpr->args.end(), args );
 
-                *out++ = new ExprStmt( fExpr );
+                *out++ = new ExprStmt( noLabels, fExpr );
 
                 srcParam.clearArrayIndices();
@@ -162 +162 @@
 
                 // for stmt's body, eventually containing call
-                CompoundStmt * body = new CompoundStmt();
+                CompoundStmt * body = new CompoundStmt( noLabels );
                 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();
-                block->push_back( new DeclStmt( index ) );
+                CompoundStmt * block = new CompoundStmt( noLabels );
+                block->push_back( new DeclStmt( noLabels, index ) );
                 if ( listInit ) block->get_kids().push_back( listInit );
-                block->push_back( new ForStmt( initList, cond, inc, body ) );
+                block->push_back( new ForStmt( noLabels, initList, cond, inc, body ) );
 
                 *out++ = block;

src/SymTab/Validate.cc

@@ -81 +81 @@
 
 namespace SymTab {
-        struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
+        class HoistStruct final : public Visitor {
+                template< typename Visitor >
+                friend void acceptAndAdd( std::list< Declaration * > &translationUnit, Visitor &visitor );
+            template< typename Visitor >
+            friend void addVisitStatementList( std::list< Statement* > &stmts, Visitor &visitor );
+          public:
                 /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
 
-                void previsit( EnumInstType * enumInstType );
-                void previsit( StructInstType * structInstType );
-                void previsit( UnionInstType * unionInstType );
-                void previsit( StructDecl * aggregateDecl );
-                void previsit( UnionDecl * aggregateDecl );
-
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+
+                virtual void visit( EnumInstType *enumInstType );
+                virtual void visit( StructInstType *structInstType );
+                virtual void visit( UnionInstType *unionInstType );
+                virtual void visit( StructDecl *aggregateDecl );
+                virtual void visit( UnionDecl *aggregateDecl );
+
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
           private:
+                HoistStruct();
+
                 template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
 
-                bool inStruct = false;
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                bool inStruct;
         };
 
@@ -293 +305 @@
 
         void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<HoistStruct> hoister;
-                acceptAll( translationUnit, hoister );
+                HoistStruct hoister;
+                acceptAndAdd( translationUnit, hoister );
+        }
+
+        HoistStruct::HoistStruct() : inStruct( false ) {
         }
 
@@ -305 +320 @@
                 if ( inStruct ) {
                         // Add elements in stack order corresponding to nesting structure.
-                        declsToAddBefore.push_front( aggregateDecl );
+                        declsToAdd.push_front( aggregateDecl );
+                        Visitor::visit( aggregateDecl );
                 } else {
-                        GuardValue( inStruct );
                         inStruct = true;
+                        Visitor::visit( aggregateDecl );
+                        inStruct = false;
                 } // if
                 // Always remove the hoisted aggregate from the inner structure.
-                GuardAction( [this, aggregateDecl]() { filter( aggregateDecl->members, isStructOrUnion, false ); } );
-        }
-
-        void HoistStruct::previsit( EnumInstType * inst ) {
-                if ( inst->baseEnum ) {
-                        declsToAddBefore.push_front( inst->baseEnum );
-                }
-        }
-
-        void HoistStruct::previsit( StructInstType * inst ) {
-                if ( inst->baseStruct ) {
-                        declsToAddBefore.push_front( inst->baseStruct );
-                }
-        }
-
-        void HoistStruct::previsit( UnionInstType * inst ) {
-                if ( inst->baseUnion ) {
-                        declsToAddBefore.push_front( inst->baseUnion );
-                }
-        }
-
-        void HoistStruct::previsit( StructDecl * aggregateDecl ) {
+                filter( aggregateDecl->get_members(), isStructOrUnion, false );
+        }
+
+        void HoistStruct::visit( EnumInstType *structInstType ) {
+                if ( structInstType->get_baseEnum() ) {
+                        declsToAdd.push_front( structInstType->get_baseEnum() );
+                }
+        }
+
+        void HoistStruct::visit( StructInstType *structInstType ) {
+                if ( structInstType->get_baseStruct() ) {
+                        declsToAdd.push_front( structInstType->get_baseStruct() );
+                }
+        }
+
+        void HoistStruct::visit( UnionInstType *structInstType ) {
+                if ( structInstType->get_baseUnion() ) {
+                        declsToAdd.push_front( structInstType->get_baseUnion() );
+                }
+        }
+
+        void HoistStruct::visit( StructDecl *aggregateDecl ) {
                 handleAggregate( aggregateDecl );
         }
 
-        void HoistStruct::previsit( UnionDecl * aggregateDecl ) {
+        void HoistStruct::visit( UnionDecl *aggregateDecl ) {
                 handleAggregate( aggregateDecl );
+        }
+
+        void HoistStruct::visit( CompoundStmt *compoundStmt ) {
+                addVisit( compoundStmt, *this );
+        }
+
+        void HoistStruct::visit( SwitchStmt *switchStmt ) {
+                addVisit( switchStmt, *this );
         }
 

src/SymTab/module.mk

@@ -19 +19 @@
        SymTab/Validate.cc \
        SymTab/FixFunction.cc \
+       SymTab/ImplementationType.cc \
+       SymTab/TypeEquality.cc \
        SymTab/Autogen.cc

src/SynTree/CompoundStmt.cc

@@ -28 +28 @@
 using std::endl;
 
-CompoundStmt::CompoundStmt() : Statement() {
+CompoundStmt::CompoundStmt( std::list<Label> labels ) : Statement( labels ) {
 }
 
-CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement(), kids( stmts ) {
+CompoundStmt::CompoundStmt( std::list<Statement *> stmts ) : Statement( noLabels ), kids( stmts ) {
 }
 

src/SynTree/DeclStmt.cc

@@ -23 +23 @@
 #include "SynTree/Label.h"   // for Label
 
-DeclStmt::DeclStmt( Declaration *decl ) : Statement(), decl( decl ) {
+DeclStmt::DeclStmt( std::list<Label> labels, Declaration *decl ) : Statement( labels ), decl( decl ) {
 }
 

src/SynTree/Statement.cc

@@ -32 +32 @@
 using std::endl;
 
-Statement::Statement( const std::list<Label> & labels ) : labels( labels ) {}
+Statement::Statement( std::list<Label> labels ) : labels( labels ) {}
 
 void Statement::print( std::ostream & os, Indenter ) const {
@@ -46 +46 @@
 Statement::~Statement() {}
 
-ExprStmt::ExprStmt( Expression *expr ) : Statement(), expr( expr ) {}
+ExprStmt::ExprStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
 
 ExprStmt::ExprStmt( const ExprStmt &other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -60 +60 @@
 
 
-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( 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( const AsmStmt & other ) : Statement( other ), voltile( other.voltile ), instruction( maybeClone( other.instruction ) ), gotolabels( other.gotolabels ) {
@@ -96 +96 @@
 const char *BranchStmt::brType[] = { "Goto", "Break", "Continue" };
 
-BranchStmt::BranchStmt( Label target, Type type ) throw ( SemanticError ) :
-        Statement(), originalTarget( target ), target( target ), computedTarget( nullptr ), type( type ) {
+BranchStmt::BranchStmt( std::list<Label> labels, Label target, Type type ) throw ( SemanticError ) :
+        Statement( labels ), 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 +104 @@
 }
 
-BranchStmt::BranchStmt( Expression *computedTarget, Type type ) throw ( SemanticError ) :
-        Statement(), computedTarget( computedTarget ), type( type ) {
+BranchStmt::BranchStmt( std::list<Label> labels, Expression *computedTarget, Type type ) throw ( SemanticError ) :
+        Statement( labels ), computedTarget( computedTarget ), type( type ) {
         if ( type != BranchStmt::Goto || computedTarget == nullptr ) {
                 throw SemanticError("Computed target not valid in branch statement");
@@ -118 +118 @@
 }
 
-ReturnStmt::ReturnStmt( Expression *expr ) : Statement(), expr( expr ) {}
+ReturnStmt::ReturnStmt( std::list<Label> labels, Expression *expr ) : Statement( labels ), expr( expr ) {}
 
 ReturnStmt::ReturnStmt( const ReturnStmt & other ) : Statement( other ), expr( maybeClone( other.expr ) ) {}
@@ -135 +135 @@
 }
 
-IfStmt::IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart, std::list<Statement *> initialization ):
-        Statement(), condition( condition ), thenPart( thenPart ), elsePart( elsePart ), initialization( initialization ) {}
+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( const IfStmt & other ) :
@@ -176 +176 @@
 }
 
-SwitchStmt::SwitchStmt( Expression * condition, const std::list<Statement *> &statements ):
-        Statement(), condition( condition ), statements( statements ) {
+SwitchStmt::SwitchStmt( std::list<Label> labels, Expression * condition, const std::list<Statement *> &statements ):
+        Statement( labels ), condition( condition ), statements( statements ) {
 }
 
@@ -201 +201 @@
 }
 
-CaseStmt::CaseStmt( Expression *condition, const std::list<Statement *> &statements, bool deflt ) throw ( SemanticError ) :
-        Statement(), condition( condition ), stmts( statements ), _isDefault( deflt ) {
+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 ) {
         if ( isDefault() && condition != 0 ) throw SemanticError("default case with condition: ", condition);
 }
@@ -216 +216 @@
 }
 
-CaseStmt * CaseStmt::makeDefault( const std::list<Label> & labels, std::list<Statement *> stmts ) {
-        CaseStmt * stmt = new CaseStmt( nullptr, stmts, true );
-        stmt->labels = labels;
-        return stmt;
+CaseStmt * CaseStmt::makeDefault( std::list<Label> labels, std::list<Statement *> stmts ) {
+        return new CaseStmt( labels, 0, stmts, true );
 }
 
@@ -235 +233 @@
 }
 
-WhileStmt::WhileStmt( Expression *condition, Statement *body, bool isDoWhile ):
-        Statement(), condition( condition), body( body), isDoWhile( isDoWhile) {
+WhileStmt::WhileStmt( std::list<Label> labels, Expression *condition, Statement *body, bool isDoWhile ):
+        Statement( labels ), condition( condition), body( body), isDoWhile( isDoWhile) {
 }
 
@@ -257 +255 @@
 }
 
-ForStmt::ForStmt( std::list<Statement *> initialization, Expression *condition, Expression *increment, Statement *body ):
-        Statement(), initialization( initialization ), condition( condition ), increment( increment ), body( body ) {
+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 ) {
 }
 
@@ -304 +302 @@
 }
 
-ThrowStmt::ThrowStmt( Kind kind, Expression * expr, Expression * target ) :
-                Statement(), kind(kind), expr(expr), target(target)     {
+ThrowStmt::ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target ) :
+                Statement( labels ), kind(kind), expr(expr), target(target)     {
         assertf(Resume == kind || nullptr == target, "Non-local termination throw is not accepted." );
 }
@@ -328 +326 @@
 }
 
-TryStmt::TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
-        Statement(), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
+TryStmt::TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock ) :
+        Statement( labels ), block( tryBlock ),  handlers( handlers ), finallyBlock( finallyBlock ) {
 }
 
@@ -361 +359 @@
 }
 
-CatchStmt::CatchStmt( Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
-        Statement(), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
+CatchStmt::CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl, Expression *cond, Statement *body ) :
+        Statement( labels ), kind ( kind ), decl ( decl ), cond ( cond ), body( body ) {
                 assertf( decl, "Catch clause must have a declaration." );
 }
@@ -393 +391 @@
 
 
-FinallyStmt::FinallyStmt( CompoundStmt *block ) : Statement(), block( block ) {
+FinallyStmt::FinallyStmt( std::list<Label> labels, CompoundStmt *block ) : Statement( labels ), block( block ) {
+        assert( labels.empty() ); // finally statement cannot be labeled
 }
 
@@ -409 +408 @@
 }
 
-WaitForStmt::WaitForStmt() : Statement() {
+WaitForStmt::WaitForStmt( std::list<Label> labels ) : Statement( labels ) {
         timeout.time      = nullptr;
         timeout.statement = nullptr;
@@ -456 +455 @@
 }
 
-NullStmt::NullStmt( const std::list<Label> & labels ) : Statement( labels ) {
-}
+NullStmt::NullStmt( std::list<Label> labels ) : Statement( labels ) {}
+NullStmt::NullStmt() : Statement( std::list<Label>() ) {}
 
 void NullStmt::print( std::ostream &os, Indenter ) const {
@@ -463 +462 @@
 }
 
-ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement(), callStmt( callStmt ) {
+ImplicitCtorDtorStmt::ImplicitCtorDtorStmt( Statement * callStmt ) : Statement( std::list<Label>() ), callStmt( callStmt ) {
         assert( callStmt );
 }

src/SynTree/Statement.h

@@ -37 +37 @@
         std::list<Label> labels;
 
-        Statement( const std::list<Label> & labels = {} );
+        Statement( std::list<Label> labels );
         virtual ~Statement();
 
@@ -53 +53 @@
         std::list<Statement*> kids;
 
-        CompoundStmt();
+        CompoundStmt( std::list<Label> labels );
         CompoundStmt( std::list<Statement *> stmts );
         CompoundStmt( const CompoundStmt &other );
@@ -70 +70 @@
 class NullStmt : public Statement {
   public:
-        NullStmt( const std::list<Label> & labels = {} );
+        NullStmt();
+        NullStmt( std::list<Label> labels );
 
         virtual NullStmt *clone() const override { return new NullStmt( *this ); }
@@ -82 +83 @@
         Expression *expr;
 
-        ExprStmt( Expression *expr );
+        ExprStmt( std::list<Label> labels, Expression *expr );
         ExprStmt( const ExprStmt &other );
         virtual ~ExprStmt();
@@ -103 +104 @@
         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( 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( const AsmStmt &other );
         virtual ~AsmStmt();
@@ -133 +134 @@
         std::list<Statement *> initialization;
 
-        IfStmt( Expression *condition, Statement *thenPart, Statement *elsePart,
+        IfStmt( std::list<Label> labels, Expression *condition, Statement *thenPart, Statement *elsePart,
                         std::list<Statement *> initialization = std::list<Statement *>() );
         IfStmt( const IfStmt &other );
@@ -157 +158 @@
         std::list<Statement *> statements;
 
-        SwitchStmt( Expression *condition, const std::list<Statement *> &statements );
+        SwitchStmt( std::list<Label> labels, Expression *condition, const std::list<Statement *> &statements );
         SwitchStmt( const SwitchStmt &other );
         virtual ~SwitchStmt();
@@ -179 +180 @@
         std::list<Statement *> stmts;
 
-        CaseStmt( Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
+        CaseStmt( std::list<Label> labels, Expression *conditions, const std::list<Statement *> &stmts, bool isdef = false ) throw(SemanticError);
         CaseStmt( const CaseStmt &other );
         virtual ~CaseStmt();
 
-        static CaseStmt * makeDefault( const std::list<Label> & labels = {}, std::list<Statement *> stmts = std::list<Statement *>() );
+        static CaseStmt * makeDefault( std::list<Label> labels = std::list<Label>(), std::list<Statement *> stmts = std::list<Statement *>() );
 
         bool isDefault() const { return _isDefault; }
@@ -209 +210 @@
         bool isDoWhile;
 
-        WhileStmt( Expression *condition,
+        WhileStmt( std::list<Label> labels, Expression *condition,
                Statement *body, bool isDoWhile = false );
         WhileStmt( const WhileStmt &other );
@@ -234 +235 @@
         Statement *body;
 
-        ForStmt( std::list<Statement *> initialization,
+        ForStmt( std::list<Label> labels, std::list<Statement *> initialization,
              Expression *condition = 0, Expression *increment = 0, Statement *body = 0 );
         ForStmt( const ForStmt &other );
@@ -263 +264 @@
         Type type;
 
-        BranchStmt( Label target, Type ) throw (SemanticError);
-        BranchStmt( Expression *computedTarget, Type ) throw (SemanticError);
+        BranchStmt( std::list<Label> labels, Label target, Type ) throw (SemanticError);
+        BranchStmt( std::list<Label> labels, Expression *computedTarget, Type ) throw (SemanticError);
 
         Label get_originalTarget() { return originalTarget; }
@@ -288 +289 @@
         Expression *expr;
 
-        ReturnStmt( Expression *expr );
+        ReturnStmt( std::list<Label> labels, Expression *expr );
         ReturnStmt( const ReturnStmt &other );
         virtual ~ReturnStmt();
@@ -309 +310 @@
         Expression * target;
 
-        ThrowStmt( Kind kind, Expression * expr, Expression * target = nullptr );
+        ThrowStmt( std::list<Label> labels, Kind kind, Expression * expr, Expression * target = nullptr );
         ThrowStmt( const ThrowStmt &other );
         virtual ~ThrowStmt();
@@ -331 +332 @@
         FinallyStmt * finallyBlock;
 
-        TryStmt( CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
+        TryStmt( std::list<Label> labels, CompoundStmt *tryBlock, std::list<CatchStmt *> &handlers, FinallyStmt *finallyBlock = 0 );
         TryStmt( const TryStmt &other );
         virtual ~TryStmt();
@@ -357 +358 @@
         Statement *body;
 
-        CatchStmt( Kind kind, Declaration *decl,
+        CatchStmt( std::list<Label> labels, Kind kind, Declaration *decl,
                    Expression *cond, Statement *body );
         CatchStmt( const CatchStmt &other );
@@ -380 +381 @@
         CompoundStmt *block;
 
-        FinallyStmt( CompoundStmt *block );
+        FinallyStmt( std::list<Label> labels, CompoundStmt *block );
         FinallyStmt( const FinallyStmt &other );
         virtual ~FinallyStmt();
@@ -407 +408 @@
         };
 
-        WaitForStmt();
+        WaitForStmt( std::list<Label> labels = noLabels );
         WaitForStmt( const WaitForStmt & );
         virtual ~WaitForStmt();
@@ -437 +438 @@
         Declaration *decl;
 
-        DeclStmt( Declaration *decl );
+        DeclStmt( std::list<Label> labels, Declaration *decl );
         DeclStmt( const DeclStmt &other );
         virtual ~DeclStmt();

src/SynTree/TupleExpr.cc

@@ -23 +23 @@
 #include "Declaration.h"        // for ObjectDecl
 #include "Expression.h"         // for Expression, TupleExpr, TupleIndexExpr
-#include "SynTree/Label.h"      // for Label
+#include "SynTree/Label.h"      // for Label, noLabels
 #include "SynTree/Statement.h"  // for CompoundStmt, DeclStmt, ExprStmt, Sta...
 #include "Tuples/Tuples.h"      // for makeTupleType
@@ -89 +89 @@
         // 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();
+        CompoundStmt * compoundStmt = new CompoundStmt( noLabels );
         std::list< Statement * > & stmts = compoundStmt->get_kids();
         for ( ObjectDecl * obj : tempDecls ) {
-                stmts.push_back( new DeclStmt( obj ) );
+                stmts.push_back( new DeclStmt( noLabels, obj ) );
         }
         TupleExpr * tupleExpr = new TupleExpr( assigns );
         assert( tupleExpr->get_result() );
-        stmts.push_back( new ExprStmt( tupleExpr ) );
+        stmts.push_back( new ExprStmt( noLabels, tupleExpr ) );
         stmtExpr = new StmtExpr( compoundStmt );
 }

src/Tuples/TupleAssignment.cc

@@ -23 +23 @@
 
 #include "CodeGen/OperatorTable.h"
-#include "Common/PassVisitor.h"
 #include "Common/UniqueName.h"             // for UniqueName
 #include "Common/utility.h"                // for zipWith
@@ -62 +61 @@
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const 
                                 ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
@@ -76 +75 @@
                 struct MassAssignMatcher : public Matcher {
                   public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -83 +82 @@
                 struct MultipleAssignMatcher : public Matcher {
                   public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -120 +119 @@
         }
 
-        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
+        void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr, 
                                 std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 TupleAssignSpotter spotter( currentFinder );
@@ -129 +128 @@
                 : currentFinder(f) {}
 
-        void TupleAssignSpotter::spot( UntypedExpr * expr,
+        void TupleAssignSpotter::spot( UntypedExpr * expr, 
                         std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
@@ -138 +137 @@
                                 if ( args.size() == 0 ) return;
 
-                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote
+                                // if an assignment only takes 1 argument, that's odd, but maybe someone wrote 
                                 // the function, in which case AlternativeFinder will handle it normally
                                 if ( args.size() == 1 && CodeGen::isAssignment( fname ) ) return;
@@ -147 +146 @@
                                         if ( ! refToTuple(lhsAlt.expr) ) continue;
 
-                                        // explode is aware of casts - ensure every LHS expression is sent into explode
+                                        // explode is aware of casts - ensure every LHS expression is sent into explode 
                                         // with a reference cast
-                                        // xxx - this seems to change the alternatives before the normal
+                                        // xxx - this seems to change the alternatives before the normal 
                                         //  AlternativeFinder flow; maybe this is desired?
                                         if ( ! dynamic_cast<CastExpr*>( lhsAlt.expr ) ) {
-                                                lhsAlt.expr = new CastExpr( lhsAlt.expr,
-                                                                new ReferenceType( Type::Qualifiers(),
+                                                lhsAlt.expr = new CastExpr( lhsAlt.expr, 
+                                                                new ReferenceType( Type::Qualifiers(), 
                                                                         lhsAlt.expr->get_result()->clone() ) );
                                         }
@@ -161 +160 @@
                                         explode( lhsAlt, currentFinder.get_indexer(), back_inserter(lhs), true );
                                         for ( ResolvExpr::Alternative& alt : lhs ) {
-                                                // each LHS value must be a reference - some come in with a cast expression,
+                                                // each LHS value must be a reference - some come in with a cast expression, 
                                                 // if not just cast to reference here
                                                 if ( ! dynamic_cast<ReferenceType*>( alt.expr->get_result() ) ) {
-                                                        alt.expr = new CastExpr( alt.expr,
-                                                                new ReferenceType( Type::Qualifiers(),
+                                                        alt.expr = new CastExpr( alt.expr, 
+                                                                new ReferenceType( Type::Qualifiers(), 
                                                                         alt.expr->get_result()->clone() ) );
                                                 }
@@ -179 +178 @@
                                                 // TODO build iterative version of this instead of using combos
                                                 std::vector< ResolvExpr::AltList > rhsAlts;
-                                                combos( std::next(args.begin(), 1), args.end(),
+                                                combos( std::next(args.begin(), 1), args.end(), 
                                                         std::back_inserter( rhsAlts ) );
                                                 for ( const ResolvExpr::AltList& rhsAlt : rhsAlts ) {
                                                         // multiple assignment
                                                         ResolvExpr::AltList rhs;
-                                                        explode( rhsAlt, currentFinder.get_indexer(),
+                                                        explode( rhsAlt, currentFinder.get_indexer(), 
                                                                 std::back_inserter(rhs), true );
                                                         matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -194 +193 @@
                                                         if ( isTuple(rhsAlt.expr) ) {
                                                                 // multiple assignment
-                                                                explode( rhsAlt, currentFinder.get_indexer(),
+                                                                explode( rhsAlt, currentFinder.get_indexer(),  
                                                                         std::back_inserter(rhs), true );
                                                                 matcher.reset( new MultipleAssignMatcher( *this, lhs, rhs ) );
@@ -223 +222 @@
                 ResolvExpr::AltList current;
                 // now resolve new assignments
-                for ( std::list< Expression * >::iterator i = new_assigns.begin();
+                for ( std::list< Expression * >::iterator i = new_assigns.begin(); 
                                 i != new_assigns.end(); ++i ) {
                         PRINT(
@@ -230 +229 @@
                         )
 
-                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(),
+                        ResolvExpr::AlternativeFinder finder{ currentFinder.get_indexer(), 
                                 currentFinder.get_environ() };
                         try {
@@ -254 +253 @@
                 // xxx -- was push_front
                 currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
-                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
+                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, 
                         ResolvExpr::sumCost( current ) + matcher->baseCost ) );
         }
 
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter,
-                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
-        : lhs(lhs), rhs(rhs), spotter(spotter),
+        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter, 
+                const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs ) 
+        : lhs(lhs), rhs(rhs), spotter(spotter), 
           baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
                 simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
@@ -278 +277 @@
         // xxx - maybe this should happen in alternative finder for every StmtExpr?
         // xxx - it's possible that these environments could contain some useful information. Maybe the right thing to do is aggregate the environments and pass the aggregate back to be added into the compositeEnv
-        struct EnvRemover {
-                void previsit( ExprStmt * stmt ) {
-                        delete stmt->expr->env;
-                        stmt->expr->env = nullptr;
+        struct EnvRemover : public Visitor {
+                virtual void visit( ExprStmt * stmt ) {
+                        delete stmt->get_expr()->get_env();
+                        stmt->get_expr()->set_env( nullptr );
+                        Visitor::visit( stmt );
                 }
         };
@@ -293 +293 @@
                         ret->set_init( ctorInit );
                         ResolvExpr::resolveCtorInit( ctorInit, spotter.currentFinder.get_indexer() ); // resolve ctor/dtors for the new object
-                        PassVisitor<EnvRemover> rm; // remove environments from subexpressions of StmtExprs
+                        EnvRemover rm; // remove environments from subexpressions of StmtExprs
                         ctorInit->accept( rm );
                 }

src/Tuples/TupleExpansion.cc

@@ -315 +315 @@
         namespace {
                 /// determines if impurity (read: side-effects) may exist in a piece of code. Currently gives a very crude approximation, wherein any function call expression means the code may be impure
-                struct ImpurityDetector : public WithShortCircuiting {
+                class ImpurityDetector : public Visitor {
+                public:
                         ImpurityDetector( bool ignoreUnique ) : ignoreUnique( ignoreUnique ) {}
 
-                        void previsit( ApplicationExpr * appExpr ) {
-                                visit_children = false;
+                        typedef Visitor Parent;
+                        virtual void visit( ApplicationExpr * appExpr ) {
                                 if ( DeclarationWithType * function = InitTweak::getFunction( appExpr ) ) {
                                         if ( function->get_linkage() == LinkageSpec::Intrinsic ) {
                                                 if ( function->get_name() == "*?" || function->get_name() == "?[?]" ) {
                                                         // intrinsic dereference, subscript are pure, but need to recursively look for impurity
-                                                        visit_children = true;
+                                                        Parent::visit( appExpr );
                                                         return;
                                                 }
@@ -331 +332 @@
                                 maybeImpure = true;
                         }
-                        void previsit( UntypedExpr * ) { maybeImpure = true; visit_children = false; }
-                        void previsit( UniqueExpr * ) {
+                        virtual void visit( UntypedExpr * ) { maybeImpure = true; }
+                        virtual void visit( UniqueExpr * unq ) {
                                 if ( ignoreUnique ) {
                                         // bottom out at unique expression.
                                         // The existence of a unique expression doesn't change the purity of an expression.
                                         // That is, even if the wrapped expression is impure, the wrapper protects the rest of the expression.
-                                        visit_children = false;
                                         return;
                                 }
+                                maybeAccept( unq->expr, *this );
                         }
 
@@ -348 +349 @@
 
         bool maybeImpure( Expression * expr ) {
-                PassVisitor<ImpurityDetector> detector( false );
+                ImpurityDetector detector( false );
                 expr->accept( detector );
-                return detector.pass.maybeImpure;
+                return detector.maybeImpure;
         }
 
         bool maybeImpureIgnoreUnique( Expression * expr ) {
-                PassVisitor<ImpurityDetector> detector( true );
+                ImpurityDetector detector( true );
                 expr->accept( detector );
-                return detector.pass.maybeImpure;
+                return detector.maybeImpure;
         }
 } // namespace Tuples

src/tests/except-mac.h

@@ -30 +30 @@
         size_t size; \
         void (*copy)(except_name *this, except_name * other); \
-        void (*free)(except_name &this); \
+        void (*free)(except_name *this); \
         const char * (*msg)(except_name *this); \
         __VA_ARGS__ \
@@ -42 +42 @@
 // In each constructor the vtable must be initialized.
 #define VTABLE_INIT(this_name,except_name) \
-this_name.virtual_table = &INSTANCE(except_name)
+this_name->virtual_table = &INSTANCE(except_name)
 
 // Declare the vtable instance. This should end an exception declaration.
@@ -73 +73 @@
     this->virtual_table = other->virtual_table; \
 } \
-void ?{}(name & this) { \
+void ?{}(name * this) { \
         VTABLE_INIT(this,name); \
 } \