Changeset cce9429 for src/InitTweak

Timestamp:

Dec 13, 2016, 6:42:39 PM (8 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, with_gc

Children:

1aa4b71

Parents:

31f379c

Message:

fix function return type in Validate and add single return decl, construct the return decl, fix polymorphic functions to use the return decl

File:

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

src/InitTweak/GenInit.cc

@@ -46 +46 @@
                 ReturnFixer();
 
-                using GenPoly::PolyMutator::mutate;
+                typedef GenPoly::PolyMutator Parent;
+                using Parent::mutate;
                 virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
                 virtual Statement * mutate( ReturnStmt * returnStmt ) override;
@@ -142 +143 @@
                 // hands off if the function returns an lvalue - we don't want to allocate a temporary if a variable's address
                 // is being returned
+                // Note: under the assumption that assignments return *this, checking for ?=? here is an optimization, since it shouldn't be necessary to copy construct `this`. This is a temporary optimization until reference types are added, at which point this should be removed, along with the analogous optimization in copy constructor generation.
                 if ( returnStmt->get_expr() && returnVals.size() == 1 && funcName != "?=?" && ! returnVals.front()->get_type()->get_isLvalue() ) {
-                        // ensure return value is not destructed by explicitly creating
-                        // an empty SingleInit node wherein maybeConstruct is false
-                        ObjectDecl *newObj = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, returnVals.front()->get_type()->clone(), new ListInit( std::list<Initializer*>(), noDesignators, false ) );
-                        stmtsToAdd.push_back( new DeclStmt( noLabels, newObj ) );
-
-                        // and explicitly create the constructor expression separately
+                        // explicitly construct the return value using the return expression and the retVal object
+                        assertf( returnVals.front()->get_name() != "", "Function %s has unnamed return value\n", funcName.c_str() );
                         UntypedExpr *construct = new UntypedExpr( new NameExpr( "?{}" ) );
-                        construct->get_args().push_back( new AddressExpr( new VariableExpr( newObj ) ) );
+                        construct->get_args().push_back( new AddressExpr( new VariableExpr( returnVals.front() ) ) );
                         construct->get_args().push_back( returnStmt->get_expr() );
                         stmtsToAdd.push_back(new ExprStmt(noLabels, construct));
 
-                        returnStmt->set_expr( new VariableExpr( newObj ) );
+                        // return the retVal object
+                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
                 } // if
                 return returnStmt;
@@ -160 +159 @@
 
         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::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 );
-                }
                 funcName = functionDecl->get_name();
-                DeclarationWithType * decl = Mutator::mutate( functionDecl );
-                return decl;
+                return Parent::mutate( functionDecl );
         }