Changeset 6840e7c for src/InitTweak/FixInit.cc

Timestamp:

Oct 19, 2017, 12:01:04 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

837ce06

Parents:

b96ec83 (diff), a15b72c (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

src/InitTweak/FixInit.cc

@@ -94 +94 @@
                         /// true if type does not need to be copy constructed to ensure correctness
                         bool skipCopyConstruct( Type * type );
-                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal );
                         void destructRet( ObjectDecl * ret, ImplicitCopyCtorExpr * impCpCtorExpr );
 
@@ -259 +259 @@
 
                 GenStructMemberCalls::generate( translationUnit );
+
                 // xxx - ctor expansion currently has to be after FixCopyCtors, because there is currently a
                 // hack in the way untyped assignments are generated, where the first argument cannot have
@@ -288 +289 @@
                         for ( std::list< Declaration * >::iterator i = translationUnit.begin(); i != translationUnit.end(); ++i ) {
                                 try {
-                                        *i = maybeMutate( *i, fixer );
+                                        maybeMutate( *i, fixer );
                                         translationUnit.splice( i, fixer.pass.staticDtorDecls );
                                 } catch( SemanticError &e ) {
@@ -322 +323 @@
 
                 Expression * InsertImplicitCalls::postmutate( ApplicationExpr * appExpr ) {
-                        assert( appExpr );
-
                         if ( VariableExpr * function = dynamic_cast< VariableExpr * > ( appExpr->get_function() ) ) {
-                                if ( LinkageSpec::isBuiltin( function->get_var()->get_linkage() ) ) {
+                                if ( function->var->linkage.is_builtin ) {
                                         // optimization: don't need to copy construct in order to call intrinsic functions
                                         return appExpr;
@@ -331 +330 @@
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
                                         assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
-                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
-                                                Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
-                                                Type * t2 = ftype->get_parameters().back()->get_type();
+                                        if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->parameters.size() == 2 ) {
+                                                Type * t1 = getPointerBase( ftype->parameters.front()->get_type() );
+                                                Type * t2 = ftype->parameters.back()->get_type();
                                                 assert( t1 );
 
@@ -366 +365 @@
                         ImplicitCtorDtorStmt * stmt = genCtorDtor( fname, var, cpArg );
                         ExprStmt * exprStmt = strict_dynamic_cast< ExprStmt * >( stmt->get_callStmt() );
-                        Expression * untyped = exprStmt->get_expr();
+                        Expression * resolved = exprStmt->expr;
+                        exprStmt->expr = nullptr; // take ownership of expr
 
                         // resolve copy constructor
                         // should only be one alternative for copy ctor and dtor expressions, since all arguments are fixed
                         // (VariableExpr and already resolved expression)
-                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << untyped << std::endl; )
-                        Expression * resolved = ResolvExpr::findVoidExpression( untyped, indexer );
+                        CP_CTOR_PRINT( std::cerr << "ResolvingCtorDtor " << resolved << std::endl; )
+                        ResolvExpr::findVoidExpression( resolved, indexer );
                         assert( resolved );
                         if ( resolved->get_env() ) {
@@ -380 +380 @@
                                 resolved->set_env( nullptr );
                         } // if
-
                         delete stmt;
                         return resolved;
                 }
 
-                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                void ResolveCopyCtors::copyConstructArg( Expression *& arg, ImplicitCopyCtorExpr * impCpCtorExpr, Type * formal ) {
                         static UniqueName tempNamer("_tmp_cp");
                         assert( env );
                         CP_CTOR_PRINT( std::cerr << "Type Substitution: " << *env << std::endl; )
-                        assert( arg->has_result() );
-                        Type * result = arg->get_result();
+                        assert( arg->result );
+                        Type * result = arg->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
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
                         result = result->clone();
-                        env->apply( result );
+                        env->applyFree( result );
                         ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
@@ -406 +406 @@
                                 // 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;
+                                VariableExpr * function = strict_dynamic_cast< VariableExpr * >( appExpr->function );
+                                if ( function->var->linkage == LinkageSpec::Intrinsic ) {
+                                        // arguments that need to be boxed need a temporary regardless of whether the copy constructor is intrinsic,
+                                        // so that the object isn't changed inside of the polymorphic function
+                                        if ( ! GenPoly::needsBoxing( formal, result, impCpCtorExpr->callExpr, env ) ) return;
+                                }
                         }
 
@@ -416 +419 @@
                         // 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 ) );
+                        impCpCtorExpr->tempDecls.push_back( tmp );
+                        impCpCtorExpr->dtors.push_front( makeCtorDtor( "^?{}", tmp ) );
                 }
 
@@ -427 +430 @@
                         CP_CTOR_PRINT( std::cerr << "ResolveCopyCtors: " << impCpCtorExpr << std::endl; )
 
-                        ApplicationExpr * appExpr = impCpCtorExpr->get_callExpr();
+                        ApplicationExpr * appExpr = impCpCtorExpr->callExpr;
 
                         // take each argument and attempt to copy construct it.
-                        for ( Expression * & arg : appExpr->get_args() ) {
-                                copyConstructArg( arg, impCpCtorExpr );
+                        FunctionType * ftype = GenPoly::getFunctionType( appExpr->function->result );
+                        assert( ftype );
+                        auto & params = ftype->parameters;
+                        auto iter = params.begin();
+                        for ( Expression * & arg : appExpr->args ) {
+                                Type * formal = nullptr;
+                                if ( iter != params.end() ) {
+                                        DeclarationWithType * param = *iter++;
+                                        formal = param->get_type();
+                                }
+
+                                copyConstructArg( arg, impCpCtorExpr, formal );
                         } // for
 
@@ -437 +450 @@
                         // initialized with the return value and is destructed later
                         // xxx - handle named return values?
-                        Type * result = appExpr->get_result();
+                        Type * result = appExpr->result;
                         if ( ! result->isVoid() ) {
                                 static UniqueName retNamer("_tmp_cp_ret");
@@ -443 +456 @@
                                 env->apply( result );
                                 ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
-                                ret->get_type()->set_const( false );
-                                impCpCtorExpr->get_returnDecls().push_back( ret );
+                                ret->type->set_const( false );
+                                impCpCtorExpr->returnDecls.push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
@@ -551 +564 @@
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
-                                retExpr->set_env( callExpr->get_env() );
-                                callExpr->set_env( nullptr );
+                                std::swap( retExpr->env, callExpr->env );
                                 return retExpr;
                         } else {
@@ -754 +766 @@
                                                 if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->init = new SingleInit( ctorCall->args.back() );
+                                                        Expression * ctorArg = ctorCall->args.back();
+                                                        std::swap( ctorArg->env, ctorCall->env );
+                                                        objDecl->init = new SingleInit( ctorArg );
+
                                                         ctorCall->args.pop_back();
                                                 } else {
@@ -822 +837 @@
                         GuardValue( labelVars );
                         labelVars.clear();
+                        // LabelFinder does not recurse into FunctionDecl, so need to visit
+                        // its children manually.
                         maybeAccept( funcDecl->type, finder );
                         maybeAccept( funcDecl->statements, finder );
@@ -1079 +1096 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl *objectDecl ) {
+                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
                         // add object to the indexer assumes that there will be no name collisions
                         // in generated code. If this changes, add mutate methods for entities with
@@ -1087 +1104 @@
                 }
 
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
                 }
 
@@ -1094 +1113 @@
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
-                        assert( ctorExpr->has_result() && ctorExpr->get_result()->size() == 1 );
+                        assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
                         // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
@@ -1113 +1132 @@
 
                         // resolve assignment and dispose of new env
-                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
-                        delete resolvedAssign->env;
-                        resolvedAssign->env = nullptr;
-                        delete assign;
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
 
                         // for constructor expr:
@@ -1125 +1143 @@
                         //   T & tmp;
                         //   &tmp = &x, ?{}(tmp), tmp
-                        CommaExpr * commaExpr = new CommaExpr( resolvedAssign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
+                        CommaExpr * commaExpr = new CommaExpr( assign, new CommaExpr( callExpr, new VariableExpr( tmp ) ) );
                         commaExpr->set_env( env );
                         return commaExpr;