Changeset 54dd994 for src

Timestamp:

Jun 24, 2019, 10:30:47 AM (6 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

84917e2

Parents:

3c6e417 (diff), 9e0a360 (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

Files:

• AST/Expr.hpp (modified) (2 diffs)
• AST/Init.hpp (modified) (4 diffs)
• AST/Node.hpp (modified) (2 diffs)
• AST/Stmt.hpp (modified) (2 diffs)
• Common/utility.h (modified) (3 diffs)
• InitTweak/FixInit.cc (modified) (1 diff)
• InitTweak/GenInit.cc (modified) (4 diffs)
• InitTweak/GenInit.h (modified) (2 diffs)
• InitTweak/InitTweak.cc (modified) (11 diffs)
• InitTweak/InitTweak.h (modified) (3 diffs)
• ResolvExpr/Alternative.cc (modified) (1 diff)
• ResolvExpr/Alternative.h (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (1 diff)
• ResolvExpr/Candidate.hpp (modified) (1 diff)
• ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)
• ResolvExpr/Cost.h (modified) (3 diffs)
• ResolvExpr/RenameVars.cc (modified) (5 diffs)
• ResolvExpr/Resolver.cc (modified) (3 diffs)
• ResolvExpr/Resolver.h (modified) (2 diffs)
• SymTab/Autogen.cc (modified) (3 diffs)
• SymTab/Autogen.h (modified) (8 diffs)
• SymTab/FixFunction.cc (modified) (4 diffs)
• SymTab/FixFunction.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (27 diffs)
• Tuples/Explode.cc (modified) (4 diffs)
• Tuples/Explode.h (modified) (2 diffs)
• Tuples/TupleAssignment.cc (modified) (13 diffs)

src/AST/Expr.hpp

@@ -248 +248 @@
         AddressExpr( const CodeLocation & loc, const Expr * a );
 
+        /// Generate AddressExpr wrapping given expression at same location
+        AddressExpr( const Expr * a ) : AddressExpr( a->location, a ) {}
+
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -281 +284 @@
         /// Cast-to-void
         CastExpr( const CodeLocation & loc, const Expr * a, GeneratedFlag g = GeneratedCast );
+
+        /// Wrap a cast expression around an existing expression (always generated)
+        CastExpr( const Expr * a, const Type * to ) : CastExpr( a->location, a, to, GeneratedCast ) {}
+
+        /// Wrap a cast-to-void expression around an existing expression (always generated)
+        CastExpr( const Expr * a ) : CastExpr( a->location, a, GeneratedCast ) {}
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Init.hpp

@@ -55 +55 @@
         ConstructFlag maybeConstructed;
 
-        Init( const CodeLocation& loc, ConstructFlag mc ) : ParseNode( loc ), maybeConstructed( mc ) {}
+        Init( const CodeLocation & loc, ConstructFlag mc ) : ParseNode( loc ), maybeConstructed( mc ) {}
 
-        const Init * accept( Visitor& v ) const override = 0;
+        const Init * accept( Visitor & v ) const override = 0;
 private:
         Init * clone() const override = 0;
@@ -69 +69 @@
         ptr<Expr> value;
 
-        SingleInit( const CodeLocation& loc, Expr* val, ConstructFlag mc = DoConstruct )
+        SingleInit( const CodeLocation & loc, const Expr * val, ConstructFlag mc = DoConstruct )
         : Init( loc, mc ), value( val ) {}
 
@@ -87 +87 @@
         std::vector<ptr<Designation>> designations;
 
-        ListInit( const CodeLocation& loc, std::vector<ptr<Init>>&& is,
-                std::vector<ptr<Designation>>&& ds = {}, ConstructFlag mc = DoConstruct );
+        ListInit( const CodeLocation & loc, std::vector<ptr<Init>> && is,
+                std::vector<ptr<Designation>> && ds = {}, ConstructFlag mc = DoConstruct );
 
         using iterator = std::vector<ptr<Init>>::iterator;
@@ -114 +114 @@
         ptr<Init> init;
 
-        ConstructorInit( const CodeLocation& loc, Stmt* ctor, Stmt* dtor, Init* init )
+        ConstructorInit( 
+                const CodeLocation & loc, const Stmt * ctor, const Stmt * dtor, const Init * init )
         : Init( loc, DoConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}
 

src/AST/Node.hpp

@@ -17 +17 @@
 
 #include <cassert>
+#include <cstddef>     // for nullptr_t
 #include <iosfwd>
 #include <type_traits> // for remove_reference
@@ -181 +182 @@
         }
 
+        ptr_base & operator=( std::nullptr_t ) {
+                if ( node ) _dec(node);
+                node = nullptr;
+                return *this;
+        }
+
         ptr_base & operator=( const ptr_base & o ) {
                 assign(o.node);

src/AST/Stmt.hpp

@@ -61 +61 @@
         CompoundStmt( CompoundStmt&& o ) = default;
 
-        void push_back( Stmt * s ) { kids.emplace_back( s ); }
-        void push_front( Stmt * s ) { kids.emplace_front( s ); }
+        void push_back( const Stmt * s ) { kids.emplace_back( s ); }
+        void push_front( const Stmt * s ) { kids.emplace_front( s ); }
 
         const CompoundStmt * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -143 +143 @@
 
         IfStmt( const CodeLocation & loc, const Expr * cond, const Stmt * thenPart,
-                Stmt * const elsePart, std::vector<ptr<Stmt>> && inits,
+                const Stmt * elsePart = nullptr, std::vector<ptr<Stmt>> && inits = {},
                 std::vector<Label> && labels = {} )
         : Stmt(loc, std::move(labels)), cond(cond), thenPart(thenPart), elsePart(elsePart),

src/Common/utility.h

@@ -16 +16 @@
 #pragma once
 
+#include <cassert>
 #include <cctype>
 #include <algorithm>
@@ -27 +28 @@
 #include <type_traits>
 #include <utility>
-
-#include <cassert>
+#include <vector>
 
 #include "Common/Indenter.h"
 
 class Expression;
+
+/// bring std::move into global scope
+using std::move;
+
+/// partner to move that copies any copyable type
+template<typename T>
+T copy( const T & x ) { return x; }
 
 template< typename T >
@@ -145 +152 @@
                 return ret;
         } // switch
+}
+
+/// Splice src onto the end of dst, clearing src
+template< typename T >
+void splice( std::vector< T > & dst, std::vector< T > & src ) {
+        dst.reserve( dst.size() + src.size() );
+        for ( T & x : src ) { dst.emplace_back( std::move( x ) ); }
+        src.clear();
+}
+
+/// Splice src onto the begining of dst, clearing src
+template< typename T >
+void spliceBegin( std::vector< T > & dst, std::vector< T > & src ) {
+        splice( src, dst );
+        dst.swap( src );
 }
 

src/InitTweak/FixInit.cc

@@ -1111 +1111 @@
                                                 arg2 = new MemberExpr( field, new VariableExpr( params.back() ) );
                                         }
-                                        InitExpander srcParam( arg2 );
+                                        InitExpander_old srcParam( arg2 );
                                         // cast away reference type and construct field.
                                         Expression * thisExpr = new CastExpr( new VariableExpr( thisParam ), thisParam->get_type()->stripReferences()->clone() );

src/InitTweak/GenInit.cc

@@ -18 +18 @@
 #include <algorithm>                   // for any_of
 #include <cassert>                     // for assert, strict_dynamic_cast, assertf
+#include <deque>
 #include <iterator>                    // for back_inserter, inserter, back_inse...
 #include <list>                        // for _List_iterator, list
 
+#include "AST/Decl.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Stmt.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
@@ -274 +279 @@
                 assertf( objDecl, "genCtorDtor passed null objDecl" );
                 std::list< Statement * > stmts;
-                InitExpander srcParam( maybeClone( arg ) );
+                InitExpander_old srcParam( maybeClone( arg ) );
                 SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), fname, back_inserter( stmts ), objDecl );
                 assert( stmts.size() <= 1 );
@@ -286 +291 @@
                 std::list< Statement * > dtor;
 
-                InitExpander srcParam( objDecl->get_init() );
-                InitExpander nullParam( (Initializer *)NULL );
+                InitExpander_old srcParam( objDecl->get_init() );
+                InitExpander_old nullParam( (Initializer *)NULL );
                 SymTab::genImplicitCall( srcParam, new VariableExpr( objDecl ), "?{}", back_inserter( ctor ), objDecl );
                 SymTab::genImplicitCall( nullParam, new VariableExpr( objDecl ), "^?{}", front_inserter( dtor ), objDecl, false );
@@ -353 +358 @@
                 GuardScope( managedTypes );
         }
+
+ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl ) {
+        // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor for each 
+        // constructable object
+        InitExpander_new srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr };
+        
+        ast::ptr< ast::Stmt > ctor = SymTab::genImplicitCall( 
+                srcParam, new ast::VariableExpr{ loc, objDecl }, loc, "?{}", objDecl );
+        ast::ptr< ast::Stmt > dtor = SymTab::genImplicitCall( 
+                nullParam, new ast::VariableExpr{ loc, objDecl }, loc, "^?{}", objDecl, 
+                SymTab::LoopBackward );
+        
+        // check that either both ctor and dtor are present, or neither
+        assert( (bool)ctor == (bool)dtor );
+
+        if ( ctor ) {
+                // need to remember init expression, in case no ctors exist. If ctor does exist, want to 
+                // use ctor expression instead of init.
+                ctor.strict_as< ast::ImplicitCtorDtorStmt >(); 
+                dtor.strict_as< ast::ImplicitCtorDtorStmt >();
+
+                return new ast::ConstructorInit{ loc, ctor, dtor, objDecl->init };
+        }
+
+        return nullptr;
+}
+
 } // namespace InitTweak
 

src/InitTweak/GenInit.h

@@ -19 +19 @@
 #include <string>              // for string
 
+#include "AST/Fwd.hpp"
+#include "Common/CodeLocation.h"
+#include "GenPoly/ScopedSet.h" // for ScopedSet
 #include "SynTree/SynTree.h"   // for Visitor Nodes
-
-#include "GenPoly/ScopedSet.h" // for ScopedSet
 
 namespace InitTweak {
@@ -35 +36 @@
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
         ConstructorInit * genCtorInit( ObjectDecl * objDecl );
+        ast::ConstructorInit * genCtorInit( const CodeLocation & loc, const ast::ObjectDecl * objDecl );
 
         class ManagedTypes {

src/InitTweak/InitTweak.cc

@@ -22 +22 @@
 
 #include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 #include "AST/Stmt.hpp"
 #include "AST/Type.hpp"
@@ -84 +87 @@
                 };
 
-                struct InitFlattener : public WithShortCircuiting {
+                struct InitFlattener_old : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
                                 visit_children = false;
@@ -92 +95 @@
                 };
 
-        }
+                struct InitFlattener_new : public ast::WithShortCircuiting {
+                        std::vector< ast::ptr< ast::Expr > > argList;
+
+                        void previsit( const ast::SingleInit * singleInit ) {
+                                visit_children = false;
+                                argList.emplace_back( singleInit->value );
+                        }
+                };
+
+        } // anonymous namespace
 
         std::list< Expression * > makeInitList( Initializer * init ) {
-                PassVisitor<InitFlattener> flattener;
+                PassVisitor<InitFlattener_old> flattener;
                 maybeAccept( init, flattener );
                 return flattener.pass.argList;
@@ -112 +124 @@
         }
 
-        class InitExpander::ExpanderImpl {
+std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
+        ast::Pass< InitFlattener_new > flattener;
+        maybe_accept( init, flattener );
+        return std::move( flattener.pass.argList );
+}
+
+        class InitExpander_old::ExpanderImpl {
         public:
                 virtual ~ExpanderImpl() = default;
@@ -119 +137 @@
         };
 
-        class InitImpl : public InitExpander::ExpanderImpl {
+        class InitImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                InitImpl( Initializer * init ) : init( init ) {}
-                virtual ~InitImpl() = default;
+                InitImpl_old( Initializer * init ) : init( init ) {}
+                virtual ~InitImpl_old() = default;
 
                 virtual std::list< Expression * > next( __attribute((unused)) std::list< Expression * > & indices ) {
@@ -136 +154 @@
         };
 
-        class ExprImpl : public InitExpander::ExpanderImpl {
+        class ExprImpl_old : public InitExpander_old::ExpanderImpl {
         public:
-                ExprImpl( Expression * expr ) : arg( expr ) {}
-                virtual ~ExprImpl() { delete arg; }
+                ExprImpl_old( Expression * expr ) : arg( expr ) {}
+                virtual ~ExprImpl_old() { delete arg; }
 
                 virtual std::list< Expression * > next( std::list< Expression * > & indices ) {
@@ -163 +181 @@
         };
 
-        InitExpander::InitExpander( Initializer * init ) : expander( new InitImpl( init ) ) {}
-
-        InitExpander::InitExpander( Expression * expr ) : expander( new ExprImpl( expr ) ) {}
-
-        std::list< Expression * > InitExpander::operator*() {
+        InitExpander_old::InitExpander_old( Initializer * init ) : expander( new InitImpl_old( init ) ) {}
+
+        InitExpander_old::InitExpander_old( Expression * expr ) : expander( new ExprImpl_old( expr ) ) {}
+
+        std::list< Expression * > InitExpander_old::operator*() {
                 return cur;
         }
 
-        InitExpander & InitExpander::operator++() {
+        InitExpander_old & InitExpander_old::operator++() {
                 cur = expander->next( indices );
                 return *this;
@@ -177 +195 @@
 
         // use array indices list to build switch statement
-        void InitExpander::addArrayIndex( Expression * index, Expression * dimension ) {
+        void InitExpander_old::addArrayIndex( Expression * index, Expression * dimension ) {
                 indices.push_back( index );
                 indices.push_back( dimension );
         }
 
-        void InitExpander::clearArrayIndices() {
+        void InitExpander_old::clearArrayIndices() {
                 deleteAll( indices );
                 indices.clear();
         }
 
-        bool InitExpander::addReference() {
+        bool InitExpander_old::addReference() {
                 bool added = false;
                 for ( Expression *& expr : cur ) {
@@ -218 +236 @@
 
                 template< typename OutIterator >
-                void build( UntypedExpr * callExpr, InitExpander::IndexList::iterator idx, InitExpander::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
+                void build( UntypedExpr * callExpr, InitExpander_old::IndexList::iterator idx, InitExpander_old::IndexList::iterator idxEnd, Initializer * init, OutIterator out ) {
                         if ( idx == idxEnd ) return;
                         Expression * index = *idx++;
@@ -275 +293 @@
         // remaining elements.
         // To accomplish this, generate switch statement, consuming all of expander's elements
-        Statement * InitImpl::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
+        Statement * InitImpl_old::buildListInit( UntypedExpr * dst, std::list< Expression * > & indices ) {
                 if ( ! init ) return nullptr;
                 CompoundStmt * block = new CompoundStmt();
@@ -288 +306 @@
         }
 
-        Statement * ExprImpl::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
+        Statement * ExprImpl_old::buildListInit( UntypedExpr *, std::list< Expression * > & ) {
                 return nullptr;
         }
 
-        Statement * InitExpander::buildListInit( UntypedExpr * dst ) {
+        Statement * InitExpander_old::buildListInit( UntypedExpr * dst ) {
                 return expander->buildListInit( dst, indices );
         }
+
+class InitExpander_new::ExpanderImpl {
+public:
+        virtual ~ExpanderImpl() = default;
+        virtual std::vector< ast::ptr< ast::Expr > > next( IndexList & indices ) = 0;
+        virtual ast::ptr< ast::Stmt > buildListInit( 
+                ast::UntypedExpr * callExpr, IndexList & indices ) = 0;
+};
+
+namespace {
+        template< typename Out >
+        void buildCallExpr( 
+                ast::UntypedExpr * callExpr, const ast::Expr * index, const ast::Expr * dimension, 
+                const ast::Init * init, Out & out
+        ) {
+                const CodeLocation & loc = init->location;
+
+                auto cond = new ast::UntypedExpr{ 
+                        loc, new ast::NameExpr{ loc, "?<?" }, { index, dimension } };
+                
+                std::vector< ast::ptr< ast::Expr > > args = makeInitList( init );
+                splice( callExpr->args, args );
+
+                out.emplace_back( new ast::IfStmt{ loc, cond, new ast::ExprStmt{ loc, callExpr } } );
+
+                out.emplace_back( new ast::ExprStmt{ 
+                        loc, new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, "++?" }, { index } } } );
+        }
+
+        template< typename Out >
+        void build(
+                ast::UntypedExpr * callExpr, const InitExpander_new::IndexList & indices, 
+                const ast::Init * init, Out & out
+        ) {
+                if ( indices.empty() ) return;
+
+                unsigned idx = 0;
+
+                const ast::Expr * index = indices[idx++];
+                assert( idx != indices.size() );
+                const ast::Expr * dimension = indices[idx++];
+
+                if ( idx == indices.size() ) {
+                        if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
+                                for ( const ast::Init * init : *listInit ) {
+                                        buildCallExpr( callExpr, index, dimension, init, out );
+                                }
+                        } else {
+                                buildCallExpr( callExpr, index, dimension, init, out );
+                        }
+                } else {
+                        const CodeLocation & loc = init->location;
+
+                        unsigned long cond = 0;
+                        auto listInit = dynamic_cast< const ast::ListInit * >( init );
+                        if ( ! listInit ) { SemanticError( loc, "unbalanced list initializers" ); }
+
+                        static UniqueName targetLabel( "L__autogen__" );
+                        ast::Label switchLabel{ 
+                                loc, targetLabel.newName(), { new ast::Attribute{ "unused" } } };
+                        
+                        std::vector< ast::ptr< ast::Stmt > > branches;
+                        for ( const ast::Init * init : *listInit ) {
+                                auto condition = ast::ConstantExpr::from_ulong( loc, cond );
+                                ++cond;
+
+                                std::vector< ast::ptr< ast::Stmt > > stmts;
+                                build( callExpr, indices, init, stmts );
+                                stmts.emplace_back( 
+                                        new ast::BranchStmt{ loc, ast::BranchStmt::Break, switchLabel } );
+                                branches.emplace_back( new ast::CaseStmt{ loc, condition, std::move( stmts ) } );
+                        }
+                        out.emplace_back( new ast::SwitchStmt{ loc, index, std::move( branches ) } );
+                        out.emplace_back( new ast::NullStmt{ loc, { switchLabel } } );
+                }
+        }
+
+        class InitImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Init > init;
+        public:
+                InitImpl_new( const ast::Init * i ) : init( i ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next( InitExpander_new::IndexList & ) override {
+                        return makeInitList( init );
+                }
+                
+                ast::ptr< ast::Stmt > buildListInit( 
+                        ast::UntypedExpr * callExpr, InitExpander_new::IndexList & indices 
+                ) override {
+                        // If array came with an initializer list, initialize each element. We may have more 
+                        // initializers than elements of the array; need to check at each index that we have 
+                        // not exceeded size. We may have fewer initializers than elements in the array; need 
+                        // to default-construct remaining elements. To accomplish this, generate switch 
+                        // statement consuming all of expander's elements
+
+                        if ( ! init ) return {};
+
+                        std::list< ast::ptr< ast::Stmt > > stmts;
+                        build( callExpr, indices, init, stmts );
+                        if ( stmts.empty() ) {
+                                return {};
+                        } else {
+                                auto block = new ast::CompoundStmt{ init->location, std::move( stmts ) };
+                                init = nullptr;  // consumed in creating the list init
+                                return block;
+                        }
+                }
+        };
+
+        class ExprImpl_new final : public InitExpander_new::ExpanderImpl {
+                ast::ptr< ast::Expr > arg;
+        public:
+                ExprImpl_new( const ast::Expr * a ) : arg( a ) {}
+
+                std::vector< ast::ptr< ast::Expr > > next( 
+                        InitExpander_new::IndexList & indices 
+                ) override {
+                        if ( ! arg ) return {};
+
+                        const CodeLocation & loc = arg->location;
+                        const ast::Expr * expr = arg;
+                        for ( auto it = indices.rbegin(); it != indices.rend(); ++it ) {
+                                // go through indices and layer on subscript exprs ?[?]
+                                ++it;
+                                expr = new ast::UntypedExpr{ 
+                                        loc, new ast::NameExpr{ loc, "?[?]" }, { expr, *it } };
+                        }
+                        return { expr };
+                }
+                
+                ast::ptr< ast::Stmt > buildListInit( 
+                        ast::UntypedExpr *, InitExpander_new::IndexList & 
+                ) override { 
+                        return {};
+                }
+        };
+} // anonymous namespace
+
+InitExpander_new::InitExpander_new( const ast::Init * init )
+: expander( new InitImpl_new{ init } ), crnt(), indices() {}
+
+InitExpander_new::InitExpander_new( const ast::Expr * expr )
+: expander( new ExprImpl_new{ expr } ), crnt(), indices() {}
+
+std::vector< ast::ptr< ast::Expr > > InitExpander_new::operator* () { return crnt; }
+
+InitExpander_new & InitExpander_new::operator++ () {
+        crnt = expander->next( indices );
+        return *this;
+}
+
+/// builds statement which has the same semantics as a C-style list initializer (for array 
+/// initializers) using callExpr as the base expression to perform initialization
+ast::ptr< ast::Stmt > InitExpander_new::buildListInit( ast::UntypedExpr * callExpr ) {
+        return expander->buildListInit( callExpr, indices );
+}
+
+void InitExpander_new::addArrayIndex( const ast::Expr * index, const ast::Expr * dimension ) {
+        indices.emplace_back( index );
+        indices.emplace_back( dimension );
+}
+
+void InitExpander_new::clearArrayIndices() { indices.clear(); }
+
+bool InitExpander_new::addReference() {
+        for ( ast::ptr< ast::Expr > & expr : crnt ) {
+                expr = new ast::AddressExpr{ expr };
+        }
+        return ! crnt.empty();
+}
 
         Type * getTypeofThis( FunctionType * ftype ) {

src/InitTweak/InitTweak.h

@@ -44 +44 @@
         /// transform Initializer into an argument list that can be passed to a call expression
         std::list< Expression * > makeInitList( Initializer * init );
+        std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init );
 
         /// True if the resolver should try to construct dwt
@@ -101 +102 @@
         bool isConstExpr( Initializer * init );
 
-        class InitExpander {
+        class InitExpander_old {
         public:
                 // expand by stepping through init to get each list of arguments
-                InitExpander( Initializer * init );
+                InitExpander_old( Initializer * init );
 
                 // always expand to expr
-                InitExpander( Expression * expr );
+                InitExpander_old( Expression * expr );
 
                 // iterator-like interface
                 std::list< Expression * > operator*();
-                InitExpander & operator++();
+                InitExpander_old & operator++();
 
                 // builds statement which has the same semantics as a C-style list initializer
@@ -130 +131 @@
                 IndexList indices;
         };
+
+        class InitExpander_new {
+        public:
+                using IndexList = std::vector< ast::ptr< ast::Expr > >;
+                class ExpanderImpl;
+
+        private:
+                std::shared_ptr< ExpanderImpl > expander;
+                std::vector< ast::ptr< ast::Expr > > crnt;
+                // invariant: list of size 2N (elements come in pairs [index, dimension])
+                IndexList indices;
+
+        public:
+                /// Expand by stepping through init to get each list of arguments
+                InitExpander_new( const ast::Init * init );
+
+                /// Always expand to expression
+                InitExpander_new( const ast::Expr * expr );
+
+                std::vector< ast::ptr< ast::Expr > > operator* ();
+                InitExpander_new & operator++ ();
+
+                /// builds statement which has the same semantics as a C-style list initializer (for array 
+                /// initializers) using callExpr as the base expression to perform initialization. 
+                /// Mutates callExpr
+                ast::ptr< ast::Stmt > buildListInit( ast::UntypedExpr * callExpr );
+
+                void addArrayIndex( const ast::Expr * index, const ast::Expr * dimension );
+
+                void clearArrayIndices();
+
+                bool addReference();
+        };
 } // namespace
 

src/ResolvExpr/Alternative.cc

@@ -125 +125 @@
         }
 
-        void splice( AltList& dst, AltList& src ) {
-                dst.reserve( dst.size() + src.size() );
-                for ( Alternative& alt : src ) {
-                        dst.push_back( std::move(alt) );
-                }
-                src.clear();
-        }
-
-        void spliceBegin( AltList& dst, AltList& src ) {
-                splice( src, dst );
-                dst.swap( src );
-        }
-
 } // namespace ResolvExpr
 

src/ResolvExpr/Alternative.h

@@ -112 +112 @@
         typedef std::vector< Alternative > AltList;
 
-        /// Moves all elements from src to the end of dst
-        void splice( AltList& dst, AltList& src );
-
-        /// Moves all elements from src to the beginning of dst
-        void spliceBegin( AltList& dst, AltList& src );
-
         static inline std::ostream & operator<<(std::ostream & os, const ResolvExpr::Alternative & alt) {
                 alt.print( os );

src/ResolvExpr/AlternativeFinder.cc

@@ -56 +56 @@
 #define PRINT( text ) if ( resolvep ) { text }
 //#define DEBUG_COST
-
-using std::move;
-
-/// copies any copyable type
-template<typename T>
-T copy(const T& x) { return x; }
 
 namespace ResolvExpr {

src/ResolvExpr/Candidate.hpp

@@ -75 +75 @@
 using CandidateList = std::vector< CandidateRef >;
 
-/// Splice src after dst, clearing src
-static inline void splice( CandidateList & dst, CandidateList & src ) {
-        dst.reserve( dst.size() + src.size() );
-        for ( CandidateRef & r : src ) { dst.emplace_back( std::move( r ) ); }
-        src.clear();
-}
-
-/// Splice src before dst
-static inline void spliceBegin( CandidateList & dst, CandidateList & src ) {
-        splice( src, dst );
-        dst.swap( src );
-}
-
 /// Sum the cost of a list of candidates
 static inline Cost sumCost( const CandidateList & candidates ) {

src/ResolvExpr/CandidateFinder.cpp

@@ -39 +39 @@
 #include "AST/SymbolTable.hpp"
 #include "AST/Type.hpp"
+#include "Common/utility.h"       // for move, copy
 #include "SymTab/Mangler.h"
 #include "SymTab/Validate.h"      // for validateType
@@ -46 +47 @@
 
 namespace ResolvExpr {
-
-using std::move;
-
-/// partner to move that copies any copyable type
-template<typename T>
-T copy( const T & x ) { return x; }
 
 const ast::Expr * referenceToRvalueConversion( const ast::Expr * expr, Cost & cost ) {
@@ -57 +52 @@
                 // cast away reference from expr
                 cost.incReference();
-                return new ast::CastExpr{ expr->location, expr, expr->result->stripReferences() };
+                return new ast::CastExpr{ expr, expr->result->stripReferences() };
         }
         
@@ -126 +121 @@
                         ast::ptr< ast::Type > newType = paramType;
                         env.apply( newType );
-                        return new ast::CastExpr{ arg->location, arg, newType };
+                        return new ast::CastExpr{ arg, newType };
 
                         // xxx - *should* be able to resolve this cast, but at the moment pointers are not 
@@ -793 +788 @@
                         
                         if ( aggrType.as< ast::ReferenceType >() ) {
-                                aggrExpr = 
-                                        new ast::CastExpr{ aggrExpr->location, aggrExpr, aggrType->stripReferences() };
+                                aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
                         }
 

src/ResolvExpr/Cost.h

@@ -10 +10 @@
 // Created On       : Sun May 17 09:39:50 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Apr 29 18:33:44 2019
-// Update Count     : 49
+// Last Modified On : Fri Jun 21 11:39:13 2019
+// Update Count     : 63
 //
 
@@ -21 +21 @@
 
 namespace ResolvExpr {
-#if 0
-
-        //*************************** OLD ***************************
-
-        class Cost {
-          private:
-                Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
-                          int varCost, int specCost, int referenceCost );
-          public:
-                Cost & incUnsafe( int inc = 1 );
-                Cost & incPoly( int inc = 1 );
-                Cost & incSafe( int inc = 1 );
-                Cost & incSign( int inc = 1 );
-                Cost & incVar( int inc = 1 );
-                Cost & decSpec( int inc = 1 );
-                Cost & incReference( int inc = 1 );
-
-                int get_unsafeCost() const { return unsafeCost; }
-                int get_polyCost() const { return polyCost; }
-                int get_safeCost() const { return safeCost; }
-                int get_signCost() const { return signCost; }
-                int get_varCost() const { return varCost; }
-                int get_specCost() const { return specCost; }
-                int get_referenceCost() const { return referenceCost; }
-
-                Cost operator+( const Cost &other ) const;
-                Cost &operator+=( const Cost &other );
-                bool operator<( const Cost &other ) const;
-                bool operator==( const Cost &other ) const;
-                bool operator!=( const Cost &other ) const;
-                friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
-                // returns negative for *this < other, 0 for *this == other, positive for *this > other
-                int compare( const Cost &other ) const;
-
-                static const Cost zero;
-                static const Cost infinity;
-
-                static const Cost unsafe;
-                static const Cost poly;
-                static const Cost safe;
-                static const Cost sign;
-                static const Cost var;
-                static const Cost spec;
-                static const Cost reference;
-
-          private:
-                int unsafeCost;     ///< Unsafe (narrowing) conversions
-                int polyCost;       ///< Count of parameters and return values bound to some poly type
-                int safeCost;       ///< Safe (widening) conversions
-                int signCost;       ///< Count of safe sign conversions
-                int varCost;        ///< Count of polymorphic type variables
-                int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
-                int referenceCost;  ///< reference conversions
-        };
-
-        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int signCost,
-                                           int varCost, int specCost, int referenceCost )
-                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), signCost( signCost ),
-                  varCost( varCost ), specCost( specCost ), referenceCost( referenceCost ) {}
-
-        inline Cost & Cost::incUnsafe( int inc ) {
-                if ( *this == infinity ) return *this;
-                unsafeCost += inc;
-                return *this;
-        }
-
-        inline Cost & Cost::incPoly( int inc ) {
-                if ( *this == infinity ) return *this;
-                polyCost += inc;
-                return *this;
-        }
-
-        inline Cost & Cost::incSafe( int inc ) {
-                if ( *this == infinity ) return *this;
-                safeCost += inc;
-                return *this;
-        }
-
-        inline Cost & Cost::incSign( int inc ) {
-                if ( *this == infinity ) return *this;
-                signCost += inc;
-                return *this;
-        }
-
-        inline Cost & Cost::incVar( int inc ) {
-                if ( *this == infinity ) return *this;
-                varCost += inc;
-                return *this;
-        }
-
-        inline Cost& Cost::decSpec( int dec ) {
-                if ( *this == infinity ) return *this;
-                specCost -= dec;
-                return *this;
-        }
-
-        inline Cost & Cost::incReference( int inc ) {
-                if ( *this == infinity ) return *this;
-                referenceCost += inc;
-                return *this;
-        }
-
-        inline Cost Cost::operator+( const Cost &other ) const {
-                if ( *this == infinity || other == infinity ) return infinity;
-                return Cost{
-                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost,
-                                signCost + other.signCost, varCost + other.varCost, specCost + other.specCost,
-                                referenceCost + other.referenceCost };
-        }
-
-        inline Cost &Cost::operator+=( const Cost &other ) {
-                if ( *this == infinity ) return *this;
-                if ( other == infinity ) {
-                        *this = infinity;
-                        return *this;
-                }
-                unsafeCost += other.unsafeCost;
-                polyCost += other.polyCost;
-                safeCost += other.safeCost;
-                signCost += other.signCost;
-                varCost += other.varCost;
-                specCost += other.specCost;
-                referenceCost += other.referenceCost;
-                return *this;
-        }
-
-        inline bool Cost::operator<( const Cost &other ) const {
-                if ( *this == infinity ) return false;
-                if ( other == infinity ) return true;
-
-                if ( unsafeCost > other.unsafeCost ) {
-                        return false;
-                } else if ( unsafeCost < other.unsafeCost ) {
-                        return true;
-                } else if ( polyCost > other.polyCost ) {
-                        return false;
-                } else if ( polyCost < other.polyCost ) {
-                        return true;
-                } else if ( safeCost > other.safeCost ) {
-                        return false;
-                } else if ( safeCost < other.safeCost ) {
-                        return true;
-                } else if ( signCost > other.signCost ) {
-                        return false;
-                } else if ( signCost < other.signCost ) {
-                        return true;
-                } else if ( varCost > other.varCost ) {
-                        return false;
-                } else if ( varCost < other.varCost ) {
-                        return true;
-                } else if ( specCost > other.specCost ) {
-                        return false;
-                } else if ( specCost > other.specCost ) {
-                        return true;
-                } else if ( referenceCost > other.referenceCost ) {
-                        return false;
-                } else if ( referenceCost < other.referenceCost ) {
-                        return true;
-                } else {
-                        return false;
-                } // if
-        }
-
-        inline int Cost::compare( const Cost &other ) const {
-                if ( *this == infinity ) return +1;
-                if ( other == infinity ) return -1;
-
-                int c = unsafeCost - other.unsafeCost; if ( c ) return c;
-                c = polyCost - other.polyCost; if ( c ) return c;
-                c = safeCost - other.safeCost; if ( c ) return c;
-                c = signCost - other.signCost; if ( c ) return c;
-                c = varCost - other.varCost; if ( c ) return c;
-                c = specCost - other.specCost; if ( c ) return c;
-                return referenceCost - other.referenceCost;
-        }
-
-        inline bool Cost::operator==( const Cost &other ) const {
-                return unsafeCost == other.unsafeCost
-                        && polyCost == other.polyCost
-                        && safeCost == other.safeCost
-                        && signCost == other.signCost
-                        && varCost == other.varCost
-                        && specCost == other.specCost
-                        && referenceCost == other.referenceCost;
-        }
-
-        inline bool Cost::operator!=( const Cost &other ) const {
-                return !( *this == other );
-        }
-
-        inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", "
-                          << cost.safeCost << ", " << cost.signCost << ", "
-                                  << cost.varCost << ", " << cost.specCost << ", "
-                          << cost.referenceCost << " )";
-        }
-
-#else
-
-        //*************************** NEW ***************************
-
         // To maximize performance and space, the 7 resolution costs are packed into a single 64-bit word. However, the
         // specialization cost is a negative value so a correction is needed is a few places.
@@ -371 +170 @@
                                   << ", " << cost.get_referenceCost() << " )";
         }
-#endif // 0
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:05:18 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Tue Apr 30 17:07:57 2019
-// Update Count     : 7
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jun 20 17:39:00 2019
+// Update Count     : 8
 //
 
@@ -19 +19 @@
 #include <utility>                 // for pair
 
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"
+#include "Common/ScopedMap.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "RenameVars.h"
@@ -28 +31 @@
 
 namespace ResolvExpr {
-        namespace {
-                struct RenameVars {
-                        RenameVars();
-                        void reset();
 
-                        void previsit( TypeInstType * instType );
-                        void previsit( Type * );
-                        void postvisit( Type * );
+namespace {
+        class RenamingData {
+                int level = 0;
+                int resetCount = 0;
+                ScopedMap< std::string, std::string > nameMap;
 
-                  private:
-                        int level, resetCount;
-                        std::list< std::unordered_map< std::string, std::string > > mapStack;
-                };
-
-                PassVisitor<RenameVars> global_renamer;
-        } // namespace
-
-        void renameTyVars( Type * t ) {
-                t->accept( global_renamer );
-        }
-
-        void resetTyVarRenaming() {
-                global_renamer.pass.reset();
-        }
-
-        namespace {
-                RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
-                        mapStack.push_front( std::unordered_map< std::string, std::string >() );
+        public:
+                void reset() {
+                        level = 0;
+                        ++resetCount;
                 }
 
-                void RenameVars::reset() {
-                        level = 0;
-                        resetCount++;
+                using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator;
+
+                void rename( TypeInstType * type ) {
+                        mapConstIterator it = nameMap.find( type->name );
+                        if ( it != nameMap.end() ) {
+                                type->name = it->second;
+                        }
                 }
 
-                void RenameVars::previsit( TypeInstType * instType ) {
-                        previsit( (Type *)instType );
-                        std::unordered_map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
-                        if ( i != mapStack.front().end() ) {
-                                instType->name = i->second;
-                        } // if
-                }
-
-                void RenameVars::previsit( Type * type ) {
+                void openLevel( Type * type ) {
                         if ( ! type->forall.empty() ) {
-                                // copies current name mapping into new mapping
-                                mapStack.push_front( mapStack.front() );
+                                nameMap.beginScope();
                                 // renames all "forall" type names to `_${level}_${name}'
                                 for ( auto td : type->forall ) {
@@ -80 +61 @@
                                         output << "_" << resetCount << "_" << level << "_" << td->name;
                                         std::string newname( output.str() );
-                                        mapStack.front()[ td->get_name() ] = newname;
+                                        nameMap[ td->get_name() ] = newname;
                                         td->name = newname;
                                         // ditto for assertion names, the next level in
@@ -89 +70 @@
                 }
 
-                void RenameVars::postvisit( Type * type ) {
-                        // clears name mapping added by typeBefore()
-                        if ( ! type->forall.empty() ) {
-                                mapStack.pop_front();
-                        } // if
+                void closeLevel( Type * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.endScope();
+                        }
                 }
-        } // namespace
 
-        const ast::Type * renameTyVars( const ast::Type * t ) {
-                #warning unimplemented; make sure resetTyVarRenaming() updated when implemented
-                (void)t;
-                assert(false);
-                return t;
-        }
+                const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
+                        mapConstIterator it = nameMap.find( type->name );
+                        if ( it != nameMap.end() ) {
+                                ast::TypeInstType * mutType = ast::mutate( type );
+                                mutType->name = it->second;
+                    type = mutType;
+                        }
+                        return type;
+                }
+
+                template<typename NodeT>
+                const NodeT * openLevel( const NodeT * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.beginScope();
+                                // Load new names from this forall clause and perform renaming.
+                                NodeT * mutType = ast::mutate( type );
+                                for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
+                                        std::ostringstream output;
+                                        output << "_" << resetCount << "_" << level << "_" << td->name;
+                                        std::string newname( output.str() );
+                                        nameMap[ td->name ] = newname;
+                                        ++level;
+
+                                        ast::TypeDecl * decl = ast::mutate( td.get() );
+                                        decl->name = newname;
+                                        td = decl;
+                                }
+                        }
+                        return type;
+                }
+
+                template<typename NodeT>
+                const NodeT * closeLevel( const NodeT * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.endScope();
+                        }
+                        return type;
+                }
+        };
+
+        // Global State:
+        RenamingData renaming;
+
+        struct RenameVars {
+                void previsit( TypeInstType * instType ) {
+                        renaming.openLevel( (Type*)instType );
+                        renaming.rename( instType );
+                }
+                void previsit( Type * type ) {
+                        renaming.openLevel( type );
+                }
+                void postvisit( Type * type ) {
+                        renaming.closeLevel( type );
+                }
+
+                const ast::FunctionType * previsit( const ast::FunctionType * type ) {
+                        return renaming.openLevel( type );
+                }
+                const ast::StructInstType * previsit( const ast::StructInstType * type ) {
+                        return renaming.openLevel( type );
+                }
+                const ast::UnionInstType * previsit( const ast::UnionInstType * type ) {
+                        return renaming.openLevel( type );
+                }
+                const ast::TraitInstType * previsit( const ast::TraitInstType * type ) {
+                        return renaming.openLevel( type );
+                }
+                const ast::TypeInstType * previsit( const ast::TypeInstType * type ) {
+                        return renaming.rename( renaming.openLevel( type ) );
+                }
+                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
+                        return renaming.closeLevel( type );
+                }
+        };
+
+} // namespace
+
+void renameTyVars( Type * t ) {
+        PassVisitor<RenameVars> renamer;
+        t->accept( renamer );
+}
+
+const ast::Type * renameTyVars( const ast::Type * t ) {
+        ast::Pass<RenameVars> renamer;
+        return t->accept( renamer );
+}
+
+void resetTyVarRenaming() {
+        renaming.reset();
+}
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -1109 +1109 @@
                 
                 // set up and resolve expression cast to void
-                ast::CastExpr * untyped = new ast::CastExpr{ expr->location, expr };
+                ast::CastExpr * untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression( 
                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
@@ -1161 +1161 @@
                 ) {
                         assert( untyped && type );
-                        ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped->location, untyped, type };
+                        ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
                         ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, symtab );
                         removeExtraneousCast( newExpr, symtab );
@@ -1251 +1251 @@
                 ast::Pass< Resolver_new > resolver;
                 accept_all( translationUnit, resolver );
+        }
+
+        ast::ptr< ast::Init > resolveCtorInit( 
+                const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab 
+        ) {
+                assert( ctorInit );
+                ast::Pass< Resolver_new > resolver{ symtab };
+                return ctorInit->accept( resolver );
         }
 

src/ResolvExpr/Resolver.h

@@ -29 +29 @@
 
 namespace ast {
+        class ConstructorInit;
         class Decl;
         class DeletedExpr;
+        class Init;
         class StmtExpr;
         class SymbolTable;
@@ -59 +61 @@
         ast::ptr< ast::Expr > resolveInVoidContext(
                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
+        /// Resolves a constructor init expression
+        ast::ptr< ast::Init > resolveCtorInit( 
+                const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab );
         /// Resolves a statement expression
         ast::ptr< ast::Expr > resolveStmtExpr( 

src/SymTab/Autogen.cc

@@ -24 +24 @@
 #include <vector>                  // for vector
 
+#include "AST/Decl.hpp"
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/PassVisitor.h"    // for PassVisitor
@@ -209 +210 @@
         }
 
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+                return obj && obj->name.empty() && obj->bitfieldWidth;
+        }
+
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
@@ -388 +393 @@
 
         void StructFuncGenerator::makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward ) {
-                InitTweak::InitExpander srcParam( src );
+                InitTweak::InitExpander_old srcParam( src );
 
                 // assign to destination

src/SymTab/Autogen.h

@@ -17 +17 @@
 
 #include <cassert>                // for assert
+#include <iterator>               // for back_inserter
 #include <string>                 // for string
 
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
+#include "Common/utility.h"       // for splice
 #include "InitTweak/InitTweak.h"  // for InitExpander
 #include "SynTree/Constant.h"     // for Constant
@@ -36 +44 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
 
         /// generate the type of an assignment function for paramType.
@@ -49 +58 @@
         FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
 
+        /// Enum for loop direction
+        enum LoopDirection { LoopBackward, LoopForward };
+
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
+        Statement * genScalarCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -106 +124 @@
         }
 
+        /// inserts into out a generated call expression to function fname with arguments dstParam and 
+        /// srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if 
+        /// there is one
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genScalarCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
+                const ast::Type * addCast = nullptr
+        ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new ast::AddressExpr{ dstParam };
+                        addCast = nullptr;
+                        isReferenceCtorDtor = true;
+                }
+
+                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
+                // "?=?", "?{}", or "^?{}"
+                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
+
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and 
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue 
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an 
+                        // lvalue-qualified type, so remove all qualifiers except lvalue.
+                        // xxx -- old code actually removed lvalue too...
+                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
+                        ast::ptr< ast::Type > castType = addCast;
+                        ast::remove_qualifiers( 
+                                castType, 
+                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
+                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
+                fExpr->args.emplace_back( dstParam );
+
+                const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
+
+                // fetch next set of arguments
+                ++srcParam;
+
+                // return if adding reference fails -- will happen on default ctor and dtor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
+
+                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
+                splice( fExpr->args, args );
+
+                *out++ = new ast::ExprStmt{ loc, fExpr };
+
+                srcParam.clearArrayIndices();
+                
+                return listInit;
+        }
+
         /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander_old & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -170 +245 @@
         }
 
+        /// Store in out a loop which calls fname on each element of the array with srcParam and 
+        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
+        template< typename OutIter >
+        void genArrayCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
+                LoopDirection forward = LoopForward 
+        ) {
+                static UniqueName indexName( "_index" );
+
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->dimension ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
+
+                ast::ptr< ast::Expr > begin, end, cmp, update;
+
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = ast::ConstantExpr::from_int( loc, 0 );
+                        end = array->dimension;
+                        cmp = new ast::NameExpr{ loc, "?<?" };
+                        update = new ast::NameExpr{ loc, "++?" };
+                } else {
+                        // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = new ast::UntypedExpr{ 
+                                loc, new ast::NameExpr{ loc, "?-?" }, 
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
+                        end = ast::ConstantExpr::from_int( loc, 0 );
+                        cmp = new ast::NameExpr{ loc, "?>=?" };
+                        update = new ast::NameExpr{ loc, "--?" };
+                }
+
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
+                        loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
+                        new ast::SingleInit{ loc, begin } };
+                
+                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
+                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
+                
+                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
+                        loc, update, { new ast::VariableExpr{ loc, index } } };
+                
+                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
+                        loc, new ast::NameExpr{ loc, "?[?]" }, 
+                        { dstParam, new ast::VariableExpr{ loc, index } } };
+                
+                // srcParam must keep track of the array indices to build the source parameter and/or 
+                // array list initializer
+                srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
+
+                // for stmt's body, eventually containing call
+                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
+                ast::ptr< ast::Stmt > listInit = genCall( 
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
+                        forward );
+                
+                // block containing the stmt and index variable
+                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
+                block->push_back( new ast::DeclStmt{ loc, index } );
+                if ( listInit ) { block->push_back( listInit ); }
+                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
+
+                *out++ = block;
+        }
+
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -180 +325 @@
         }
 
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
+        ) {
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        genArrayCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
+                                forward );
+                        return {};
+                } else {
+                        return genScalarCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                }
+        }
+
         /// inserts into out a generated call expression to function fname with arguments dstParam
         /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
@@ -185 +347 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
@@ -213 +375 @@
                 }
         }
+
+        static inline ast::ptr< ast::Stmt > genImplicitCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
+                LoopDirection forward = LoopForward 
+        ) {
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return {};
+
+                ast::ptr< ast::Type > addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
+
+                std::vector< ast::ptr< ast::Stmt > > stmts;
+                genCall( 
+                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
+
+                if ( stmts.empty() ) {
+                        return {};
+                } else if ( stmts.size() == 1 ) {
+                        const ast::Stmt * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
+                                // aware they were generated.
+                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
+                        return callStmt;
+                } else {
+                        assert( false );
+                        return {};
+                }
+        }
 } // namespace SymTab
 

src/SymTab/FixFunction.cc

@@ -18 +18 @@
 #include <list>                   // for list
 
-#include "Common/utility.h"       // for maybeClone
+#include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
+#include "Common/utility.h"       // for maybeClone, copy
 #include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
 #include "SynTree/Expression.h"   // for Expression
@@ -24 +27 @@
 
 namespace SymTab {
-        FixFunction::FixFunction() : isVoid( false ) {}
+        class FixFunction_old : public WithShortCircuiting {
+                typedef Mutator Parent;
+          public:
+                FixFunction_old() : isVoid( false ) {}
 
+                void premutate(FunctionDecl *functionDecl);
+                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
 
-        DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
+                Type * postmutate(ArrayType * arrayType);
+
+                void premutate(ArrayType * arrayType);
+                void premutate(VoidType * voidType);
+                void premutate(BasicType * basicType);
+                void premutate(PointerType * pointerType);
+                void premutate(StructInstType * aggregateUseType);
+                void premutate(UnionInstType * aggregateUseType);
+                void premutate(EnumInstType * aggregateUseType);
+                void premutate(TraitInstType * aggregateUseType);
+                void premutate(TypeInstType * aggregateUseType);
+                void premutate(TupleType * tupleType);
+                void premutate(VarArgsType * varArgsType);
+                void premutate(ZeroType * zeroType);
+                void premutate(OneType * oneType);
+
+                bool isVoid;
+        };
+
+        DeclarationWithType * FixFunction_old::postmutate(FunctionDecl *functionDecl) {
                 // can't delete function type because it may contain assertions, so transfer ownership to new object
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
@@ -41 +68 @@
         // does not cause an error
 
-        Type * FixFunction::postmutate(ArrayType *arrayType) {
+        Type * FixFunction_old::postmutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
@@ -51 +78 @@
         }
 
-        void FixFunction::premutate(VoidType *) {
+        void FixFunction_old::premutate(VoidType *) {
                 isVoid = true;
         }
 
-        void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
-        void FixFunction::premutate(ArrayType *) { visit_children = false; }
-        void FixFunction::premutate(BasicType *) { visit_children = false; }
-        void FixFunction::premutate(PointerType *) { visit_children = false; }
-        void FixFunction::premutate(StructInstType *) { visit_children = false; }
-        void FixFunction::premutate(UnionInstType *) { visit_children = false; }
-        void FixFunction::premutate(EnumInstType *) { visit_children = false; }
-        void FixFunction::premutate(TraitInstType *) { visit_children = false; }
-        void FixFunction::premutate(TypeInstType *) { visit_children = false; }
-        void FixFunction::premutate(TupleType *) { visit_children = false; }
-        void FixFunction::premutate(VarArgsType *) { visit_children = false; }
-        void FixFunction::premutate(ZeroType *) { visit_children = false; }
-        void FixFunction::premutate(OneType *) { visit_children = false; }
+        void FixFunction_old::premutate(FunctionDecl *) { visit_children = false; }
+        void FixFunction_old::premutate(ArrayType *) { visit_children = false; }
+        void FixFunction_old::premutate(BasicType *) { visit_children = false; }
+        void FixFunction_old::premutate(PointerType *) { visit_children = false; }
+        void FixFunction_old::premutate(StructInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(UnionInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(EnumInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TraitInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TypeInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TupleType *) { visit_children = false; }
+        void FixFunction_old::premutate(VarArgsType *) { visit_children = false; }
+        void FixFunction_old::premutate(ZeroType *) { visit_children = false; }
+        void FixFunction_old::premutate(OneType *) { visit_children = false; }
 
         bool fixFunction( DeclarationWithType *& dwt ) {
-                PassVisitor<FixFunction> fixer;
+                PassVisitor<FixFunction_old> fixer;
                 dwt = dwt->acceptMutator( fixer );
                 return fixer.pass.isVoid;
         }
+
+namespace {
+        struct FixFunction_new final : public ast::WithShortCircuiting {
+                bool isVoid = false;
+
+                void premutate( const ast::FunctionDecl * ) { visit_children = false; }
+
+                const ast::DeclWithType * postmutate( const ast::FunctionDecl * func ) {
+                        return new ast::ObjectDecl{ 
+                                func->location, func->name, new ast::PointerType{ func->type }, nullptr, 
+                                func->storage, func->linkage, nullptr, copy( func->attributes ) };
+                }
+
+                void premutate( const ast::ArrayType * ) { visit_children = false; }
+
+                const ast::Type * postmutate( const ast::ArrayType * array ) {
+                        return new ast::PointerType{ 
+                                array->base, array->dimension, array->isVarLen, array->isStatic, 
+                                array->qualifiers };
+                }
+
+                void premutate( const ast::VoidType * ) { isVoid = true; }
+
+                void premutate( const ast::BasicType * ) { visit_children = false; }
+                void premutate( const ast::PointerType * ) { visit_children = false; }
+                void premutate( const ast::StructInstType * ) { visit_children = false; }
+                void premutate( const ast::UnionInstType * ) { visit_children = false; }
+                void premutate( const ast::EnumInstType * ) { visit_children = false; }
+                void premutate( const ast::TraitInstType * ) { visit_children = false; }
+                void premutate( const ast::TypeInstType * ) { visit_children = false; }
+                void premutate( const ast::TupleType * ) { visit_children = false; }
+                void premutate( const ast::VarArgsType * ) { visit_children = false; }
+                void premutate( const ast::ZeroType * ) { visit_children = false; }
+                void premutate( const ast::OneType * ) { visit_children = false; }
+        };
+} // anonymous namespace
+
+const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid ) {
+        ast::Pass< FixFunction_new > fixer;
+        dwt = dwt->accept( fixer );
+        isVoid |= fixer.pass.isVoid;
+        return dwt;
+}
+
 } // namespace SymTab
 

src/SymTab/FixFunction.h

@@ -19 +19 @@
 #include "SynTree/SynTree.h"    // for Types
 
+namespace ast {
+        class DeclWithType;
+}
+
 namespace SymTab {
-        /// Replaces function and array types by equivalent pointer types.
-        class FixFunction : public WithShortCircuiting {
-                typedef Mutator Parent;
-          public:
-                FixFunction();
+        /// Replaces function and array types by equivalent pointer types. Returns true if type is 
+        /// void
+        bool fixFunction( DeclarationWithType *& );
 
-                void premutate(FunctionDecl *functionDecl);
-                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
-
-                Type * postmutate(ArrayType * arrayType);
-
-                void premutate(ArrayType * arrayType);
-                void premutate(VoidType * voidType);
-                void premutate(BasicType * basicType);
-                void premutate(PointerType * pointerType);
-                void premutate(StructInstType * aggregateUseType);
-                void premutate(UnionInstType * aggregateUseType);
-                void premutate(EnumInstType * aggregateUseType);
-                void premutate(TraitInstType * aggregateUseType);
-                void premutate(TypeInstType * aggregateUseType);
-                void premutate(TupleType * tupleType);
-                void premutate(VarArgsType * varArgsType);
-                void premutate(ZeroType * zeroType);
-                void premutate(OneType * oneType);
-
-                bool isVoid;
-        };
-
-        bool fixFunction( DeclarationWithType *& );
+        /// Returns declaration with function and array types replaced by equivalent pointer types.
+        /// Sets isVoid to true if type is void
+        const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid );
 } // namespace SymTab
 

src/SymTab/Validate.cc

@@ -46 +46 @@
 #include <utility>                     // for pair
 
+#include "AST/Decl.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/CodeGenerator.h"     // for genName
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
@@ -124 +129 @@
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        struct EnumAndPointerDecay {
+        struct EnumAndPointerDecay_old {
                 void previsit( EnumDecl *aggregateDecl );
                 void previsit( FunctionType *func );
@@ -130 +135 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes>, public WithShortCircuiting {
-                LinkReferenceToTypes( const Indexer *indexer );
+        struct LinkReferenceToTypes_old final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes_old>, public WithShortCircuiting {
+                LinkReferenceToTypes_old( const Indexer *indexer );
                 void postvisit( TypeInstType *typeInst );
 
@@ -165 +170 @@
 
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
-        struct ForallPointerDecay final {
+        struct ForallPointerDecay_old final {
                 void previsit( ObjectDecl * object );
                 void previsit( FunctionDecl * func );
@@ -290 +295 @@
 
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
-                PassVisitor<EnumAndPointerDecay> epc;
-                PassVisitor<LinkReferenceToTypes> lrt( nullptr );
-                PassVisitor<ForallPointerDecay> fpd;
+                PassVisitor<EnumAndPointerDecay_old> epc;
+                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
+                PassVisitor<ForallPointerDecay_old> fpd;
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
@@ -305 +310 @@
                         ReplaceTypedef::replaceTypedef( translationUnit );
                         ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
-                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
+                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
                 }
                 {
@@ -314 +319 @@
                         });
                         Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
-                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes, because aggregate members are accessed
+                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
                         });
                         Stats::Time::TimeBlock("Hoist Structs", [&]() {
@@ -326 +331 @@
                         Stats::Heap::newPass("validate-C");
                         Stats::Time::BlockGuard guard("validate-C");
-                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
+                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
                         VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
                         ReturnChecker::checkFunctionReturns( translationUnit );
@@ -344 +349 @@
                         });
                         Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
-                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
+                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
                         });
                 }
@@ -385 +390 @@
 
         void validateType( Type *type, const Indexer *indexer ) {
-                PassVisitor<EnumAndPointerDecay> epc;
-                PassVisitor<LinkReferenceToTypes> lrt( indexer );
-                PassVisitor<ForallPointerDecay> fpd;
+                PassVisitor<EnumAndPointerDecay_old> epc;
+                PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
+                PassVisitor<ForallPointerDecay_old> fpd;
                 type->accept( epc );
                 type->accept( lrt );
@@ -586 +591 @@
         }
 
-        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
+        void EnumAndPointerDecay_old::previsit( EnumDecl *enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
                 for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
@@ -618 +623 @@
         }
 
-        void EnumAndPointerDecay::previsit( FunctionType *func ) {
+        void EnumAndPointerDecay_old::previsit( FunctionType *func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->parameters, func->isVarArgs, func );
@@ -624 +629 @@
         }
 
-        LinkReferenceToTypes::LinkReferenceToTypes( const Indexer *other_indexer ) {
+        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer *other_indexer ) {
                 if ( other_indexer ) {
                         local_indexer = other_indexer;
@@ -632 +637 @@
         }
 
-        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
+        void LinkReferenceToTypes_old::postvisit( EnumInstType *enumInst ) {
                 EnumDecl *st = local_indexer->lookupEnum( enumInst->name );
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
@@ -652 +657 @@
         }
 
-        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
+        void LinkReferenceToTypes_old::postvisit( StructInstType *structInst ) {
                 StructDecl *st = local_indexer->lookupStruct( structInst->name );
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
@@ -665 +670 @@
         }
 
-        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
+        void LinkReferenceToTypes_old::postvisit( UnionInstType *unionInst ) {
                 UnionDecl *un = local_indexer->lookupUnion( unionInst->name );
                 // it's not a semantic error if the union is not found, just an implicit forward declaration
@@ -678 +683 @@
         }
 
-        void LinkReferenceToTypes::previsit( QualifiedType * ) {
+        void LinkReferenceToTypes_old::previsit( QualifiedType * ) {
                 visit_children = false;
         }
 
-        void LinkReferenceToTypes::postvisit( QualifiedType * qualType ) {
+        void LinkReferenceToTypes_old::postvisit( QualifiedType * qualType ) {
                 // linking only makes sense for the 'oldest ancestor' of the qualified type
                 qualType->parent->accept( *visitor );
@@ -729 +734 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TraitDecl * traitDecl ) {
+        void LinkReferenceToTypes_old::postvisit( TraitDecl * traitDecl ) {
                 if ( traitDecl->name == "sized" ) {
                         // "sized" is a special trait - flick the sized status on for the type variable
@@ -751 +756 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TraitInstType * traitInst ) {
+        void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
                 // handle other traits
                 TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
@@ -777 +782 @@
         }
 
-        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
+        void LinkReferenceToTypes_old::postvisit( EnumDecl *enumDecl ) {
                 // visit enum members first so that the types of self-referencing members are updated properly
                 if ( enumDecl->body ) {
@@ -799 +804 @@
         }
 
-        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
+        void LinkReferenceToTypes_old::renameGenericParams( std::list< TypeDecl * > & params ) {
                 // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
                 //   forall(otype T)
@@ -817 +822 @@
         }
 
-        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
+        void LinkReferenceToTypes_old::previsit( StructDecl * structDecl ) {
                 renameGenericParams( structDecl->parameters );
         }
 
-        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
+        void LinkReferenceToTypes_old::previsit( UnionDecl * unionDecl ) {
                 renameGenericParams( unionDecl->parameters );
         }
 
-        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes_old::postvisit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
                 // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
@@ -839 +844 @@
         }
 
-        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
+        void LinkReferenceToTypes_old::postvisit( UnionDecl *unionDecl ) {
                 if ( unionDecl->body ) {
                         ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
@@ -851 +856 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+        void LinkReferenceToTypes_old::postvisit( TypeInstType *typeInst ) {
                 // ensure generic parameter instances are renamed like the base type
                 if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
@@ -888 +893 @@
         }
 
-        void ForallPointerDecay::previsit( ObjectDecl *object ) {
+        void ForallPointerDecay_old::previsit( ObjectDecl *object ) {
                 // ensure that operator names only apply to functions or function pointers
                 if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
@@ -896 +901 @@
         }
 
-        void ForallPointerDecay::previsit( FunctionDecl *func ) {
+        void ForallPointerDecay_old::previsit( FunctionDecl *func ) {
                 func->fixUniqueId();
         }
 
-        void ForallPointerDecay::previsit( FunctionType * ftype ) {
+        void ForallPointerDecay_old::previsit( FunctionType * ftype ) {
                 forallFixer( ftype->forall, ftype );
         }
 
-        void ForallPointerDecay::previsit( StructDecl * aggrDecl ) {
+        void ForallPointerDecay_old::previsit( StructDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
         }
 
-        void ForallPointerDecay::previsit( UnionDecl * aggrDecl ) {
+        void ForallPointerDecay_old::previsit( UnionDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
         }
@@ -1368 +1373 @@
         }
 
-        const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab ) {
-                #warning unimplemented
-                (void)type; (void)symtab;
-                assert(false);
-                return nullptr;
-        }
+namespace {
+        /// Replaces enum types by int, and function/array types in function parameter and return 
+        /// lists by appropriate pointers
+        struct EnumAndPointerDecay_new {
+                const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
+                        // set the type of each member of the enumeration to be EnumConstant
+                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
+                                // build new version of object with EnumConstant
+                                ast::ptr< ast::ObjectDecl > obj = 
+                                        enumDecl->members[i].strict_as< ast::ObjectDecl >();
+                                obj.get_and_mutate()->type = 
+                                        new ast::EnumInstType{ enumDecl->name, ast::CV::Const };
+                                
+                                // set into decl
+                                ast::EnumDecl * mut = mutate( enumDecl );
+                                mut->members[i] = obj.get();
+                                enumDecl = mut;
+                        }
+                        return enumDecl;
+                }
+
+                static const ast::FunctionType * fixFunctionList(
+                        const ast::FunctionType * func, 
+                        std::vector< ast::ptr< ast::DeclWithType > > ast::FunctionType::* field,
+                        ast::ArgumentFlag isVarArgs = ast::FixedArgs
+                ) {
+                        const auto & dwts = func->*field;
+                        unsigned nvals = dwts.size();
+                        bool hasVoid = false;
+                        for ( unsigned i = 0; i < nvals; ++i ) {
+                                func = ast::mutate_field_index( func, field, i, fixFunction( dwts[i], hasVoid ) );
+                        }
+                        
+                        // the only case in which "void" is valid is where it is the only one in the list
+                        if ( hasVoid && ( nvals > 1 || isVarArgs ) ) {
+                                SemanticError( 
+                                        dwts.front()->location, func, "invalid type void in function type" );
+                        }
+
+                        // one void is the only thing in the list, remove it
+                        if ( hasVoid ) {
+                                func = ast::mutate_field( 
+                                        func, field, std::vector< ast::ptr< ast::DeclWithType > >{} );
+                        }
+
+                        return func;
+                }
+
+                const ast::FunctionType * previsit( const ast::FunctionType * func ) {
+                        func = fixFunctionList( func, &ast::FunctionType::params, func->isVarArgs );
+                        return fixFunctionList( func, &ast::FunctionType::returns );
+                }
+        };
+
+        /// Associates forward declarations of aggregates with their definitions
+        struct LinkReferenceToTypes_new final 
+        : public ast::WithSymbolTable, public ast::WithGuards, public 
+          ast::WithVisitorRef<LinkReferenceToTypes_new>, public ast::WithShortCircuiting {
+                
+                const ast::SymbolTable * localSyms;
+
+                LinkReferenceToTypes_new( const ast::SymbolTable & syms ) : localSyms( &syms ) {}
+
+                #warning incomplete
+        };
+
+        /// Replaces array and function types in forall lists by appropriate pointer type and assigns 
+        /// each object and function declaration a unique ID
+        struct ForallPointerDecay_new {
+                #warning incomplete
+        };
+} // anonymous namespace
+
+const ast::Type * validateType( const ast::Type * type, const ast::SymbolTable & symtab ) {
+        ast::Pass< EnumAndPointerDecay_new > epc;
+        ast::Pass< LinkReferenceToTypes_new > lrt{ symtab };
+        ast::Pass< ForallPointerDecay_new > fpd;
+
+        return type->accept( epc )->accept( lrt )->accept( fpd );
+}
+
 } // namespace SymTab
 

src/Tuples/Explode.cc

@@ -133 +133 @@
                         if ( first ) {
                                 castAdded = true;
-                                const ast::Expr * tuple = new ast::TupleExpr(
-                                        tupleExpr->location, std::move( exprs ) );
-                                return new ast::CastExpr( tuple->location,
-                                        tuple, new ast::ReferenceType( tuple->result.get(), ast::CV::Qualifiers() ) );
+                                const ast::Expr * tuple = new ast::TupleExpr{
+                                        tupleExpr->location, std::move( exprs ) };
+                                return new ast::CastExpr{ tuple, new ast::ReferenceType{ tuple->result } };
                         } else {
                                 return new ast::TupleExpr( tupleExpr->location, std::move( exprs ) );
@@ -145 +144 @@
                 } else {
                         castAdded = true;
-                        return new ast::CastExpr( expr->location, expr,
-                                new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+                        return new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
                 }
         }
@@ -164 +162 @@
                         castAdded = false;
                         const ast::Type * newType = getReferenceBase( newNode->result );
-                        return new ast::CastExpr( newNode->location, node, newType );
+                        return new ast::CastExpr{ newNode->location, node, newType };
                 }
                 return newNode;
@@ -183 +181 @@
         expr = expr->accept( exploder );
         if ( ! exploder.pass.foundUniqueExpr ) {
-                expr = new ast::CastExpr( expr->location, expr,
-                        new ast::ReferenceType( expr->result, ast::CV::Qualifiers() ) );
+                expr = new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
         }
         return expr;

src/Tuples/Explode.h

@@ -211 +211 @@
                         // Cast a reference away to a value-type to allow further explosion.
                         if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
-                                local = new ast::CastExpr( local->location, local, tupleType );
+                                local = new ast::CastExpr{ local, tupleType };
                         }
                         // Now we have to go across the tuple via indexing.
@@ -238 +238 @@
 }
 
+/// explode list of candidates into flattened list of candidates
+template< typename Output >
+void explode( 
+        const ResolvExpr::CandidateList & cands, const ast::SymbolTable & symtab, Output && out, 
+        bool isTupleAssign = false
+) {
+        for ( const ResolvExpr::CandidateRef & cand : cands ) {
+                explode( *cand, symtab, std::forward< Output >( out ), isTupleAssign );
+        }
+}
+
 } // namespace Tuples
 

src/Tuples/TupleAssignment.cc

@@ -22 +22 @@
 #include <vector>
 
+#include "AST/Decl.hpp"
+#include "AST/Init.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/TypeEnvironment.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"
 #include "Common/UniqueName.h"             // for UniqueName
-#include "Common/utility.h"                // for zipWith
+#include "Common/utility.h"                // for splice, zipWith
 #include "Explode.h"                       // for explode
 #include "InitTweak/GenInit.h"             // for genCtorInit
@@ -51 +56 @@
 
 namespace Tuples {
-        class TupleAssignSpotter {
+        class TupleAssignSpotter_old {
           public:
                 // dispatcher for Tuple (multiple and mass) assignment operations
-                TupleAssignSpotter( ResolvExpr::AlternativeFinder & );
+                TupleAssignSpotter_old( ResolvExpr::AlternativeFinder & );
                 void spot( UntypedExpr * expr, std::vector<ResolvExpr::AlternativeFinder> &args );
 
@@ -62 +67 @@
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                        Matcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs, 
                                 const ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
@@ -80 +85 @@
                         
                         ResolvExpr::AltList lhs, rhs;
-                        TupleAssignSpotter &spotter;
+                        TupleAssignSpotter_old &spotter;
                         ResolvExpr::Cost baseCost;
                         std::list< ObjectDecl * > tmpDecls;
@@ -90 +95 @@
                 struct MassAssignMatcher : public Matcher {
                   public:
-                        MassAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                        MassAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -97 +102 @@
                 struct MultipleAssignMatcher : public Matcher {
                   public:
-                        MultipleAssignMatcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs,
+                        MultipleAssignMatcher( TupleAssignSpotter_old &spotter, const ResolvExpr::AltList& lhs,
                                 const ResolvExpr::AltList& rhs ) : Matcher(spotter, lhs, rhs) {}
                         virtual void match( std::list< Expression * > &out );
@@ -136 +141 @@
         void handleTupleAssignment( ResolvExpr::AlternativeFinder & currentFinder, UntypedExpr * expr,
                                 std::vector<ResolvExpr::AlternativeFinder> &args ) {
-                TupleAssignSpotter spotter( currentFinder );
+                TupleAssignSpotter_old spotter( currentFinder );
                 spotter.spot( expr, args );
         }
 
-        TupleAssignSpotter::TupleAssignSpotter( ResolvExpr::AlternativeFinder &f )
+        TupleAssignSpotter_old::TupleAssignSpotter_old( ResolvExpr::AlternativeFinder &f )
                 : currentFinder(f) {}
 
-        void TupleAssignSpotter::spot( UntypedExpr * expr,
+        void TupleAssignSpotter_old::spot( UntypedExpr * expr,
                         std::vector<ResolvExpr::AlternativeFinder> &args ) {
                 if (  NameExpr *op = dynamic_cast< NameExpr * >(expr->get_function()) ) {
@@ -224 +229 @@
         }
 
-        void TupleAssignSpotter::match() {
+        void TupleAssignSpotter_old::match() {
                 assert ( matcher != 0 );
 
@@ -275 +280 @@
         }
 
-        TupleAssignSpotter::Matcher::Matcher( TupleAssignSpotter &spotter,
+        TupleAssignSpotter_old::Matcher::Matcher( TupleAssignSpotter_old &spotter,
                 const ResolvExpr::AltList &lhs, const ResolvExpr::AltList &rhs )
         : lhs(lhs), rhs(rhs), spotter(spotter),
@@ -313 +318 @@
         };
 
-        ObjectDecl * TupleAssignSpotter::Matcher::newObject( UniqueName & namer, Expression * expr ) {
+        ObjectDecl * TupleAssignSpotter_old::Matcher::newObject( UniqueName & namer, Expression * expr ) {
                 assert( expr->result && ! expr->get_result()->isVoid() );
                 ObjectDecl * ret = new ObjectDecl( namer.newName(), Type::StorageClasses(), LinkageSpec::Cforall, nullptr, expr->result->clone(), new SingleInit( expr->clone() ) );
@@ -329 +334 @@
         }
 
-        void TupleAssignSpotter::MassAssignMatcher::match( std::list< Expression * > &out ) {
+        void TupleAssignSpotter_old::MassAssignMatcher::match( std::list< Expression * > &out ) {
                 static UniqueName lhsNamer( "__massassign_L" );
                 static UniqueName rhsNamer( "__massassign_R" );
@@ -347 +352 @@
         }
 
-        void TupleAssignSpotter::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
+        void TupleAssignSpotter_old::MultipleAssignMatcher::match( std::list< Expression * > &out ) {
                 static UniqueName lhsNamer( "__multassign_L" );
                 static UniqueName rhsNamer( "__multassign_R" );
@@ -378 +383 @@
         }
 
-        void handleTupleAssignment( 
-                ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign, 
-                std::vector< ResolvExpr::CandidateFinder > & args
-        ) {
-                #warning unimplmented
-                (void)finder; (void)assign; (void)args;
-                assert(false);
-        }
+namespace {
+        /// true if `expr` is of tuple type
+        bool isTuple( const ast::Expr * expr ) {
+                if ( ! expr ) return false;
+                assert( expr->result );
+                return dynamic_cast< const ast::TupleType * >( expr->result->stripReferences() );
+        }
+        
+        /// true if `expr` is of tuple type or a reference to one
+        bool refToTuple( const ast::Expr * expr ) {
+                assert( expr->result );
+                // check for function returning tuple of reference types
+                if ( auto castExpr = dynamic_cast< const ast::CastExpr * >( expr ) ) {
+                        return refToTuple( castExpr->arg );
+                } else {
+                        return isTuple( expr );
+                }
+        }
+
+        /// Dispatcher for tuple (multiple and mass) assignment operations
+        class TupleAssignSpotter_new final {
+                /// Actually finds tuple assignment operations, by subclass
+                struct Matcher {
+                        ResolvExpr::CandidateList lhs, rhs;
+                        TupleAssignSpotter_new & spotter;
+                        CodeLocation location;
+                        ResolvExpr::Cost baseCost;
+                        std::vector< ast::ptr< ast::ObjectDecl > > tmpDecls;
+                        ast::TypeEnvironment env;
+                        ast::OpenVarSet open;
+                        ast::AssertionSet need;
+
+                        void combineState( const ResolvExpr::Candidate & cand ) {
+                                env.simpleCombine( cand.env );
+                                ast::mergeOpenVars( open, cand.open );
+                                need.insert( cand.need.begin(), cand.need.end() );
+                        }
+
+                        Matcher( 
+                                TupleAssignSpotter_new & s, const CodeLocation & loc,
+                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
+                        : lhs( l ), rhs( r ), spotter( s ), location( loc ), 
+                          baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ), tmpDecls(), 
+                          env(), open(), need() {
+                                for ( auto & cand : lhs ) combineState( *cand );
+                                for ( auto & cand : rhs ) combineState( *cand );
+                        }
+
+                        virtual std::vector< ast::ptr< ast::Expr > > match() = 0;
+
+                        /// removes environments from subexpressions within statement expressions, which could 
+                        /// throw off later passes like those in Box which rely on PolyMutator, and adds the 
+                        /// bindings to the env
+                        struct EnvRemover {
+                                /// environment to hoist ExprStmt environments to
+                                ast::TypeEnvironment & tenv;
+
+                                EnvRemover( ast::TypeEnvironment & e ) : tenv( e ) {}
+
+                                const ast::ExprStmt * previsit( const ast::ExprStmt * stmt ) {
+                                        if ( stmt->expr->env ) {
+                                                tenv.add( *stmt->expr->env );
+                                                ast::ExprStmt * mut = mutate( stmt );
+                                                mut->expr.get_and_mutate()->env = nullptr;
+                                                return mut;
+                                        }
+                                        return stmt;
+                                }
+                        };
+
+                        ast::ObjectDecl * newObject( UniqueName & namer, const ast::Expr * expr ) {
+                                assert( expr->result && ! expr->result->isVoid() );
+                                
+                                ast::ObjectDecl * ret = new ast::ObjectDecl{ 
+                                        location, namer.newName(), expr->result, new ast::SingleInit{ location, expr }, 
+                                        ast::Storage::Classes{}, ast::Linkage::Cforall };
+                                
+                                // if expression type is a reference, just need an initializer, otherwise construct
+                                if ( ! expr->result.as< ast::ReferenceType >() ) {
+                                        // resolve ctor/dtor for the new object
+                                        ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit( 
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
+                                        // remove environments from subexpressions of stmtExpr
+                                        ast::Pass< EnvRemover > rm{ env };
+                                        ret->init = ctorInit->accept( rm );
+                                }
+
+                                PRINT( std::cerr << "new object: " << ret << std::endl; )
+                                return ret;
+                        }
+
+                        ast::UntypedExpr * createFunc( 
+                                const std::string & fname, const ast::ObjectDecl * left, 
+                                const ast::ObjectDecl * right 
+                        ) {
+                                assert( left );
+                                std::vector< ast::ptr< ast::Expr > > args;
+                                args.emplace_back( new ast::VariableExpr{ location, left } );
+                                if ( right ) { args.emplace_back( new ast::VariableExpr{ location, right } ); }
+
+                                if ( left->type->referenceDepth() > 1 && CodeGen::isConstructor( fname ) ) {
+                                        args.front() = new ast::AddressExpr{ location, args.front() };
+                                        if ( right ) { args.back() = new ast::AddressExpr{ location, args.back() }; }
+                                        return new ast::UntypedExpr{ 
+                                                location, new ast::NameExpr{ location, "?=?" }, std::move(args) };
+                                } else {
+                                        return new ast::UntypedExpr{ 
+                                                location, new ast::NameExpr{ location, fname }, std::move(args) };
+                                }
+                        }
+                };
+
+                /// Finds mass-assignment operations
+                struct MassAssignMatcher final : public Matcher {
+                        MassAssignMatcher(
+                                TupleAssignSpotter_new & s, const CodeLocation & loc, 
+                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
+                        : Matcher( s, loc, l, r ) {}
+
+                        std::vector< ast::ptr< ast::Expr > > match() override {
+                                static UniqueName lhsNamer( "__massassign_L" );
+                                static UniqueName rhsNamer( "__massassign_R" );
+                                // empty tuple case falls into this matcher
+                                assert( lhs.empty() ? rhs.empty() : rhs.size() <= 1 );
+
+                                ast::ptr< ast::ObjectDecl > rtmp = 
+                                        rhs.size() == 1 ? newObject( rhsNamer, rhs.front()->expr ) : nullptr;
+
+                                std::vector< ast::ptr< ast::Expr > > out;
+                                for ( ResolvExpr::CandidateRef & lhsCand : lhs ) {
+                                        // create a temporary object for each value in the LHS and create a call 
+                                        // involving the RHS
+                                        ast::ptr< ast::ObjectDecl > ltmp = newObject( lhsNamer, lhsCand->expr );
+                                        out.emplace_back( createFunc( spotter.fname, ltmp, rtmp ) );
+                                        tmpDecls.emplace_back( std::move( ltmp ) );
+                                }
+                                if ( rtmp ) tmpDecls.emplace_back( std::move( rtmp ) );
+
+                                return out;
+                        }
+                };
+
+                /// Finds multiple-assignment operations
+                struct MultipleAssignMatcher final : public Matcher {
+                        MultipleAssignMatcher(
+                                TupleAssignSpotter_new & s, const CodeLocation & loc, 
+                                const ResolvExpr::CandidateList & l, const ResolvExpr::CandidateList & r )
+                        : Matcher( s, loc, l, r ) {}
+
+                        std::vector< ast::ptr< ast::Expr > > match() override {
+                                static UniqueName lhsNamer( "__multassign_L" );
+                                static UniqueName rhsNamer( "__multassign_R" );
+
+                                if ( lhs.size() != rhs.size() ) return {};
+
+                                // produce a new temporary object for each value in the LHS and RHS and pairwise 
+                                // create the calls
+                                std::vector< ast::ptr< ast::ObjectDecl > > ltmp, rtmp;
+
+                                std::vector< ast::ptr< ast::Expr > > out;
+                                for ( unsigned i = 0; i < lhs.size(); ++i ) {
+                                        ResolvExpr::CandidateRef & lhsCand = lhs[i];
+                                        ResolvExpr::CandidateRef & rhsCand = rhs[i];
+
+                                        // convert RHS to LHS type minus one reference -- important for case where LHS 
+                                        // is && and RHS is lvalue
+                                        auto lhsType = lhsCand->expr->result.strict_as< ast::ReferenceType >();
+                                        rhsCand->expr = new ast::CastExpr{ rhsCand->expr, lhsType->base };
+                                        ast::ptr< ast::ObjectDecl > lobj = newObject( lhsNamer, lhsCand->expr );
+                                        ast::ptr< ast::ObjectDecl > robj = newObject( rhsNamer, rhsCand->expr );
+                                        out.emplace_back( createFunc( spotter.fname, lobj, robj ) );
+                                        ltmp.emplace_back( std::move( lobj ) );
+                                        rtmp.emplace_back( std::move( robj ) );
+
+                                        // resolve the cast expression so that rhsCand return type is bound by the cast 
+                                        // type as needed, and transfer the resulting environment
+                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env };
+                                        finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
+                                        assert( finder.candidates.size() == 1 );
+                                        env = std::move( finder.candidates.front()->env );
+                                }
+                                
+                                splice( tmpDecls, ltmp );
+                                splice( tmpDecls, rtmp );
+                                
+                                return out;
+                        }
+                };
+
+                ResolvExpr::CandidateFinder & crntFinder;
+                std::string fname;
+                std::unique_ptr< Matcher > matcher;
+        
+        public:
+                TupleAssignSpotter_new( ResolvExpr::CandidateFinder & f ) 
+                : crntFinder( f ), fname(), matcher() {}
+
+                // find left- and right-hand-sides for mass or multiple assignment
+                void spot( 
+                        const ast::UntypedExpr * expr, std::vector< ResolvExpr::CandidateFinder > & args 
+                ) {
+                        if ( auto op = expr->func.as< ast::NameExpr >() ) {
+                                // skip non-assignment functions
+                                if ( ! CodeGen::isCtorDtorAssign( op->name ) ) return;
+                                fname = op->name;
+
+                                // handled by CandidateFinder if applicable (both odd cases)
+                                if ( args.empty() || ( args.size() == 1 && CodeGen::isAssignment( fname ) ) ) {
+                                        return;
+                                }
+
+                                // look over all possible left-hand-side
+                                for ( ResolvExpr::CandidateRef & lhsCand : args[0] ) {
+                                        // skip non-tuple LHS
+                                        if ( ! refToTuple( lhsCand->expr ) ) continue;
+
+                                        // explode is aware of casts - ensure every LHS is sent into explode with a 
+                                        // reference cast
+                                        if ( ! lhsCand->expr.as< ast::CastExpr >() ) {
+                                                lhsCand->expr = new ast::CastExpr{ 
+                                                        lhsCand->expr, new ast::ReferenceType{ lhsCand->expr->result } };
+                                        }
+
+                                        // explode the LHS so that each field of a tuple-valued expr is assigned
+                                        ResolvExpr::CandidateList lhs;
+                                        explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
+                                        for ( ResolvExpr::CandidateRef & cand : lhs ) {
+                                                // each LHS value must be a reference - some come in with a cast, if not 
+                                                // just cast to reference here
+                                                if ( ! cand->expr->result.as< ast::ReferenceType >() ) {
+                                                        cand->expr = new ast::CastExpr{
+                                                                cand->expr, new ast::ReferenceType{ cand->expr->result } };
+                                                }
+                                        }
+
+                                        if ( args.size() == 1 ) {
+                                                // mass default-initialization/destruction
+                                                ResolvExpr::CandidateList rhs{};
+                                                matcher.reset( new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
+                                                match();
+                                        } else if ( args.size() == 2 ) {
+                                                for ( const ResolvExpr::CandidateRef & rhsCand : args[1] ) {
+                                                        ResolvExpr::CandidateList rhs;
+                                                        if ( isTuple( rhsCand->expr ) ) {
+                                                                // multiple assignment
+                                                                explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                                matcher.reset( 
+                                                                        new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
+                                                        } else {
+                                                                // mass assignment
+                                                                rhs.emplace_back( rhsCand );
+                                                                matcher.reset( 
+                                                                        new MassAssignMatcher{ *this, expr->location, lhs, rhs } );
+                                                        }
+                                                        match();
+                                                }
+                                        } else {
+                                                // expand all possible RHS possibilities
+                                                std::vector< ResolvExpr::CandidateList > rhsCands;
+                                                combos( 
+                                                        std::next( args.begin(), 1 ), args.end(), back_inserter( rhsCands ) );
+                                                for ( const ResolvExpr::CandidateList & rhsCand : rhsCands ) {
+                                                        // multiple assignment
+                                                        ResolvExpr::CandidateList rhs;
+                                                        explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                        matcher.reset( 
+                                                                new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
+                                                        match();
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                void match() {
+                        assert( matcher );
+
+                        std::vector< ast::ptr< ast::Expr > > newAssigns = matcher->match();
+
+                        if ( ! ( matcher->lhs.empty() && matcher->rhs.empty() ) ) {
+                                // if both LHS and RHS are empty than this is the empty tuple case, wherein it's 
+                                // okay for newAssigns to be empty. Otherwise, return early so that no new 
+                                // candidates are generated
+                                if ( newAssigns.empty() ) return;
+                        }
+
+                        ResolvExpr::CandidateList crnt;
+                        // now resolve new assignments
+                        for ( const ast::Expr * expr : newAssigns ) {
+                                PRINT(
+                                        std::cerr << "== resolving tuple assign ==" << std::endl;
+                                        std::cerr << expr << std::endl;
+                                )
+
+                                ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env };
+
+                                try {
+                                        finder.find( expr, ResolvExpr::ResolvMode::withAdjustment() );
+                                } catch (...) {
+                                        // no match is not failure, just that this tuple assignment is invalid
+                                        return;
+                                }
+
+                                ResolvExpr::CandidateList & cands = finder.candidates;
+                                assert( cands.size() == 1 );
+                                assert( cands.front()->expr );
+                                crnt.emplace_back( std::move( cands.front() ) );
+                        }
+
+                        // extract expressions from the assignment candidates to produce a list of assignments 
+                        // that together form a sigle candidate
+                        std::vector< ast::ptr< ast::Expr > > solved;
+                        for ( ResolvExpr::CandidateRef & cand : crnt ) {
+                                solved.emplace_back( cand->expr );
+                                matcher->combineState( *cand );
+                        }
+
+                        crntFinder.candidates.emplace_back( std::make_shared< ResolvExpr::Candidate >(
+                                new ast::TupleAssignExpr{ 
+                                        matcher->location, std::move( solved ), std::move( matcher->tmpDecls ) }, 
+                                std::move( matcher->env ), std::move( matcher->open ), std::move( matcher->need ), 
+                                ResolvExpr::sumCost( crnt ) + matcher->baseCost ) );
+                }
+        };
+} // anonymous namespace
+
+void handleTupleAssignment( 
+        ResolvExpr::CandidateFinder & finder, const ast::UntypedExpr * assign, 
+        std::vector< ResolvExpr::CandidateFinder > & args
+) {
+        TupleAssignSpotter_new spotter{ finder };
+        spotter.spot( assign, args );
+}
+
 } // namespace Tuples