Changes in src/InitTweak/FixInitNew.cpp [8060b2b:39d8950]

File:

• src/InitTweak/FixInitNew.cpp (modified) (4 diffs)

src/InitTweak/FixInitNew.cpp

@@ -454 +454 @@
 
                 auto expr = new ast::ImplicitCopyCtorExpr( appExpr->location, mutExpr );
-                // Move the type substitution to the new top-level. The substitution
-                // is needed to obtain the type of temporary variables so that copy
-                // constructor calls can be resolved.
+                // Move the type substitution to the new top-level, if it is attached to the appExpr.
+                // 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.
                 assert( typeSubs );
+                // assert (mutExpr->env);
                 expr->env = tmp;
+                // mutExpr->env = nullptr;
+                //std::swap( expr->env, appExpr->env );
                 return expr;
         }
 
         void ResolveCopyCtors::previsit(const ast::Expr * expr) {
-                if ( nullptr == expr->env ) {
-                        return;
-                }
-                GuardValue( env ) = expr->env->clone();
-                GuardValue( envModified ) = false;
+                if (expr->env) {
+                        GuardValue(env);
+                        GuardValue(envModified);
+                        env = expr->env->clone();
+                        envModified = false;
+                }
         }
 
         const ast::Expr * ResolveCopyCtors::postvisit(const ast::Expr * expr) {
-                // No local environment, skip.
-                if ( nullptr == expr->env ) {
-                        return expr;
-                // Environment was modified, mutate and replace.
-                } else if ( envModified ) {
-                        auto mutExpr = mutate(expr);
-                        mutExpr->env = env;
-                        return mutExpr;
-                // Environment was not mutated, delete the shallow copy before guard.
-                } else {
-                        delete env;
+                if (expr->env) {
+                        if (envModified) {
+                                auto mutExpr = mutate(expr);
+                                mutExpr->env = env;
+                                return mutExpr;
+                        }
+                        else {
+                                // env was not mutated, skip and delete the shallow copy
+                                delete env;
+                                return expr;
+                        }
+                }
+                else {
                         return expr;
                 }
@@ -490 +497 @@
         const ast::Expr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, const ast::ObjectDecl * var, const ast::Expr * cpArg ) {
                 assert( var );
-                assert( var->isManaged() );
-                assert( !cpArg || cpArg->isManaged() );
+                assert (var->isManaged());
+                assert (!cpArg || cpArg->isManaged());
                 // arrays are not copy constructed, so this should always be an ExprStmt
                 ast::ptr< ast::Stmt > stmt = genCtorDtor(var->location, fname, var, cpArg );
@@ -497 +504 @@
                 auto exprStmt = stmt.strict_as<ast::ImplicitCtorDtorStmt>()->callStmt.strict_as<ast::ExprStmt>();
                 ast::ptr<ast::Expr> untyped = exprStmt->expr; // take ownership of expr
+                // exprStmt->expr = nullptr;
 
                 // resolve copy constructor
@@ -508 +516 @@
                         env->add( *resolved->env );
                         envModified = true;
+                        // delete resolved->env;
                         auto mut = mutate(resolved.get());
                         assertf(mut == resolved.get(), "newly resolved expression must be unique");
                         mut->env = nullptr;
                 } // if
+                // delete stmt;
                 if ( auto assign = resolved.as<ast::TupleAssignExpr>() ) {
                         // fix newly generated StmtExpr