Changes in src/InitTweak/FixInit.cc [888339e:698ec72]

File:

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

src/InitTweak/FixInit.cc

@@ -36 +36 @@
 #include "FixGlobalInit.h"             // for fixGlobalInit
 #include "GenInit.h"                   // for genCtorDtor
+#include "GenPoly/DeclMutator.h"       // for DeclMutator
 #include "GenPoly/GenPoly.h"           // for getFunctionType
+#include "GenPoly/PolyMutator.h"       // for PolyMutator
 #include "InitTweak.h"                 // for getFunctionName, getCallArg
 #include "Parser/LinkageSpec.h"        // for C, Spec, Cforall, isBuiltin
@@ -44 +46 @@
 #include "SymTab/Indexer.h"            // for Indexer
 #include "SymTab/Mangler.h"            // for Mangler
+#include "SynTree/AddStmtVisitor.h"    // for AddStmtVisitor
 #include "SynTree/Attribute.h"         // for Attribute
 #include "SynTree/Constant.h"          // for Constant
@@ -55 +58 @@
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution, operator<<
 #include "SynTree/Visitor.h"           // for acceptAll, maybeAccept
+#include "Tuples/Tuples.h"             // for isTtype
 
 bool ctordtorp = false; // print all debug
@@ -183 +187 @@
                 };
 
-                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
+                class FixCopyCtors final : public GenPoly::PolyMutator {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -190 +194 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
 
-                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
-                        void premutate( StmtExpr * stmtExpr );
-                        void premutate( UniqueExpr * unqExpr );
+                        typedef GenPoly::PolyMutator Parent;
+                        using Parent::mutate;
+                        virtual Expression * mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) override;
+                        virtual Expression * mutate( UniqueExpr * unqExpr ) override;
+                        virtual Expression * mutate( StmtExpr * stmtExpr ) override;
 
                         UnqCount & unqCount;
@@ -237 +243 @@
                 };
 
-                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
+                class FixCtorExprs final : public GenPoly::DeclMutator {
+                  public:
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
 
-                        Expression * postmutate( ConstructorExpr * ctorExpr );
+                        using GenPoly::DeclMutator::mutate;
+                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
                 };
         } // namespace
@@ -308 +316 @@
 
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
-                        PassVisitor<FixCopyCtors> fixer( unqCount );
+                        FixCopyCtors fixer( unqCount );
                         mutateAll( translationUnit, fixer );
                 }
@@ -318 +326 @@
 
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
-                        PassVisitor<FixCtorExprs> fixer;
-                        mutateAll( translationUnit, fixer );
+                        FixCtorExprs fixer;
+                        fixer.mutateDeclarationList( translationUnit );
                 }
 
@@ -331 +339 @@
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
-                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
+                                        assert( ftype );
                                         if ( CodeGen::isConstructor( funcDecl->get_name() ) && ftype->get_parameters().size() == 2 ) {
                                                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
@@ -360 +368 @@
                 }
 
-                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
+                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
+                }
 
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
@@ -397 +407 @@
                         result = result->clone();
                         env->apply( result );
-                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                         tmp->get_type()->set_const( false );
 
@@ -411 +421 @@
                                 if ( function->get_var()->get_linkage() == LinkageSpec::Intrinsic ) return;
                         }
-
-                        // set a unique name for the temporary once it's certain the call is necessary
-                        tmp->name = tempNamer.newName();
 
                         // replace argument to function call with temporary
@@ -443 +450 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_const( false );
                                 impCpCtorExpr->get_returnDecls().push_back( ret );
                                 CP_CTOR_PRINT( std::cerr << "makeCtorDtor for a return" << std::endl; )
                                 if ( ! dynamic_cast< ReferenceType * >( result ) ) {
-                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
                                 }
@@ -465 +472 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
@@ -502 +509 @@
                         } else {
                                 // expr isn't a call expr, so create a new temporary variable to use to hold the value of the unique expression
-                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
                         }
@@ -508 +515 @@
                 }
 
-                Expression * FixCopyCtors::postmutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                         CP_CTOR_PRINT( std::cerr << "FixCopyCtors: " << impCpCtorExpr << std::endl; )
 
+                        impCpCtorExpr = strict_dynamic_cast< ImplicitCopyCtorExpr * >( Parent::mutate( impCpCtorExpr ) );
                         std::list< ObjectDecl * > & tempDecls = impCpCtorExpr->get_tempDecls();
                         std::list< ObjectDecl * > & returnDecls = impCpCtorExpr->get_returnDecls();
@@ -517 +525 @@
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
-                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 
@@ -528 +536 @@
                         } // for
 
+                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
@@ -560 +569 @@
                 }
 
-                void FixCopyCtors::premutate( StmtExpr * stmtExpr ) {
+                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
                         // function call temporaries should be placed at statement-level, rather than nested inside of a new statement expression,
                         // since temporaries can be shared across sub-expressions, e.g.
                         //   [A, A] f();
                         //   g([A] x, [A] y);
-                        //   g(f());
+                        //   f(g());
                         // f is executed once, so the return temporary is shared across the tuple constructors for x and y.
-                        // Explicitly mutating children instead of mutating the inner compound statment forces the temporaries to be added
-                        // to the outer context, rather than inside of the statement expression.
-                        visit_children = false;
                         std::list< Statement * > & stmts = stmtExpr->get_statements()->get_kids();
                         for ( Statement *& stmt : stmts ) {
-                                stmt = stmt->acceptMutator( *visitor );
+                                stmt = stmt->acceptMutator( *this );
                         } // for
+                        // stmtExpr = strict_dynamic_cast< StmtExpr * >( Parent::mutate( stmtExpr ) );
                         assert( stmtExpr->get_result() );
                         Type * result = stmtExpr->get_result();
                         if ( ! result->isVoid() ) {
                                 for ( ObjectDecl * obj : stmtExpr->get_returnDecls() ) {
-                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
@@ -585 +592 @@
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                assert( ! stmts.empty() );
+                                CompoundStmt * body = stmtExpr->get_statements();
+                                assert( ! body->get_kids().empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
-                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
@@ -593 +601 @@
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
-                }
-
-                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
-                        visit_children = false;
+                        return stmtExpr;
+                }
+
+                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
                         unqCount[ unqExpr->get_id() ]--;
                         static std::unordered_map< int, std::list< Statement * > > dtors;
                         static std::unordered_map< int, UniqueExpr * > unqMap;
+                        static std::unordered_set< int > addDeref;
                         // has to be done to clean up ImplicitCopyCtorExpr nodes, even when this node was skipped in previous passes
                         if ( unqMap.count( unqExpr->get_id() ) ) {
@@ -610 +619 @@
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                                 }
-                                return;
-                        }
-                        PassVisitor<FixCopyCtors> fixer( unqCount );
+                                if ( addDeref.count( unqExpr->get_id() ) ) {
+                                        // other UniqueExpr was dereferenced because it was an lvalue return, so this one should be too
+                                        return UntypedExpr::createDeref( unqExpr );
+                                }
+                                return unqExpr;
+                        }
+                        FixCopyCtors fixer( unqCount );
                         unqExpr->set_expr( unqExpr->get_expr()->acceptMutator( fixer ) ); // stmtexprs contained should not be separately fixed, so this must occur after the lookup
-                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
+                        stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
                         unqMap[unqExpr->get_id()] = unqExpr;
                         if ( unqCount[ unqExpr->get_id() ] == 0 ) {  // insert destructor after the last use of the unique expression
                                 stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                         } else { // remember dtors for last instance of unique expr
-                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
-                        }
-                        return;
+                                dtors[ unqExpr->get_id() ] = fixer.stmtsToAddAfter;
+                        }
+                        if ( UntypedExpr * deref = dynamic_cast< UntypedExpr * >( unqExpr->get_expr() ) ) {
+                                // unique expression is now a dereference, because the inner expression is an lvalue returning function call.
+                                // Normalize the expression by dereferencing the unique expression, rather than the inner expression
+                                // (i.e. move the dereference out a level)
+                                assert( getFunctionName( deref ) == "*?" );
+                                unqExpr->set_expr( getCallArg( deref, 0 ) );
+                                getCallArg( deref, 0 ) = unqExpr;
+                                addDeref.insert( unqExpr->get_id() );
+                                return deref;
+                        }
+                        return unqExpr;
                 }
 
@@ -796 +819 @@
                                         assert( ! ctorInit->get_ctor() || ! ctorInit->get_init() );
                                         Statement * dtor = ctorInit->get_dtor();
-                                        // don't need to call intrinsic dtor, because it does nothing, but
-                                        // non-intrinsic dtors must be called
                                         if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
-                                                // set dtor location to the object's location for error messages
-                                                ctorInit->dtor->location = objDecl->location;
+                                                // don't need to call intrinsic dtor, because it does nothing, but
+                                                // non-intrinsic dtors must be called
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
@@ -991 +1012 @@
                                         // skip non-DWT members
                                         if ( ! field ) continue;
-                                        // skip non-constructable members
-                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
@@ -1123 +1142 @@
                 }
 
-                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
+                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
                         static UniqueName tempNamer( "_tmp_ctor_expr" );
                         // xxx - is the size check necessary?
@@ -1129 +1148 @@
 
                         // 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.
-                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
-                        declsToAddBefore.push_back( tmp );
+                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
+                        addDeclaration( tmp );
 
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
@@ -1139 +1158 @@
                         delete ctorExpr;
 
-                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
-                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
+
+                        // xxx - hack in 'fake' assignment operator until resolver can easily be called in this pass. Once the resolver can be used in PassVisitor, this hack goes away.
+
+                        // generate the type of assignment operator using the type of tmp minus any reference types
+                        Type * type = tmp->get_type()->stripReferences();
+                        FunctionType * ftype = SymTab::genAssignType( type );
+
+                        // generate fake assignment decl and call it using &tmp and &firstArg
+                        // since tmp is guaranteed to be a reference and we want to assign pointers
+                        FunctionDecl * assignDecl = new FunctionDecl( "?=?", Type::StorageClasses(), LinkageSpec::Intrinsic, ftype, nullptr );
+                        ApplicationExpr * assign = new ApplicationExpr( VariableExpr::functionPointer( assignDecl ) );
+                        assign->get_args().push_back( new AddressExpr( new VariableExpr( tmp ) ) );
+                        Expression * addrArg = new AddressExpr( firstArg );
+                        // if firstArg has type T&&, then &firstArg has type T*&.
+                        // Cast away the reference to a value type so that the argument
+                        // matches the assignment's parameter types
+                        if ( dynamic_cast<ReferenceType *>( addrArg->get_result() ) ) {
+                                addrArg = new CastExpr( addrArg, addrArg->get_result()->stripReferences()->clone() );
+                        }
+                        assign->get_args().push_back( addrArg );
                         firstArg = new VariableExpr( tmp );
-
-                        // resolve assignment and dispose of new env
-                        Expression * resolvedAssign = ResolvExpr::findVoidExpression( assign, indexer );
-                        delete resolvedAssign->env;
-                        resolvedAssign->env = nullptr;
-                        delete assign;
 
                         // for constructor expr:
@@ -1157 +1188 @@
                         //   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;