Changeset 5b2f5bb for src/InitTweak/RemoveInit.cc

Timestamp:

Mar 30, 2016, 3:48:55 PM (9 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, ctor, deferred_resn, demangler, enum, forall-pointer-decay, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

e0323a2

Parents:

4cc4286

Message:

choose destructor at at object declaration (CtorInit), overhaul and simplification of resolver code for CtorInit

File:

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

src/InitTweak/RemoveInit.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Rob Schluntz
-// Last Modified On : Tue Feb 09 15:12:29 2016
+// Last Modified On : Wed Mar 30 15:45:12 2016
 // Update Count     : 166
 //
@@ -72 +72 @@
                 virtual Declaration* mutate( TypedefDecl *typeDecl );
 
-                virtual CompoundStmt * mutate( CompoundStmt * compoundStmt );
-
           protected:
                 bool inFunction;
-
-                // to be added before block ends - use push_front so order is correct
-                std::list< Statement * > destructorStmts;
         };
 
@@ -199 +194 @@
                                         // call into makeArrayFunction from validate.cc to generate calls to ctor/dtor for each element of array
                                         // TODO: walk initializer and generate appropriate copy ctor if element has initializer
-                                        SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "?{}", back_inserter( stmtsToAddAfter ) );
-                                        SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "^?{}", front_inserter( destructorStmts ), false );
+                                        std::list< Statement * > ctor;
+                                        std::list< Statement * > dtor;
+
+                                        SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "?{}", back_inserter( ctor ) );
+                                        SymTab::makeArrayFunction( NULL, new VariableExpr( objDecl ), at, "^?{}", front_inserter( dtor ), false );
+
+                                        // Currently makeArrayFunction produces a single Statement - a CompoundStmt
+                                        // which  wraps everything that needs to happen. As such, it's technically
+                                        // possible to use a Statement ** in the above calls, but this is inherently
+                                        // unsafe, so instead we take the slightly less efficient route, but will be
+                                        // immediately informed if somehow the above assumption is broken. In this case,
+                                        // we could always wrap the list of statements at this point with a CompoundStmt,
+                                        // but it seems reasonable at the moment for this to be done by makeArrayFunction
+                                        // itself
+                                        assert( ctor.size() == 1 );
+                                        assert( dtor.size() == 1 );
+
+                                        objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
                                 } else {
                                         // it's sufficient to attempt to call the ctor/dtor for the given object and its initializer
@@ -209 +220 @@
                                         // if ctor does exist, want to use ctor expression instead of init
                                         // push this decision to the resolver
-                                        objDecl->set_init( new ConstructorInit( ctor, objDecl->get_init() ) );
-                                        destructorStmts.push_front( new ExprStmt( noLabels, dtor ) );
+                                        ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
+                                        ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
+                                        objDecl->set_init( new ConstructorInit( ctorStmt, dtorStmt, objDecl->get_init() ) );
                                 }
                         } else {
@@ -234 +246 @@
         }
 
-        CompoundStmt * CtorDtor::mutate( CompoundStmt * compoundStmt ) {
-                // don't want to dump all destructors when block is left,
-                // just the destructors associated with variables defined in this block
-                std::list< Statement * > oldDestructorStmts = destructorStmts;
-                destructorStmts = std::list<Statement *>();
-
-                CompoundStmt * ret = PolyMutator::mutate( compoundStmt );
-                std::list< Statement * > &statements = ret->get_kids();
-                if ( ! destructorStmts.empty() ) {
-                        // TODO: adding to the end of a block isn't sufficient, since
-                        // return/break/goto should trigger destructor when block is left.
-                        statements.splice( statements.end(), destructorStmts );
-                } // if
-
-                destructorStmts = oldDestructorStmts;
-                return ret;
-        }
-
         // should not traverse into any of these declarations to find objects
         // that need to be constructed or destructed