Changes in src/InitTweak/FixInit.cc [31f379c:9a063c8]

File:

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

src/InitTweak/FixInit.cc

@@ -49 +49 @@
 namespace InitTweak {
         namespace {
-                typedef std::unordered_map< Expression *, TypeSubstitution * > EnvMap;
-
                 class InsertImplicitCalls final : public GenPoly::PolyMutator {
                 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, EnvMap & envMap );
-
-                        InsertImplicitCalls( EnvMap & envMap ) : envMap( envMap ) {}
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        static void insert( std::list< Declaration * > & translationUnit );
+
+                        using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ApplicationExpr * appExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
-
-                        // collects environments for relevant nodes
-                        EnvMap & envMap;
                 };
 
@@ -72 +64 @@
                         /// 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, const EnvMap & envMap );
+                        static void resolveImplicitCalls( std::list< Declaration * > & translationUnit );
 
                         typedef SymTab::Indexer Parent;
                         using Parent::visit;
 
-                        ResolveCopyCtors( const EnvMap & envMap ) : envMap( envMap ) {}
-
                         virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
-                        virtual void visit( UniqueExpr * unqExpr ) override;
-                        virtual void visit( StmtExpr * stmtExpr ) override;
+                        virtual void visit( UniqueExpr * unqExpr );
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
@@ -90 +79 @@
                         void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
                         void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
-
+                private:
                         TypeSubstitution * env;
-                        const EnvMap & envMap;
                 };
 
@@ -186 +174 @@
                         static void fixInitializers( std::list< Declaration * > &translationUnit );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        using GenPoly::PolyMutator::mutate;
                         virtual DeclarationWithType * mutate( ObjectDecl *objDecl ) override;
 
@@ -199 +186 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit );
 
-                        typedef GenPoly::PolyMutator Parent;
-                        using Parent::mutate;
+                        using GenPoly::PolyMutator::mutate;
                         virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
                         virtual Expression * mutate( UniqueExpr * unqExpr ) override;
-                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
                 };
 
@@ -263 +248 @@
                 InitTweak::fixGlobalInit( translationUnit, filename, inLibrary );
 
-                EnvMap envMap;
-
-                InsertImplicitCalls::insert( translationUnit, envMap );
-                ResolveCopyCtors::resolveImplicitCalls( translationUnit, envMap );
+
+                InsertImplicitCalls::insert( translationUnit );
+                ResolveCopyCtors::resolveImplicitCalls( translationUnit );
                 InsertDtors::insert( translationUnit );
                 FixInit::fixInitializers( translationUnit );
@@ -285 +269 @@
 
         namespace {
-                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit, EnvMap & envMap ) {
-                        InsertImplicitCalls inserter( envMap );
+                void InsertImplicitCalls::insert( std::list< Declaration * > & translationUnit ) {
+                        InsertImplicitCalls inserter;
                         mutateAll( translationUnit, inserter );
                 }
 
-                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit, const EnvMap & envMap ) {
-                        ResolveCopyCtors resolver( envMap );
+                void ResolveCopyCtors::resolveImplicitCalls( std::list< Declaration * > & translationUnit ) {
+                        ResolveCopyCtors resolver;
                         acceptAll( translationUnit, resolver );
                 }
@@ -342 +326 @@
 
                 Expression * InsertImplicitCalls::mutate( ApplicationExpr * appExpr ) {
-                        appExpr = dynamic_cast< ApplicationExpr * >( Parent::mutate( appExpr ) );
+                        appExpr = dynamic_cast< ApplicationExpr * >( Mutator::mutate( appExpr ) );
                         assert( appExpr );
 
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
-                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) {
+                                if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;
@@ -355 +339 @@
                                                 Type * t1 = ftype->get_parameters().front()->get_type();
                                                 Type * t2 = ftype->get_parameters().back()->get_type();
-                                                PointerType * ptrType = safe_dynamic_cast< PointerType * > ( t1 );
+                                                PointerType * ptrType = dynamic_cast< PointerType * > ( t1 );
+                                                assert( ptrType );
 
                                                 if ( ResolvExpr::typesCompatible( ptrType->get_base(), t2, SymTab::Indexer() ) ) {
@@ -372 +357 @@
                         // wrap each function call so that it is easy to identify nodes that have to be copy constructed
                         ImplicitCopyCtorExpr * expr = new ImplicitCopyCtorExpr( appExpr );
-                        // save the type substitution into the envMap so that it is easy to find.
+                        // save the type substitution onto the new node 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
@@ -381 +366 @@
                         // constructor calls together.
                         assert( env );
-                        envMap[expr] = env;
+                        expr->set_env( env );
                         return expr;
-                }
-
-                Expression * InsertImplicitCalls::mutate( StmtExpr * stmtExpr ) {
-                        assert( env );
-                        envMap[stmtExpr] = env;
-                        return Parent::mutate( stmtExpr );
                 }
 
@@ -413 +392 @@
                         assert( resolved );
                         if ( resolved->get_env() ) {
-                                // Extract useful information and discard new environments. Keeping them causes problems in PolyMutator passes.
                                 env->add( *resolved->get_env() );
-                                delete resolved->get_env();
-                                resolved->set_env( nullptr );
                         } // if
 
@@ -425 +401 @@
                 void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
-                        assert( env );
-                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
+                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
                         assert( arg->has_result() );
                         Type * result = arg->get_result();
@@ -433 +408 @@
                         // type may involve type variables, so apply type substitution to get temporary variable's actual type
                         result = result->clone();
-                        env->apply( result );
+                        impCpCtorExpr->get_env()->apply( result );
                         ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_isConst( false );
@@ -462 +437 @@
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         Parent::visit( impCpCtorExpr );
-                        env = envMap.at(impCpCtorExpr);
-                        assert( env );
+                        env = impCpCtorExpr->get_env(); // xxx - maybe we really should just have a PolyIndexer...
 
                         ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
@@ -474 +448 @@
                         // each return value from the call needs to be connected with an ObjectDecl at the call site, which is
                         // initialized with the return value and is destructed later
-                        // xxx - handle named return values?
+                        // xxx - handle multiple return values
+                        ApplicationExpr * callExpr = impCpCtorExpr->get_callExpr();
+                        // xxx - is this right? callExpr may not have the right environment, because it was attached at a higher
+                        // level. Trying to pass that environment along.
+                        callExpr->set_env( impCpCtorExpr->get_env()->clone() );
                         Type * result = appExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
                                 result = result->clone();
-                                env->apply( result );
+                                impCpCtorExpr->get_env()->apply( result );
                                 ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_isConst( false );
@@ -490 +468 @@
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
-                }
-
-                void ResolveCopyCtors::visit( StmtExpr * stmtExpr ) {
-                        Parent::visit( stmtExpr );
-                        env = envMap.at(stmtExpr);
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                static UniqueName retNamer("_tmp_stmtexpr_ret");
-
-                                // create variable that will hold the result of the stmt expr
-                                result = result->clone();
-                                env->apply( result );
-                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
-                                ret->get_type()->set_isConst( false );
-                                stmtExpr->get_returnDecls().push_front( ret );
-
-                                // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
-                                // must be an ExprStmt, otherwise it wouldn't have a result
-                                ExprStmt * last = safe_dynamic_cast< ExprStmt * >( body->get_kids().back() );
-                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
-
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( new VariableExpr( ret ) ) ) );
-                        } // if
-
                 }
 
@@ -541 +492 @@
                 }
 
+
                 Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        impCpCtorExpr = safe_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
+                        impCpCtorExpr = dynamic_cast< ImplicitCopyCtorExpr * >( Mutator::mutate( impCpCtorExpr ) );
+                        assert( impCpCtorExpr );
+
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -604 +558 @@
                                         retExpr = UntypedExpr::createDeref( retExpr );
                                 } // if
-                                // move env from callExpr to retExpr
-                                retExpr->set_env( callExpr->get_env() );
-                                callExpr->set_env( nullptr );
+                                retExpr->set_env( env->clone() );
                                 return retExpr;
                         } else {
@@ -613 +565 @@
                 }
 
-                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
-                        stmtExpr = safe_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
-                                } // for
-                                // add destructors after current statement
-                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
-                                        stmtsToAddAfter.push_back( new ExprStmt( noLabels, dtor ) );
-                                } // for
-                                // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
-                                assert( ! stmtExpr->get_returnDecls().empty() );
-                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
-                        }
-                        stmtExpr->get_returnDecls().clear();
-                        stmtExpr->get_dtors().clear();
-                        return stmtExpr;
-                }
-
                 Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
                         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
+                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) );
                         if ( unqMap.count( unqExpr->get_id() ) ) {
                                 // take data from other UniqueExpr to ensure consistency
@@ -652 +582 @@
                                 return unqExpr;
                         }
-                        unqExpr = safe_dynamic_cast< UniqueExpr * >( Parent::mutate( unqExpr ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
@@ -670 +599 @@
                         // first recursively handle pieces of ObjectDecl so that they aren't missed by other visitors when the init
                         // is removed from the ObjectDecl
-                        objDecl = dynamic_cast< ObjectDecl * >( Parent::mutate( objDecl ) );
+                        objDecl = dynamic_cast< ObjectDecl * >( Mutator::mutate( objDecl ) );
+
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
                                 // a decision should have been made by the resolver, so ctor and init are not both non-NULL
@@ -974 +904 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        UntypedExpr * deref = UntypedExpr::createDeref( new VariableExpr( thisParam ) );
+                                        UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
+                                        deref->get_args().push_back( new VariableExpr( thisParam ) );
 
                                         Expression * arg2 = 0;