Changeset 3f7e12cb for src/InitTweak

Timestamp:

Nov 8, 2017, 5:43:33 PM (8 years ago)

Author:

Aaron Moss <a3moss@…>

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, stuck-waitfor-destruct, with_gc

Children:

954908d

Parents:

78315272 (diff), e35f30a (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/InitTweak

Files:

• FixInit.cc (modified) (38 diffs)
• GenInit.cc (modified) (19 diffs)
• GenInit.h (modified) (2 diffs)
• InitTweak.cc (modified) (14 diffs)
• InitTweak.h (modified) (2 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
@@ -46 +44 @@
 #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
@@ -58 +55 @@
 #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
@@ -97 +93 @@
                         /// 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 );
 
@@ -187 +183 @@
                 };
 
-                class FixCopyCtors final : public GenPoly::PolyMutator {
+                class FixCopyCtors final : public WithStmtsToAdd, public WithShortCircuiting, public WithVisitorRef<FixCopyCtors> {
                   public:
                         FixCopyCtors( UnqCount & unqCount ) : unqCount( unqCount ){}
@@ -194 +190 @@
                         static void fixCopyCtors( std::list< Declaration * > &translationUnit, UnqCount & unqCount );
 
-                        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;
+                        Expression * postmutate( ImplicitCopyCtorExpr * impCpCtorExpr );
+                        void premutate( StmtExpr * stmtExpr );
+                        void premutate( UniqueExpr * unqExpr );
 
                         UnqCount & unqCount;
@@ -220 +214 @@
                         void emit( CodeLocation, const Params &... params );
 
-                        FunctionDecl * function = 0;
+                        FunctionDecl * function = nullptr;
                         std::set< DeclarationWithType * > unhandled;
                         std::map< DeclarationWithType *, CodeLocation > usedUninit;
-                        ObjectDecl * thisParam = 0;
+                        ObjectDecl * thisParam = nullptr;
                         bool isCtor = false; // true if current function is a constructor
-                        StructDecl * structDecl = 0;
+                        StructDecl * structDecl = nullptr;
                 };
 
@@ -243 +237 @@
                 };
 
-                class FixCtorExprs final : public GenPoly::DeclMutator {
-                  public:
+                struct FixCtorExprs final : public WithDeclsToAdd, public WithIndexer {
                         /// expands ConstructorExpr nodes into comma expressions, using a temporary for the first argument
                         static void fix( std::list< Declaration * > & translationUnit );
 
-                        using GenPoly::DeclMutator::mutate;
-                        virtual Expression * mutate( ConstructorExpr * ctorExpr ) override;
+                        Expression * postmutate( ConstructorExpr * ctorExpr );
                 };
         } // namespace
@@ -268 +260 @@
 
                 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
@@ -297 +290 @@
                         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 ) {
@@ -316 +309 @@
 
                 void FixCopyCtors::fixCopyCtors( std::list< Declaration * > & translationUnit, UnqCount & unqCount ) {
-                        FixCopyCtors fixer( unqCount );
+                        PassVisitor<FixCopyCtors> fixer( unqCount );
                         mutateAll( translationUnit, fixer );
                 }
@@ -326 +319 @@
 
                 void FixCtorExprs::fix( std::list< Declaration * > & translationUnit ) {
-                        FixCtorExprs fixer;
-                        fixer.mutateDeclarationList( translationUnit );
+                        PassVisitor<FixCtorExprs> fixer;
+                        mutateAll( translationUnit, fixer );
                 }
 
                 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;
                                 } else if ( DeclarationWithType * funcDecl = dynamic_cast< DeclarationWithType * > ( function->get_var() ) ) {
                                         FunctionType * ftype = dynamic_cast< FunctionType * >( GenPoly::getFunctionType( funcDecl->get_type() ) );
-                                        assert( ftype );
-                                        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();
+                                        assertf( ftype, "Function call without function type: %s", toString( funcDecl ).c_str() );
+                                        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 );
 
@@ -368 +359 @@
                 }
 
-                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) {
-                        return dynamic_cast< VarArgsType * >( type ) || dynamic_cast< ReferenceType * >( type ) || GenPoly::getFunctionType( type ) || Tuples::isTtype( type );
-                }
+                bool ResolveCopyCtors::skipCopyConstruct( Type * type ) { return ! isConstructable( type ); }
 
                 Expression * ResolveCopyCtors::makeCtorDtor( const std::string & fname, ObjectDecl * var, Expression * cpArg ) {
@@ -377 +366 @@
                         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() ) {
@@ -391 +381 @@
                                 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 );
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                        env->applyFree( result );
+                        ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
                         tmp->get_type()->set_const( false );
 
@@ -417 +407 @@
                                 // 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;
+                                }
+                        }
+
+                        // 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
                         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 ) );
                 }
 
@@ -435 +431 @@
                         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
 
@@ -445 +451 @@
                         // 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");
                                 result = result->clone();
                                 env->apply( result );
-                                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 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
+                                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 ) ) {
-                                        // destructing lvalue returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
+                                        // destructing reference returns is bad because it can cause multiple destructor calls to the same object - the returned object is not a temporary
                                         destructRet( ret, impCpCtorExpr );
                                 }
@@ -472 +478 @@
                                 result = result->clone();
                                 env->apply( result );
-                                ObjectDecl * ret = new ObjectDecl( retNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0, result, 0 );
+                                ObjectDecl * ret = ObjectDecl::newObject( retNamer.newName(), result, nullptr );
                                 ret->get_type()->set_const( false );
                                 stmtExpr->get_returnDecls().push_front( ret );
@@ -493 +499 @@
                                 visit_children = false;
                         }
+                }
+
+                // to prevent warnings (‘_unq0’ may be used uninitialized in this function),
+                // insert an appropriate zero initializer for UniqueExpr temporaries.
+                Initializer * makeInit( Type * t ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( t ) ) {
+                                // initizer for empty struct must be empty
+                                if ( inst->baseStruct->members.empty() ) return new ListInit({});
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( t ) ) {
+                                // initizer for empty union must be empty
+                                if ( inst->baseUnion->members.empty() ) return new ListInit({});
+                        }
+
+                        return new ListInit( { new SingleInit( new ConstantExpr( Constant::from_int( 0 ) ) ) } );
                 }
 
@@ -509 +529 @@
                         } 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( new ObjectDecl( toString("_unq", unqExpr->get_id()), Type::StorageClasses(), LinkageSpec::C, nullptr, unqExpr->get_result()->clone(), nullptr ) );
+                                unqExpr->set_object( ObjectDecl::newObject( toString("_unq", unqExpr->get_id()), unqExpr->get_result()->clone(), makeInit( unqExpr->get_result() ) ) );
                                 unqExpr->set_var( new VariableExpr( unqExpr->get_object() ) );
                         }
@@ -515 +535 @@
                 }
 
-                Expression * FixCopyCtors::mutate( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+                Expression * FixCopyCtors::postmutate( 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();
@@ -525 +544 @@
                         // add all temporary declarations and their constructors
                         for ( ObjectDecl * obj : tempDecls ) {
-                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
                         for ( ObjectDecl * obj : returnDecls ) {
-                                stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                         } // for
 
@@ -536 +555 @@
                         } // for
 
-                        // xxx - update to work with multiple return values
                         ObjectDecl * returnDecl = returnDecls.empty() ? nullptr : returnDecls.front();
                         Expression * callExpr = impCpCtorExpr->get_callExpr();
@@ -561 +579 @@
                                 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 {
@@ -569 +586 @@
                 }
 
-                Expression * FixCopyCtors::mutate( StmtExpr * stmtExpr ) {
+                void FixCopyCtors::premutate( 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);
-                        //   f(g());
+                        //   g(f());
                         // 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( *this );
+                                stmt = stmt->acceptMutator( *visitor );
                         } // 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() ) {
-                                        stmtsToAdd.push_back( new DeclStmt( noLabels, obj ) );
+                                        stmtsToAddBefore.push_back( new DeclStmt( noLabels, obj ) );
                                 } // for
                                 // add destructors after current statement
@@ -592 +611 @@
                                 } // for
                                 // must have a non-empty body, otherwise it wouldn't have a result
-                                CompoundStmt * body = stmtExpr->get_statements();
-                                assert( ! body->get_kids().empty() );
+                                assert( ! stmts.empty() );
                                 assert( ! stmtExpr->get_returnDecls().empty() );
-                                body->get_kids().push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
+                                stmts.push_back( new ExprStmt( noLabels, new VariableExpr( stmtExpr->get_returnDecls().front() ) ) );
                                 stmtExpr->get_returnDecls().clear();
                                 stmtExpr->get_dtors().clear();
@@ -601 +619 @@
                         assert( stmtExpr->get_returnDecls().empty() );
                         assert( stmtExpr->get_dtors().empty() );
-                        return stmtExpr;
-                }
-
-                Expression * FixCopyCtors::mutate( UniqueExpr * unqExpr ) {
+                }
+
+                void FixCopyCtors::premutate( UniqueExpr * unqExpr ) {
+                        visit_children = false;
                         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() ) ) {
@@ -619 +636 @@
                                         stmtsToAddAfter.splice( stmtsToAddAfter.end(), dtors[ unqExpr->get_id() ] );
                                 }
-                                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 );
+                                return;
+                        }
+                        PassVisitor<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
-                        stmtsToAdd.splice( stmtsToAdd.end(), fixer.stmtsToAdd );
+                        stmtsToAddBefore.splice( stmtsToAddBefore.end(), fixer.pass.stmtsToAddBefore );
                         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.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;
-                }
-
-                DeclarationWithType *FixInit::postmutate( ObjectDecl *objDecl ) {
+                                dtors[ unqExpr->get_id() ] = fixer.pass.stmtsToAddAfter;
+                        }
+                        return;
+                }
+
+                DeclarationWithType * FixInit::postmutate( ObjectDecl *objDecl ) {
                         // since this removes the init field from objDecl, it must occur after children are mutated (i.e. postmutate)
                         if ( ConstructorInit * ctorInit = dynamic_cast< ConstructorInit * >( objDecl->get_init() ) ) {
@@ -745 +748 @@
                                         } else {
                                                 ImplicitCtorDtorStmt * implicit = strict_dynamic_cast< ImplicitCtorDtorStmt * > ( ctor );
-                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->get_callStmt() );
+                                                ExprStmt * ctorStmt = dynamic_cast< ExprStmt * >( implicit->callStmt );
                                                 ApplicationExpr * ctorCall = nullptr;
-                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->get_expr() )) && ctorCall->get_args().size() == 2 ) {
+                                                if ( ctorStmt && (ctorCall = isIntrinsicCallExpr( ctorStmt->expr )) && ctorCall->get_args().size() == 2 ) {
                                                         // clean up intrinsic copy constructor calls by making them into SingleInits
-                                                        objDecl->set_init( new SingleInit( ctorCall->get_args().back() ) );
-                                                        ctorCall->get_args().pop_back();
+                                                        Expression * ctorArg = ctorCall->args.back();
+                                                        std::swap( ctorArg->env, ctorCall->env );
+                                                        objDecl->init = new SingleInit( ctorArg );
+
+                                                        ctorCall->args.pop_back();
                                                 } else {
                                                         stmtsToAddAfter.push_back( ctor );
-                                                        objDecl->set_init( nullptr );
-                                                        ctorInit->set_ctor( nullptr );
+                                                        objDecl->init = nullptr;
+                                                        ctorInit->ctor = nullptr;
                                                 }
                                         } // if
-                                } else if ( Initializer * init = ctorInit->get_init() ) {
-                                        objDecl->set_init( init );
-                                        ctorInit->set_init( nullptr );
+                                } else if ( Initializer * init = ctorInit->init ) {
+                                        objDecl->init = init;
+                                        ctorInit->init = nullptr;
                                 } else {
                                         // no constructor and no initializer, which is okay
-                                        objDecl->set_init( nullptr );
+                                        objDecl->init = nullptr;
                                 } // if
                                 delete ctorInit;
@@ -819 +825 @@
                                         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 ) ) {
-                                                // don't need to call intrinsic dtor, because it does nothing, but
-                                                // non-intrinsic dtors must be called
+                                                // set dtor location to the object's location for error messages
+                                                ctorInit->dtor->location = objDecl->location;
                                                 reverseDeclOrder.front().push_front( objDecl );
                                         } // if
@@ -832 +840 @@
                         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 );
@@ -933 +943 @@
                 }
 
+                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
+                        for ( auto d : decls ) {
+                                indexer.addId( d );
+                        }
+                }
+
+                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
+                        for ( auto td : tds ) {
+                                indexer.addType( td );
+                                addIds( indexer, td->assertions );
+                        }
+                }
+
                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
-                        GuardValue( funcDecl );
+                        GuardValue( function );
                         GuardValue( unhandled );
                         GuardValue( usedUninit );
@@ -967 +990 @@
                 }
 
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
                 void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
@@ -1012 +1022 @@
                                         // skip non-DWT members
                                         if ( ! field ) continue;
+                                        // skip non-constructable members
+                                        if ( ! tryConstruct( field ) ) continue;
                                         // skip handled members
                                         if ( ! unhandled.count( field ) ) continue;
@@ -1130 +1142 @@
                 }
 
-                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
@@ -1138 +1150 @@
                 }
 
-                Expression* MutatingResolver::mutate( UntypedExpr *untypedExpr ) {
-                        return strict_dynamic_cast< ApplicationExpr * >( ResolvExpr::findVoidExpression( untypedExpr, indexer ) );
-                }
-
-                Expression * FixCtorExprs::mutate( ConstructorExpr * ctorExpr ) {
+                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                        Expression * newExpr = untypedExpr;
+                        ResolvExpr::findVoidExpression( newExpr, indexer );
+                        return newExpr;
+                }
+
+                Expression * FixCtorExprs::postmutate( ConstructorExpr * ctorExpr ) {
                         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.
-                        ObjectDecl * tmp = new ObjectDecl( tempNamer.newName(), Type::StorageClasses(), LinkageSpec::C, nullptr, ctorExpr->get_result()->clone(), nullptr );
-                        addDeclaration( tmp );
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
 
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
@@ -1158 +1172 @@
                         delete ctorExpr;
 
+                        // build assignment and replace constructor's first argument with new temporary
                         Expression *& firstArg = callExpr->get_args().front();
-
-                        // 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 );
+                        Expression * assign = new UntypedExpr( new NameExpr( "?=?" ), { new AddressExpr( new VariableExpr( tmp ) ), new AddressExpr( firstArg ) } );
                         firstArg = new VariableExpr( tmp );
+
+                        // resolve assignment and dispose of new env
+                        ResolvExpr::findVoidExpression( assign, indexer );
+                        delete assign->env;
+                        assign->env = nullptr;
 
                         // for constructor expr:

src/InitTweak/GenInit.cc

@@ -26 +26 @@
 #include "Common/UniqueName.h"     // for UniqueName
 #include "Common/utility.h"        // for ValueGuard, maybeClone
-#include "GenPoly/DeclMutator.h"   // for DeclMutator
 #include "GenPoly/GenPoly.h"       // for getFunctionType, isPolyType
 #include "GenPoly/ScopedSet.h"     // for ScopedSet, ScopedSet<>::const_iter...
@@ -62 +61 @@
         };
 
-        struct CtorDtor : public WithGuards, public WithShortCircuiting  {
+        struct CtorDtor : public WithGuards, public WithShortCircuiting, public WithVisitorRef<CtorDtor>  {
                 /// create constructor and destructor statements for object declarations.
                 /// the actual call statements will be added in after the resolver has run
@@ -75 +74 @@
                 // that need to be constructed or destructed
                 void previsit( StructDecl *aggregateDecl );
-                void previsit( __attribute__((unused)) UnionDecl    * aggregateDecl ) { visit_children = false; }
-                void previsit( __attribute__((unused)) EnumDecl     * aggregateDecl ) { visit_children = false; }
-                void previsit( __attribute__((unused)) TraitDecl    * aggregateDecl ) { visit_children = false; }
-                void previsit( __attribute__((unused)) TypeDecl     * typeDecl )      { visit_children = false; }
-                void previsit( __attribute__((unused)) TypedefDecl  * typeDecl )      { visit_children = false; }
-                void previsit( __attribute__((unused)) FunctionType * funcType )      { visit_children = false; }
+                void previsit( AggregateDecl * ) { visit_children = false; }
+                void previsit( NamedTypeDecl * ) { visit_children = false; }
+                void previsit( FunctionType * ) { visit_children = false; }
 
                 void previsit( CompoundStmt * compoundStmt );
@@ -89 +85 @@
                 // should not have a ConstructorInit generated.
 
-                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;
+                ManagedTypes managedTypes;
                 bool inFunction = false;
         };
 
-        class HoistArrayDimension final : public GenPoly::DeclMutator {
-          public:
-                typedef GenPoly::DeclMutator Parent;
-
+        struct HoistArrayDimension final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
                 /// hoist dimension from array types in object declaration so that it uses a single
                 /// const variable of type size_t, so that side effecting array dimensions are only
@@ -105 +95 @@
                 static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
 
-          private:
-                using Parent::mutate;
-
-                virtual DeclarationWithType * mutate( ObjectDecl * objectDecl ) override;
-                virtual DeclarationWithType * mutate( FunctionDecl *functionDecl ) override;
+                void premutate( ObjectDecl * objectDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+                void premutate( FunctionDecl *functionDecl );
                 // should not traverse into any of these declarations to find objects
                 // that need to be constructed or destructed
-                virtual Declaration* mutate( StructDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual Declaration* mutate( UnionDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual Declaration* mutate( EnumDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual Declaration* mutate( TraitDecl *aggregateDecl ) override { return aggregateDecl; }
-                virtual TypeDecl* mutate( TypeDecl *typeDecl ) override { return typeDecl; }
-                virtual Declaration* mutate( TypedefDecl *typeDecl ) override { return typeDecl; }
-
-                virtual Type* mutate( FunctionType *funcType ) override { return funcType; }
+                void premutate( AggregateDecl * ) { visit_children = false; }
+                void premutate( NamedTypeDecl * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
 
                 void hoist( Type * type );
@@ -128 +111 @@
 
         void genInit( std::list< Declaration * > & translationUnit ) {
-                ReturnFixer::makeReturnTemp( translationUnit );
+                fixReturnStatements( translationUnit );
                 HoistArrayDimension::hoistArrayDimension( translationUnit );
                 CtorDtor::generateCtorDtor( translationUnit );
         }
 
-        void ReturnFixer::makeReturnTemp( std::list< Declaration * > & translationUnit ) {
+        void fixReturnStatements( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ReturnFixer> fixer;
                 mutateAll( translationUnit, fixer );
@@ -143 +126 @@
                 // hands off if the function returns a reference - we don't want to allocate a temporary if a variable's address
                 // is being returned
-                if ( returnStmt->get_expr() && returnVals.size() == 1 && ! dynamic_cast< ReferenceType * >( returnVals.front()->get_type() ) ) {
+                if ( returnStmt->expr && returnVals.size() == 1 && isConstructable( returnVals.front()->get_type() ) ) {
                         // 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() );
-
-                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", dynamic_cast< ObjectDecl *>( returnVals.front() ), returnStmt->get_expr() ) );
+                        assertf( returnVals.front()->name != "", "Function %s has unnamed return value\n", funcName.c_str() );
+
+                        ObjectDecl * retVal = strict_dynamic_cast< ObjectDecl * >( returnVals.front() );
+                        if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( returnStmt->expr ) ) {
+                                // return statement has already been mutated - don't need to do it again
+                                if ( varExpr->var == retVal ) return;
+                        }
+                        stmtsToAddBefore.push_back( genCtorDtor( "?{}", retVal, returnStmt->get_expr() ) );
 
                         // return the retVal object
-                        returnStmt->set_expr( new VariableExpr( returnVals.front() ) );
+                        returnStmt->expr = new VariableExpr( returnVals.front() );
                 } // if
         }
@@ -158 +146 @@
                 GuardValue( funcName );
 
-                ftype = functionDecl->get_functionType();
-                funcName = functionDecl->get_name();
+                ftype = functionDecl->type;
+                funcName = functionDecl->name;
         }
 
@@ -165 +153 @@
         // which would be incorrect if it is a side-effecting computation.
         void HoistArrayDimension::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
-                HoistArrayDimension hoister;
-                hoister.mutateDeclarationList( translationUnit );
-        }
-
-        DeclarationWithType * HoistArrayDimension::mutate( ObjectDecl * objectDecl ) {
+                PassVisitor<HoistArrayDimension> hoister;
+                mutateAll( translationUnit, hoister );
+        }
+
+        void HoistArrayDimension::premutate( ObjectDecl * objectDecl ) {
+                GuardValue( storageClasses );
                 storageClasses = objectDecl->get_storageClasses();
-                DeclarationWithType * temp = Parent::mutate( objectDecl );
+        }
+
+        DeclarationWithType * HoistArrayDimension::postmutate( ObjectDecl * objectDecl ) {
                 hoist( objectDecl->get_type() );
-                return temp;
+                return objectDecl;
         }
 
@@ -194 +185 @@
 
                         arrayType->set_dimension( new VariableExpr( arrayDimension ) );
-                        addDeclaration( arrayDimension );
+                        declsToAddBefore.push_back( arrayDimension );
 
                         hoist( arrayType->get_base() );
@@ -201 +192 @@
         }
 
-        DeclarationWithType * HoistArrayDimension::mutate( FunctionDecl *functionDecl ) {
-                ValueGuard< bool > oldInFunc( inFunction );
-                inFunction = true;
-                DeclarationWithType * decl = Parent::mutate( functionDecl );
-                return decl;
+        void HoistArrayDimension::premutate( FunctionDecl * ) {
+                GuardValue( inFunction );
         }
 
@@ -213 +201 @@
         }
 
-        bool CtorDtor::isManaged( Type * type ) const {
-                // at least for now, references are never constructed
+        bool ManagedTypes::isManaged( Type * type ) const {
+                // references are never constructed
                 if ( dynamic_cast< ReferenceType * >( type ) ) return false;
                 // need to clear and reset qualifiers when determining if a type is managed
@@ -221 +209 @@
                 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 ); }) ) {
+                        if ( std::any_of( tupleType->types.begin(), tupleType->types.end(), [&](Type * type) { return isManaged( type ); }) ) {
                                 return true;
                         }
                 }
                 // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
-                return managedTypes.find( SymTab::Mangler::mangle( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
-        }
-
-        bool CtorDtor::isManaged( ObjectDecl * objDecl ) const {
+                return managedTypes.find( SymTab::Mangler::mangleConcrete( type ) ) != managedTypes.end() || GenPoly::isPolyType( type );
+        }
+
+        bool ManagedTypes::isManaged( ObjectDecl * objDecl ) const {
                 Type * type = objDecl->get_type();
                 while ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
@@ -237 +225 @@
         }
 
-        void CtorDtor::handleDWT( DeclarationWithType * dwt ) {
+        void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
                 if ( ! LinkageSpec::isOverridable( dwt->get_linkage() ) && CodeGen::isCtorDtor( dwt->get_name() ) ) {
@@ -244 +232 @@
                         Type * type = InitTweak::getPointerBase( params.front()->get_type() );
                         assert( type );
-                        managedTypes.insert( SymTab::Mangler::mangle( type ) );
-                }
-        }
+                        managedTypes.insert( SymTab::Mangler::mangleConcrete( type ) );
+                }
+        }
+
+        void ManagedTypes::handleStruct( StructDecl * aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( Declaration * member : aggregateDecl->get_members() ) {
+                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
+                                if ( isManaged( field ) ) {
+                                        // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
+                                        // polymorphic constructors make generic types managed types
+                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
+                                        managedTypes.insert( SymTab::Mangler::mangleConcrete( &inst ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+
+        void ManagedTypes::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes::endScope() { managedTypes.endScope(); }
 
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
@@ -291 +298 @@
 
         void CtorDtor::previsit( ObjectDecl * objDecl ) {
-                handleDWT( objDecl );
+                managedTypes.handleDWT( objDecl );
                 // hands off if @=, extern, builtin, etc.
                 // even if unmanaged, try to construct global or static if initializer is not constexpr, since this is not legal C
-                if ( tryConstruct( objDecl ) && ( isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
+                if ( tryConstruct( objDecl ) && ( managedTypes.isManaged( objDecl ) || ((! inFunction || objDecl->get_storageClasses().is_static ) && ! isConstExpr( objDecl->get_init() ) ) ) ) {
                         // constructed objects cannot be designated
                         if ( isDesignated( objDecl->get_init() ) ) throw SemanticError( "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n", objDecl );
@@ -305 +312 @@
 
         void CtorDtor::previsit( FunctionDecl *functionDecl ) {
+                visit_children = false;  // do not try and construct parameters or forall parameters
                 GuardValue( inFunction );
                 inFunction = true;
 
-                handleDWT( functionDecl );
+                managedTypes.handleDWT( functionDecl );
 
                 GuardScope( managedTypes );
@@ -314 +322 @@
                 for ( auto & tyDecl : functionDecl->get_functionType()->get_forall() ) {
                         for ( DeclarationWithType *& assertion : tyDecl->get_assertions() ) {
-                                handleDWT( assertion );
+                                managedTypes.handleDWT( assertion );
                         }
                 }
 
-                PassVisitor<CtorDtor> newCtorDtor;
-                newCtorDtor.pass = *this;
-                maybeAccept( functionDecl->get_statements(), newCtorDtor );
-                visit_children = false;  // do not try and construct parameters or forall parameters - must happen after maybeAccept
+                maybeAccept( functionDecl->get_statements(), *visitor );
         }
 
@@ -327 +332 @@
                 visit_children = false; // do not try to construct and destruct aggregate members
 
-                // don't construct members, but need to take note if there is a managed member,
-                // because that means that this type is also managed
-                for ( Declaration * member : aggregateDecl->get_members() ) {
-                        if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( member ) ) {
-                                if ( isManaged( field ) ) {
-                                        StructInstType inst( Type::Qualifiers(), aggregateDecl );
-                                        managedTypes.insert( SymTab::Mangler::mangle( &inst ) );
-                                        break;
-                                }
-                        }
-                }
-        }
-
-        void CtorDtor::previsit( __attribute__((unused)) CompoundStmt * compoundStmt ) {
+                managedTypes.handleStruct( aggregateDecl );
+        }
+
+        void CtorDtor::previsit( CompoundStmt * ) {
                 GuardScope( managedTypes );
         }

src/InitTweak/GenInit.h

@@ -16 +16 @@
 #pragma once
 
-#include <list>               // for list
-#include <string>             // for string
+#include <list>                // for list
+#include <string>              // for string
 
-#include "SynTree/SynTree.h"  // for Visitor Nodes
+#include "SynTree/SynTree.h"   // for Visitor Nodes
+
+#include "GenPoly/ScopedSet.h" // for ScopedSet
 
 namespace InitTweak {
@@ -25 +27 @@
         void genInit( std::list< Declaration * > & translationUnit );
 
-  /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
-  ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        /// Converts return statements into copy constructor calls on the hidden return variable
+        void fixReturnStatements( std::list< Declaration * > & translationUnit );
+
+        /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
+        ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
 
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
+
+        class ManagedTypes {
+        public:
+                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
+                void handleStruct( StructDecl * aggregateDecl ); // add type to managed if child is managed
+
+                void beginScope();
+                void endScope();
+        private:
+                GenPoly::ScopedSet< std::string > managedTypes;
+        };
 } // namespace
 

src/InitTweak/InitTweak.cc

@@ -1 @@
-#include <stddef.h>                // for NULL
 #include <algorithm>               // for find, all_of
 #include <cassert>                 // for assertf, assert, strict_dynamic_cast
@@ -23 +22 @@
 #include "SynTree/Type.h"          // for FunctionType, ArrayType, PointerType
 #include "SynTree/Visitor.h"       // for Visitor, maybeAccept
+#include "Tuples/Tuples.h"         // for Tuples::isTtype
 
 class UntypedValofExpr;
@@ -170 +170 @@
         }
 
+        bool InitExpander::addReference() {
+                bool added = false;
+                for ( Expression *& expr : cur ) {
+                        expr = new AddressExpr( expr );
+                        added = true;
+                }
+                return added;
+        }
+
         namespace {
                 /// given index i, dimension d, initializer init, and callExpr f, generates
@@ -184 +193 @@
                         callExpr->get_args().splice( callExpr->get_args().end(), args );
 
-                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), NULL );
+                        *out++ = new IfStmt( noLabels, cond, new ExprStmt( noLabels, callExpr ), nullptr );
 
                         UntypedExpr * increment = new UntypedExpr( new NameExpr( "++?" ) );
@@ -250 +259 @@
         // To accomplish this, generate switch statement, consuming all of expander's elements
         Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
-                if ( ! init ) return NULL;
+                if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt( noLabels );
                 build( dst, indices.begin(), indices.end(), init, back_inserter( block->get_kids() ) );
                 if ( block->get_kids().empty() ) {
                         delete block;
-                        return NULL;
+                        return nullptr;
                 } else {
-                        init = NULL; // init was consumed in creating the list init
+                        init = nullptr; // init was consumed in creating the list init
                         return block;
                 }
         }
 
-        Statement * ExprImpl::buildListInit( __attribute((unused)) UntypedExpr * dst, __attribute((unused)) std::list< Expression * > & indices ) {
-                return NULL;
+        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+                return nullptr;
         }
 
@@ -270 +279 @@
         }
 
-        bool tryConstruct( ObjectDecl * objDecl ) {
+        Type * getTypeofThis( FunctionType * ftype ) {
+                assertf( ftype, "getTypeofThis: nullptr ftype" );
+                ObjectDecl * thisParam = getParamThis( ftype );
+                ReferenceType * refType = strict_dynamic_cast< ReferenceType * >( thisParam->type );
+                return refType->base;
+        }
+
+        ObjectDecl * getParamThis( FunctionType * ftype ) {
+                assertf( ftype, "getParamThis: nullptr ftype" );
+                auto & params = ftype->parameters;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( ftype ).c_str() );
+                return strict_dynamic_cast< ObjectDecl * >( params.front() );
+        }
+
+        bool tryConstruct( DeclarationWithType * dwt ) {
+                ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
                 return ! LinkageSpec::isBuiltin( objDecl->get_linkage() ) &&
-                        (objDecl->get_init() == NULL ||
-                                ( objDecl->get_init() != NULL && objDecl->get_init()->get_maybeConstructed() ))
-                        && ! objDecl->get_storageClasses().is_extern;
+                        (objDecl->get_init() == nullptr ||
+                                ( objDecl->get_init() != nullptr && objDecl->get_init()->get_maybeConstructed() ))
+                        && ! objDecl->get_storageClasses().is_extern
+                        && isConstructable( objDecl->type );
+        }
+
+        bool isConstructable( Type * type ) {
+                return ! dynamic_cast< VarArgsType * >( type ) && ! dynamic_cast< ReferenceType * >( type ) && ! dynamic_cast< FunctionType * >( type ) && ! Tuples::isTtype( type );
         }
 
@@ -314 +344 @@
                 collectCtorDtorCalls( stmt, matches );
                 assert( matches.size() <= 1 );
-                return matches.size() == 1 ? matches.front() : NULL;
+                return matches.size() == 1 ? matches.front() : nullptr;
         }
 
@@ -332 +362 @@
                         assert( expr );
                         if ( VariableExpr * varExpr = dynamic_cast< VariableExpr * >( expr ) ) {
-                                return varExpr->get_var();
+                                return varExpr->var;
                         } else if ( MemberExpr * memberExpr = dynamic_cast< MemberExpr * >( expr ) ) {
-                                return memberExpr->get_member();
+                                return memberExpr->member;
                         } else if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                return getCalledFunction( castExpr->get_arg() );
+                                return getCalledFunction( castExpr->arg );
                         } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
                                 return handleDerefCalledFunction( untypedExpr );
@@ -342 +372 @@
                                 return handleDerefCalledFunction( appExpr );
                         } else if ( AddressExpr * addrExpr = dynamic_cast< AddressExpr * >( expr ) ) {
-                                return getCalledFunction( addrExpr->get_arg() );
+                                return getCalledFunction( addrExpr->arg );
+                        } else if ( CommaExpr * commaExpr = dynamic_cast< CommaExpr * >( expr ) ) {
+                                return getCalledFunction( commaExpr->arg2 );
                         }
                         return nullptr;
@@ -359 +391 @@
         ApplicationExpr * isIntrinsicCallExpr( Expression * expr ) {
                 ApplicationExpr * appExpr = dynamic_cast< ApplicationExpr * >( expr );
-                if ( ! appExpr ) return NULL;
+                if ( ! appExpr ) return nullptr;
                 DeclarationWithType * function = getCalledFunction( appExpr->get_function() );
                 assertf( function, "getCalledFunction returned nullptr: %s", toString( appExpr->get_function() ).c_str() );
                 // check for Intrinsic only - don't want to remove all overridable ctor/dtors because autogenerated ctor/dtor
                 // will call all member dtors, and some members may have a user defined dtor.
-                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : NULL;
+                return function->get_linkage() == LinkageSpec::Intrinsic ? appExpr : nullptr;
         }
 
@@ -482 +514 @@
                         return refType->get_base();
                 } else {
-                        return NULL;
+                        return nullptr;
                 }
         }
@@ -488 +520 @@
         Type * isPointerType( Type * type ) {
                 if ( getPointerBase( type ) ) return type;
-                else return NULL;
+                else return nullptr;
         }
 
@@ -557 +589 @@
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname ) {
                 FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl );
-                if ( ! function ) return 0;
-                if ( function->get_name() != fname ) return 0;
-                FunctionType * ftype = function->get_functionType();
-                if ( ftype->get_parameters().size() != 2 ) return 0;
+                if ( ! function ) return nullptr;
+                if ( function->name != fname ) return nullptr;
+                FunctionType * ftype = function->type;
+                if ( ftype->parameters.size() != 2 ) return nullptr;
 
                 Type * t1 = getPointerBase( ftype->get_parameters().front()->get_type() );
-                Type * t2 = ftype->get_parameters().back()->get_type();
+                Type * t2 = ftype->parameters.back()->get_type();
                 assert( t1 );
 
@@ -583 +615 @@
         }
         FunctionDecl * isDefaultConstructor( Declaration * decl ) {
-                if ( isConstructor( decl->get_name() ) ) {
+                if ( isConstructor( decl->name ) ) {
                         if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
-                                if ( func->get_functionType()->get_parameters().size() == 1 ) {
+                                if ( func->type->parameters.size() == 1 ) {
                                         return func;
                                 }

src/InitTweak/InitTweak.h

@@ -30 +30 @@
         FunctionDecl * isCopyFunction( Declaration * decl, const std::string & fname );
 
+        /// returns the base type of the first parameter to a constructor/destructor/assignment function
+        Type * getTypeofThis( FunctionType * ftype );
+
+        /// returns the first parameter of a constructor/destructor/assignment function
+        ObjectDecl * getParamThis( FunctionType * ftype );
+
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
 
-        /// True if the resolver should try to construct objDecl
-        bool tryConstruct( ObjectDecl * objDecl );
+        /// True if the resolver should try to construct dwt
+        bool tryConstruct( DeclarationWithType * dwt );
+
+        /// True if the type can have a user-defined constructor
+        bool isConstructable( Type * t );
 
         /// True if the Initializer contains designations
@@ -96 +105 @@
                 void addArrayIndex( Expression * index, Expression * dimension );
                 void clearArrayIndices();
+                bool addReference();
 
                 class ExpanderImpl;