Changes in / [a2d4d1c:4dfa562]

Location:

src

Files:

• CodeGen/CodeGenerator.cc (modified) (8 diffs)
• GenPoly/Box.cc (modified) (28 diffs)
• GenPoly/DeclMutator.cc (added)
• GenPoly/DeclMutator.h (added)
• GenPoly/PolyMutator.cc (added)
• GenPoly/PolyMutator.h (added)
• GenPoly/Specialize.cc (modified) (9 diffs)
• GenPoly/module.mk (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (28 diffs)
• InitTweak/GenInit.cc (modified) (16 diffs)
• InitTweak/GenInit.h (modified) (1 diff)
• InitTweak/InitTweak.cc (modified) (9 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• Makefile.in (modified) (13 diffs)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• ResolvExpr/Resolver.h (modified) (1 diff)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• SymTab/Autogen.cc (modified) (17 diffs)
• SymTab/FixFunction.cc (modified) (1 diff)
• SymTab/Indexer.cc (modified) (2 diffs)
• SymTab/Indexer.h (modified) (3 diffs)
• SymTab/Mangler.cc (modified) (15 diffs)
• SymTab/Validate.cc (modified) (6 diffs)
• SynTree/AddStmtVisitor.cc (added)
• SynTree/AddStmtVisitor.h (added)
• SynTree/Visitor.h (modified) (1 diff)
• SynTree/module.mk (modified) (1 diff)
• Tuples/TupleExpansion.cc (modified) (1 diff)
• main.cc (modified) (1 diff)
• tests/.expect/64/sched-ext-parse.txt (modified) (2 diffs)

src/CodeGen/CodeGenerator.cc

@@ -443 +443 @@
         void CodeGenerator::postvisit( UntypedExpr * untypedExpr ) {
                 extension( untypedExpr );
-                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->function ) ) {
+                if ( NameExpr * nameExpr = dynamic_cast< NameExpr* >( untypedExpr->get_function() ) ) {
                         OperatorInfo opInfo;
-                        if ( operatorLookup( nameExpr->name, opInfo ) ) {
-                                std::list< Expression* >::iterator arg = untypedExpr->args.begin();
+                        if ( operatorLookup( nameExpr->get_name(), opInfo ) ) {
+                                std::list< Expression* >::iterator arg = untypedExpr->get_args().begin();
                                 switch ( opInfo.type ) {
                                   case OT_INDEX:
-                                        assert( untypedExpr->args.size() == 2 );
+                                        assert( untypedExpr->get_args().size() == 2 );
                                         (*arg++)->accept( *visitor );
                                         output << "[";
@@ -461 +461 @@
                                   case OT_CTOR:
                                   case OT_DTOR:
-                                        if ( untypedExpr->args.size() == 1 ) {
+                                        if ( untypedExpr->get_args().size() == 1 ) {
                                                 // the expression fed into a single parameter constructor or destructor may contain side
                                                 // effects, so must still output this expression
@@ -480 +480 @@
                                                 (*arg++)->accept( *visitor );
                                                 output << opInfo.symbol << "{ ";
-                                                genCommaList( arg, untypedExpr->args.end() );
+                                                genCommaList( arg, untypedExpr->get_args().end() );
                                                 output << "}) /* " << opInfo.inputName << " */";
                                         } // if
@@ -488 +488 @@
                                   case OT_PREFIXASSIGN:
                                   case OT_LABELADDRESS:
-                                        assert( untypedExpr->args.size() == 1 );
+                                        assert( untypedExpr->get_args().size() == 1 );
                                         output << "(";
                                         output << opInfo.symbol;
@@ -497 +497 @@
                                   case OT_POSTFIX:
                                   case OT_POSTFIXASSIGN:
-                                        assert( untypedExpr->args.size() == 1 );
+                                        assert( untypedExpr->get_args().size() == 1 );
                                         (*arg)->accept( *visitor );
                                         output << opInfo.symbol;
@@ -504 +504 @@
                                   case OT_INFIX:
                                   case OT_INFIXASSIGN:
-                                        assert( untypedExpr->args.size() == 2 );
+                                        assert( untypedExpr->get_args().size() == 2 );
                                         output << "(";
                                         (*arg++)->accept( *visitor );
@@ -517 +517 @@
                                 } // switch
                         } else {
-                                // builtin routines
-                                nameExpr->accept( *visitor );
-                                output << "(";
-                                genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
-                                output << ")";
+                                if ( nameExpr->get_name() == "..." ) { // case V1 ... V2 or case V1~V2
+                                        assert( untypedExpr->get_args().size() == 2 );
+                                        (*untypedExpr->get_args().begin())->accept( *visitor );
+                                        output << " ... ";
+                                        (*--untypedExpr->get_args().end())->accept( *visitor );
+                                } else {                                                                // builtin routines
+                                        nameExpr->accept( *visitor );
+                                        output << "(";
+                                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
+                                        output << ")";
+                                } // if
                         } // if
                 } else {
-                        untypedExpr->function->accept( *visitor );
+                        untypedExpr->get_function()->accept( *visitor );
                         output << "(";
-                        genCommaList( untypedExpr->args.begin(), untypedExpr->args.end() );
+                        genCommaList( untypedExpr->get_args().begin(), untypedExpr->get_args().end() );
                         output << ")";
                 } // if
@@ -532 +538 @@
 
         void CodeGenerator::postvisit( RangeExpr * rangeExpr ) {
-                rangeExpr->low->accept( *visitor );
+                rangeExpr->get_low()->accept( *visitor );
                 output << " ... ";
-                rangeExpr->high->accept( *visitor );
+                rangeExpr->get_high()->accept( *visitor );
         }
 

src/GenPoly/Box.cc

@@ -32 +32 @@
 #include "Common/UniqueName.h"           // for UniqueName
 #include "Common/utility.h"              // for toString
+#include "DeclMutator.h"                 // for DeclMutator
 #include "FindFunction.h"                // for findFunction, findAndReplace...
 #include "GenPoly/ErasableScopedMap.h"   // for ErasableScopedMap<>::const_i...
@@ -38 +39 @@
 #include "Lvalue.h"                      // for generalizedLvalue
 #include "Parser/LinkageSpec.h"          // for C, Spec, Cforall, Intrinsic
+#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass
 #include "ResolvExpr/typeops.h"          // for typesCompatible
@@ -60 +62 @@
                 FunctionType *makeAdapterType( FunctionType *adaptee, const TyVarMap &tyVars );
 
-                class BoxPass {
-                protected:
-                        BoxPass() : scopeTyVars( TypeDecl::Data{} ) {}
-                        TyVarMap scopeTyVars;
+                /// Adds layout-generation functions to polymorphic types
+                class LayoutFunctionBuilder final : public DeclMutator {
+                        unsigned int functionNesting;  // current level of nested functions
+                public:
+                        LayoutFunctionBuilder() : functionNesting( 0 ) {}
+
+                        using DeclMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
                 };
 
-                /// Adds layout-generation functions to polymorphic types
-                class LayoutFunctionBuilder final : public WithDeclsToAdd, public WithVisitorRef<LayoutFunctionBuilder>, public WithShortCircuiting {
-                        unsigned int functionNesting = 0;  // current level of nested functions
-                public:
-                        void previsit( FunctionDecl *functionDecl );
-                        void previsit( StructDecl *structDecl );
-                        void previsit( UnionDecl *unionDecl );
-                };
-
                 /// Replaces polymorphic return types with out-parameters, replaces calls to polymorphic functions with adapter calls as needed, and adds appropriate type variables to the function call
-                class Pass1 final : public BoxPass, public WithTypeSubstitution, public WithStmtsToAdd, public WithGuards, public WithVisitorRef<Pass1>, public WithShortCircuiting {
+                class Pass1 final : public PolyMutator {
                   public:
                         Pass1();
 
-                        void premutate( FunctionDecl * functionDecl );
-                        void premutate( TypeDecl * typeDecl );
-                        void premutate( CommaExpr * commaExpr );
-                        Expression * postmutate( ApplicationExpr * appExpr );
-                        Expression * postmutate( UntypedExpr *expr );
-                        void premutate( AddressExpr * addrExpr );
-                        Expression * postmutate( AddressExpr * addrExpr );
-                        void premutate( ReturnStmt * returnStmt );
-                        void premutate( PointerType * pointerType );
-                        void premutate( FunctionType * functionType );
-
-                        void beginScope();
-                        void endScope();
+                        using PolyMutator::mutate;
+                        virtual Expression *mutate( ApplicationExpr *appExpr ) override;
+                        virtual Expression *mutate( AddressExpr *addrExpr ) override;
+                        virtual Expression *mutate( UntypedExpr *expr ) override;
+                        virtual DeclarationWithType* mutate( FunctionDecl *functionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual Expression *mutate( CommaExpr *commaExpr ) override;
+                        virtual Expression *mutate( ConditionalExpr *condExpr ) override;
+                        virtual Statement * mutate( ReturnStmt *returnStmt ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type * mutate( FunctionType *functionType ) override;
+
+                        virtual void doBeginScope() override;
+                        virtual void doEndScope() override;
                   private:
                         /// Pass the extra type parameters from polymorphic generic arguments or return types into a function application
@@ -129 +129 @@
                 /// * Moves polymorphic returns in function types to pointer-type parameters
                 /// * adds type size and assertion parameters to parameter lists
-                struct Pass2 final : public BoxPass, public WithGuards {
-                        void handleAggDecl();
-
-                        DeclarationWithType * postmutate( FunctionDecl *functionDecl );
-                        void premutate( StructDecl *structDecl );
-                        void premutate( UnionDecl *unionDecl );
-                        void premutate( TraitDecl *unionDecl );
-                        void premutate( TypeDecl *typeDecl );
-                        void premutate( PointerType *pointerType );
-                        void premutate( FunctionType *funcType );
+                class Pass2 final : public PolyMutator {
+                  public:
+                        template< typename DeclClass >
+                        DeclClass *handleDecl( DeclClass *decl );
+                        template< typename AggDecl >
+                        AggDecl * handleAggDecl( AggDecl * aggDecl );
+
+                        typedef PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual StructDecl *mutate( StructDecl *structDecl ) override;
+                        virtual UnionDecl *mutate( UnionDecl *unionDecl ) override;
+                        virtual TraitDecl *mutate( TraitDecl *unionDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *typeDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *typedefDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
 
                   private:
@@ -150 +158 @@
                 /// * Calculates polymorphic offsetof expressions from offset array
                 /// * Inserts dynamic calculation of polymorphic type layouts where needed
-                class PolyGenericCalculator final : public BoxPass, public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
+                class PolyGenericCalculator final : public WithGuards, public WithVisitorRef<PolyGenericCalculator>, public WithStmtsToAdd, public WithDeclsToAdd, public WithTypeSubstitution {
                 public:
                         PolyGenericCalculator();
@@ -189 +197 @@
                         ScopedSet< std::string > knownOffsets;          ///< Set of non-generic types for which the offset array exists in the current scope, indexed by offsetofName
                         UniqueName bufNamer;                           ///< Namer for VLA buffers
+                        TyVarMap scopeTyVars;
                 };
 
                 /// Replaces initialization of polymorphic values with alloca, declaration of dtype/ftype with appropriate void expression, sizeof expressions of polymorphic types with the proper variable, and strips fields from generic struct declarations.
-                struct Pass3 final : public BoxPass, public WithGuards {
+                class Pass3 final : public PolyMutator {
+                  public:
                         template< typename DeclClass >
-                        void handleDecl( DeclClass * decl, Type * type );
-
-                        void premutate( ObjectDecl * objectDecl );
-                        void premutate( FunctionDecl * functionDecl );
-                        void premutate( TypedefDecl * typedefDecl );
-                        void premutate( StructDecl * structDecl );
-                        void premutate( UnionDecl * unionDecl );
-                        void premutate( TypeDecl * typeDecl );
-                        void premutate( PointerType * pointerType );
-                        void premutate( FunctionType * funcType );
+                        DeclClass *handleDecl( DeclClass *decl, Type *type );
+
+                        using PolyMutator::mutate;
+                        virtual DeclarationWithType *mutate( FunctionDecl *functionDecl ) override;
+                        virtual Declaration *mutate( StructDecl *structDecl ) override;
+                        virtual Declaration *mutate( UnionDecl *unionDecl ) override;
+                        virtual ObjectDecl *mutate( ObjectDecl *objectDecl ) override;
+                        virtual TypedefDecl *mutate( TypedefDecl *objectDecl ) override;
+                        virtual TypeDecl *mutate( TypeDecl *objectDecl ) override;
+                        virtual Type *mutate( PointerType *pointerType ) override;
+                        virtual Type *mutate( FunctionType *funcType ) override;
+                  private:
                 };
         } // anonymous namespace
@@ -235 +247 @@
 
         void box( std::list< Declaration *>& translationUnit ) {
-                PassVisitor<LayoutFunctionBuilder> layoutBuilder;
-                PassVisitor<Pass1> pass1;
-                PassVisitor<Pass2> pass2;
+                LayoutFunctionBuilder layoutBuilder;
+                Pass1 pass1;
+                Pass2 pass2;
                 PassVisitor<PolyGenericCalculator> polyCalculator;
-                PassVisitor<Pass3> pass3;
-
-                acceptAll( translationUnit, layoutBuilder );
-                mutateAll( translationUnit, pass1 );
-                mutateAll( translationUnit, pass2 );
+                Pass3 pass3;
+
+                layoutBuilder.mutateDeclarationList( translationUnit );
+                mutateTranslationUnit/*All*/( translationUnit, pass1 );
+                mutateTranslationUnit/*All*/( translationUnit, pass2 );
                 mutateAll( translationUnit, polyCalculator );
-                mutateAll( translationUnit, pass3 );
+                mutateTranslationUnit/*All*/( translationUnit, pass3 );
         }
 
         ////////////////////////////////// LayoutFunctionBuilder ////////////////////////////////////////////
 
-        void LayoutFunctionBuilder::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;
-                maybeAccept( functionDecl->get_functionType(), *visitor );
+        DeclarationWithType *LayoutFunctionBuilder::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
                 ++functionNesting;
-                maybeAccept( functionDecl->get_statements(), *visitor );
+                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
                 --functionNesting;
+                return functionDecl;
         }
 
@@ -344 +356 @@
         }
 
-        void LayoutFunctionBuilder::previsit( StructDecl *structDecl ) {
+        Declaration *LayoutFunctionBuilder::mutate( StructDecl *structDecl ) {
                 // do not generate layout function for "empty" tag structs
-                visit_children = false;
-                if ( structDecl->get_members().empty() ) return;
+                if ( structDecl->get_members().empty() ) return structDecl;
 
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( structDecl->get_parameters() );
-                if ( otypeParams.empty() ) return;
+                if ( otypeParams.empty() ) return structDecl;
 
                 // build layout function signature
@@ -402 +413 @@
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
 
-                declsToAddAfter.push_back( layoutDecl );
+                addDeclarationAfter( layoutDecl );
+                return structDecl;
         }
 
-        void LayoutFunctionBuilder::previsit( UnionDecl *unionDecl ) {
+        Declaration *LayoutFunctionBuilder::mutate( UnionDecl *unionDecl ) {
                 // do not generate layout function for "empty" tag unions
-                visit_children = false;
-                if ( unionDecl->get_members().empty() ) return;
+                if ( unionDecl->get_members().empty() ) return unionDecl;
 
                 // get parameters that can change layout, exiting early if none
                 std::list< TypeDecl* > otypeParams = takeOtypeOnly( unionDecl->get_parameters() );
-                if ( otypeParams.empty() ) return;
+                if ( otypeParams.empty() ) return unionDecl;
 
                 // build layout function signature
@@ -445 +456 @@
                 addStmt( layoutDecl->get_statements(), makeAlignTo( derefVar( sizeParam ), derefVar( alignParam ) ) );
 
-                declsToAddAfter.push_back( layoutDecl );
+                addDeclarationAfter( layoutDecl );
+                return unionDecl;
         }
 
@@ -489 +501 @@
                 Pass1::Pass1() : tempNamer( "_temp" ) {}
 
-                void Pass1::premutate( FunctionDecl *functionDecl ) {
+                DeclarationWithType *Pass1::mutate( FunctionDecl *functionDecl ) {
                         if ( functionDecl->get_statements() ) {         // empty routine body ?
                                 // std::cerr << "mutating function: " << functionDecl->get_mangleName() << std::endl;
-                                GuardScope( scopeTyVars );
-                                GuardValue( retval );
+                                doBeginScope();
+                                scopeTyVars.beginScope();
+
+                                DeclarationWithType *oldRetval = retval;
 
                                 // process polymorphic return value
                                 retval = nullptr;
-                                FunctionType *functionType = functionDecl->type;
-                                if ( isDynRet( functionType ) && functionDecl->linkage != LinkageSpec::C ) {
-                                        retval = functionType->returnVals.front();
+                                if ( isDynRet( functionDecl->get_functionType() ) && functionDecl->get_linkage() != LinkageSpec::C ) {
+                                        retval = functionDecl->get_functionType()->get_returnVals().front();
 
                                         // give names to unnamed return values
-                                        if ( retval->name == "" ) {
-                                                retval->name = "_retparm";
-                                                retval->linkage = LinkageSpec::C;
+                                        if ( retval->get_name() == "" ) {
+                                                retval->set_name( "_retparm" );
+                                                retval->set_linkage( LinkageSpec::C );
                                         } // if
                                 } // if
 
-                                makeTyVarMap( functionType, scopeTyVars );
-
-                                std::list< DeclarationWithType *> &paramList = functionType->parameters;
+                                FunctionType *functionType = functionDecl->get_functionType();
+                                makeTyVarMap( functionDecl->get_functionType(), scopeTyVars );
+
+                                std::list< DeclarationWithType *> &paramList = functionType->get_parameters();
                                 std::list< FunctionType *> functions;
-                                for ( Type::ForallList::iterator tyVar = functionType->forall.begin(); tyVar != functionType->forall.end(); ++tyVar ) {
-                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
+                                for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
+                                        for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->get_assertions().begin(); assert != (*tyVar)->get_assertions().end(); ++assert ) {
                                                 findFunction( (*assert)->get_type(), functions, scopeTyVars, needsAdapter );
                                         } // for
@@ -528 +542 @@
                                         } // if
                                 } // for
+
+                                functionDecl->set_statements( functionDecl->get_statements()->acceptMutator( *this ) );
+
+                                scopeTyVars.endScope();
+                                retval = oldRetval;
+                                doEndScope();
                                 // std::cerr << "end function: " << functionDecl->get_mangleName() << std::endl;
                         } // if
-                }
-
-                void Pass1::premutate( TypeDecl *typeDecl ) {
+                        return functionDecl;
+                }
+
+                TypeDecl *Pass1::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                }
-
-                void Pass1::premutate( CommaExpr *commaExpr ) {
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+
+                Expression *Pass1::mutate( CommaExpr *commaExpr ) {
                         // Attempting to find application expressions that were mutated by the copy constructor passes
                         // to use an explicit return variable, so that the variable can be reused as a parameter to the
@@ -552 +574 @@
                                 }
                         }
+
+                        commaExpr->set_arg1( maybeMutate( commaExpr->get_arg1(), *this ) );
+                        commaExpr->set_arg2( maybeMutate( commaExpr->get_arg2(), *this ) );
+                        return commaExpr;
+                }
+
+                Expression *Pass1::mutate( ConditionalExpr *condExpr ) {
+                        condExpr->set_arg1( maybeMutate( condExpr->get_arg1(), *this ) );
+                        condExpr->set_arg2( maybeMutate( condExpr->get_arg2(), *this ) );
+                        condExpr->set_arg3( maybeMutate( condExpr->get_arg3(), *this ) );
+                        return condExpr;
+
                 }
 
@@ -625 +659 @@
                 ObjectDecl *Pass1::makeTemporary( Type *type ) {
                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, type, 0 );
-                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
                         return newObj;
                 }
@@ -741 +775 @@
                                         ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, newType, 0 );
                                         newObj->get_type()->get_qualifiers() = Type::Qualifiers(); // TODO: is this right???
-                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, newObj ) );
+                                        stmtsToAdd.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( noLabels, assign ) );
+                                        stmtsToAdd.push_back( new ExprStmt( noLabels, assign ) );
                                         arg = new AddressExpr( new VariableExpr( newObj ) );
                                 } // if
@@ -927 +961 @@
                                                 std::pair< AdapterIter, bool > answer = adapters.insert( std::pair< std::string, DeclarationWithType *>( mangleName, newAdapter ) );
                                                 adapter = answer.first;
-                                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, newAdapter ) );
+                                                stmtsToAdd.push_back( new DeclStmt( noLabels, newAdapter ) );
                                         } // if
                                         assert( adapter != adapters.end() );
@@ -1084 +1118 @@
                 }
 
-                Expression *Pass1::postmutate( ApplicationExpr *appExpr ) {
+                Expression *Pass1::mutate( ApplicationExpr *appExpr ) {
                         // std::cerr << "mutate appExpr: " << InitTweak::getFunctionName( appExpr ) << std::endl;
                         // for ( TyVarMap::iterator i = scopeTyVars.begin(); i != scopeTyVars.end(); ++i ) {
@@ -1090 +1124 @@
                         // }
                         // std::cerr << "\n";
-
-                        assert( appExpr->function->result );
-                        FunctionType * function = getFunctionType( appExpr->function->result );
-                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->function->result ).c_str() );
+                        appExpr->get_function()->acceptMutator( *this );
+                        mutateAll( appExpr->get_args(), *this );
+
+                        assert( appExpr->get_function()->has_result() );
+                        FunctionType * function = getFunctionType( appExpr->get_function()->get_result() );
+                        assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->get_function()->get_result() ).c_str() );
 
                         if ( Expression *newExpr = handleIntrinsics( appExpr ) ) {
@@ -1146 +1182 @@
                 }
 
-                Expression * Pass1::postmutate( UntypedExpr *expr ) {
-                        if ( expr->result && isPolyType( expr->result, scopeTyVars, env ) ) {
-                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->function ) ) {
+                Expression *Pass1::mutate( UntypedExpr *expr ) {
+                        if ( expr->has_result() && isPolyType( expr->get_result(), scopeTyVars, env ) ) {
+                                if ( NameExpr *name = dynamic_cast< NameExpr *>( expr->get_function() ) ) {
                                         if ( name->get_name() == "*?" ) {
-                                                Expression *ret = expr->args.front();
-                                                expr->args.clear();
+                                                Expression *ret = expr->get_args().front();
+                                                expr->get_args().clear();
                                                 delete expr;
-                                                return ret;
+                                                return ret->acceptMutator( *this );
                                         } // if
                                 } // if
                         } // if
-                        return expr;
-                }
-
-                void Pass1::premutate( AddressExpr * ) { visit_children = false; }
-                Expression * Pass1::postmutate( AddressExpr * addrExpr ) {
+                        return PolyMutator::mutate( expr );
+                }
+
+                Expression *Pass1::mutate( AddressExpr *addrExpr ) {
                         assert( addrExpr->get_arg()->has_result() && ! addrExpr->get_arg()->get_result()->isVoid() );
 
@@ -1181 +1216 @@
                         // isPolyType check needs to happen before mutating addrExpr arg, so pull it forward
                         // out of the if condition.
-                        addrExpr->arg = addrExpr->get_arg()->acceptMutator( *visitor );
+                        addrExpr->set_arg( mutateExpression( addrExpr->get_arg() ) );
                         // ... but must happen after mutate, since argument might change (e.g. intrinsic *?, ?[?]) - re-evaluate above comment
                         bool polytype = isPolyType( addrExpr->get_arg()->get_result(), scopeTyVars, env );
@@ -1196 +1231 @@
                 }
 
-                void Pass1::premutate( ReturnStmt *returnStmt ) {
-                        if ( retval && returnStmt->expr ) {
-                                assert( returnStmt->expr->result && ! returnStmt->expr->result->isVoid() );
-                                delete returnStmt->expr;
-                                returnStmt->expr = nullptr;
+                Statement * Pass1::mutate( ReturnStmt *returnStmt ) {
+                        if ( retval && returnStmt->get_expr() ) {
+                                assert( returnStmt->get_expr()->has_result() && ! returnStmt->get_expr()->get_result()->isVoid() );
+                                delete returnStmt->get_expr();
+                                returnStmt->set_expr( 0 );
+                        } else {
+                                returnStmt->set_expr( mutateExpression( returnStmt->get_expr() ) );
                         } // if
-                }
-
-                void Pass1::premutate( PointerType *pointerType ) {
-                        GuardScope( scopeTyVars );
+                        return returnStmt;
+                }
+
+                Type * Pass1::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
-                }
-
-                void Pass1::premutate( FunctionType *functionType ) {
-                        GuardScope( scopeTyVars );
+
+                        Type *ret = Mutator::mutate( pointerType );
+
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+
+                Type * Pass1::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( functionType, scopeTyVars );
-                }
-
-                void Pass1::beginScope() {
+
+                        Type *ret = Mutator::mutate( functionType );
+
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+
+                void Pass1::doBeginScope() {
                         adapters.beginScope();
                 }
 
-                void Pass1::endScope() {
+                void Pass1::doEndScope() {
                         adapters.endScope();
                 }
@@ -1245 +1293 @@
                 }
 
-                DeclarationWithType * Pass2::postmutate( FunctionDecl *functionDecl ) {
+                template< typename DeclClass >
+                DeclClass * Pass2::handleDecl( DeclClass *decl ) {
+                        DeclClass *ret = static_cast< DeclClass *>( Parent::mutate( decl ) );
+
+                        return ret;
+                }
+
+                DeclarationWithType * Pass2::mutate( FunctionDecl *functionDecl ) {
+                        functionDecl = strict_dynamic_cast< FunctionDecl * > ( handleDecl( functionDecl ) );
                         FunctionType * ftype = functionDecl->get_functionType();
                         if ( ! ftype->get_returnVals().empty() && functionDecl->get_statements() ) {
@@ -1269 +1325 @@
                 }
 
-                void Pass2::premutate( StructDecl * ) {
+                ObjectDecl * Pass2::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl );
+                }
+
+                template< typename AggDecl >
+                AggDecl * Pass2::handleAggDecl( AggDecl * aggDecl ) {
                         // prevent tyVars from leaking into containing scope
-                        GuardScope( scopeTyVars );
-                }
-
-                void Pass2::premutate( UnionDecl * ) {
-                        // prevent tyVars from leaking into containing scope
-                        GuardScope( scopeTyVars );
-                }
-
-                void Pass2::premutate( TraitDecl * ) {
-                        // prevent tyVars from leaking into containing scope
-                        GuardScope( scopeTyVars );
-                }
-
-                void Pass2::premutate( TypeDecl *typeDecl ) {
+                        scopeTyVars.beginScope();
+                        Parent::mutate( aggDecl );
+                        scopeTyVars.endScope();
+                        return aggDecl;
+                }
+
+                StructDecl * Pass2::mutate( StructDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
+                UnionDecl * Pass2::mutate( UnionDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
+                TraitDecl * Pass2::mutate( TraitDecl *aggDecl ) {
+                        return handleAggDecl( aggDecl );
+                }
+
+                TypeDecl * Pass2::mutate( TypeDecl *typeDecl ) {
                         addToTyVarMap( typeDecl, scopeTyVars );
-                }
-
-                void Pass2::premutate( PointerType *pointerType ) {
-                        GuardScope( scopeTyVars );
+                        if ( typeDecl->get_base() ) {
+                                return handleDecl( typeDecl );
+                        } else {
+                                return dynamic_cast<TypeDecl*>( Parent::mutate( typeDecl ) );
+                        }
+                }
+
+                TypedefDecl * Pass2::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl );
+                }
+
+                Type * Pass2::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
-                }
-
-                void Pass2::premutate( FunctionType *funcType ) {
-                        GuardScope( scopeTyVars );
+
+                        Type *ret = Parent::mutate( pointerType );
+
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+
+                Type *Pass2::mutate( FunctionType *funcType ) {
+                        scopeTyVars.beginScope();
+
                         makeTyVarMap( funcType, scopeTyVars );
 
@@ -1333 +1414 @@
                                 // move all assertions into parameter list
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyParm)->get_assertions().begin(); assert != (*tyParm)->get_assertions().end(); ++assert ) {
+//      *assert = (*assert)->acceptMutator( *this );
                                         // assertion parameters may not be used in body, pass along with unused attribute.
                                         (*assert)->get_attributes().push_back( new Attribute( "unused" ) );
@@ -1368 +1450 @@
                                                 }
                                         }
+
                                         seenTypes.insert( typeName );
                                 }
@@ -1375 +1458 @@
                         funcType->get_parameters().splice( last, inferredParams );
                         addAdapters( funcType );
+                        mutateAll( funcType->get_returnVals(), *this );
+                        mutateAll( funcType->get_parameters(), *this );
+
+                        scopeTyVars.endScope();
+                        return funcType;
                 }
 
@@ -1380 +1468 @@
 
                 PolyGenericCalculator::PolyGenericCalculator()
-                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ) {}
+                        : knownLayouts(), knownOffsets(), bufNamer( "_buf" ), scopeTyVars( TypeDecl::Data{} ) {}
 
                 void PolyGenericCalculator::beginTypeScope( Type *ty ) {
@@ -1741 +1829 @@
 
                 template< typename DeclClass >
-                void Pass3::handleDecl( DeclClass * decl, Type * type ) {
-                        GuardScope( scopeTyVars );
+                DeclClass * Pass3::handleDecl( DeclClass *decl, Type *type ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( type, scopeTyVars );
+
+                        DeclClass *ret = static_cast< DeclClass *>( Mutator::mutate( decl ) );
+                        // ScrubTyVars::scrub( decl, scopeTyVars );
                         ScrubTyVars::scrubAll( decl );
-                }
-
-                void Pass3::premutate( ObjectDecl * objectDecl ) {
-                        handleDecl( objectDecl, objectDecl->type );
-                }
-
-                void Pass3::premutate( FunctionDecl * functionDecl ) {
-                        handleDecl( functionDecl, functionDecl->type );
-                }
-
-                void Pass3::premutate( TypedefDecl * typedefDecl ) {
-                        handleDecl( typedefDecl, typedefDecl->base );
+
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+
+                ObjectDecl * Pass3::mutate( ObjectDecl *objectDecl ) {
+                        return handleDecl( objectDecl, objectDecl->get_type() );
+                }
+
+                DeclarationWithType * Pass3::mutate( FunctionDecl *functionDecl ) {
+                        return handleDecl( functionDecl, functionDecl->get_functionType() );
+                }
+
+                TypedefDecl * Pass3::mutate( TypedefDecl *typedefDecl ) {
+                        return handleDecl( typedefDecl, typedefDecl->get_base() );
                 }
 
                 /// Strips the members from a generic aggregate
-                void stripGenericMembers(AggregateDecl * decl) {
-                        if ( ! decl->parameters.empty() ) decl->members.clear();
-                }
-
-                void Pass3::premutate( StructDecl * structDecl ) {
+                void stripGenericMembers(AggregateDecl* decl) {
+                        if ( ! decl->get_parameters().empty() ) decl->get_members().clear();
+                }
+
+                Declaration *Pass3::mutate( StructDecl *structDecl ) {
                         stripGenericMembers( structDecl );
-                }
-
-                void Pass3::premutate( UnionDecl * unionDecl ) {
+                        return structDecl;
+                }
+
+                Declaration *Pass3::mutate( UnionDecl *unionDecl ) {
                         stripGenericMembers( unionDecl );
-                }
-
-                void Pass3::premutate( TypeDecl * typeDecl ) {
+                        return unionDecl;
+                }
+
+                TypeDecl * Pass3::mutate( TypeDecl *typeDecl ) {
+//   Initializer *init = 0;
+//   std::list< Expression *> designators;
+//   addToTyVarMap( typeDecl, scopeTyVars );
+//   if ( typeDecl->get_base() ) {
+//     init = new SimpleInit( new SizeofExpr( handleDecl( typeDecl, typeDecl->get_base() ) ), designators );
+//   }
+//   return new ObjectDecl( typeDecl->get_name(), Declaration::Extern, LinkageSpec::C, 0, new BasicType( Type::Qualifiers(), BasicType::UnsignedInt ), init );
+
                         addToTyVarMap( typeDecl, scopeTyVars );
-                }
-
-                void Pass3::premutate( PointerType * pointerType ) {
-                        GuardScope( scopeTyVars );
+                        return dynamic_cast<TypeDecl*>( Mutator::mutate( typeDecl ) );
+                }
+
+                Type * Pass3::mutate( PointerType *pointerType ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( pointerType, scopeTyVars );
-                }
-
-                void Pass3::premutate( FunctionType * functionType ) {
-                        GuardScope( scopeTyVars );
+
+                        Type *ret = Mutator::mutate( pointerType );
+
+                        scopeTyVars.endScope();
+                        return ret;
+                }
+
+                Type * Pass3::mutate( FunctionType *functionType ) {
+                        scopeTyVars.beginScope();
                         makeTyVarMap( functionType, scopeTyVars );
+
+                        Type *ret = Mutator::mutate( functionType );
+
+                        scopeTyVars.endScope();
+                        return ret;
                 }
         } // anonymous namespace

src/GenPoly/Specialize.cc

@@ -22 +22 @@
 #include <utility>                       // for pair
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/UniqueName.h"           // for UniqueName
@@ -29 +28 @@
 #include "InitTweak/InitTweak.h"         // for isIntrinsicCallExpr
 #include "Parser/LinkageSpec.h"          // for C
+#include "PolyMutator.h"                 // for PolyMutator
 #include "ResolvExpr/FindOpenVars.h"     // for findOpenVars
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
@@ -43 +43 @@
 
 namespace GenPoly {
-        struct Specialize final : public WithTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
-                Expression * postmutate( ApplicationExpr *applicationExpr );
-                Expression * postmutate( AddressExpr *castExpr );
-                Expression * postmutate( CastExpr *castExpr );
+        class Specialize final : public PolyMutator {
+          public:
+                using PolyMutator::mutate;
+                virtual Expression * mutate( ApplicationExpr *applicationExpr ) override;
+                virtual Expression * mutate( AddressExpr *castExpr ) override;
+                virtual Expression * mutate( CastExpr *castExpr ) override;
+                // virtual Expression * mutate( LogicalExpr *logicalExpr );
+                // virtual Expression * mutate( ConditionalExpr *conditionalExpr );
+                // virtual Expression * mutate( CommaExpr *commaExpr );
 
                 void handleExplicitParams( ApplicationExpr *appExpr );
@@ -199 +204 @@
         }
 
-        struct EnvTrimmer {
+        struct EnvTrimmer : public Visitor {
                 TypeSubstitution * env, * newEnv;
                 EnvTrimmer( TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( TypeDecl * tyDecl ) {
+                virtual void visit( TypeDecl * tyDecl ) {
                         // transfer known bindings for seen type variables
-                        if ( Type * t = env->lookup( tyDecl->name ) ) {
-                                newEnv->add( tyDecl->name, t );
+                        if ( Type * t = env->lookup( tyDecl->get_name() ) ) {
+                                newEnv->add( tyDecl->get_name(), t );
                         }
                 }
@@ -214 +219 @@
                 if ( env ) {
                         TypeSubstitution * newEnv = new TypeSubstitution();
-                        PassVisitor<EnvTrimmer> trimmer( env, newEnv );
+                        EnvTrimmer trimmer( env, newEnv );
                         expr->accept( trimmer );
                         return newEnv;
@@ -272 +277 @@
                 std::string oldParamPrefix = paramPrefix;
                 paramPrefix += "p";
-                // save stmtsToAddBefore in oldStmts
+                // save stmtsToAdd in oldStmts
                 std::list< Statement* > oldStmts;
-                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
-                appExpr->acceptMutator( *visitor );
+                oldStmts.splice( oldStmts.end(), stmtsToAdd );
+                mutate( appExpr );
                 paramPrefix = oldParamPrefix;
                 // write any statements added for recursive specializations into the thunk body
-                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
-                // restore oldStmts into stmtsToAddBefore
-                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
+                thunkFunc->get_statements()->get_kids().splice( thunkFunc->get_statements()->get_kids().end(), stmtsToAdd );
+                // restore oldStmts into stmtsToAdd
+                stmtsToAdd.splice( stmtsToAdd.end(), oldStmts );
 
                 // add return (or valueless expression) to the thunk
                 Statement *appStmt;
-                if ( funType->returnVals.empty() ) {
+                if ( funType->get_returnVals().empty() ) {
                         appStmt = new ExprStmt( noLabels, appExpr );
                 } else {
                         appStmt = new ReturnStmt( noLabels, appExpr );
                 } // if
-                thunkFunc->statements->kids.push_back( appStmt );
+                thunkFunc->get_statements()->get_kids().push_back( appStmt );
 
                 // add thunk definition to queue of statements to add
-                stmtsToAddBefore.push_back( new DeclStmt( noLabels, thunkFunc ) );
+                stmtsToAdd.push_back( new DeclStmt( noLabels, thunkFunc ) );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );
@@ -299 +304 @@
         void Specialize::handleExplicitParams( ApplicationExpr *appExpr ) {
                 // create thunks for the explicit parameters
-                assert( appExpr->function->result );
-                FunctionType *function = getFunctionType( appExpr->function->result );
+                assert( appExpr->get_function()->has_result() );
+                FunctionType *function = getFunctionType( appExpr->get_function()->get_result() );
                 assert( function );
                 std::list< DeclarationWithType* >::iterator formal;
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
-                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
-                }
-        }
-
-        Expression * Specialize::postmutate( ApplicationExpr *appExpr ) {
+                        *actual = doSpecialization( (*formal )->get_type(), *actual, &appExpr->get_inferParams() );
+                }
+        }
+
+        Expression * Specialize::mutate( ApplicationExpr *appExpr ) {
+                appExpr->get_function()->acceptMutator( *this );
+                mutateAll( appExpr->get_args(), *this );
+
                 if ( ! InitTweak::isIntrinsicCallExpr( appExpr ) ) {
                         // create thunks for the inferred parameters
@@ -323 +331 @@
         }
 
-        Expression * Specialize::postmutate( AddressExpr *addrExpr ) {
-                assert( addrExpr->result );
-                addrExpr->set_arg( doSpecialization( addrExpr->result, addrExpr->arg ) );
+        Expression * Specialize::mutate( AddressExpr *addrExpr ) {
+                addrExpr->get_arg()->acceptMutator( *this );
+                assert( addrExpr->has_result() );
+                addrExpr->set_arg( doSpecialization( addrExpr->get_result(), addrExpr->get_arg() ) );
                 return addrExpr;
         }
 
-        Expression * Specialize::postmutate( CastExpr *castExpr ) {
-                if ( castExpr->result->isVoid() ) {
+        Expression * Specialize::mutate( CastExpr *castExpr ) {
+                castExpr->get_arg()->acceptMutator( *this );
+                if ( castExpr->get_result()->isVoid() ) {
                         // can't specialize if we don't have a return value
                         return castExpr;
                 }
-                Expression *specialized = doSpecialization( castExpr->result, castExpr->arg );
-                if ( specialized != castExpr->arg ) {
+                Expression *specialized = doSpecialization( castExpr->get_result(), castExpr->get_arg() );
+                if ( specialized != castExpr->get_arg() ) {
                         // assume here that the specialization incorporates the cast
                         return specialized;
@@ -343 +353 @@
         }
 
+        // Removing these for now. Richard put these in for some reason, but it's not clear why.
+        // In particular, copy constructors produce a comma expression, and with this code the parts
+        // of that comma expression are not specialized, which causes problems.
+
+        // Expression * Specialize::mutate( LogicalExpr *logicalExpr ) {
+        //      return logicalExpr;
+        // }
+
+        // Expression * Specialize::mutate( ConditionalExpr *condExpr ) {
+        //      return condExpr;
+        // }
+
+        // Expression * Specialize::mutate( CommaExpr *commaExpr ) {
+        //      return commaExpr;
+        // }
+
         void convertSpecializations( std::list< Declaration* >& translationUnit ) {
-                PassVisitor<Specialize> spec;
+                Specialize spec;
                 mutateAll( translationUnit, spec );
         }

src/GenPoly/module.mk

@@ -6 +6 @@
 ## file "LICENCE" distributed with Cforall.
 ##
-## module.mk --
+## module.mk -- 
 ##
 ## Author           : Richard C. Bilson
@@ -17 +17 @@
 SRC += GenPoly/Box.cc \
        GenPoly/GenPoly.cc \
+       GenPoly/PolyMutator.cc \
        GenPoly/ScrubTyVars.cc \
        GenPoly/Lvalue.cc \
@@ -22 +23 @@
        GenPoly/CopyParams.cc \
        GenPoly/FindFunction.cc \
+       GenPoly/DeclMutator.cc \
        GenPoly/InstantiateGeneric.cc

src/InitTweak/FixInit.cc

@@ -36 +36 @@
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
+#include "GenPoly/DeclMutator.h"       // for DeclMutator
 #include "GenPoly/GenPoly.h"           // for getFunctionType
+#include "GenPoly/PolyMutator.h"       // for PolyMutator
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
@@ -44 +46 @@
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
+#include "SynTree/AddStmtVisitor.h"    // for AddStmtVisitor
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
@@ -55 +58 @@
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
+#include "Tuples/Tuples.h"             // for isTtype
 
 bool ctordtorp = false; // print all debug
@@ -183 +187 @@
                 };
 
-                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
+                class FixCopyCtors final : public GenPoly::PolyMutator {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -190 +194 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
 
-                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void premutate( StmtExpr * stmtExpr );
-                        void premutate( UniqueExpr * unqExpr );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
 
                         UnqCount & unqCount;
@@ -237 +243 @@
                 };
 
-                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
+                class FixCtorExprs final : public GenPoly::DeclMutator {
+                  public:
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
 
-                        Expression * postmutate( ConstructorExpr * ctorExpr );
+                        using GenPoly::DeclMutator::mutate;
+                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
                 };
         } // namespace
@@ -308 +316 @@
 
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
-                        PassVisitor<FixCopyCtors> fixer( unqCount );
+                        FixCopyCtors fixer( unqCount );
                         mutateAll( translationUnit, fixer );
                 }
@@ -318 +326 @@
 
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<FixCtorExprs> fixer;
-                        mutateAll( translationUnit, fixer );
+                        FixCtorExprs fixer;
+                        fixer.mutateDeclarationList( translationUnit );
                 }
 
@@ -331 +339 @@
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
-                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
+                                        assert( ftype );
                                         if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
@@ -360 +368 @@
                 }
 
-                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
 
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
@@ -397 +407 @@
                         result = result->clone();
                         env->apply( result );
-                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_const( false );
 
@@ -411 +421 @@
                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
                         }
-
-                        // set a unique name for the temporary once it's certain the call is necessary
-                        tmp->name = tempNamer.newName();
 
                         // replace argument to function call with temporary
@@ -443 +450 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
-                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
                                 }
@@ -465 +472 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
@@ -502 +509 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
                         }
@@ -508 +515 @@
                 }
 
-                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
+                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -517 +525 @@
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 
@@ -528 +536 @@
                         } // for
 
+                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
@@ -560 +569 @@
                 }
 
-                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
+                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
-                        //   g(f());
+                        //   f(g());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
-                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
-                        // to the outer context, rather than inside of the statement expression.
-                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
-                                stmt = stmt->acceptMutator( *visitor );
+                                stmt = stmt->acceptMutator( *this );
                         } // for
+                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
@@ -585 +592 @@
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                assert( ! stmts.empty() );
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
-                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
@@ -593 +601 @@
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
-                }
-
-                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
-                        visit_children = false;
+                        return stmtExpr;
+                }
+
+                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
+                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
@@ -610 +619 @@
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                                 }
-                                return;
-                        }
-                        PassVisitor<FixCopyCtors> fixer( unqCount );
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        FixCopyCtors fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
-                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
+                        stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
-                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
-                        }
-                        return;
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
                 }
 
@@ -796 +819 @@
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
-                                        // don't need to call intrinsic dtor, because it does nothing, but
-                                        // non-intrinsic dtors must be called
                                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
-                                                // set dtor location to the object's location for error messages
-                                                ctorInit->dtor->location = objDecl->location;
+                                                // don't need to call intrinsic dtor, because it does nothing, but
+                                                // non-intrinsic dtors must be called
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
@@ -991 +1012 @@
                                         // skip non-DWT members
                                         if ( ! field ) continue;
-                                        // skip non-constructable members
-                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
@@ -1123 +1142 @@
                 }
 
-                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
+                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
@@ -1129 +1148 @@
 
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
-                        declsToAddBefore.push_back( tmp );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        addDeclaration( tmp );
 
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
@@ -1139 +1158 @@
                         delete ctorExpr;
 
-                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
-                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
+
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
                         firstArg = new VariableExpr( tmp );
-
-                        // resolve assignment and dispose of new env
-                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
-                        delete resolvedAssign->env;
-                        resolvedAssign->env = nullptr;
-                        delete assign;
 
                         // for constructor expr:
@@ -1157 +1188 @@
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
-                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;

src/InitTweak/GenInit.cc

@@ -26 +26 @@
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
+#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
@@ -61 +62 @@
         };
 
-        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
+        struct CtorDtor : public WithGuards, public WithShortCircuiting  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -74 +75 @@
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
-                void previsit( AggregateDecl * ) { visit_children = false; }
-                void previsit( NamedTypeDecl * ) { visit_children = false; }
-                void previsit( FunctionType * ) { visit_children = false; }
+                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
+                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
+                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
 
                 void previsit( CompoundStmt * compoundStmt );
@@ -92 +96 @@
         };
 
-        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
+        class HoistArrayDimension final : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
@@ -98 +105 @@
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
 
-                void premutate( ObjectDecl * objectDecl );
-                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
-                void premutate( FunctionDecl *functionDecl );
+          private:
+                using Parent::mutate;
+
+                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                void premutate( AggregateDecl * ) { visit_children = false; }
-                void premutate( NamedTypeDecl * ) { visit_children = false; }
-                void premutate( FunctionType * ) { visit_children = false; }
+                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
+                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
+                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
+
+                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
 
                 void hoist( Type * type );
@@ -114 +128 @@
 
         void genInit( std::list< Declaration * > & translationUnit ) {
-                fixReturnStatements( translationUnit );
+                ReturnFixer::makeReturnTemp( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
         }
 
-        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
+        void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
@@ -129 +143 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
                         assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
@@ -144 +158 @@
                 GuardValue( funcName );
 
-                ftype = functionDecl->type;
-                funcName = functionDecl->name;
+                ftype = functionDecl->get_functionType();
+                funcName = functionDecl->get_name();
         }
 
@@ -151 +165 @@
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<HoistArrayDimension> hoister;
-                mutateAll( translationUnit, hoister );
-        }
-
-        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
-                GuardValue( storageClasses );
+                HoistArrayDimension hoister;
+                hoister.mutateDeclarationList( translationUnit );
+        }
+
+        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
-        }
-
-        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
+                DeclarationWithType * temp = Parent::mutate( objectDecl );
                 hoist( objectDecl->get_type() );
-                return objectDecl;
+                return temp;
         }
 
@@ -183 +194 @@
 
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        declsToAddBefore.push_back( arrayDimension );
+                        addDeclaration( arrayDimension );
 
                         hoist( arrayType->get_base() );
@@ -190 +201 @@
         }
 
-        void HoistArrayDimension::premutate( FunctionDecl * ) {
-                GuardValue( inFunction );
+        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
+                ValueGuard< bool > oldInFunc( inFunction );
+                inFunction = true;
+                DeclarationWithType * decl = Parent::mutate( functionDecl );
+                return decl;
         }
 
@@ -200 +214 @@
 
         bool CtorDtor::isManaged( Type * type ) const {
-                // references are never constructed
+                // at least for now, references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
@@ -207 +221 @@
                 if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
                         // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
+                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
                         }
@@ -291 +305 @@
 
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
@@ -305 +318 @@
                 }
 
-                maybeAccept( functionDecl->get_statements(), *visitor );
+                PassVisitor<CtorDtor> newCtorDtor;
+                newCtorDtor.pass = *this;
+                maybeAccept( functionDecl->get_statements(), newCtorDtor );
+                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
         }
 
@@ -324 +340 @@
         }
 
-        void CtorDtor::previsit( CompoundStmt * ) {
+        void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
                 GuardScope( managedTypes );
         }

src/InitTweak/GenInit.h

@@ -25 +25 @@
         void genInit( std::list< Declaration * > & translationUnit );
 
-        /// Converts return statements into copy constructor calls on the hidden return variable
-        void fixReturnStatements( std::list< Declaration * > & translationUnit );
-
-        /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
-        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
 
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer

src/InitTweak/InitTweak.cc

@@ +1 @@
+#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
@@ -22 +23 @@
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
-#include "Tuples/Tuples.h"         // for Tuples::isTtype
 
 class UntypedValofExpr;
@@ -184 +184 @@
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
 
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
@@ -250 +250 @@
         // To accomplish this, generate switch statement, consuming all of expander's elements
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
-                if ( ! init ) return nullptr;
+                if ( ! init ) return NULL;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
                         delete block;
-                        return nullptr;
+                        return NULL;
                 } else {
-                        init = nullptr; // init was consumed in creating the list init
+                        init = NULL; // init was consumed in creating the list init
                         return block;
                 }
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
-                return nullptr;
+        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
+                return NULL;
         }
 
@@ -270 +270 @@
         }
 
-        bool tryConstruct( DeclarationWithType * dwt ) {
-                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
-                if ( ! objDecl ) return false;
+        bool tryConstruct( ObjectDecl * objDecl ) {
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
-                        (objDecl->get_init() == nullptr ||
-                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
-                        && ! objDecl->get_storageClasses().is_extern
-                        && isConstructable( objDecl->type );
-        }
-
-        bool isConstructable( Type * type ) {
-                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
+                        (objDecl->get_init() == NULL ||
+                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern;
         }
 
@@ -321 +314 @@
                 collectCtorDtorCalls( stmt, matches );
                 assert( matches.size() <= 1 );
-                return matches.size() == 1 ? matches.front() : nullptr;
+                return matches.size() == 1 ? matches.front() : NULL;
         }
 
@@ -366 +359 @@
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
                 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
-                if ( ! appExpr ) return nullptr;
+                if ( ! appExpr ) return NULL;
                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
                 assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
                 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
                 // will call all member dtors, and some members may have a user defined dtor.
-                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
+                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
         }
 
@@ -489 +482 @@
                         return refType->get_base();
                 } else {
-                        return nullptr;
+                        return NULL;
                 }
         }
@@ -495 +488 @@
         Type * isPointerType( Type * type ) {
                 if ( getPointerBase( type ) ) return type;
-                else return nullptr;
+                else return NULL;
         }
 

src/InitTweak/InitTweak.h

@@ -33 +33 @@
         std::list< Expression * > makeInitList( Initializer * init );
 
-        /// True if the resolver should try to construct dwt
-        bool tryConstruct( DeclarationWithType * dwt );
-
-        /// True if the type can have a user-defined constructor
-        bool isConstructable( Type * t );
+        /// True if the resolver should try to construct objDecl
+        bool tryConstruct( ObjectDecl * objDecl );
 
         /// True if the Initializer contains designations

src/Makefile.in

@@ -172 +172 @@
         GenPoly/driver_cfa_cpp-Box.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT) \
+        GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-Lvalue.$(OBJEXT) \
@@ -177 +178 @@
         GenPoly/driver_cfa_cpp-CopyParams.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT) \
+        GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT) \
         GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT) \
         InitTweak/driver_cfa_cpp-GenInit.$(OBJEXT) \
@@ -251 +253 @@
         SynTree/driver_cfa_cpp-Visitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Mutator.$(OBJEXT) \
+        SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT) \
         SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT) \
         SynTree/driver_cfa_cpp-Attribute.$(OBJEXT) \
@@ -494 +497 @@
         ControlStruct/ForExprMutator.cc \
         ControlStruct/ExceptTranslate.cc GenPoly/Box.cc \
-        GenPoly/GenPoly.cc GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc \
-        GenPoly/Specialize.cc GenPoly/CopyParams.cc \
-        GenPoly/FindFunction.cc GenPoly/InstantiateGeneric.cc \
+        GenPoly/GenPoly.cc GenPoly/PolyMutator.cc \
+        GenPoly/ScrubTyVars.cc GenPoly/Lvalue.cc GenPoly/Specialize.cc \
+        GenPoly/CopyParams.cc GenPoly/FindFunction.cc \
+        GenPoly/DeclMutator.cc GenPoly/InstantiateGeneric.cc \
         InitTweak/GenInit.cc InitTweak/FixInit.cc \
         InitTweak/FixGlobalInit.cc InitTweak/InitTweak.cc \
@@ -531 +535 @@
         SynTree/NamedTypeDecl.cc SynTree/TypeDecl.cc \
         SynTree/Initializer.cc SynTree/Visitor.cc SynTree/Mutator.cc \
-        SynTree/TypeSubstitution.cc SynTree/Attribute.cc \
-        SynTree/VarExprReplacer.cc Tuples/TupleAssignment.cc \
-        Tuples/TupleExpansion.cc Tuples/Explode.cc \
-        Virtual/ExpandCasts.cc
+        SynTree/AddStmtVisitor.cc SynTree/TypeSubstitution.cc \
+        SynTree/Attribute.cc SynTree/VarExprReplacer.cc \
+        Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc \
+        Tuples/Explode.cc Virtual/ExpandCasts.cc
 MAINTAINERCLEANFILES = Parser/parser.output ${libdir}/${notdir \
         ${cfa_cpplib_PROGRAMS}}
@@ -713 +717 @@
 GenPoly/driver_cfa_cpp-GenPoly.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
+GenPoly/driver_cfa_cpp-PolyMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
+        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-ScrubTyVars.$(OBJEXT): GenPoly/$(am__dirstamp) \
         GenPoly/$(DEPDIR)/$(am__dirstamp)
@@ -723 +729 @@
 GenPoly/driver_cfa_cpp-FindFunction.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
+GenPoly/driver_cfa_cpp-DeclMutator.$(OBJEXT): GenPoly/$(am__dirstamp) \
+        GenPoly/$(DEPDIR)/$(am__dirstamp)
 GenPoly/driver_cfa_cpp-InstantiateGeneric.$(OBJEXT):  \
         GenPoly/$(am__dirstamp) GenPoly/$(DEPDIR)/$(am__dirstamp)
@@ -921 +929 @@
 SynTree/driver_cfa_cpp-Mutator.$(OBJEXT): SynTree/$(am__dirstamp) \
         SynTree/$(DEPDIR)/$(am__dirstamp)
+SynTree/driver_cfa_cpp-AddStmtVisitor.$(OBJEXT):  \
+        SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
 SynTree/driver_cfa_cpp-TypeSubstitution.$(OBJEXT):  \
         SynTree/$(am__dirstamp) SynTree/$(DEPDIR)/$(am__dirstamp)
@@ -998 +1008 @@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Box.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-CopyParams.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-FindFunction.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-GenPoly.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Lvalue.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@GenPoly/$(DEPDIR)/driver_cfa_cpp-Specialize.Po@am__quote@
@@ -1044 +1056 @@
 @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-AddStmtVisitor.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AddressExpr.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@SynTree/$(DEPDIR)/driver_cfa_cpp-AggregateDecl.Po@am__quote@
@@ -1437 +1450 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-GenPoly.obj `if test -f 'GenPoly/GenPoly.cc'; then $(CYGPATH_W) 'GenPoly/GenPoly.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/GenPoly.cc'; fi`
 
+GenPoly/driver_cfa_cpp-PolyMutator.o: GenPoly/PolyMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.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 GenPoly/driver_cfa_cpp-PolyMutator.o `test -f 'GenPoly/PolyMutator.cc' || echo '$(srcdir)/'`GenPoly/PolyMutator.cc
+
+GenPoly/driver_cfa_cpp-PolyMutator.obj: GenPoly/PolyMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-PolyMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo -c -o GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-PolyMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/PolyMutator.cc' object='GenPoly/driver_cfa_cpp-PolyMutator.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 GenPoly/driver_cfa_cpp-PolyMutator.obj `if test -f 'GenPoly/PolyMutator.cc'; then $(CYGPATH_W) 'GenPoly/PolyMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/PolyMutator.cc'; fi`
+
 GenPoly/driver_cfa_cpp-ScrubTyVars.o: GenPoly/ScrubTyVars.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-ScrubTyVars.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-ScrubTyVars.Tpo -c -o GenPoly/driver_cfa_cpp-ScrubTyVars.o `test -f 'GenPoly/ScrubTyVars.cc' || echo '$(srcdir)/'`GenPoly/ScrubTyVars.cc
@@ -1507 +1534 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o GenPoly/driver_cfa_cpp-FindFunction.obj `if test -f 'GenPoly/FindFunction.cc'; then $(CYGPATH_W) 'GenPoly/FindFunction.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/FindFunction.cc'; fi`
 
+GenPoly/driver_cfa_cpp-DeclMutator.o: GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.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 GenPoly/driver_cfa_cpp-DeclMutator.o `test -f 'GenPoly/DeclMutator.cc' || echo '$(srcdir)/'`GenPoly/DeclMutator.cc
+
+GenPoly/driver_cfa_cpp-DeclMutator.obj: GenPoly/DeclMutator.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-DeclMutator.obj -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo -c -o GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Tpo GenPoly/$(DEPDIR)/driver_cfa_cpp-DeclMutator.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='GenPoly/DeclMutator.cc' object='GenPoly/driver_cfa_cpp-DeclMutator.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 GenPoly/driver_cfa_cpp-DeclMutator.obj `if test -f 'GenPoly/DeclMutator.cc'; then $(CYGPATH_W) 'GenPoly/DeclMutator.cc'; else $(CYGPATH_W) '$(srcdir)/GenPoly/DeclMutator.cc'; fi`
+
 GenPoly/driver_cfa_cpp-InstantiateGeneric.o: GenPoly/InstantiateGeneric.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT GenPoly/driver_cfa_cpp-InstantiateGeneric.o -MD -MP -MF GenPoly/$(DEPDIR)/driver_cfa_cpp-InstantiateGeneric.Tpo -c -o GenPoly/driver_cfa_cpp-InstantiateGeneric.o `test -f 'GenPoly/InstantiateGeneric.cc' || echo '$(srcdir)/'`GenPoly/InstantiateGeneric.cc
@@ -2542 +2583 @@
 @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 SynTree/driver_cfa_cpp-Mutator.obj `if test -f 'SynTree/Mutator.cc'; then $(CYGPATH_W) 'SynTree/Mutator.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/Mutator.cc'; fi`
+
+SynTree/driver_cfa_cpp-AddStmtVisitor.o: SynTree/AddStmtVisitor.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.o -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.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 SynTree/driver_cfa_cpp-AddStmtVisitor.o `test -f 'SynTree/AddStmtVisitor.cc' || echo '$(srcdir)/'`SynTree/AddStmtVisitor.cc
+
+SynTree/driver_cfa_cpp-AddStmtVisitor.obj: SynTree/AddStmtVisitor.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SynTree/driver_cfa_cpp-AddStmtVisitor.obj -MD -MP -MF SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo -c -o SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Tpo SynTree/$(DEPDIR)/driver_cfa_cpp-AddStmtVisitor.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='SynTree/AddStmtVisitor.cc' object='SynTree/driver_cfa_cpp-AddStmtVisitor.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 SynTree/driver_cfa_cpp-AddStmtVisitor.obj `if test -f 'SynTree/AddStmtVisitor.cc'; then $(CYGPATH_W) 'SynTree/AddStmtVisitor.cc'; else $(CYGPATH_W) '$(srcdir)/SynTree/AddStmtVisitor.cc'; fi`
 
 SynTree/driver_cfa_cpp-TypeSubstitution.o: SynTree/TypeSubstitution.cc

src/ResolvExpr/Resolver.cc

@@ -95 +95 @@
                 PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
-        }
-
-        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
-                PassVisitor<Resolver> resolver( indexer );
-                maybeAccept( decl, resolver );
         }
 

src/ResolvExpr/Resolver.h

@@ -29 +29 @@
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< Declaration * > translationUnit );
-        void resolveDecl( Declaration *, const SymTab::Indexer &indexer );
-        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer );
-        Expression *findVoidExpression( Expression *untyped, const SymTab::Indexer &indexer );
+        Expression * resolveInVoidContext( Expression *expr   , const SymTab::Indexer &indexer );
+        Expression * findVoidExpression  ( Expression *untyped, const SymTab::Indexer &indexer );
         Expression * findSingleExpression( Expression *untyped, const SymTab::Indexer &indexer );
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );

src/ResolvExpr/TypeEnvironment.cc

@@ -123 +123 @@
                 for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
                         for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
-///       std::cerr << "adding " << *theVar;
+///       std::cout << "adding " << *theVar;
                                 if ( theClass->type ) {
-///         std::cerr << " bound to ";
-///         theClass->type->print( std::cerr );
-///         std::cerr << std::endl;
+///         std::cout << " bound to ";
+///         theClass->type->print( std::cout );
+///         std::cout << std::endl;
                                         sub.add( *theVar, theClass->type );
                                 } else if ( theVar != theClass->vars.begin() ) {
                                         TypeInstType *newTypeInst = new TypeInstType( Type::Qualifiers(), *theClass->vars.begin(), theClass->data.kind == TypeDecl::Ftype );
-///         std::cerr << " bound to variable " << *theClass->vars.begin() << std::endl;
+///         std::cout << " bound to variable " << *theClass->vars.begin() << std::endl;
                                         sub.add( *theVar, newTypeInst );
                                         delete newTypeInst;

src/SymTab/Autogen.cc

@@ -16 +16 @@
 #include "Autogen.h"
 
+#include <cstddef>                 // for NULL
 #include <algorithm>               // for count_if
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
@@ -26 +27 @@
 #include "AddVisit.h"              // for addVisit
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
-#include "Common/PassVisitor.h"    // for PassVisitor
 #include "Common/ScopedMap.h"      // for ScopedMap<>::const_iterator, Scope...
 #include "Common/utility.h"        // for cloneAll, operator+
+#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::iterator
-#include "InitTweak/GenInit.h"     // for fixReturnStatements
-#include "ResolvExpr/Resolver.h"   // for resolveDecl
 #include "SymTab/Mangler.h"        // for Mangler
 #include "SynTree/Attribute.h"     // For Attribute
@@ -54 +53 @@
         };
 
-        struct AutogenerateRoutines final : public WithDeclsToAdd, public WithVisitorRef<AutogenerateRoutines>, public WithGuards, public WithShortCircuiting {
+        class AutogenerateRoutines 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:
+                std::list< Declaration * > &get_declsToAdd() { return declsToAdd; }
+
+                typedef Visitor Parent;
+                using Parent::visit;
+
                 AutogenerateRoutines();
 
-                void previsit( EnumDecl * enumDecl );
-                void previsit( StructDecl * structDecl );
-                void previsit( UnionDecl * structDecl );
-                void previsit( TypeDecl * typeDecl );
-                void previsit( TraitDecl * traitDecl );
-                void previsit( FunctionDecl * functionDecl );
-
-                void previsit( FunctionType * ftype );
-                void previsit( PointerType * ptype );
-
-                void previsit( CompoundStmt * compoundStmt );
+                virtual void visit( EnumDecl *enumDecl );
+                virtual void visit( StructDecl *structDecl );
+                virtual void visit( UnionDecl *structDecl );
+                virtual void visit( TypeDecl *typeDecl );
+                virtual void visit( TraitDecl *ctxDecl );
+                virtual void visit( FunctionDecl *functionDecl );
+
+                virtual void visit( FunctionType *ftype );
+                virtual void visit( PointerType *ftype );
+
+                virtual void visit( CompoundStmt *compoundStmt );
+                virtual void visit( SwitchStmt *switchStmt );
 
           private:
-                GenPoly::ScopedSet< std::string > structsDone;
+                template< typename StmtClass > void visitStatement( StmtClass *stmt );
+
+                std::list< Declaration * > declsToAdd, declsToAddAfter;
+                std::set< std::string > structsDone;
                 unsigned int functionNesting = 0;     // current level of nested functions
                 /// Note: the following maps could be ScopedSets, but it should be easier to work
@@ -80 +93 @@
 
         /// generates routines for tuple types.
-        struct AutogenTupleRoutines : public WithDeclsToAdd, public WithVisitorRef<AutogenTupleRoutines>, public WithGuards, public WithShortCircuiting {
-                void previsit( FunctionDecl *functionDecl );
-
-                void postvisit( TupleType *tupleType );
-
-                void previsit( CompoundStmt *compoundStmt );
+        /// Doesn't really need to be a mutator, but it's easier to reuse DeclMutator than it is to use AddVisit
+        /// or anything we currently have that supports adding new declarations for visitors
+        class AutogenTupleRoutines : public GenPoly::DeclMutator {
+          public:
+                typedef GenPoly::DeclMutator Parent;
+                using Parent::mutate;
+
+                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
+
+                virtual Type * mutate( TupleType *tupleType );
+
+                virtual CompoundStmt * mutate( CompoundStmt *compoundStmt );
 
           private:
@@ -93 +112 @@
 
         void autogenerateRoutines( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<AutogenerateRoutines> generator;
-                acceptAll( translationUnit, generator );
+                AutogenerateRoutines generator;
+                acceptAndAdd( translationUnit, generator );
 
                 // needs to be done separately because AutogenerateRoutines skips types that appear as function arguments, etc.
                 // AutogenTupleRoutines tupleGenerator;
-                // acceptAll( translationUnit, tupleGenerator );
+                // tupleGenerator.mutateDeclarationList( translationUnit );
         }
 
         bool isUnnamedBitfield( ObjectDecl * obj ) {
-                return obj != nullptr && obj->get_name() == "" && obj->get_bitfieldWidth() != nullptr;
+                return obj != NULL && obj->get_name() == "" && obj->get_bitfieldWidth() != NULL;
         }
 
@@ -109 +128 @@
                 FunctionDecl * decl = functionDecl->clone();
                 delete decl->get_statements();
-                decl->set_statements( nullptr );
+                decl->set_statements( NULL );
                 declsToAdd.push_back( decl );
                 decl->fixUniqueId();
@@ -320 +339 @@
                                 assert( ! func->get_functionType()->get_parameters().empty() );
                                 ObjectDecl * dstParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().front() );
-                                ObjectDecl * srcParam = nullptr;
+                                ObjectDecl * srcParam = NULL;
                                 if ( func->get_functionType()->get_parameters().size() == 2 ) {
                                         srcParam = dynamic_cast<ObjectDecl*>( func->get_functionType()->get_parameters().back() );
@@ -327 +346 @@
                                 assert( dstParam );
 
-                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : nullptr;
+                                Expression *srcselect = srcParam ? new MemberExpr( field, new VariableExpr( srcParam ) ) : NULL;
                                 makeStructMemberOp( dstParam, srcselect, field, func, forward );
                         } // if
@@ -366 +385 @@
                                 } else {
                                         // no matching parameter, initialize field with default ctor
-                                        makeStructMemberOp( dstParam, nullptr, field, func );
+                                        makeStructMemberOp( dstParam, NULL, field, func );
                                 }
                         }
@@ -382 +401 @@
         void makeStructFunctions( StructDecl *aggregateDecl, StructInstType *refType, unsigned int functionNesting, std::list< Declaration * > & declsToAdd, const std::vector< FuncData > & data ) {
                 // Builtins do not use autogeneration.
-                if ( LinkageSpec::isBuiltin( aggregateDecl->get_linkage() ) ) {
+                if ( aggregateDecl->get_linkage() == LinkageSpec::BuiltinCFA ||
+                         aggregateDecl->get_linkage() == LinkageSpec::BuiltinC ) {
                         return;
                 }
 
                 // Make function polymorphic in same parameters as generic struct, if applicable
-                const std::list< TypeDecl * > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
+                const std::list< TypeDecl* > & typeParams = aggregateDecl->get_parameters(); // List of type variables to be placed on the generated functions
 
                 // generate each of the functions based on the supplied FuncData objects
@@ -552 +572 @@
                 // the order here determines the order that these functions are generated.
                 // assignment should come last since it uses copy constructor in return.
-                data.emplace_back( "?{}", genDefaultType, constructable );
-                data.emplace_back( "?{}", genCopyType, copyable );
-                data.emplace_back( "^?{}", genDefaultType, destructable );
-                data.emplace_back( "?=?", genAssignType, assignable );
-        }
-
-        void AutogenerateRoutines::previsit( EnumDecl * enumDecl ) {
-                visit_children = false;
+                data.push_back( FuncData( "?{}", genDefaultType, constructable ) );
+                data.push_back( FuncData( "?{}", genCopyType, copyable ) );
+                data.push_back( FuncData( "^?{}", genDefaultType, destructable ) );
+                data.push_back( FuncData( "?=?", genAssignType, assignable ) );
+        }
+
+        void AutogenerateRoutines::visit( EnumDecl *enumDecl ) {
                 if ( ! enumDecl->get_members().empty() ) {
                         EnumInstType *enumInst = new EnumInstType( Type::Qualifiers(), enumDecl->get_name() );
@@ -567 +586 @@
         }
 
-        void AutogenerateRoutines::previsit( StructDecl * structDecl ) {
-                visit_children = false;
-                if ( structDecl->has_body() && structsDone.find( structDecl->name ) == structsDone.end() ) {
-                        StructInstType structInst( Type::Qualifiers(), structDecl->name );
-                        for ( TypeDecl * typeDecl : structDecl->parameters ) {
+        void AutogenerateRoutines::visit( StructDecl *structDecl ) {
+                if ( structDecl->has_body() && structsDone.find( structDecl->get_name() ) == structsDone.end() ) {
+                        StructInstType structInst( Type::Qualifiers(), structDecl->get_name() );
+                        for ( TypeDecl * typeDecl : structDecl->get_parameters() ) {
                                 // need to visit assertions so that they are added to the appropriate maps
-                                acceptAll( typeDecl->assertions, *visitor );
-                                structInst.parameters.push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->name, typeDecl ) ) );
+                                acceptAll( typeDecl->get_assertions(), *this );
+                                structInst.get_parameters().push_back( new TypeExpr( new TypeInstType( Type::Qualifiers(), typeDecl->get_name(), typeDecl ) ) );
                         }
                         structInst.set_baseStruct( structDecl );
                         makeStructFunctions( structDecl, &structInst, functionNesting, declsToAddAfter, data );
-                        structsDone.insert( structDecl->name );
+                        structsDone.insert( structDecl->get_name() );
                 } // if
         }
 
-        void AutogenerateRoutines::previsit( UnionDecl * unionDecl ) {
-                visit_children = false;
+        void AutogenerateRoutines::visit( UnionDecl *unionDecl ) {
                 if ( ! unionDecl->get_members().empty() ) {
                         UnionInstType unionInst( Type::Qualifiers(), unionDecl->get_name() );
@@ -602 +619 @@
 
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
-        void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
-                visit_children = false;
+        void AutogenerateRoutines::visit( TypeDecl *typeDecl ) {
                 if ( ! typeDecl->base ) return;
 
@@ -648 +664 @@
         }
 
-        void AutogenerateRoutines::previsit( FunctionType *) {
+        void addDecls( std::list< Declaration * > &declsToAdd, std::list< Statement * > &statements, std::list< Statement * >::iterator i ) {
+                for ( std::list< Declaration * >::iterator decl = declsToAdd.begin(); decl != declsToAdd.end(); ++decl ) {
+                        statements.insert( i, new DeclStmt( noLabels, *decl ) );
+                } // for
+                declsToAdd.clear();
+        }
+
+        void AutogenerateRoutines::visit( FunctionType *) {
                 // ensure that we don't add assignment ops for types defined as part of the function
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( PointerType *) {
+        }
+
+        void AutogenerateRoutines::visit( PointerType *) {
                 // ensure that we don't add assignment ops for types defined as part of the pointer
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( TraitDecl * ) {
+        }
+
+        void AutogenerateRoutines::visit( TraitDecl *) {
                 // ensure that we don't add assignment ops for types defined as part of the trait
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
-                visit_children = false;
+        }
+
+        template< typename StmtClass >
+        inline void AutogenerateRoutines::visitStatement( StmtClass *stmt ) {
+                std::set< std::string > oldStructs = structsDone;
+                addVisit( stmt, *this );
+                structsDone = oldStructs;
+        }
+
+        void AutogenerateRoutines::visit( FunctionDecl *functionDecl ) {
                 // record the existence of this function as appropriate
                 insert( functionDecl, constructable, InitTweak::isDefaultConstructor );
@@ -671 +697 @@
                 insert( functionDecl, destructable, InitTweak::isDestructor );
 
-                maybeAccept( functionDecl->type, *visitor );
+                maybeAccept( functionDecl->get_functionType(), *this );
                 functionNesting += 1;
-                maybeAccept( functionDecl->statements, *visitor );
+                maybeAccept( functionDecl->get_statements(), *this );
                 functionNesting -= 1;
         }
 
-        void AutogenerateRoutines::previsit( CompoundStmt * ) {
-                GuardScope( constructable );
-                GuardScope( assignable );
-                GuardScope( copyable );
-                GuardScope( destructable );
-                GuardScope( structsDone );
+        void AutogenerateRoutines::visit( CompoundStmt *compoundStmt ) {
+                constructable.beginScope();
+                assignable.beginScope();
+                copyable.beginScope();
+                destructable.beginScope();
+                visitStatement( compoundStmt );
+                constructable.endScope();
+                assignable.endScope();
+                copyable.endScope();
+                destructable.endScope();
+        }
+
+        void AutogenerateRoutines::visit( SwitchStmt *switchStmt ) {
+                visitStatement( switchStmt );
         }
 
@@ -700 +734 @@
         }
 
-        void AutogenTupleRoutines::postvisit( TupleType * tupleType ) {
+        Type * AutogenTupleRoutines::mutate( TupleType * tupleType ) {
+                tupleType = strict_dynamic_cast< TupleType * >( Parent::mutate( tupleType ) );
                 std::string mangleName = SymTab::Mangler::mangleType( tupleType );
-                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return;
+                if ( seenTuples.find( mangleName ) != seenTuples.end() ) return tupleType;
                 seenTuples.insert( mangleName );
 
@@ -750 +785 @@
                 makeTupleFunctionBody( dtorDecl );
 
-                declsToAddBefore.push_back( ctorDecl );
-                declsToAddBefore.push_back( copyCtorDecl );
-                declsToAddBefore.push_back( dtorDecl );
-                declsToAddBefore.push_back( assignDecl ); // assignment should come last since it uses copy constructor in return
-        }
-
-        void AutogenTupleRoutines::previsit( FunctionDecl *functionDecl ) {
-                visit_children = false;
-                maybeAccept( functionDecl->type, *visitor );
+                addDeclaration( ctorDecl );
+                addDeclaration( copyCtorDecl );
+                addDeclaration( dtorDecl );
+                addDeclaration( assignDecl ); // assignment should come last since it uses copy constructor in return
+
+                return tupleType;
+        }
+
+        DeclarationWithType * AutogenTupleRoutines::mutate( FunctionDecl *functionDecl ) {
+                functionDecl->set_functionType( maybeMutate( functionDecl->get_functionType(), *this ) );
                 functionNesting += 1;
-                maybeAccept( functionDecl->statements, *visitor );
+                functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
                 functionNesting -= 1;
-        }
-
-        void AutogenTupleRoutines::previsit( CompoundStmt * ) {
-                GuardScope( seenTuples );
+                return functionDecl;
+        }
+
+        CompoundStmt * AutogenTupleRoutines::mutate( CompoundStmt *compoundStmt ) {
+                seenTuples.beginScope();
+                compoundStmt = strict_dynamic_cast< CompoundStmt * >( Parent::mutate( compoundStmt ) );
+                seenTuples.endScope();
+                return compoundStmt;
         }
 } // SymTab

src/SymTab/FixFunction.cc

@@ -27 +27 @@
 
         DeclarationWithType * FixFunction::mutate(FunctionDecl *functionDecl) {
-                // can't delete function type because it may contain assertions, so transfer ownership to new object
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->get_name(), functionDecl->get_storageClasses(), functionDecl->get_linkage(), 0, new PointerType( Type::Qualifiers(), functionDecl->get_type() ), 0, functionDecl->get_attributes() );
                 functionDecl->get_attributes().clear();
-                functionDecl->type = nullptr;
+                // can't delete function type because it may contain assertions, but can't transfer ownership without a clone since set_type checks for nullptr
+                functionDecl->set_type( functionDecl->get_type()->clone() );
                 delete functionDecl;
                 return pointer;

src/SymTab/Indexer.cc

@@ -40 +40 @@
 
 namespace SymTab {
+        struct NewScope {
+                NewScope( SymTab::Indexer & indexer ) : indexer( indexer ) { indexer.enterScope(); }
+                ~NewScope() { indexer.leaveScope(); }
+                SymTab::Indexer & indexer;
+        };
+
+        template< typename TreeType, typename VisitorType >
+        inline void acceptNewScope( TreeType *tree, VisitorType &visitor ) {
+                visitor.enterScope();
+                maybeAccept( tree, visitor );
+                visitor.leaveScope();
+        }
+
         typedef std::unordered_map< std::string, DeclarationWithType* > MangleTable;
         typedef std::unordered_map< std::string, MangleTable > IdTable;
@@ -185 +198 @@
         }
 
-        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
-
-        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
-
-        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
+        Indexer::Indexer( bool _doDebug ) : tables( 0 ), scope( 0 ), doDebug( _doDebug ) {}
+
+        Indexer::Indexer( const Indexer &that ) : tables( newRef( that.tables ) ), scope( that.scope ), doDebug( that.doDebug ) {}
+
+        Indexer::Indexer( Indexer &&that ) : tables( that.tables ), scope( that.scope ), doDebug( that.doDebug ) {
                 that.tables = 0;
         }

src/SymTab/Indexer.h

@@ -26 +26 @@
         class Indexer {
           public:
-                explicit Indexer();
+                explicit Indexer( bool useDebug = false );
 
                 Indexer( const Indexer &that );
@@ -76 +76 @@
                 void addTrait( TraitDecl *decl );
 
-                bool doDebug = false; ///< Display debugging trace?
           private:
                 struct Impl;
@@ -82 +81 @@
                 Impl *tables;         ///< Copy-on-write instance of table data structure
                 unsigned long scope;  ///< Scope index of this pointer
+                bool doDebug;         ///< Display debugging trace?
 
                 /// Takes a new ref to a table (returns null if null)

src/SymTab/Mangler.cc

@@ -31 +31 @@
 
 namespace SymTab {
-        std::string Mangler::mangleType( Type * ty ) {
+        std::string Mangler::mangleType( Type *ty ) {
                 Mangler mangler( false, true );
                 maybeAccept( ty, mangler );
@@ -48 +48 @@
         }
 
-        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
+        void Mangler::mangleDecl( DeclarationWithType *declaration ) {
                 bool wasTopLevel = isTopLevel;
                 if ( isTopLevel ) {
@@ -79 +79 @@
         }
 
-        void Mangler::visit( ObjectDecl * declaration ) {
+        void Mangler::visit( ObjectDecl *declaration ) {
                 mangleDecl( declaration );
         }
 
-        void Mangler::visit( FunctionDecl * declaration ) {
+        void Mangler::visit( FunctionDecl *declaration ) {
                 mangleDecl( declaration );
         }
 
-        void Mangler::visit( VoidType * voidType ) {
+        void Mangler::visit( VoidType *voidType ) {
                 printQualifiers( voidType );
                 mangleName << "v";
         }
 
-        void Mangler::visit( BasicType * basicType ) {
+        void Mangler::visit( BasicType *basicType ) {
                 static const char *btLetter[] = {
                         "b",    // Bool
@@ -121 +121 @@
         }
 
-        void Mangler::visit( PointerType * pointerType ) {
+        void Mangler::visit( PointerType *pointerType ) {
                 printQualifiers( pointerType );
                 mangleName << "P";
@@ -127 +127 @@
         }
 
-        void Mangler::visit( ArrayType * arrayType ) {
+        void Mangler::visit( ArrayType *arrayType ) {
                 // TODO: encode dimension
                 printQualifiers( arrayType );
@@ -134 +134 @@
         }
 
-        void Mangler::visit( ReferenceType * refType ) {
+        void Mangler::visit( ReferenceType *refType ) {
                 printQualifiers( refType );
                 mangleName << "R";
@@ -149 +149 @@
         }
 
-        void Mangler::visit( FunctionType * functionType ) {
+        void Mangler::visit( FunctionType *functionType ) {
                 printQualifiers( functionType );
                 mangleName << "F";
@@ -160 +160 @@
         }
 
-        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
+        void Mangler::mangleRef( ReferenceToType *refType, std::string prefix ) {
                 printQualifiers( refType );
 
@@ -166 +166 @@
         }
 
-        void Mangler::mangleGenericRef( ReferenceToType * refType, std::string prefix ) {
+        void Mangler::mangleGenericRef( ReferenceToType *refType, std::string prefix ) {
                 printQualifiers( refType );
 
@@ -189 +189 @@
         }
 
-        void Mangler::visit( StructInstType * aggregateUseType ) {
+        void Mangler::visit( StructInstType *aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "s" );
                 else mangleRef( aggregateUseType, "s" );
         }
 
-        void Mangler::visit( UnionInstType * aggregateUseType ) {
+        void Mangler::visit( UnionInstType *aggregateUseType ) {
                 if ( typeMode ) mangleGenericRef( aggregateUseType, "u" );
                 else mangleRef( aggregateUseType, "u" );
         }
 
-        void Mangler::visit( EnumInstType * aggregateUseType ) {
+        void Mangler::visit( EnumInstType *aggregateUseType ) {
                 mangleRef( aggregateUseType, "e" );
         }
 
-        void Mangler::visit( TypeInstType * typeInst ) {
+        void Mangler::visit( TypeInstType *typeInst ) {
                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                 if ( varNum == varNums.end() ) {
@@ -231 +231 @@
         }
 
-        void Mangler::visit( TupleType * tupleType ) {
+        void Mangler::visit( TupleType *tupleType ) {
                 printQualifiers( tupleType );
                 mangleName << "T";
-                acceptAll( tupleType->types, *this );
+                acceptAll( tupleType->get_types(), *this );
                 mangleName << "_";
         }
 
-        void Mangler::visit( VarArgsType * varArgsType ) {
+        void Mangler::visit( VarArgsType *varArgsType ) {
                 printQualifiers( varArgsType );
                 mangleName << "VARGS";
         }
 
-        void Mangler::visit( ZeroType * ) {
+        void Mangler::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 mangleName << "Z";
         }
 
-        void Mangler::visit( OneType * ) {
+        void Mangler::visit( __attribute__((unused)) OneType *oneType ) {
                 mangleName << "O";
         }
 
-        void Mangler::visit( TypeDecl * decl ) {
+        void Mangler::visit( TypeDecl *decl ) {
                 static const char *typePrefix[] = { "BT", "BD", "BF" };
-                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->get_name().length() + 1 ) << decl->get_name();
         }
 
@@ -262 +262 @@
         }
 
-        void Mangler::printQualifiers( Type * type ) {
+        void Mangler::printQualifiers( Type *type ) {
                 // skip if not including qualifiers
                 if ( typeMode ) return;
@@ -270 +270 @@
                         int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
                         mangleName << "A";
-                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
+                        for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
                                 switch ( (*i)->get_kind() ) {
                                   case TypeDecl::Any:
@@ -287 +287 @@
                                         assert( false );
                                 } // switch
-                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
-                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
+                                varNums[ (*i )->get_name() ] = std::pair< int, int >( nextVarNum++, (int )(*i )->get_kind() );
+                                for ( std::list< DeclarationWithType* >::iterator assert = (*i )->get_assertions().begin(); assert != (*i )->get_assertions().end(); ++assert ) {
                                         Mangler sub_mangler( mangleOverridable, typeMode );
                                         sub_mangler.nextVarNum = nextVarNum;
@@ -315 +315 @@
 //              } // if
                 if ( type->get_lvalue() ) {
-                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
                         mangleName << "L";
-                }
+                } // if
                 if ( type->get_atomic() ) {
                         mangleName << "A";

src/SymTab/Validate.cc

@@ -56 +56 @@
 #include "FixFunction.h"               // for FixFunction
 #include "Indexer.h"                   // for Indexer
-#include "InitTweak/GenInit.h"         // for fixReturnStatements
 #include "InitTweak/InitTweak.h"       // for isCtorDtorAssign
 #include "Parser/LinkageSpec.h"        // for C
@@ -151 +150 @@
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
         struct ForallPointerDecay final {
-                void previsit( ObjectDecl * object );
-                void previsit( FunctionDecl * func );
+                void previsit( ObjectDecl *object );
+                void previsit( FunctionDecl *func );
         };
 
@@ -580 +579 @@
 
         /// Fix up assertions - flattens assertion lists, removing all trait instances
-        void forallFixer( std::list< TypeDecl * > & forall, BaseSyntaxNode * node ) {
-                for ( TypeDecl * type : forall ) {
+        void forallFixer( Type * func ) {
+                for ( TypeDecl * type : func->get_forall() ) {
                         std::list< DeclarationWithType * > asserts;
                         asserts.splice( asserts.end(), type->assertions );
@@ -600 +599 @@
                                 assertion = assertion->acceptMutator( fixer );
                                 if ( fixer.get_isVoid() ) {
-                                        throw SemanticError( "invalid type void in assertion of function ", node );
+                                        throw SemanticError( "invalid type void in assertion of function ", func );
                                 } // if
                         } // for
@@ -608 +607 @@
 
         void ForallPointerDecay::previsit( ObjectDecl *object ) {
-                forallFixer( object->type->forall, object );
-                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->type ) ) {
-                        forallFixer( pointer->base->forall, object );
+                forallFixer( object->get_type() );
+                if ( PointerType *pointer = dynamic_cast< PointerType * >( object->get_type() ) ) {
+                        forallFixer( pointer->get_base() );
                 } // if
                 object->fixUniqueId();
@@ -616 +615 @@
 
         void ForallPointerDecay::previsit( FunctionDecl *func ) {
-                forallFixer( func->type->forall, func );
+                forallFixer( func->get_type() );
                 func->fixUniqueId();
         }

src/SynTree/Visitor.h

@@ -25 +25 @@
   public:
         // visit: Default implementation of all functions visits the children
-        // of the given syntax node, but performs no other action.
+    // of the given syntax node, but performs no other action.
 
         virtual void visit( ObjectDecl *objectDecl );

src/SynTree/module.mk

@@ -48 +48 @@
        SynTree/Visitor.cc \
        SynTree/Mutator.cc \
+       SynTree/AddStmtVisitor.cc \
        SynTree/TypeSubstitution.cc \
        SynTree/Attribute.cc \

src/Tuples/TupleExpansion.cc

@@ -21 +21 @@
 #include "Common/ScopedMap.h"     // for ScopedMap
 #include "Common/utility.h"       // for CodeLocation
+#include "GenPoly/DeclMutator.h"  // for DeclMutator
 #include "InitTweak/InitTweak.h"  // for getFunction
 #include "Parser/LinkageSpec.h"   // for Spec, C, Intrinsic

src/main.cc

@@ -239 +239 @@
                 } // if
 
+                // OPTPRINT( "Concurrency" )
+                // Concurrency::applyKeywords( translationUnit );
+
                 // add the assignment statement after the initialization of a type parameter
                 OPTPRINT( "validate" )

src/tests/.expect/64/sched-ext-parse.txt

@@ -1055 +1055 @@
 static inline struct condition ___operator_assign__F10scondition_R10scondition10scondition_autogen___1(struct condition *___dst__R10scondition_1, struct condition ___src__10scondition_1){
     struct condition ___ret__10scondition_1;
-    struct __condition_blocked_queue_t _tmp_cp4;
+    struct __condition_blocked_queue_t _tmp_cp56;
     struct __condition_blocked_queue_t _tmp_cp_ret29;
-    ((void)(((void)(_tmp_cp_ret29=___operator_assign__F28s__condition_blocked_queue_t_R28s__condition_blocked_queue_t28s__condition_blocked_queue_t_autogen___1((&(*___dst__R10scondition_1).__blocked__28s__condition_blocked_queue_t_1), (((void)___constructor__F_R28s__condition_blocked_queue_t28s__condition_blocked_queue_t_autogen___1((&_tmp_cp4), ___src__10scondition_1.__blocked__28s__condition_blocked_queue_t_1)) , _tmp_cp4)))) , _tmp_cp_ret29));
+    ((void)(((void)(_tmp_cp_ret29=___operator_assign__F28s__condition_blocked_queue_t_R28s__condition_blocked_queue_t28s__condition_blocked_queue_t_autogen___1((&(*___dst__R10scondition_1).__blocked__28s__condition_blocked_queue_t_1), (((void)___constructor__F_R28s__condition_blocked_queue_t28s__condition_blocked_queue_t_autogen___1((&_tmp_cp56), ___src__10scondition_1.__blocked__28s__condition_blocked_queue_t_1)) , _tmp_cp56)))) , _tmp_cp_ret29));
     ((void)___destructor__F_R28s__condition_blocked_queue_t_autogen___1((&_tmp_cp_ret29)));
-    ((void)___destructor__F_R28s__condition_blocked_queue_t_autogen___1((&_tmp_cp4)));
+    ((void)___destructor__F_R28s__condition_blocked_queue_t_autogen___1((&_tmp_cp56)));
     ((void)((*___dst__R10scondition_1).__monitors__PP13smonitor_desc_1=___src__10scondition_1.__monitors__PP13smonitor_desc_1));
     ((void)((*___dst__R10scondition_1).__monitor_count__Us_1=___src__10scondition_1.__monitor_count__Us_1));
@@ -1155 +1155 @@
 static inline struct M ___operator_assign__F2sM_R2sM2sM_autogen___1(struct M *___dst__R2sM_1, struct M ___src__2sM_1){
     struct M ___ret__2sM_1;
-    struct monitor_desc _tmp_cp5;
+    struct monitor_desc _tmp_cp60;
     struct monitor_desc _tmp_cp_ret31;
-    ((void)(((void)(_tmp_cp_ret31=___operator_assign__F13smonitor_desc_R13smonitor_desc13smonitor_desc_autogen___1((&(*___dst__R2sM_1).____mon__13smonitor_desc_1), (((void)___constructor__F_R13smonitor_desc13smonitor_desc_autogen___1((&_tmp_cp5), ___src__2sM_1.____mon__13smonitor_desc_1)) , _tmp_cp5)))) , _tmp_cp_ret31));
+    ((void)(((void)(_tmp_cp_ret31=___operator_assign__F13smonitor_desc_R13smonitor_desc13smonitor_desc_autogen___1((&(*___dst__R2sM_1).____mon__13smonitor_desc_1), (((void)___constructor__F_R13smonitor_desc13smonitor_desc_autogen___1((&_tmp_cp60), ___src__2sM_1.____mon__13smonitor_desc_1)) , _tmp_cp60)))) , _tmp_cp_ret31));
     ((void)___destructor__F_R13smonitor_desc_autogen___1((&_tmp_cp_ret31)));
-    ((void)___destructor__F_R13smonitor_desc_autogen___1((&_tmp_cp5)));
+    ((void)___destructor__F_R13smonitor_desc_autogen___1((&_tmp_cp60)));
     ((void)___constructor__F_R2sM2sM_autogen___1((&___ret__2sM_1), ___src__2sM_1));
     return ((struct M )___ret__2sM_1);