Changes in src/InitTweak/GenInit.cc [30b65d8:62e5546]

File:

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

src/InitTweak/GenInit.cc

@@ -29 +29 @@
 #include "GenPoly/DeclMutator.h"
 #include "GenPoly/ScopedSet.h"
-#include "ResolvExpr/typeops.h"
 
 namespace InitTweak {
@@ -51 +50 @@
 
           protected:
-                FunctionType * ftype;
+                std::list<DeclarationWithType*> returnVals;
                 UniqueName tempNamer;
                 std::string funcName;
@@ -87 +86 @@
 
                 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;
@@ -138 +136 @@
 
         Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
-                std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
+                // update for multiple return values
                 assert( returnVals.size() == 0 || returnVals.size() == 1 );
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
@@ -160 +158 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                // xxx - need to handle named return values - this pass may need to happen
-                // after resolution? the ordering is tricky because return statements must be
-                // constructed - the simplest way to do that (while also handling multiple
-                // returns) is to structure the returnVals into a tuple, as done here.
-                // however, if the tuple return value is structured before resolution,
-                // it's difficult to resolve named return values, since the name is lost
-                // in conversion to a tuple. this might be easiest to deal with
-                // after reference types are added, as it may then be possible to
-                // uniformly move named return values to the parameter list directly
-                ValueGuard< FunctionType * > oldFtype( ftype );
+                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
                 ValueGuard< std::string > oldFuncName( funcName );
 
-                ftype = functionDecl->get_functionType();
-                std::list< DeclarationWithType * > & retVals = ftype->get_returnVals();
-                if ( retVals.size() > 1 ) {
-                        TupleType * tupleType = safe_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
-                        ObjectDecl * newRet = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
-                        retVals.clear();
-                        retVals.push_back( newRet );
-                }
+                FunctionType * type = functionDecl->get_functionType();
+                returnVals = type->get_returnVals();
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
@@ -239 +222 @@
         }
 
-        bool CtorDtor::isManaged( Type * type ) const {
-                if ( TupleType * tupleType = dynamic_cast< TupleType * > ( type ) ) {
-                        // tuple is also managed if any of its components are managed
-                        if ( std::any_of( tupleType->get_types().begin(), tupleType->get_types().end(), [&](Type * type) { return isManaged( type ); }) ) {
-                                return true;
-                        }
-                }
-                // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
-        }
-
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
@@ -255 +227 @@
                         type = at->get_base();
                 }
-                return isManaged( type );
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
         }
 
@@ -266 +238 @@
                         managedTypes.insert( SymTab::Mangler::mangle( type->get_base() ) );
                 }
-        }
-
-        ConstructorInit * genCtorInit( ObjectDecl * 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() ) );
-                        return new ConstructorInit( ctor.front(), dtor.front(), objDecl->get_init() );
-                }
-                return nullptr;
         }
 
@@ -310 +250 @@
                         if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", objDecl );
 
-                        objDecl->set_init( genCtorInit( 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() ) );
+                        }
                 }
                 return Parent::mutate( objDecl );
@@ -323 +290 @@
                 managedTypes.beginScope();
                 // go through assertions and recursively add seen ctor/dtors
-                for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 assertion = assertion->acceptMutator( *this );