Changes in src/InitTweak/FixInit.cc [1bc749f:b0f601fa]

File:

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

src/InitTweak/FixInit.cc

@@ -54 +54 @@
 #include "SynTree/Type.h"              // for Type, Type::StorageClasses
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
-#include "SynTree/VarExprReplacer.h"   // for VarExprReplacer
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
 
@@ -159 +158 @@
                         using Parent::previsit;
 
+                        void previsit( ObjectDecl * objDecl );
                         void previsit( FunctionDecl * funcDecl );
 
+                        void previsit( CompoundStmt * compoundStmt );
+                        void postvisit( CompoundStmt * compoundStmt );
+                        void previsit( ReturnStmt * returnStmt );
                         void previsit( BranchStmt * stmt );
                 private:
@@ -176 +179 @@
 
                         DeclarationWithType * postmutate( ObjectDecl *objDecl );
-
-                        DeclarationWithType * getDtorFunc( ObjectDecl * objDecl, Statement * dtor );
 
                         std::list< Declaration * > staticDtorDecls;
@@ -213 +214 @@
                         void emit( CodeLocation, const Params &... params );
 
-                        FunctionDecl * function = 0;
+                        FunctionDecl * function = nullptr;
                         std::set< DeclarationWithType * > unhandled;
                         std::map< DeclarationWithType *, CodeLocation > usedUninit;
-                        ObjectDecl * thisParam = 0;
+                        ObjectDecl * thisParam = nullptr;
                         bool isCtor = false; // true if current function is a constructor
-                        StructDecl * structDecl = 0;
+                        StructDecl * structDecl = nullptr;
                 };
 
@@ -623 +624 @@
                 }
 
-                DeclarationWithType * FixInit::getDtorFunc( ObjectDecl * objDecl, Statement * dtor ) {
-                        if ( dynamic_cast< ExprStmt * >( dtor ) ) {
-                                if ( DeclarationWithType * func = getFunction( getCtorDtorCall( dtor ) ) ) {
-                                        // cleanup argument must be a function, not an object (including function pointer)
-                                        if ( FunctionDecl * dtorFunc = dynamic_cast< FunctionDecl * > ( func ) ) {
-                                                if ( dtorFunc->type->forall.empty() ) {
-                                                        // simple case where the destructor is a monomorphic function call - can simply
-                                                        // use that function as the cleanup function.
-                                                        delete dtor;
-                                                        return func;
-                                                }
-                                        }
-                                }
-                        }
-
-                        // otherwise the cleanup is more complicated - need to build a single argument cleanup function that
-                        // wraps the more complicated code.
-                        static UniqueName dtorNamer( "__cleanup_dtor" );
-                        FunctionDecl * dtorFunc = FunctionDecl::newFunction( dtorNamer.newName(), SymTab::genDefaultType( objDecl->type ), new CompoundStmt( noLabels ) );
-                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, dtorFunc ) );
-
-                        // the original code contains uses of objDecl - replace them with the newly generated 'this' parameter.
-                        ObjectDecl * thisParam = getThisParam( dtorFunc->type );
-                        VarExprReplacer::replace( dtor, { std::make_pair( objDecl, thisParam ) } );
-                        dtorFunc->statements->push_back( dtor );
-
-                        return dtorFunc;
-                }
-
                 DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) {
                         // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
@@ -750 +722 @@
                                         } else {
                                                 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
-                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt );
                                                 ApplicationExpr * ctorCall = nullptr;
-                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
-                                                        ctorCall->get_args().pop_back();
+                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        ctorCall->args.pop_back();
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( nullptr );
-                                                        ctorInit->set_ctor( nullptr );
-                                                }
-
-                                                Statement * dtor = ctorInit->dtor;
-                                                if ( dtor ) {
-                                                        ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * >( dtor );
-                                                        Statement * dtorStmt = implicit->callStmt;
-                                                        // don't need to call intrinsic dtor, because it does nothing, but
-                                                        // non-intrinsic dtors must be called
-                                                        if ( ! isIntrinsicSingleArgCallStmt( dtorStmt ) ) {
-                                                                // set dtor location to the object's location for error messages
-                                                                DeclarationWithType * dtorFunc = getDtorFunc( objDecl, dtorStmt );
-                                                                objDecl->attributes.push_back( new Attribute( "cleanup", { new VariableExpr( dtorFunc ) } ) );
-                                                                // objDecl->attributes.push_back( new Attribute( "cleanup", { new NameExpr( dtorFunc->name ) } ) );
-                                                                ctorInit->dtor = nullptr;
-                                                        } // if
+                                                        objDecl->init = nullptr;
+                                                        ctorInit->ctor = nullptr;
                                                 }
                                         } // if
-                                } else if ( Initializer * init = ctorInit->get_init() ) {
-                                        objDecl->set_init( init );
-                                        ctorInit->set_init( nullptr );
+                                } else if ( Initializer * init = ctorInit->init ) {
+                                        objDecl->init = init;
+                                        ctorInit->init = nullptr;
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( nullptr );
+                                        objDecl->init = nullptr;
                                 } // if
                                 delete ctorInit;
@@ -817 +774 @@
                 }
 
+
+                template<typename Iterator, typename OutputIterator>
+                void insertDtors( Iterator begin, Iterator end, OutputIterator out ) {
+                        for ( Iterator it = begin ; it != end ; ++it ) {
+                                // extract destructor statement from the object decl and insert it into the output. Note that this is
+                                // only called on lists of non-static objects with implicit non-intrinsic dtors, so if the user manually
+                                // calls an intrinsic dtor then the call must (and will) still be generated since the argument may
+                                // contain side effects.
+                                ObjectDecl * objDecl = *it;
+                                ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() );
+                                assert( ctorInit && ctorInit->get_dtor() );
+                                *out++ = ctorInit->get_dtor()->clone();
+                        } // for
+                }
+
+                void InsertDtors::previsit( ObjectDecl * objDecl ) {
+                        // remember non-static destructed objects so that their destructors can be inserted later
+                        if ( ! objDecl->get_storageClasses().is_static ) {
+                                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
+                                        assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
+                                        Statement * dtor = ctorInit->get_dtor();
+                                        // don't need to call intrinsic dtor, because it does nothing, but
+                                        // non-intrinsic dtors must be called
+                                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
+                                                reverseDeclOrder.front().push_front( objDecl );
+                                        } // if
+                                } // if
+                        } // if
+                }
 
                 void InsertDtors::previsit( FunctionDecl * funcDecl ) {
@@ -826 +815 @@
 
                         // all labels for this function have been collected, insert destructors as appropriate via implicit recursion.
+                }
+
+                void InsertDtors::previsit( CompoundStmt * compoundStmt ) {
+                        // visit statements - this will also populate reverseDeclOrder list.  don't want to dump all destructors
+                        // when block is left, just the destructors associated with variables defined in this block, so push a new
+                        // list to the top of the stack so that we can differentiate scopes
+                        reverseDeclOrder.push_front( OrderedDecls() );
+                        Parent::previsit( compoundStmt );
+                }
+
+                void InsertDtors::postvisit( CompoundStmt * compoundStmt ) {
+                        // add destructors for the current scope that we're exiting, unless the last statement is a return, which
+                        // causes unreachable code warnings
+                        std::list< Statement * > & statements = compoundStmt->get_kids();
+                        if ( ! statements.empty() && ! dynamic_cast< ReturnStmt * >( statements.back() ) ) {
+                                insertDtors( reverseDeclOrder.front().begin(), reverseDeclOrder.front().end(), back_inserter( statements ) );
+                        }
+                        reverseDeclOrder.pop_front();
+                }
+
+                void InsertDtors::previsit( ReturnStmt * ) {
+                        // return exits all scopes, so dump destructors for all scopes
+                        for ( OrderedDecls & od : reverseDeclOrder ) {
+                                insertDtors( od.begin(), od.end(), back_inserter( stmtsToAddBefore ) );
+                        } // for
                 }
 
@@ -855 +869 @@
                         if ( ! diff.empty() ) {
                                 throw SemanticError( std::string("jump to label '") + stmt->get_target().get_name() + "' crosses initialization of " + (*diff.begin())->get_name() + " ", stmt );
+                        } // if
+                        // S_G-S_L results in set of objects that must be destructed
+                        diff.clear();
+                        std::set_difference( curVars.begin(), curVars.end(), lvars.begin(), lvars.end(), std::inserter( diff, diff.end() ) );
+                        DTOR_PRINT(
+                                std::cerr << "S_G-S_L = " << printSet( diff ) << std::endl;
+                        )
+                        if ( ! diff.empty() ) {
+                                // create an auxilliary set for fast lookup -- can't make diff a set, because diff ordering should be consistent for error messages.
+                                std::unordered_set<ObjectDecl *> needsDestructor( diff.begin(), diff.end() );
+
+                                // go through decl ordered list of objectdecl. for each element that occurs in diff, output destructor
+                                OrderedDecls ordered;
+                                for ( OrderedDecls & rdo : reverseDeclOrder ) {
+                                        // add elements from reverseDeclOrder into ordered if they occur in diff - it is key that this happens in reverse declaration order.
+                                        copy_if( rdo.begin(), rdo.end(), back_inserter( ordered ), [&]( ObjectDecl * objDecl ) { return needsDestructor.count( objDecl ); } );
+                                } // for
+                                insertDtors( ordered.begin(), ordered.end(), back_inserter( stmtsToAddBefore ) );
                         } // if
                 }
@@ -880 +912 @@
                 }
 
+                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::previsit( FunctionDecl * funcDecl ) {
-                        GuardValue( funcDecl );
+                        GuardValue( function );
                         GuardValue( unhandled );
                         GuardValue( usedUninit );
@@ -914 +959 @@
                 }
 
-                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 ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted