Changes in src/InitTweak/GenInit.cc [4d2434a:cad355a]

File:

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

src/InitTweak/GenInit.cc

@@ -26 +26 @@
 #include "SymTab/Autogen.h"
 #include "GenPoly/PolyMutator.h"
-#include "GenPoly/DeclMutator.h"
 
 namespace InitTweak {
@@ -56 +55 @@
           public:
                 /// create constructor and destructor statements for object declarations.
-                /// the actual call statements will be added in after the resolver has run
-                /// so that the initializer expression is only removed if a constructor is found
-                /// and the same destructor call is inserted in all of the appropriate locations.
+                /// Destructors are inserted directly into the code, whereas constructors
+                /// will be added in after the resolver has run so that the initializer expression
+                /// is only removed if a constructor is found
                 static void generateCtorDtor( std::list< Declaration * > &translationUnit );
+
+                CtorDtor() : inFunction( false ) {}
 
                 virtual DeclarationWithType * mutate( ObjectDecl * );
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
-                virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
-
-                virtual Type * mutate( FunctionType *funcType ) { return funcType; }
+                virtual Declaration* mutate( StructDecl *aggregateDecl );
+                virtual Declaration* mutate( UnionDecl *aggregateDecl );
+                virtual Declaration* mutate( EnumDecl *aggregateDecl );
+                virtual Declaration* mutate( TraitDecl *aggregateDecl );
+                virtual TypeDecl* mutate( TypeDecl *typeDecl );
+                virtual Declaration* mutate( TypedefDecl *typeDecl );
+
+                virtual Type * mutate( FunctionType *funcType );
 
           protected:
-        };
-
-        class HoistArrayDimension : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
-
-                /// hoist dimension from array types in object declaration so that it uses a single
-                /// const variable of type size_t, so that side effecting array dimensions are only
-                /// computed once.
-                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
-
-          private:
-                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl );
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl );
-                // should not traverse into any of these declarations to find objects
-                // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual Declaration* mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
-                virtual TypeDecl* mutate( TypeDecl *typeDecl ) { return typeDecl; }
-                virtual Declaration* mutate( TypedefDecl *typeDecl ) { return typeDecl; }
-
-                virtual Type* mutate( FunctionType *funcType ) { return funcType; }
-
-                void hoist( Type * type );
-
-                DeclarationNode::StorageClass storageclass = DeclarationNode::NoStorageClass;
-                bool inFunction = false;
+                bool inFunction;
         };
 
         void genInit( std::list< Declaration * > & translationUnit ) {
                 ReturnFixer::makeReturnTemp( translationUnit );
-                HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
         }
@@ -154 +124 @@
         }
 
-        // precompute array dimension expression, because constructor generation may duplicate it,
-        // which would be incorrect if it is a side-effecting computation.
-        void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                HoistArrayDimension hoister;
-                hoister.mutateDeclarationList( translationUnit );
-        }
-
-        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
-                storageclass = objectDecl->get_storageClass();
-                DeclarationWithType * temp = Parent::mutate( objectDecl );
-                hoist( objectDecl->get_type() );
-                storageclass = DeclarationNode::NoStorageClass;
-                return temp;
-        }
-
-        void HoistArrayDimension::hoist( Type * type ) {
-                // if in function, generate const size_t var
-                static UniqueName dimensionName( "_array_dim" );
-                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
-                        if ( ! inFunction ) return;
-
-                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
-
-                        // don't need to hoist dimension if it's a constexpr - only need to if there's potential
-                        // for side effects.
-                        if ( isConstExpr( arrayType->get_dimension() ) ) return;
-
-                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageclass, LinkageSpec::C, 0, SymTab::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
-                        arrayDimension->get_type()->set_isConst( true );
-
-                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        addDeclaration( arrayDimension );
-
-                        hoist( arrayType->get_base() );
-                        return;
-                }
-        }
-
-        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                bool oldInFunc = inFunction;
-                inFunction = true;
-                DeclarationWithType * decl = Parent::mutate( functionDecl );
-                inFunction = oldInFunc;
-                return decl;
-        }
 
         void CtorDtor::generateCtorDtor( std::list< Declaration * > & translationUnit ) {
@@ -215 +140 @@
 
         DeclarationWithType * CtorDtor::mutate( ObjectDecl * objDecl ) {
-                // hands off if designated, if @=, or if extern
+                // hands off if designated or if @=
                 if ( tryConstruct( objDecl ) ) {
-                        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
-                        // for each constructable object
-                        std::list< Statement * > ctor;
-                        std::list< Statement * > dtor;
-
-                        InitExpander srcParam( objDecl->get_init() );
-                        InitExpander nullParam( (Initializer *)NULL );
-                        SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
-                        SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
-
-                        // Currently genImplicitCall 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 genImplicitCall
-                        // itself. It is possible that genImplicitCall produces no statements (e.g. if
-                        // an array type does not have a dimension). In this case, it's fine to ignore
-                        // the object for the purposes of construction.
-                        assert( ctor.size() == dtor.size() && ctor.size() <= 1 );
-                        if ( ctor.size() == 1 ) {
-                                // need to remember init expression, in case no ctors exist
-                                // if ctor does exist, want to use ctor expression instead of init
-                                // push this decision to the resolver
-                                assert( dynamic_cast< ImplicitCtorDtorStmt * > ( ctor.front() ) && dynamic_cast< ImplicitCtorDtorStmt * > ( dtor.front() ) );
-                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
+                        if ( inFunction ) {
+                                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
+                                        // 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
+                                        std::list< Expression * > args = makeInitList( objDecl->get_init() );
+                                        if ( args.empty() ) {
+                                                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 && dynamic_cast< ImplicitCtorDtorStmt * >( ctor.front() ) );
+                                                assert( dtor.size() == 1 && dynamic_cast< ImplicitCtorDtorStmt * >( dtor.front() ) );
+                                                objDecl->set_init( new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() ) );
+                                        } else {
+                                                // array came with an initializer list: initialize each element
+                                                // may have more initializers than elements in the array - need to check at each index that
+                                                // we haven't exceeded size. This requires precomputing the size because it might be a side-effecting
+                                                // computation.
+                                                // may have fewer initializers than eleemnts in the array - need to default construct
+                                                // remaining elements.
+                                                // might be able to merge this with the case above.
+                                        }
+                                } else {
+                                        // it's sufficient to attempt to call the ctor/dtor for the given object and its initializer
+                                        Expression * ctor = makeCtorDtorExpr( "?{}", objDecl, makeInitList( objDecl->get_init() ) );
+                                        Expression * dtor = makeCtorDtorExpr( "^?{}", objDecl, std::list< Expression * >() );
+
+                                        // need to remember init expression, in case no ctors exist
+                                        // if ctor does exist, want to use ctor expression instead of init
+                                        // push this decision to the resolver
+                                        ExprStmt * ctorStmt = new ExprStmt( noLabels, ctor );
+                                        ExprStmt * dtorStmt = new ExprStmt( noLabels, dtor );
+                                        objDecl->set_init( new ConstructorInit( new ImplicitCtorDtorStmt( ctorStmt ), new ImplicitCtorDtorStmt( dtorStmt ), objDecl->get_init() ) );
+                                }
                         }
                 }
@@ -251 +193 @@
         DeclarationWithType * CtorDtor::mutate( FunctionDecl *functionDecl ) {
                 // parameters should not be constructed and destructed, so don't mutate FunctionType
+                bool oldInFunc = inFunction;
                 mutateAll( functionDecl->get_oldDecls(), *this );
+                inFunction = true;
                 functionDecl->set_statements( maybeMutate( functionDecl->get_statements(), *this ) );
+                inFunction = oldInFunc;
                 return functionDecl;
         }
+
+        // should not traverse into any of these declarations to find objects
+        // that need to be constructed or destructed
+        Declaration* CtorDtor::mutate( StructDecl *aggregateDecl ) { return aggregateDecl; }
+        Declaration* CtorDtor::mutate( UnionDecl *aggregateDecl ) { return aggregateDecl; }
+        Declaration* CtorDtor::mutate( EnumDecl *aggregateDecl ) { return aggregateDecl; }
+        Declaration* CtorDtor::mutate( TraitDecl *aggregateDecl ) { return aggregateDecl; }
+        TypeDecl* CtorDtor::mutate( TypeDecl *typeDecl ) { return typeDecl; }
+        Declaration* CtorDtor::mutate( TypedefDecl *typeDecl ) { return typeDecl; }
+        Type* CtorDtor::mutate( FunctionType *funcType ) { return funcType; }
+
 } // namespace InitTweak