Changes in src/InitTweak/GenInit.cc [ac9ca967:dcd73d1]

File:

• src/InitTweak/GenInit.cc (modified) (8 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;
@@ -136 +134 @@
 
         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
@@ -158 +156 @@
 
         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 );
@@ -237 +220 @@
         }
 
-        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;
-                        }
-                }
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
-        }
-
         bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
@@ -252 +225 @@
                         type = at->get_base();
                 }
-                return isManaged( type );
+                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end();
         }
 
@@ -315 +288 @@
                 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 );