Changes in src/InitTweak/GenInit.cc [18ca28e:ac74057]

File:

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

src/InitTweak/GenInit.cc

@@ -85 +85 @@
                 // should not have a ConstructorInit generated.
 
-                ManagedTypes managedTypes;
+                bool isManaged( ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( Type * type ) const; // determine if type is managed
+                void handleDWT( DeclarationWithType * dwt ); // add type to managed if ctor/dtor
+                GenPoly::ScopedSet< std::string > managedTypes;
                 bool inFunction = false;
         };
@@ -126 +129 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->get_expr() && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // explicitly construct the return value using the return expression and the retVal object
-                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
-
-                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
-                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
-                                // return statement has already been mutated - don't need to do it again
-                                if ( varExpr->var == retVal ) return;
-                        }
-                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
+
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
 
                         // return the retVal object
-                        returnStmt->expr = new VariableExpr( returnVals.front() );
+                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
                 } // if
         }
@@ -201 +199 @@
         }
 
-        bool ManagedTypes::isManaged( Type * type ) const {
+        bool CtorDtor::isManaged( Type * type ) const {
                 // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
@@ -217 +215 @@
         }
 
-        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
+        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
@@ -225 +223 @@
         }
 
-        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
+        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
@@ -235 +233 @@
                 }
         }
-
-        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
-                // don't construct members, but need to take note if there is a managed member,
-                // because that means that this type is also managed
-                for ( Declaration * member : aggregateDecl->get_members() ) {
-                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                if ( isManaged( field ) ) {
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
-                                        break;
-                                }
-                        }
-                }
-        }
-
-        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
-        void ManagedTypes::endScope() { managedTypes.endScope(); }
 
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
@@ -296 +277 @@
 
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
-                managedTypes.handleDWT( objDecl );
+                handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
-                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
@@ -314 +295 @@
                 inFunction = true;
 
-                managedTypes.handleDWT( functionDecl );
+                handleDWT( functionDecl );
 
                 GuardScope( managedTypes );
@@ -320 +301 @@
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                managedTypes.handleDWT( assertion );
+                                handleDWT( assertion );
                         }
                 }
@@ -330 +311 @@
                 visit_children = false; // do not try to construct and destruct aggregate members
 
-                managedTypes.handleStruct( aggregateDecl );
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
+                                        break;
+                                }
+                        }
+                }
         }