Changes in src/InitTweak/FixInit.cc [65660bd:b6fe7e6]

File:

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

src/InitTweak/FixInit.cc

@@ -69 +69 @@
 
                         /// create and resolve ctor/dtor expression: fname(var, [cpArg])
-                        Expression * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
-                        Expression * makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg = NULL );
+                        ApplicationExpr * makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg = NULL );
                         /// true if type does not need to be copy constructed to ensure correctness
-                        bool skipCopyConstruct( Type * type );
-                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        bool skipCopyConstruct( Type * );
                 private:
                         TypeSubstitution * env;
@@ -360 +357 @@
                 }
 
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
+                ApplicationExpr * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
                         assert( var );
-                        return makeCtorDtor( fname, new AddressExpr( new VariableExpr( var ) ), cpArg );
-                }
-
-                Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, Expression * thisArg, Expression * cpArg ) {
-                        assert( thisArg );
                         UntypedExpr * untyped = new UntypedExpr( new NameExpr( fname ) );
-                        untyped->get_args().push_back( thisArg );
+                        untyped->get_args().push_back( new AddressExpr( new VariableExpr( var ) ) );
                         if (cpArg) untyped->get_args().push_back( cpArg->clone() );
 
@@ -375 +367 @@
                         // (VariableExpr and already resolved expression)
                         CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, *this );
-                        assert( resolved );
+                        ApplicationExpr * resolved = dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untyped, *this ) );
                         if ( resolved->get_env() ) {
                                 env->add( *resolved->get_env() );
                         } // if
 
+                        assert( resolved );
                         delete untyped;
                         return resolved;
                 }
 
-                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
                         static UniqueName tempNamer("_tmp_cp");
-                        CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
-                        assert( arg->has_result() );
-                        Type * result = arg->get_result();
-                        if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
-
-                        // type may involve type variables, so apply type substitution to get temporary variable's actual type
-                        result = result->clone();
-                        impCpCtorExpr->get_env()->apply( result );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
-                        tmp->get_type()->set_isConst( false );
-
-                        // create and resolve copy constructor
-                        CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
-                        Expression * cpCtor = makeCtorDtor( "?{}", tmp, arg );
-
-                        if ( ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( cpCtor ) ) {
-                                // if the chosen constructor is intrinsic, the copy is unnecessary, so
-                                // don't create the temporary and don't call the copy constructor
-                                VariableExpr * function = dynamic_cast< VariableExpr * >( appExpr->get_function() );
-                                assert( function );
-                                if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
-                        }
-
-                        // replace argument to function call with temporary
-                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
-                        impCpCtorExpr->get_tempDecls().push_back( tmp );
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
-                }
-
-                void ResolveCopyCtors::destructRet( Expression * ret, ImplicitCopyCtorExpr * impCpCtorExpr ) {
-                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", new AddressExpr( ret ) ) );
-                }
-
-                void ResolveCopyCtors::visit( ImplicitCopyCtorExpr *impCpCtorExpr ) {
+                        static UniqueName retNamer("_tmp_cp_ret");
+
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
                         Visitor::visit( impCpCtorExpr );
@@ -429 +389 @@
                         // take each argument and attempt to copy construct it.
                         for ( Expression * & arg : appExpr->get_args() ) {
-                                copyConstructArg( arg, impCpCtorExpr );
+                                CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *impCpCtorExpr->get_env() << std::endl; )
+                                // xxx - need to handle tuple arguments
+                                assert( ! arg->get_results().empty() );
+                                Type * result = arg->get_results().front();
+                                if ( skipCopyConstruct( result ) ) continue; // skip certain non-copyable types
+                                // type may involve type variables, so apply type substitution to get temporary variable's actual type
+                                result = result->clone();
+                                impCpCtorExpr->get_env()->apply( result );
+                                ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, 0, result, 0 );
+                                tmp->get_type()->set_isConst( false );
+
+                                // create and resolve copy constructor
+                                CP_CTOR_PRINT( std::cerr << "makeCtorDtor for an argument" << std::endl; )
+                                ApplicationExpr * cpCtor = makeCtorDtor( "?{}", tmp, arg );
+
+                                // if the chosen constructor is intrinsic, the copy is unnecessary, so
+                                // don't create the temporary and don't call the copy constructor
+                                VariableExpr * function = dynamic_cast< VariableExpr * >( cpCtor->get_function() );
+                                assert( function );
+                                if ( function->get_var()->get_linkage() != LinkageSpec::Intrinsic ) {
+                                        // replace argument to function call with temporary
+                                        arg = new CommaExpr( cpCtor, new VariableExpr( tmp ) );
+                                        impCpCtorExpr->get_tempDecls().push_back( tmp );
+                                        impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", tmp ) );
+                                } // if
                         } // for
 
@@ -439 +423 @@
                         // level. Trying to pass that environment along.
                         callExpr->set_env( impCpCtorExpr->get_env()->clone() );
-                        Type * result = appExpr->get_result();
-                        if ( ! result->isVoid() ) {
-                                static UniqueName retNamer("_tmp_cp_ret");
+                        for ( Type * result : appExpr->get_results() ) {
                                 result = result->clone();
                                 impCpCtorExpr->get_env()->apply( result );
@@ -448 +430 @@
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
-                                destructRet( new VariableExpr( ret ) , impCpCtorExpr );
+                                impCpCtorExpr->get_dtors().push_front( makeCtorDtor( "^?{}", ret ) );
                         } // for
                         CP_CTOR_PRINT( std::cerr << "after Resolving: " << impCpCtorExpr << std::endl; )
@@ -497 +479 @@
                                 // know the result type of the assignment is the type of the LHS (minus the pointer), so
                                 // add that onto the assignment expression so that later steps have the necessary information
-                                assign->set_result( returnDecl->get_type()->clone() );
+                                assign->add_result( returnDecl->get_type()->clone() );
 
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
-                                if ( callExpr->get_result()->get_isLvalue() ) {
+                                if ( callExpr->get_results().front()->get_isLvalue() ) {
                                         // lvalue returning functions are funny. Lvalue.cc inserts a *? in front of any lvalue returning
                                         // non-intrinsic function. Add an AddressExpr to the call to negate the derefence and change the
@@ -518 +500 @@
                                         UntypedExpr * deref = new UntypedExpr( new NameExpr( "*?" ) );
                                         deref->get_args().push_back( retExpr );
-                                        deref->set_result( resultType );
+                                        deref->add_result( resultType );
                                         retExpr = deref;
                                 } // if
@@ -957 +939 @@
                 Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
-                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        assert( ctorExpr->get_results().size() == 1 );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), DeclarationNode::NoStorageClass, LinkageSpec::C, nullptr, ctorExpr->get_results().front()->clone(), nullptr );
                         addDeclaration( tmp );
 
@@ -970 +952 @@
                         assign->get_args().push_back( new VariableExpr( tmp ) );
                         assign->get_args().push_back( firstArg );
-                        assign->set_result( ctorExpr->get_result()->clone() );
+                        cloneAll( ctorExpr->get_results(), assign->get_results() );
                         firstArg = assign;