Changes in src/InitTweak/FixInit.cc [6dfa2e1:ba3706f]

File:

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

src/InitTweak/FixInit.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixInit.cc --
+// FixInit.h --
 //
 // Author           : Rob Schluntz
@@ -365 +365 @@
                         // arrays are not copy constructed, so this should always be an ExprStmt
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
-                        assertf( stmt, "ResolveCopyCtors: genCtorDtor returned nullptr: %s / %s / %s", fname.c_str(), toString( var ).c_str(), toString( cpArg ).c_str() );
-                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->callStmt );
+                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
                         Expression * resolved = exprStmt->expr;
                         exprStmt->expr = nullptr; // take ownership of expr
@@ -383 +382 @@
                         } // if
                         delete stmt;
-                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
-                                // fix newly generated StmtExpr
-                                postvisit( assign->stmtExpr );
-                        }
                         return resolved;
                 }
@@ -480 +475 @@
                                 static UniqueName retNamer("_tmp_stmtexpr_ret");
 
+                                // create variable that will hold the result of the stmt expr
                                 result = result->clone();
                                 env->apply( result );
-                                if ( ! InitTweak::isConstructable( result ) ) {
-                                        delete result;
-                                        return;
-                                }
-
-                                // create variable that will hold the result of the stmt expr
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
-                                ret->type->set_const( false );
-                                stmtExpr->returnDecls.push_front( ret );
+                                ret->get_type()->set_const( false );
+                                stmtExpr->get_returnDecls().push_front( ret );
 
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->statements;
+                                CompoundStmt * body = stmtExpr->get_statements();
                                 assert( ! body->get_kids().empty() );
                                 // must be an ExprStmt, otherwise it wouldn't have a result
                                 ExprStmt * last = strict_dynamic_cast< ExprStmt * >( body->get_kids().back() );
-                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
-
-                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
+                                last->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
+
+                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
                 }
@@ -600 +590 @@
                         // to the outer context, rather than inside of the statement expression.
                         visit_children = false;
-                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
+                        std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        assert( stmtExpr->result );
-                        Type * result = stmtExpr->result;
+                        assert( stmtExpr->get_result() );
+                        Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
-                                for ( ObjectDecl * obj : stmtExpr->returnDecls ) {
+                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
                                         stmtsToAddBefore.push_back( new DeclStmt( obj ) );
                                 } // for
                                 // add destructors after current statement
-                                for ( Expression * dtor : stmtExpr->dtors ) {
+                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
                                         stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
                                 assert( ! stmts.empty() );
-                                assertf( ! stmtExpr->returnDecls.empty() || stmtExpr->dtors.empty(), "StmtExpr returns non-void, but no return decls: %s", toString( stmtExpr ).c_str() );
-                                // if there is a return decl, add a use as the last statement; will not have return decl on non-constructable returns
-                                if ( ! stmtExpr->returnDecls.empty() ) {
-                                        stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->returnDecls.front() ) ) );
-                                }
-                                stmtExpr->returnDecls.clear();
-                                stmtExpr->dtors.clear();
-                        }
-                        assert( stmtExpr->returnDecls.empty() );
-                        assert( stmtExpr->dtors.empty() );
+                                assert( ! stmtExpr->get_returnDecls().empty() );
+                                stmts.push_back( new ExprStmt( new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmtExpr->get_returnDecls().clear();
+                                stmtExpr->get_dtors().clear();
+                        }
+                        assert( stmtExpr->get_returnDecls().empty() );
+                        assert( stmtExpr->get_dtors().empty() );
                 }