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

File:

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

src/InitTweak/FixInit.cc

@@ -5 +5 @@
 // file "LICENCE" distributed with Cforall.
 //
-// FixInit.h --
+// FixInit.cc --
 //
 // Author           : Rob Schluntz
@@ -197 +197 @@
                 };
 
-                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
+                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef<GenStructMemberCalls> {
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
@@ -203 +203 @@
                         static void generate( std::list< Declaration * > & translationUnit );
 
-                        void previsit( FunctionDecl * funcDecl );
-                        void postvisit( FunctionDecl * funcDecl );
-
-                        void previsit( MemberExpr * memberExpr );
-                        void previsit( ApplicationExpr * appExpr );
+                        void premutate( FunctionDecl * funcDecl );
+                        DeclarationWithType * postmutate( FunctionDecl * funcDecl );
+
+                        void premutate( MemberExpr * memberExpr );
+                        void premutate( ApplicationExpr * appExpr );
+
+                        /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is
+                        /// okay for this part of the recursion to occur alongside the rest.
+                        Expression * postmutate( UntypedExpr * expr );
 
                         SemanticError errors;
@@ -220 +224 @@
                         bool isCtor = false; // true if current function is a constructor
                         StructDecl * structDecl = nullptr;
-                };
-
-                // very simple resolver-like mutator class - used to
-                // resolve UntypedExprs that are found within newly
-                // generated constructor/destructor calls
-                class MutatingResolver final : public Mutator {
-                  public:
-                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
-
-                        using Mutator::mutate;
-                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
-                        virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
-
-                  private:
-                        SymTab::Indexer & indexer;
                 };
 
@@ -315 +304 @@
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
                         PassVisitor<GenStructMemberCalls> warner;
-                        acceptAll( translationUnit, warner );
+                        mutateAll( translationUnit, warner );
                 }
 
@@ -365 +354 @@
                         // arrays are not copy constructed, so this should always be an ExprStmt
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
-                        ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
+                        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 );
                         Expression * resolved = exprStmt->expr;
                         exprStmt->expr = nullptr; // take ownership of expr
@@ -382 +372 @@
                         } // if
                         delete stmt;
+                        if ( TupleAssignExpr * assign = dynamic_cast< TupleAssignExpr * >( resolved ) ) {
+                                // fix newly generated StmtExpr
+                                postvisit( assign->stmtExpr );
+                        }
                         return resolved;
                 }
@@ -475 +469 @@
                                 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->get_type()->set_const( false );
-                                stmtExpr->get_returnDecls().push_front( ret );
+                                ret->type->set_const( false );
+                                stmtExpr->returnDecls.push_front( ret );
 
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
+                                CompoundStmt * body = stmtExpr->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->set_expr( makeCtorDtor( "?{}", ret, last->get_expr() ) );
-
-                                stmtExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
+                                last->expr = makeCtorDtor( "?{}", ret, last->get_expr() );
+
+                                stmtExpr->dtors.push_front( makeCtorDtor( "^?{}", ret ) );
                         } // if
                 }
@@ -590 +589 @@
                         // to the outer context, rather than inside of the statement expression.
                         visit_children = false;
-                        std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
+                        std::list< Statement * > & stmts = stmtExpr->statements->get_kids();
                         for ( Statement *& stmt : stmts ) {
                                 stmt = stmt->acceptMutator( *visitor );
                         } // for
-                        assert( stmtExpr->get_result() );
-                        Type * result = stmtExpr->get_result();
+                        assert( stmtExpr->result );
+                        Type * result = stmtExpr->result;
                         if ( ! result->isVoid() ) {
-                                for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
+                                for ( ObjectDecl * obj : stmtExpr->returnDecls ) {
                                         stmtsToAddBefore.push_back( new DeclStmt( obj ) );
                                 } // for
                                 // add destructors after current statement
-                                for ( Expression * dtor : stmtExpr->get_dtors() ) {
+                                for ( Expression * dtor : stmtExpr->dtors ) {
                                         stmtsToAddAfter.push_back( new ExprStmt( dtor ) );
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
                                 assert( ! stmts.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() );
+                                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() );
                 }
 
@@ -937 +939 @@
                 }
 
-                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
+                void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) {
                         GuardValue( function );
                         GuardValue( unhandled );
@@ -971 +973 @@
                 }
 
-                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
+                DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
@@ -1025 +1027 @@
                                                 Statement * callStmt = stmt.front();
 
-                                                MutatingResolver resolver( indexer );
                                                 try {
-                                                        callStmt->acceptMutator( resolver );
+                                                        callStmt->acceptMutator( *visitor );
                                                         if ( isCtor ) {
                                                                 function->get_statements()->push_front( callStmt );
@@ -1043 +1044 @@
                                 throw errors;
                         }
+                        return funcDecl;
                 }
 
@@ -1068 +1070 @@
                 }
 
-                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
+                void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) {
                                 visit_children = false;
@@ -1093 +1095 @@
                 }
 
-                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
+                void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) || ! isCtor ) {
                                 visit_children = false;
@@ -1121 +1123 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
-                        // add object to the indexer assumes that there will be no name collisions
-                        // in generated code. If this changes, add mutate methods for entities with
-                        // scope and call {enter,leave}Scope explicitly.
-                        indexer.addId( objectDecl );
-                        return objectDecl;
-                }
-
-                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) {
                         Expression * newExpr = untypedExpr;
                         ResolvExpr::findVoidExpression( newExpr, indexer );