Changes in src/InitTweak/FixInit.cc [33a25f9:e3e16bc]

File:

• src/InitTweak/FixInit.cc (modified) (23 diffs)

src/InitTweak/FixInit.cc

@@ -70 +70 @@
 namespace InitTweak {
         namespace {
+                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
                 typedef std::unordered_map< int, int > UnqCount;
 
-                struct InsertImplicitCalls : public WithTypeSubstitution {
+                class InsertImplicitCalls : public WithTypeSubstitution {
+                public:
                         /// wrap function application expressions as ImplicitCopyCtorExpr nodes so that it is easy to identify which
                         /// function calls need their parameters to be copy constructed
-                        static void insert( std::list< Declaration * > & translationUnit );
+                        static void insert( std::list< Declaration * > & translationUnit, EnvMap & envMap );
+
+                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
 
                         Expression * postmutate( ApplicationExpr * appExpr );
+                        void premutate( StmtExpr * stmtExpr );
+
+                        // collects environments for relevant nodes
+                        EnvMap & envMap;
                 };
 
-                struct ResolveCopyCtors final : public WithIndexer, public WithShortCircuiting, public WithTypeSubstitution {
+                class ResolveCopyCtors final : public SymTab::Indexer {
+                public:
                         /// generate temporary ObjectDecls for each argument and return value of each ImplicitCopyCtorExpr,
                         /// generate/resolve copy construction expressions for each, and generate/resolve destructors for both
                         /// arguments and return value temporaries
-                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount );
-
-                        ResolveCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ) {}
-
-                        void postvisit( ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void postvisit( StmtExpr * stmtExpr );
-                        void previsit( UniqueExpr * unqExpr );
-                        void postvisit( UniqueExpr * unqExpr );
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount );
+
+                        typedef SymTab::Indexer Parent;
+                        using Parent::visit;
+
+                        ResolveCopyCtors( const EnvMap & envMap, UnqCount & unqCount ) : envMap( envMap ), unqCount( unqCount ) {}
+
+                        virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual void visit( UniqueExpr * unqExpr ) override;
+                        virtual void visit( StmtExpr * stmtExpr ) override;
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -100 +111 @@
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 
+                        TypeSubstitution * env;
+                        const EnvMap & envMap;
                         UnqCount & unqCount; // count the number of times each unique expr ID appears
-                        std::unordered_set< int > vars;
                 };
 
@@ -226 +238 @@
                 };
 
-                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
+                class GenStructMemberCalls final : public SymTab::Indexer {
+                  public:
+                        typedef Indexer Parent;
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
@@ -232 +246 @@
                         static void generate( std::list< Declaration * > & translationUnit );
 
-                        void previsit( FunctionDecl * funcDecl );
-                        void postvisit( FunctionDecl * funcDecl );
-
-                        void previsit( MemberExpr * memberExpr );
-                        void previsit( ApplicationExpr * appExpr );
+                        using Parent::visit;
+
+                        virtual void visit( FunctionDecl * funcDecl ) override;
+
+                        virtual void visit( MemberExpr * memberExpr ) override;
+                        virtual void visit( ApplicationExpr * appExpr ) override;
 
                         SemanticError errors;
@@ -280 +295 @@
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
 
+                EnvMap envMap;
                 UnqCount unqCount;
 
-                InsertImplicitCalls::insert( translationUnit );
-                ResolveCopyCtors::resolveImplicitCalls( translationUnit, unqCount );
+                InsertImplicitCalls::insert( translationUnit, envMap );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap, unqCount );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
@@ -302 +318 @@
 
         namespace {
-                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<InsertImplicitCalls> inserter;
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
+                        PassVisitor<InsertImplicitCalls> inserter( envMap );
                         mutateAll( translationUnit, inserter );
                 }
 
-                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
-                        PassVisitor<ResolveCopyCtors> resolver( unqCount );
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap, UnqCount & unqCount ) {
+                        ResolveCopyCtors resolver( envMap, unqCount );
                         acceptAll( translationUnit, resolver );
                 }
@@ -344 +360 @@
 
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<GenStructMemberCalls> warner;
+                        GenStructMemberCalls warner;
                         acceptAll( translationUnit, warner );
                 }
@@ -382 +398 @@
                         // wrap each function call so that it is easy to identify nodes that have to be copy constructed
                         ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
-                        // Move the type substitution to the new top-level, if it is attached to the appExpr.
+                        // save the type substitution into the envMap so that it is easy to find.
                         // Ensure it is not deleted with the ImplicitCopyCtorExpr by removing it before deletion.
                         // The substitution is needed to obtain the type of temporary variables so that copy constructor
-                        // calls can be resolved.
+                        // calls can be resolved. Normally this is what PolyMutator is for, but the pass that resolves
+                        // copy constructor calls must be an Indexer. We could alternatively make a PolyIndexer which
+                        // saves the environment, or compute the types of temporaries here, but it's much simpler to
+                        // save the environment here, and more cohesive to compute temporary variables and resolve copy
+                        // constructor calls together.
                         assert( env );
-                        std::swap( expr->env, appExpr->env );
+                        envMap[expr] = env;
                         return expr;
+                }
+
+                void InsertImplicitCalls::premutate( StmtExpr * stmtExpr ) {
+                        assert( env );
+                        envMap[stmtExpr] = env;
                 }
 
@@ -406 +431 @@
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
                         assert( resolved );
                         if ( resolved->get_env() ) {
@@ -455 +480 @@
                 }
 
-                void ResolveCopyCtors::postvisit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
+                        Parent::visit( impCpCtorExpr );
+                        env = envMap.at(impCpCtorExpr);
+                        assert( env );
 
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
@@ -485 +513 @@
                 }
 
-                void ResolveCopyCtors::postvisit( StmtExpr * stmtExpr ) {
-                        assert( env );
+                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
+                        Parent::visit( stmtExpr );
+                        env = envMap.at(stmtExpr);
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
@@ -508 +537 @@
                                 stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
-                }
-
-                void ResolveCopyCtors::previsit( UniqueExpr * unqExpr ) {
+
+                }
+
+                void ResolveCopyCtors::visit( UniqueExpr * unqExpr ) {
+                        static std::unordered_set< int > vars;
                         unqCount[ unqExpr->get_id() ]++;  // count the number of unique expressions for each ID
                         if ( vars.count( unqExpr->get_id() ) ) {
                                 // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
-                                visit_children = false;
-                        }
-                }
-
-                void ResolveCopyCtors::postvisit( UniqueExpr * unqExpr ) {
-                        if ( vars.count( unqExpr->get_id() ) ) {
-                                // xxx - hack to prevent double-handling of unique exprs, otherwise too many temporary variables and destructors are generated
                                 return;
                         }
 
+                        Parent::visit( unqExpr );
                         // it should never be necessary to wrap a void-returning expression in a UniqueExpr - if this assumption changes, this needs to be rethought
                         assert( unqExpr->get_result() );
@@ -560 +585 @@
 
                         // xxx - update to work with multiple return values
-                        ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
+                        ObjectDecl * returnDecl = returnDecls.empty() ? NULL : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
 
@@ -569 +594 @@
                         tempDecls.clear();
                         returnDecls.clear();
-                        impCpCtorExpr->set_callExpr( nullptr );
-                        std::swap( impCpCtorExpr->env, callExpr->env );
-                        assert( impCpCtorExpr->env == nullptr );
+                        impCpCtorExpr->set_callExpr( NULL );
+                        impCpCtorExpr->set_env( NULL );
                         delete impCpCtorExpr;
 
@@ -954 +978 @@
                 }
 
-                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
-                        GuardValue( funcDecl );
-                        GuardValue( unhandled );
-                        GuardValue( usedUninit );
-                        GuardValue( thisParam );
-                        GuardValue( isCtor );
-                        GuardValue( structDecl );
+                void GenStructMemberCalls::visit( FunctionDecl * funcDecl ) {
+                        ValueGuard< FunctionDecl * > oldFunction( funcDecl );
+                        ValueGuard< std::set< DeclarationWithType * > > oldUnhandled( unhandled );
+                        ValueGuard< std::map< DeclarationWithType *, CodeLocation > > oldUsedUninit( usedUninit );
+                        ValueGuard< ObjectDecl * > oldThisParam( thisParam );
+                        ValueGuard< bool > oldIsCtor( isCtor );
+                        ValueGuard< StructDecl * > oldStructDecl( structDecl );
                         errors = SemanticError();  // clear previous errors
 
@@ -986 +1010 @@
                                 }
                         }
-                }
-
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
-                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
+                        Parent::visit( function );
+
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
@@ -1022 +1032 @@
                         if ( ! unhandled.empty() ) {
                                 // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
-                                auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
-                                addTypes( indexer, function->type->forall );
-                                addIds( indexer, function->type->returnVals );
-                                addIds( indexer, function->type->parameters );
+                                enterScope();
+                                maybeAccept( function->get_functionType(), *this );
 
                                 // need to iterate through members in reverse in order for
@@ -1055 +1063 @@
                                                 Statement * callStmt = stmt.front();
 
-                                                MutatingResolver resolver( indexer );
+                                                MutatingResolver resolver( *this );
                                                 try {
                                                         callStmt->acceptMutator( resolver );
@@ -1069 +1077 @@
                                         }
                                 }
+                                leaveScope();
                         }
                         if (! errors.isEmpty()) {
@@ -1098 +1107 @@
                 }
 
-                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
-                        if ( ! checkWarnings( function ) ) {
-                                visit_children = false;
-                                return;
-                        }
+                void GenStructMemberCalls::visit( ApplicationExpr * appExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
 
                         std::string fname = getFunctionName( appExpr );
@@ -1121 +1127 @@
                                 }
                         }
-                }
-
-                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
-                        if ( ! checkWarnings( function ) || ! isCtor ) {
-                                visit_children = false;
-                                return;
-                        }
+                        Parent::visit( appExpr );
+                }
+
+                void GenStructMemberCalls::visit( MemberExpr * memberExpr ) {
+                        if ( ! checkWarnings( function ) ) return;
+                        if ( ! isCtor ) return;
 
                         if ( isThisExpression( memberExpr->get_aggregate(), thisParam ) ) {
@@ -1135 +1140 @@
                                 }
                         }
+                        Parent::visit( memberExpr );
                 }
 
@@ -1155 +1161 @@
                         // in generated code. If this changes, add mutate methods for entities with
                         // scope and call {enter,leave}Scope explicitly.
-                        indexer.addId( objectDecl );
+                        objectDecl->accept( indexer );
                         return objectDecl;
                 }