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

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 {
@@ -50 +51 @@
 
           protected:
-                std::list<DeclarationWithType*> returnVals;
+                FunctionType * ftype;
                 UniqueName tempNamer;
                 std::string funcName;
@@ -86 +87 @@
 
                 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;
@@ -136 +138 @@
 
         Statement *ReturnFixer::mutate( ReturnStmt *returnStmt ) {
-                // update for multiple return values
+                std::list< DeclarationWithType * > & returnVals = ftype->get_returnVals();
                 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
@@ -158 +160 @@
 
         DeclarationWithType* ReturnFixer::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< std::list<DeclarationWithType*> > oldReturnVals( returnVals );
+                // 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::string > oldFuncName( funcName );
 
-                FunctionType * type = functionDecl->get_functionType();
-                returnVals = type->get_returnVals();
+                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 );
+                }
                 funcName = functionDecl->get_name();
                 DeclarationWithType * decl = Mutator::mutate( functionDecl );
@@ -222 +239 @@
         }
 
+        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();
@@ -227 +255 @@
                         type = at->get_base();
                 }
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
+                return isManaged( type );
         }
 
@@ -238 +266 @@
                         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;
         }
 
@@ -250 +310 @@
                         if ( ! checkInitDepth( objDecl ) ) throw SemanticError( "Managed object's initializer is too deep ", 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() ) );
-                        }
+                        objDecl->set_init( genCtorInit( objDecl ) );
                 }
                 return Parent::mutate( objDecl );
@@ -290 +323 @@
                 managedTypes.beginScope();
                 // go through assertions and recursively add seen ctor/dtors
-                for ( TypeDecl * tyDecl : functionDecl->get_functionType()->get_forall() ) {
+                for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
                                 assertion = assertion->acceptMutator( *this );