Changes in / [849720f:4a60488]

Files:

• Jenkinsfile (deleted)
• Jenkinsfile_disabled (added)
• src/AST/Attribute.hpp (modified) (1 diff)
• src/AST/Convert.cpp (modified) (2 diffs)
• src/AST/Copy.hpp (added)
• src/AST/Decl.cpp (modified) (1 diff)
• src/AST/Decl.hpp (modified) (6 diffs)
• src/AST/Eval.hpp (added)
• src/AST/Expr.cpp (modified) (6 diffs)
• src/AST/Expr.hpp (modified) (3 diffs)
• src/AST/ForallSubstitutionTable.cpp (added)
• src/AST/ForallSubstitutionTable.hpp (added)
• src/AST/ForallSubstitutor.hpp (added)
• src/AST/Init.hpp (modified) (1 diff)
• src/AST/Node.cpp (modified) (2 diffs)
• src/AST/Node.hpp (modified) (9 diffs)
• src/AST/Pass.hpp (modified) (6 diffs)
• src/AST/Pass.impl.hpp (modified) (13 diffs)
• src/AST/Pass.proto.hpp (modified) (3 diffs)
• src/AST/Stmt.hpp (modified) (2 diffs)
• src/AST/Type.cpp (modified) (8 diffs)
• src/AST/Type.hpp (modified) (12 diffs)
• src/AST/TypeEnvironment.hpp (modified) (6 diffs)
• src/AST/TypeSubstitution.cpp (modified) (6 diffs)
• src/AST/TypeSubstitution.hpp (modified) (4 diffs)
• src/AST/module.mk (modified) (1 diff)
• src/Common/ScopedMap.h (modified) (1 diff)
• src/Makefile.in (modified) (4 diffs)
• src/ResolvExpr/AdjustExprType.cc (modified) (1 diff)
• src/ResolvExpr/Candidate.hpp (modified) (2 diffs)
• src/ResolvExpr/CandidateFinder.cpp (modified) (81 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/CommonType.cc (modified) (1 diff)
• src/ResolvExpr/ConversionCost.cc (modified) (4 diffs)
• src/ResolvExpr/CurrentObject.cc (modified) (15 diffs)
• src/ResolvExpr/PolyCost.cc (modified) (1 diff)
• src/ResolvExpr/RenameVars.cc (modified) (11 diffs)
• src/ResolvExpr/ResolveTypeof.cc (modified) (5 diffs)
• src/ResolvExpr/Resolver.cc (modified) (6 diffs)
• src/ResolvExpr/SpecCost.cc (modified) (3 diffs)
• src/ResolvExpr/Unify.cc (modified) (7 diffs)
• src/SymTab/Autogen.h (modified) (5 diffs)
• src/SynTree/Statement.h (modified) (1 diff)
• src/Tuples/Explode.cc (modified) (1 diff)
• src/Tuples/Explode.h (modified) (2 diffs)
• src/Tuples/TupleAssignment.cc (modified) (6 diffs)
• src/main.cc (modified) (2 diffs)

src/AST/Attribute.hpp

@@ -51 +51 @@
         template<typename node_t>
         friend node_t * mutate(const node_t * node);
+        template<typename node_t>
+    friend node_t * shallowCopy(const node_t * node);
 };
 

src/AST/Convert.cpp

@@ -608 +608 @@
 
                 tgt->result = get<Type>().accept1(src->result);
+                // Unconditionally use a clone of the result type.
+                // We know this will leak some objects: much of the immediate conversion result.
+                // In some cases, using the conversion result directly gives unintended object sharing.
+                // A parameter (ObjectDecl, a child of a FunctionType) is shared by the weak-ref cache.
+                // But tgt->result must be fully owned privately by tgt.
+                // Applying these conservative copies here means
+                // - weak references point at the declaration's copy, not these expr.result copies (good)
+                // - we copy more objects than really needed (bad, tolerated)
+                if (tgt->result) {
+                        tgt->result = tgt->result->clone();
+                }
                 return visitBaseExpr_skipResultType(src, tgt);
         }
@@ -2113 +2124 @@
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
-                                GET_ACCEPT_1(aggregate, Expr)
+                                GET_ACCEPT_1(aggregate, Expr),
+                                ast::MemberExpr::NoOpConstructionChosen
                         )
                 );

src/AST/Decl.cpp

@@ -52 +52 @@
 
 const Type * FunctionDecl::get_type() const { return type.get(); }
-void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+void FunctionDecl::set_type( const Type * t ) {
+        type = strict_dynamic_cast< const FunctionType * >( t );
+}
 
 // --- TypeDecl

src/AST/Decl.hpp

@@ -32 +32 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
@@ -87 +89 @@
         virtual const Type * get_type() const = 0;
         /// Set type of this declaration. May be verified by subclass
-        virtual void set_type(Type *) = 0;
+        virtual void set_type( const Type * ) = 0;
 
         const DeclWithType * accept( Visitor & v ) const override = 0;
@@ -110 +112 @@
 
         const Type* get_type() const override { return type; }
-        void set_type( Type * ty ) override { type = ty; }
+        void set_type( const Type * ty ) override { type = ty; }
 
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
@@ -132 +134 @@
 
         const Type * get_type() const override;
-        void set_type(Type * t) override;
+        void set_type( const Type * t ) override;
 
         bool has_body() const { return stmts; }
@@ -149 +151 @@
         std::vector<ptr<DeclWithType>> assertions;
 
-        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
-                Type* b, Linkage::Spec spec = Linkage::Cforall )
+        NamedTypeDecl( 
+                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
+                const Type * b, Linkage::Spec spec = Linkage::Cforall )
         : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {}
 
@@ -185 +188 @@
         };
 
-        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
-                TypeVar::Kind k, bool s, Type* i = nullptr )
+        TypeDecl( 
+                const CodeLocation & loc, const std::string & name, Storage::Classes storage, 
+                const Type * b, TypeVar::Kind k, bool s, const Type * i = nullptr )
         : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeVar::Ttype || s ),
           init( i ) {}

src/AST/Expr.cpp

@@ -20 +20 @@
 #include <vector>
 
+#include "Copy.hpp"                // for shallowCopy
+#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
 #include "Stmt.hpp"
@@ -51 +53 @@
         assert( arg );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
-        };
+        UntypedExpr * ret = call( loc, "*?", arg );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -74 +74 @@
         assert( lhs && rhs );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ rhs } }
-        };
+        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -160 +158 @@
         assert( aggregate->result );
 
-        // take ownership of member type
-        result = mem->get_type();
+        // Deep copy on result type avoids mutation on transitively multiply referenced object.
+        //
+        // Example, adapted from parts of builtins and bootloader:
+        //
+        // forall(dtype T)
+        // struct __Destructor {
+        //   T * object;
+        //   void (*dtor)(T *);
+        // };
+        //
+        // forall(dtype S)
+        // void foo(__Destructor(S) &d) {
+        //   if (d.dtor) {  // here
+        //   }
+        // }
+        //
+        // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve.  Let d be the
+        // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level
+        // declaration of __Destructor.  Consider the types e.result and d.type.  In the old AST, one
+        // is a clone of the other.  Ordinary new-AST use would set them up as a multiply-referenced
+        // object.
+        //
+        // e.result: PointerType
+        // .base: FunctionType
+        // .params.front(): ObjectDecl, the anonymous parameter of type T*
+        // .type: PointerType
+        // .base: TypeInstType
+        // let x = that
+        // let y = similar, except start from d.type
+        //
+        // Consider two code lines down, genericSubstitution(...).apply(result).
+        //
+        // Applying this chosen-candidate's type substitution means modifying x, substituting
+        // S for T.  This mutation should affect x and not y.
+
+        result = deepCopy(mem->get_type());
+
         // substitute aggregate generic parameters into member type
         genericSubstitution( aggregate->result ).apply( result );
@@ -168 +201 @@
 }
 
+MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
+    MemberExpr::NoOpConstruction overloadSelector )
+: Expr( loc ), member( mem ), aggregate( agg ) {
+        assert( member );
+        assert( aggregate );
+        assert( aggregate->result );
+        (void) overloadSelector;
+}
+
 // --- VariableExpr
 
@@ -177 +219 @@
         assert( var );
         assert( var->get_type() );
-        result = var->get_type();
-        add_qualifiers( result, CV::Lvalue );
+        auto r = shallowCopy( var->get_type() );
+        r->qualifiers |= CV::Lvalue;
+        result = r;
 }
 

src/AST/Expr.hpp

@@ -30 +30 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+
 
 class ConverterOldToNew;
@@ -355 +358 @@
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
         MUTATE_FRIEND
+
+        // Custructor overload meant only for AST conversion
+        enum NoOpConstruction { NoOpConstructionChosen };
+        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
+            NoOpConstruction overloadSelector );
+        friend class ::ConverterOldToNew;
+        friend class ::ConverterNewToOld;
 };
 
@@ -531 +541 @@
 
         CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
-        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {
+                this->result = a2->result;
+        }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Init.hpp

@@ -25 +25 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {

src/AST/Node.cpp

@@ -17 +17 @@
 #include "Fwd.hpp"
 
+#include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
 
@@ -29 +30 @@
 #include "Print.hpp"
 
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_inc( const node_t * node ) { node->increment(ref_t); }
-
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
-
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
+/// MEMORY DEBUG -- allows breaking on ref-count changes of dynamically chosen object.
+/// Process to use in GDB:
+///   break ast::Node::_trap()
+///   run
+///   set variable MEM_TRAP_OBJ = <target>
+///   disable <first breakpoint>
+///   continue
+void * MEM_TRAP_OBJ = nullptr;
+
+void _trap( const void * node ) {
+        if ( node == MEM_TRAP_OBJ ) std::raise(SIGTRAP);
+}
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_inc( const node_t * node ) {
+        node->increment(ref_t);
+        _trap( node );
+}
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node, bool do_delete ) {
+        _trap( node );
+        node->decrement(ref_t, do_delete );
+}
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_check() const { 
+        // if(node) assert(node->was_ever_strong == false || node->strong_count > 0);
+}
 
 template< typename node_t, enum ast::Node::ref_type ref_t >

src/AST/Node.hpp

@@ -38 +38 @@
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
-        virtual ~Node() = default;
+        virtual ~Node() {}
 
         virtual const Node * accept( Visitor & v ) const = 0;
@@ -57 +57 @@
         template<typename node_t>
         friend node_t * mutate(const node_t * node);
+        template<typename node_t>
+        friend node_t * shallowCopy(const node_t * node);
 
         mutable size_t strong_count = 0;
@@ -69 +71 @@
         }
 
-        void decrement(ast::Node::ref_type ref) const {
+        void decrement(ast::Node::ref_type ref, bool do_delete = true) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -75 +77 @@
                 }
 
-                if(!strong_count && !weak_count) {
+                if( do_delete && !strong_count && !weak_count) {
                         delete this;
                 }
@@ -94 +96 @@
         assertf(
                 node->weak_count == 0,
-                "Error: mutating node with weak references to it will invalided some references"
+                "Error: mutating node with weak references to it will invalidate some references"
         );
         return node->clone();
@@ -104 +106 @@
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
-        
+
         // mutate and return
         node_t * ret = mutate( node );
@@ -123 +125 @@
         (ret->*field)[i] = std::forward< field_t >( val );
         return ret;
+}
+
+/// Mutate an entire indexed collection by cloning to accepted value
+template<typename node_t, typename parent_t, typename coll_t>
+const node_t * mutate_each( const node_t * node, coll_t parent_t::* field, Visitor & v ) {
+        for ( unsigned i = 0; i < (node->*field).size(); ++i ) {
+                node = mutate_field_index( node, field, i, (node->*field)[i]->accept( v ) );
+        }
+        return node;
 }
 
@@ -219 +230 @@
         operator const node_t * () const { _check(); return node; }
 
+        const node_t * release() {
+                const node_t * ret = node;
+                if ( node ) {
+                        _dec(node, false);
+                        node = nullptr;
+                }
+                return ret;
+        }
+
         /// wrapper for convenient access to dynamic_cast
         template<typename o_node_t>
@@ -244 +264 @@
 
         void _inc( const node_t * other );
-        void _dec( const node_t * other );
+        void _dec( const node_t * other, bool do_delete = true );
         void _check() const;
 

src/AST/Pass.hpp

@@ -35 +35 @@
 #include "AST/SymbolTable.hpp"
 
+#include "AST/ForallSubstitutionTable.hpp"
+
 // Private prelude header, needed for some of the magic tricks this class pulls off
 #include "AST/Pass.proto.hpp"
@@ -46 +48 @@
 //
 // Several additional features are available through inheritance
-// | WithTypeSubstitution - provides polymorphic const TypeSubstitution * env for the
-//                          current expression
-// | WithStmtsToAdd       - provides the ability to insert statements before or after the current
-//                          statement by adding new statements into stmtsToAddBefore or
-//                          stmtsToAddAfter respectively.
-// | WithDeclsToAdd       - provides the ability to insert declarations before or after the current
-//                          declarations by adding new DeclStmt into declsToAddBefore or
-//                          declsToAddAfter respectively.
-// | WithShortCircuiting  - provides the ability to skip visiting child nodes; set visit_children
-//                          to false in pre{visit,visit} to skip visiting children
-// | WithGuards           - provides the ability to save/restore data like a LIFO stack; to save,
-//                          call GuardValue with the variable to save, the variable will
-//                          automatically be restored to its previous value after the corresponding
-//                          postvisit/postmutate teminates.
-// | WithVisitorRef       - provides an pointer to the templated visitor wrapper
-// | WithSymbolTable      - provides symbol table functionality
+// | WithTypeSubstitution  - provides polymorphic const TypeSubstitution * env for the
+//                           current expression
+// | WithStmtsToAdd        - provides the ability to insert statements before or after the current
+//                           statement by adding new statements into stmtsToAddBefore or
+//                           stmtsToAddAfter respectively.
+// | WithDeclsToAdd        - provides the ability to insert declarations before or after the
+//                           current declarations by adding new DeclStmt into declsToAddBefore or
+//                           declsToAddAfter respectively.
+// | WithShortCircuiting   - provides the ability to skip visiting child nodes; set visit_children
+//                           to false in pre{visit,visit} to skip visiting children
+// | WithGuards            - provides the ability to save/restore data like a LIFO stack; to save,
+//                           call GuardValue with the variable to save, the variable will
+//                           automatically be restored to its previous value after the
+//                           corresponding postvisit/postmutate teminates.
+// | WithVisitorRef        - provides an pointer to the templated visitor wrapper
+// | WithSymbolTable       - provides symbol table functionality
+// | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
@@ -201 +204 @@
         container_t< ptr<node_t> > call_accept( const container_t< ptr<node_t> > & container );
 
+        /// Mutate forall-list, accounting for presence of type substitution map
+        template<typename node_t>
+        void mutate_forall( const node_t *& );
+
 public:
         /// Logic to call the accept and mutate the parent if needed, delegates call to accept
@@ -209 +216 @@
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
+                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.pass, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass.pass, 0); }
                 Pass<pass_t> & pass;
         };
@@ -216 +223 @@
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
+                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass.pass, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass.pass, 0); }
                 Pass<pass_t> & pass;
+        };
+
+        /// Internal RAII guard for forall substitutions
+        struct guard_forall_subs {
+                guard_forall_subs( Pass<pass_t> & pass, const ParameterizedType * type )
+                : pass( pass ), type( type ) { __pass::forall::enter(pass.pass, 0, type ); }
+                ~guard_forall_subs()         { __pass::forall::leave(pass.pass, 0, type ); }
+                Pass<pass_t> & pass;
+                const ParameterizedType * type;
         };
 
@@ -313 +329 @@
         SymbolTable symtab;
 };
+
+/// Use when the templated visitor needs to keep TypeInstType instances properly linked to TypeDecl
+struct WithForallSubstitutor {
+        ForallSubstitutionTable subs;
+};
+
 }
 

src/AST/Pass.impl.hpp

@@ -127 +127 @@
                         , decltype( node->accept(*this) )
                 >::type
-
         {
                 __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
+                __pedantic_pass_assert( node );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -323 +322 @@
         }
 
+
+        template< typename pass_t >
+        template< typename node_t >
+        void ast::Pass< pass_t >::mutate_forall( const node_t *& node ) {
+                if ( auto subs = __pass::forall::subs( pass, 0 ) ) {
+                        // tracking TypeDecl substitution, full clone
+                        if ( node->forall.empty() ) return;
+
+                        node_t * mut = mutate( node );
+                        mut->forall = subs->clone( node->forall, *this );
+                        node = mut;
+                } else {
+                        // not tracking TypeDecl substitution, just mutate
+                        maybe_accept( node, &node_t::forall );
+                }
+        }
 }
 
@@ -429 +444 @@
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ObjectDecl func(
-                                node->location, "__func__",
-                                new ast::ArrayType(
-                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
+                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
+                                CodeLocation{}, "__func__",
+                                new ast::ArrayType{
+                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
                                         nullptr, VariableLen, DynamicDim
-                                )
-                        );
-                        __pass::symtab::addId( pass, 0, &func );
+                                }
+                        } };
+                        __pass::symtab::addId( pass, 0, func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -610 +625 @@
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
-                }, [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
+                auto guard1 = makeFuncGuard( [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::enter(pass, 0);
+                }, [this, inFunctionCpy = this->inFunction]() {
+                        if ( ! inFunctionCpy ) __pass::symtab::leave(pass, 0);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -938 +953 @@
         // For now this isn't visited, it is unclear if this causes problem
         // if all tests are known to pass, remove this code
-        // VISIT(
-        //      maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-        // )
+        VISIT(
+                maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
+        )
 
         VISIT_END( Stmt, node );
@@ -1667 +1682 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &FunctionType::forall  );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1686 +1702 @@
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &StructInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1699 +1716 @@
         VISIT_START( node );
 
-        __pass::symtab::addStruct( pass, 0, node->name );
-
-        {
+        __pass::symtab::addUnion( pass, 0, node->name );
+
+        VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &UnionInstType::forall );
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &UnionInstType::params );
-        }
+        })
 
         VISIT_END( Type, node );
@@ -1716 +1734 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &EnumInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &EnumInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1730 +1749 @@
         VISIT_START( node );
 
-        VISIT(
-                maybe_accept( node, &TraitInstType::forall );
+        VISIT({
+                guard_forall_subs forall_guard { *this, node };
+                mutate_forall( node );
                 maybe_accept( node, &TraitInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1745 +1765 @@
 
         VISIT(
-                maybe_accept( node, &TypeInstType::forall );
-                maybe_accept( node, &TypeInstType::params );
+                {
+                        guard_forall_subs forall_guard { *this, node };
+                        mutate_forall( node );
+                        maybe_accept( node, &TypeInstType::params );
+                }
+                // ensure that base re-bound if doing substitution
+                __pass::forall::replace( pass, 0, node );
         )
 
@@ -1895 +1920 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = false;
+                                if (new_node != p.second) mutated = true;
                                 new_map.insert({ p.first, new_node });
                         }
@@ -1911 +1936 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = false;
+                                if (new_node != p.second) mutated = true;
                                 new_map.insert({ p.first, new_node });
                         }

src/AST/Pass.proto.hpp

@@ -263 +263 @@
                 template<typename pass_t>
                 static inline void leave( pass_t &, long ) {}
-        };
-
-        // Finally certain pass desire an up to date symbol table automatically
+        } // namespace scope
+
+        // Certain passes desire an up to date symbol table automatically
         // detect the presence of a member name `symtab` and call all the members appropriately
         namespace symtab {
                 // Some simple scoping rules
                 template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
+                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
                         pass.symtab.enterScope();
                 }
@@ -278 +278 @@
 
                 template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
+                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
                         pass.symtab.leaveScope();
                 }
@@ -356 +356 @@
                 #undef SYMTAB_FUNC1
                 #undef SYMTAB_FUNC2
-        };
-};
-};
+        } // namespace symtab
+
+        // Some passes need to mutate TypeDecl and properly update their pointing TypeInstType.
+        // Detect the presence of a member name `subs` and call all members appropriately
+        namespace forall {
+                // Some simple scoping rules
+                template<typename pass_t>
+                static inline auto enter( pass_t & pass, int, const ast::ParameterizedType * type ) 
+                -> decltype( pass.subs, void() ) {
+                        if ( ! type->forall.empty() ) pass.subs.beginScope();
+                }
+
+                template<typename pass_t>
+                static inline auto enter( pass_t &, long, const ast::ParameterizedType * ) {}
+
+                template<typename pass_t>
+                static inline auto leave( pass_t & pass, int, const ast::ParameterizedType * type ) 
+                -> decltype( pass.subs, void() ) {
+                        if ( ! type->forall.empty() ) { pass.subs.endScope(); }
+                }
+
+                template<typename pass_t>
+                static inline auto leave( pass_t &, long, const ast::ParameterizedType * ) {}
+
+                // Get the substitution table, if present
+                template<typename pass_t>
+                static inline auto subs( pass_t & pass, int ) -> decltype( &pass.subs ) {
+                        return &pass.subs;
+                }
+                
+                template<typename pass_t>
+                static inline ast::ForallSubstitutionTable * subs( pass_t &, long ) { return nullptr; }
+
+                // Replaces a TypeInstType's base TypeDecl according to the table
+                template<typename pass_t>
+                static inline auto replace( pass_t & pass, int, const ast::TypeInstType *& inst ) 
+                -> decltype( pass.subs, void() ) {
+                        inst = ast::mutate_field( 
+                                inst, &ast::TypeInstType::base, pass.subs.replace( inst->base ) );
+                }
+
+                template<typename pass_t>
+                static inline auto replace( pass_t &, long, const ast::TypeInstType *& ) {}
+
+        } // namespace forall
+} // namespace __pass
+} // namespace ast

src/AST/Stmt.hpp

@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
@@ -397 +399 @@
 class ImplicitCtorDtorStmt final : public Stmt {
 public:
-        readonly<Stmt> callStmt;
+        ptr<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,

src/AST/Type.cpp

@@ -21 +21 @@
 
 #include "Decl.hpp"
+#include "ForallSubstitutor.hpp" // for substituteForall
 #include "Init.hpp"
+#include "Common/utility.h"      // for copy, move
 #include "InitTweak/InitTweak.h" // for getPointerBase
 #include "Tuples/Tuples.h"       // for isTtype
@@ -91 +93 @@
 );
 
+// --- ParameterizedType
+
+void ParameterizedType::initWithSub( 
+        const ParameterizedType & o, Pass< ForallSubstitutor > & sub 
+) {
+        forall = sub.pass( o.forall );
+}
+
 // --- FunctionType
+
+FunctionType::FunctionType( const FunctionType & o )
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), returns(), params(), 
+  isVarArgs( o.isVarArgs ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );           // initialize substitution map
+        returns = sub.pass( o.returns ); // apply to return and parameter types
+        params = sub.pass( o.params );
+}
 
 namespace {
@@ -107 +126 @@
 
 // --- ReferenceToType
+
+void ReferenceToType::initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub ) {
+        ParameterizedType::initWithSub( o, sub ); // initialize substitution
+        params = sub.pass( o.params );            // apply to parameters
+}
+
+ReferenceToType::ReferenceToType( const ReferenceToType & o )
+: ParameterizedType( o.qualifiers, copy( o.attributes ) ), params(), name( o.name ), 
+  hoistType( o.hoistType ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );
+}
+
 std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
@@ -119 +151 @@
 // --- StructInstType
 
-StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+StructInstType::StructInstType( 
+        const StructDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool StructInstType::isComplete() const { return base ? base->body : false; }
@@ -127 +159 @@
 // --- UnionInstType
 
-UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+UnionInstType::UnionInstType( 
+        const UnionDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool UnionInstType::isComplete() const { return base ? base->body : false; }
@@ -135 +167 @@
 // --- EnumInstType
 
-EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+EnumInstType::EnumInstType( 
+        const EnumDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 bool EnumInstType::isComplete() const { return base ? base->body : false; }
@@ -143 +175 @@
 // --- TraitInstType
 
-TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+TraitInstType::TraitInstType( 
+        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, move(as) ), base( b ) {}
 
 // --- TypeInstType
+
+TypeInstType::TypeInstType( const TypeInstType & o ) 
+: ReferenceToType( o.name, o.qualifiers, copy( o.attributes ) ), base(), kind( o.kind ) {
+        Pass< ForallSubstitutor > sub;
+        initWithSub( o, sub );      // initialize substitution
+        base = sub.pass( o.base );  // apply to base type
+}
 
 void TypeInstType::set_base( const TypeDecl * b ) {
@@ -159 +198 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ), members() {
+: Type( q ), types( move(ts) ), members() {
         // This constructor is awkward. `TupleType` needs to contain objects so that members can be
         // named, but members without initializer nodes end up getting constructors, which breaks

src/AST/Type.hpp

@@ -30 +30 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
+
+template< typename T > class Pass;
+
+struct ForallSubstitutor;
 
 class Type : public Node {
@@ -164 +170 @@
         static const char *typeNames[];
 
-        BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} ) 
+        BasicType( Kind k, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : Type(q, std::move(as)), kind(k) {}
 
@@ -266 +272 @@
 /// Base type for potentially forall-qualified types
 class ParameterizedType : public Type {
+protected:
+        /// initializes forall with substitutor
+        void initWithSub( const ParameterizedType & o, Pass< ForallSubstitutor > & sub );
 public:
         using ForallList = std::vector<ptr<TypeDecl>>;
@@ -277 +286 @@
         ParameterizedType( CV::Qualifiers q, std::vector<ptr<Attribute>> && as = {} )
         : Type(q, std::move(as)), forall() {}
+
+        // enforce use of ForallSubstitutor to copy parameterized type
+        ParameterizedType( const ParameterizedType & ) = delete;
+
+        ParameterizedType( ParameterizedType && ) = default;
+
+        // no need to change destructor, and operator= deleted in Node
 
 private:
@@ -302 +318 @@
         : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
 
+        FunctionType( const FunctionType & o );
+
         /// true if either the parameters or return values contain a tttype
         bool isTtype() const;
@@ -315 +333 @@
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
 class ReferenceToType : public ParameterizedType {
+protected:
+        /// Initializes forall and parameters based on substitutor
+        void initWithSub( const ReferenceToType & o, Pass< ForallSubstitutor > & sub );
 public:
         std::vector<ptr<Expr>> params;
@@ -320 +341 @@
         bool hoistType = false;
 
-        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        ReferenceToType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ParameterizedType(q, std::move(as)), params(), name(n) {}
+
+        ReferenceToType( const ReferenceToType & o );
 
         /// Gets aggregate declaration this type refers to
@@ -339 +362 @@
         readonly<StructDecl> base;
 
-        StructInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        StructInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        StructInstType( const StructDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        StructInstType(
+                const StructDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -360 +384 @@
         readonly<UnionDecl> base;
 
-        UnionInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        UnionInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        UnionInstType( const UnionDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        UnionInstType(
+                const UnionDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -381 +406 @@
         readonly<EnumDecl> base;
 
-        EnumInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        EnumInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        EnumInstType( const EnumDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        EnumInstType(
+                const EnumDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
@@ -402 +428 @@
         readonly<TraitDecl> base;
 
-        TraitInstType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
+        TraitInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base() {}
-        TraitInstType( const TraitDecl * b, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} );
+
+        TraitInstType(
+                const TraitDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         // not meaningful for TraitInstType
@@ -425 +452 @@
         TypeVar::Kind kind;
 
-        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
+        TypeInstType(
+                const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
-        TypeInstType( const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
+
+        TypeInstType(
+                const std::string& n, TypeVar::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
+
+        TypeInstType( const TypeInstType & o );
 
         /// sets `base`, updating `kind` correctly

src/AST/TypeEnvironment.hpp

@@ -38 +38 @@
 /// Adding this comparison operator significantly improves assertion satisfaction run time for
 /// some cases. The current satisfaction algorithm's speed partially depends on the order of
-/// assertions. Assertions which have fewer possible matches should appear before assertions 
-/// which have more possible matches. This seems to imply that this could be further improved 
-/// by providing an indexer as an additional argument and ordering based on the number of 
+/// assertions. Assertions which have fewer possible matches should appear before assertions
+/// which have more possible matches. This seems to imply that this could be further improved
+/// by providing an indexer as an additional argument and ordering based on the number of
 /// matches of the same kind (object, function) for the names of the declarations.
 ///
-/// I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this 
+/// I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this
 /// comparator.
 ///
-/// Note: since this compares pointers for position, minor changes in the source file that 
-/// affect memory layout can alter compilation time in unpredictable ways. For example, the 
-/// placement of a line directive can reorder type pointers with respect to each other so that 
-/// assertions are seen in different orders, causing a potentially different number of 
-/// unification calls when resolving assertions. I've seen a TU go from 36 seconds to 27 
-/// seconds by reordering line directives alone, so it would be nice to fix this comparison so 
-/// that assertions compare more consistently. I've tried to modify this to compare on mangle 
-/// name instead of type as the second comparator, but this causes some assertions to never be 
+/// Note: since this compares pointers for position, minor changes in the source file that
+/// affect memory layout can alter compilation time in unpredictable ways. For example, the
+/// placement of a line directive can reorder type pointers with respect to each other so that
+/// assertions are seen in different orders, causing a potentially different number of
+/// unification calls when resolving assertions. I've seen a TU go from 36 seconds to 27
+/// seconds by reordering line directives alone, so it would be nice to fix this comparison so
+/// that assertions compare more consistently. I've tried to modify this to compare on mangle
+/// name instead of type as the second comparator, but this causes some assertions to never be
 /// recorded. More investigation is needed.
 struct AssertCompare {
@@ -87 +87 @@
 void print( std::ostream &, const OpenVarSet &, Indenter indent = {} );
 
-/// Represents an equivalence class of bound type variables, optionally with the concrete type 
+/// Represents an equivalence class of bound type variables, optionally with the concrete type
 /// they bind to.
 struct EqvClass {
@@ -96 +96 @@
 
         EqvClass() : vars(), bound(), allowWidening( true ), data() {}
-        
+
         /// Copy-with-bound constructor
-        EqvClass( const EqvClass & o, const Type * b ) 
+        EqvClass( const EqvClass & o, const Type * b )
         : vars( o.vars ), bound( b ), allowWidening( o.allowWidening ), data( o.data ) {}
 
@@ -143 +143 @@
         void writeToSubstitution( TypeSubstitution & sub ) const;
 
-        template< typename node_t, enum Node::ref_type ref_t >
-        int apply( ptr_base< node_t, ref_t > & type ) const {
+        template< typename node_t >
+        auto apply( node_t && type ) const {
                 TypeSubstitution sub;
                 writeToSubstitution( sub );
-                return sub.apply( type );
-        }
-
-        template< typename node_t, enum Node::ref_type ref_t >
-        int applyFree( ptr_base< node_t, ref_t > & type ) const {
+                return sub.apply( std::forward<node_t>(type) );
+        }
+
+        template< typename node_t >
+        auto applyFree( node_t && type ) const {
                 TypeSubstitution sub;
                 writeToSubstitution( sub );
-                return sub.applyFree( type );
+                return sub.applyFree( std::forward<node_t>(type) );
         }
 
@@ -173 +173 @@
         void addActual( const TypeEnvironment & actualEnv, OpenVarSet & openVars );
 
-        /// Binds the type class represented by `typeInst` to the type `bindTo`; will add the class if 
+        /// Binds the type class represented by `typeInst` to the type `bindTo`; will add the class if
         /// needed. Returns false on failure.
-        bool bindVar( 
-                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
+        bool bindVar(
+                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
                 ResolvExpr::WidenMode widen, const SymbolTable & symtab );
-        
-        /// Binds the type classes represented by `var1` and `var2` together; will add one or both 
+
+        /// Binds the type classes represented by `var1` and `var2` together; will add one or both
         /// classes if needed. Returns false on failure.
-        bool bindVarToVar( 
-                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars, 
+        bool bindVarToVar(
+                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & openVars,
                 ResolvExpr::WidenMode widen, const SymbolTable & symtab );
 
@@ -199 +199 @@
 
         /// Unifies the type bound of `to` with the type bound of `from`, returning false if fails
-        bool mergeBound( 
+        bool mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & openVars, const SymbolTable & symtab );
 
         /// Merges two type classes from local environment, returning false if fails
-        bool mergeClasses( 
-                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars, 
+        bool mergeClasses(
+                ClassList::iterator to, ClassList::iterator from, OpenVarSet & openVars,
                 const SymbolTable & symtab );
 

src/AST/TypeSubstitution.cpp

@@ -92 +92 @@
 namespace {
         struct EnvTrimmer {
-                ptr<TypeSubstitution> env;
+                const TypeSubstitution * env;
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
@@ -108 +108 @@
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();
-#if TIME_TO_CONVERT_PASSES
                 Pass<EnvTrimmer> trimmer( env, newEnv );
                 expr->accept( trimmer );
-#else
-                (void)expr;
-                (void)env;
-#endif
                 return newEnv;
         }
@@ -121 +116 @@
 
 void TypeSubstitution::normalize() {
-#if TIME_TO_CONVERT_PASSES
-        PassVisitor<Substituter> sub( *this, true );
+        Pass<Substituter> sub( *this, true );
         do {
                 sub.pass.subCount = 0;
                 sub.pass.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                        i->second = i->second->acceptMutator( sub );
+                        i->second = i->second->accept( sub );
                 }
         } while ( sub.pass.subCount );
-#endif
-}
-
-#if TIME_TO_CONVERT_PASSES
-
-Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
+}
+
+const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
         BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
@@ -146 +137 @@
                 // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
-                if ( TypeInstType * replacement = i->second.as<TypeInstType>() ) {
+                if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
                         if ( inst->name == replacement->name ) {
                                 return inst;
@@ -153 +144 @@
                 // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
-                Type * newtype = i->second->clone();
-                newtype->get_qualifiers() |= inst->get_qualifiers();
-                delete inst;
-                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
-                return newtype->acceptMutator( *visitor );
-        } // if
-}
-
-Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
+                ptr<Type> newType = i->second; // force clone if needed
+                add_qualifiers( newType, inst->qualifiers );
+                // Note: need to recursively apply substitution to the new type because normalize does not
+                // substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
+                newType = newType->accept( *visitor );
+                return newType.release();
+        } // if
+}
+
+const Expr * TypeSubstitution::Substituter::postvisit( const NameExpr * nameExpr ) {
         VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
         if ( i == sub.varEnv.end() ) {
@@ -167 +159 @@
         } else {
                 subCount++;
-                delete nameExpr;
-                return i->second->clone();
-        } // if
-}
-
-void TypeSubstitution::Substituter::premutate( Type * type ) {
+                return i->second;
+        } // if
+}
+
+void TypeSubstitution::Substituter::previsit( const ParameterizedType * ptype ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
+                for ( const TypeDecl * tyvar : ptype->forall ) {
+                                boundVars.insert( tyvar->name );
                 } // for
         } // if
 }
 
-template< typename TypeClass >
-void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
+void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
+                for ( const TypeDecl * tyvar : type->forall ) {
+                        boundVars.insert( tyvar->name );
                 } // for
                 // bind type variables from generic type instantiations
-                std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
-                if ( baseParameters && ! type->parameters.empty() ) {
-                        for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
-                                boundVars.insert( (*tyvar)->name );
-                        } // for
-                } // if
-        } // if
-}
-
-void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
+                if ( auto decl = type->aggr() ) {
+                        if ( ! type->params.empty() ) {
+                                for ( const TypeDecl * tyvar : decl->params ) {
+                                        boundVars.insert( tyvar->name );
+                                } // for
+                        } // if
+                }
+        } // if
+}
+
+void TypeSubstitution::Substituter::previsit( const StructInstType * aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
 
-void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
+void TypeSubstitution::Substituter::previsit( const UnionInstType *aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
-
-#endif
 
 } // namespace ast

src/AST/TypeSubstitution.hpp

@@ -44 +44 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
-        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
+        template< typename SynTreeClass >
+        struct ApplyResult {
+                const SynTreeClass * node;
+                int count;
+        };
+
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
 
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = apply(p);
-                input = p;
-                return ret;
+                auto ret = apply(p);
+                input = ret.node;
+                return ret.count;
         }
 
@@ -58 +64 @@
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = applyFree(p);
-                input = p;
-                return ret;
+                auto ret = applyFree(p);
+                input = ret.node;
+                return ret.count;
         }
 
@@ -155 +161 @@
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
-#if TIME_TO_CONVERT_PASSES
-
-                Type * postmutate( TypeInstType * aggregateUseType );
-                Expression * postmutate( NameExpr * nameExpr );
+                const Type * postvisit( const TypeInstType * aggregateUseType );
+                const Expr * postvisit( const NameExpr * nameExpr );
 
                 /// Records type variable bindings from forall-statements
-                void premutate( Type * type );
+                void previsit( const ParameterizedType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                template< typename TypeClass > void handleAggregateType( TypeClass * type );
-
-                void premutate( StructInstType * aggregateUseType );
-                void premutate( UnionInstType * aggregateUseType );
-
-#endif
+                void handleAggregateType( const ReferenceToType * type );
+
+                void previsit( const StructInstType * aggregateUseType );
+                void previsit( const UnionInstType * aggregateUseType );
 
                 const TypeSubstitution & sub;
@@ -179 +181 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, false );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.pass.subCount };
 }
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, true );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.pass.subCount };
 }
 

src/AST/module.mk

@@ -22 +22 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
+        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \

src/Common/ScopedMap.h

@@ -249 +249 @@
 
         /// Gets the note at the given scope
+        Note& getNote() { return scopes.back().note; }
+        const Note& getNote() const { return scopes.back().note; }
         Note& getNote( size_type i ) { return scopes[i].note; }
         const Note& getNote( size_type i ) const { return scopes[i].note; }

src/Makefile.in

@@ -169 +169 @@
         AST/Convert.$(OBJEXT) AST/Decl.$(OBJEXT) \
         AST/DeclReplacer.$(OBJEXT) AST/Expr.$(OBJEXT) \
+        AST/ForallSubstitutionTable.$(OBJEXT) \
         AST/GenericSubstitution.$(OBJEXT) AST/Init.$(OBJEXT) \
         AST/LinkageSpec.$(OBJEXT) AST/Node.$(OBJEXT) \
@@ -590 +591 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
+        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \
@@ -766 +768 @@
         AST/$(DEPDIR)/$(am__dirstamp)
 AST/Expr.$(OBJEXT): AST/$(am__dirstamp) AST/$(DEPDIR)/$(am__dirstamp)
+AST/ForallSubstitutionTable.$(OBJEXT): AST/$(am__dirstamp) \
+        AST/$(DEPDIR)/$(am__dirstamp)
 AST/GenericSubstitution.$(OBJEXT): AST/$(am__dirstamp) \
         AST/$(DEPDIR)/$(am__dirstamp)
@@ -1221 +1225 @@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/DeclReplacer.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Expr.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/ForallSubstitutionTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/GenericSubstitution.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@AST/$(DEPDIR)/Init.Po@am__quote@

src/ResolvExpr/AdjustExprType.cc

@@ -100 +100 @@
 
 namespace {
-        struct AdjustExprType_new final : public ast::WithShortCircuiting {
+        class AdjustExprType_new final : public ast::WithShortCircuiting {
+                const ast::SymbolTable & symtab;
+        public:
                 const ast::TypeEnvironment & tenv;
-                const ast::SymbolTable & symtab;
 
                 AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
-                : tenv( e ), symtab( syms ) {}
+                : symtab( syms ), tenv( e ) {}
 
-                void premutate( const ast::VoidType * ) { visit_children = false; }
-                void premutate( const ast::BasicType * ) { visit_children = false; }
-                void premutate( const ast::PointerType * ) { visit_children = false; }
-                void premutate( const ast::ArrayType * ) { visit_children = false; }
-                void premutate( const ast::FunctionType * ) { 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; }
+                void previsit( const ast::VoidType * ) { visit_children = false; }
+                void previsit( const ast::BasicType * ) { visit_children = false; }
+                void previsit( const ast::PointerType * ) { visit_children = false; }
+                void previsit( const ast::ArrayType * ) { visit_children = false; }
+                void previsit( const ast::FunctionType * ) { visit_children = false; }
+                void previsit( const ast::StructInstType * ) { visit_children = false; }
+                void previsit( const ast::UnionInstType * ) { visit_children = false; }
+                void previsit( const ast::EnumInstType * ) { visit_children = false; }
+                void previsit( const ast::TraitInstType * ) { visit_children = false; }
+                void previsit( const ast::TypeInstType * ) { visit_children = false; }
+                void previsit( const ast::TupleType * ) { visit_children = false; }
+                void previsit( const ast::VarArgsType * ) { visit_children = false; }
+                void previsit( const ast::ZeroType * ) { visit_children = false; }
+                void previsit( const ast::OneType * ) { visit_children = false; }
 
-                const ast::Type * postmutate( const ast::ArrayType * at ) {
+                const ast::Type * postvisit( const ast::ArrayType * at ) {
                         return new ast::PointerType{ at->base, at->qualifiers };
                 }
 
-                const ast::Type * postmutate( const ast::FunctionType * ft ) {
+                const ast::Type * postvisit( const ast::FunctionType * ft ) {
                         return new ast::PointerType{ ft };
                 }
 
-                const ast::Type * postmutate( const ast::TypeInstType * inst ) {
+                const ast::Type * postvisit( const ast::TypeInstType * inst ) {
                         // replace known function-type-variables with pointer-to-function
                         if ( const ast::EqvClass * eqvClass = tenv.lookup( inst->name ) ) {

src/ResolvExpr/Candidate.hpp

@@ -51 +51 @@
 
         Candidate( const ast::Expr * x, const ast::TypeEnvironment & e )
-        : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {}
+        : expr( x ), cost( Cost::zero ), cvtCost( Cost::zero ), env( e ), open(), need() {
+                assert(x->result);
+        }
 
         Candidate( const Candidate & o, const ast::Expr * x, const Cost & addedCost = Cost::zero )
         : expr( x ), cost( o.cost + addedCost ), cvtCost( Cost::zero ), env( o.env ), open( o.open ),
-          need( o.need ) {}
+          need( o.need ) {
+                assert(x->result);
+        }
 
         Candidate(
-                const ast::Expr * x, const ast::TypeEnvironment & e, const ast::OpenVarSet & o, 
+                const ast::Expr * x, const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
                 const ast::AssertionSet & n, const Cost & c, const Cost & cvt = Cost::zero )
-        : expr( x ), cost( c ), cvtCost( cvt ), env( e ), open( o ), need( n.begin(), n.end() ) {}
+        : expr( x ), cost( c ), cvtCost( cvt ), env( e ), open( o ), need( n.begin(), n.end() ) {
+                assert(x->result);
+        }
 
         Candidate(
@@ -66 +72 @@
                 ast::AssertionSet && n, const Cost & c, const Cost & cvt = Cost::zero )
         : expr( x ), cost( c ), cvtCost( cvt ), env( std::move( e ) ), open( std::move( o ) ),
-          need( n.begin(), n.end() ) {}
+          need( n.begin(), n.end() ) {
+                assert(x->result);
+        }
 };
 

src/ResolvExpr/CandidateFinder.cpp

@@ -54 +54 @@
                 return new ast::CastExpr{ expr, expr->result->stripReferences() };
         }
-        
+
         return expr;
 }
@@ -61 +61 @@
 UniqueId globalResnSlot = 0;
 
-Cost computeConversionCost( 
-        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, 
-        const ast::TypeEnvironment & env 
+Cost computeConversionCost(
+        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
 ) {
         PRINT(
@@ -107 +107 @@
 
         /// Computes conversion cost for a given expression to a given type
-        const ast::Expr * computeExpressionConversionCost( 
-                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost 
+        const ast::Expr * computeExpressionConversionCost(
+                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
         ) {
                 Cost convCost = computeConversionCost( arg->result, paramType, symtab, env );
                 outCost += convCost;
 
-                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires 
-                // conversion. Ignore poly cost for now, since this requires resolution of the cast to 
+                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
+                // conversion. Ignore poly cost for now, since this requires resolution of the cast to
                 // infer parameters and this does not currently work for the reason stated below
                 Cost tmpCost = convCost;
@@ -123 +123 @@
                         return new ast::CastExpr{ arg, newType };
 
-                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not 
-                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent, 
+                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not
+                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
                         // once this is fixed it should be possible to resolve the cast.
-                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable, 
-                        // but it shouldn't be because this makes the conversion from DT* to DT* since 
+                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
+                        // but it shouldn't be because this makes the conversion from DT* to DT* since
                         // commontype(zero_t, DT*) is DT*, rather than nothing
 
                         // CandidateFinder finder{ symtab, env };
                         // finder.find( arg, ResolvMode::withAdjustment() );
-                        // assertf( finder.candidates.size() > 0, 
+                        // assertf( finder.candidates.size() > 0,
                         //      "Somehow castable expression failed to find alternatives." );
-                        // assertf( finder.candidates.size() == 1, 
+                        // assertf( finder.candidates.size() == 1,
                         //      "Somehow got multiple alternatives for known cast expression." );
                         // return finder.candidates.front()->expr;
@@ -143 +143 @@
 
         /// Computes conversion cost for a given candidate
-        Cost computeApplicationConversionCost( 
-                CandidateRef cand, const ast::SymbolTable & symtab 
+        Cost computeApplicationConversionCost(
+                CandidateRef cand, const ast::SymbolTable & symtab
         ) {
                 auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >();
@@ -167 +167 @@
                                 if ( function->isVarArgs ) {
                                         convCost.incUnsafe();
-                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: " 
+                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
                                                 << convCost << std::endl; ; )
                                         // convert reference-typed expressions into value-typed expressions
-                                        cand->expr = ast::mutate_field_index( 
-                                                appExpr, &ast::ApplicationExpr::args, i, 
+                                        cand->expr = ast::mutate_field_index(
+                                                appExpr, &ast::ApplicationExpr::args, i,
                                                 referenceToRvalueConversion( args[i], convCost ) );
                                         continue;
@@ -180 +180 @@
                                 // Default arguments should be free - don't include conversion cost.
                                 // Unwrap them here because they are not relevant to the rest of the system
-                                cand->expr = ast::mutate_field_index( 
+                                cand->expr = ast::mutate_field_index(
                                         appExpr, &ast::ApplicationExpr::args, i, def->expr );
                                 ++param;
@@ -188 +188 @@
                         // mark conversion cost and also specialization cost of param type
                         const ast::Type * paramType = (*param)->get_type();
-                        cand->expr = ast::mutate_field_index( 
-                                appExpr, &ast::ApplicationExpr::args, i, 
-                                computeExpressionConversionCost( 
+                        cand->expr = ast::mutate_field_index(
+                                appExpr, &ast::ApplicationExpr::args, i,
+                                computeExpressionConversionCost(
                                         args[i], paramType, symtab, cand->env, convCost ) );
                         convCost.decSpec( specCost( paramType ) );
@@ -198 +198 @@
                 if ( param != params.end() ) return Cost::infinity;
 
-                // specialization cost of return types can't be accounted for directly, it disables 
+                // specialization cost of return types can't be accounted for directly, it disables
                 // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
                 //
@@ -215 +215 @@
         }
 
-        void makeUnifiableVars( 
-                const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars, 
-                ast::AssertionSet & need 
+        void makeUnifiableVars(
+                const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars,
+                ast::AssertionSet & need
         ) {
                 for ( const ast::TypeDecl * tyvar : type->forall ) {
@@ -254 +254 @@
 
                 ArgPack()
-                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ), 
+                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
                   tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-                
-                ArgPack( 
-                        const ast::TypeEnvironment & env, const ast::AssertionSet & need, 
+
+                ArgPack(
+                        const ast::TypeEnvironment & env, const ast::AssertionSet & need,
                         const ast::AssertionSet & have, const ast::OpenVarSet & open )
-                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ), 
+                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
                   open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-                
+
                 ArgPack(
-                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env, 
-                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, 
-                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero, 
+                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
+                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
+                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
                         unsigned nextExpl = 0, unsigned explAlt = 0 )
                 : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ),
                   have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
                   nextExpl( nextExpl ), explAlt( explAlt ) {}
-                
+
                 ArgPack(
-                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need, 
+                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
                         ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
-                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ), 
-                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), 
+                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ),
+                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ),
                   tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
-                
+
                 /// true if this pack is in the middle of an exploded argument
                 bool hasExpl() const { return nextExpl > 0; }
@@ -286 +286 @@
                         return args[ nextArg-1 ][ explAlt ];
                 }
-                
+
                 /// Ends a tuple expression, consolidating the appropriate args
                 void endTuple( const std::vector< ArgPack > & packs ) {
@@ -307 +307 @@
 
         /// Instantiates an argument to match a parameter, returns false if no matching results left
-        bool instantiateArgument( 
-                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args, 
-                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab, 
-                unsigned nTuples = 0 
+        bool instantiateArgument(
+                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
+                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
+                unsigned nTuples = 0
         ) {
                 if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) {
@@ -318 +318 @@
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
                                 // ^^^ need to handle the case where a tuple has a default argument
-                                if ( ! instantiateArgument( 
+                                if ( ! instantiateArgument(
                                         type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
                                 nTuples = 0;
@@ -329 +329 @@
                 } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) {
                         // paramType is a ttype, consumes all remaining arguments
-                        
+
                         // completed tuples; will be spliced to end of results to finish
                         std::vector< ArgPack > finalResults{};
@@ -342 +342 @@
                                 for ( std::size_t i = genStart; i < genEnd; ++i ) {
                                         unsigned nextArg = results[i].nextArg;
-                                        
+
                                         // use next element of exploded tuple if present
                                         if ( results[i].hasExpl() ) {
@@ -352 +352 @@
                                                 results.emplace_back(
                                                         i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
-                                                        copy( results[i].need ), copy( results[i].have ), 
+                                                        copy( results[i].need ), copy( results[i].have ),
                                                         copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl,
                                                         results[i].explAlt );
@@ -370 +370 @@
                                                         // push empty tuple expression
                                                         newResult.parent = i;
-                                                        std::vector< ast::ptr< ast::Expr > > emptyList;
-                                                        newResult.expr = 
-                                                                new ast::TupleExpr{ CodeLocation{}, move( emptyList ) };
+                                                        newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} };
                                                         argType = newResult.expr->result;
                                                 } else {
@@ -400 +398 @@
 
                                                 // check unification for ttype before adding to final
-                                                if ( 
-                                                        unify( 
+                                                if (
+                                                        unify(
                                                                 ttype, argType, newResult.env, newResult.need, newResult.have,
-                                                                newResult.open, symtab ) 
+                                                                newResult.open, symtab )
                                                 ) {
                                                         finalResults.emplace_back( move( newResult ) );
@@ -424 +422 @@
                                                 if ( expl.exprs.empty() ) {
                                                         results.emplace_back(
-                                                                results[i], move( env ), copy( results[i].need ), 
+                                                                results[i], move( env ), copy( results[i].need ),
                                                                 copy( results[i].have ), move( open ), nextArg + 1, expl.cost );
-                                                        
+
                                                         continue;
                                                 }
@@ -432 +430 @@
                                                 // add new result
                                                 results.emplace_back(
-                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ), 
-                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples, 
+                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ),
+                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples,
                                                         expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                         }
@@ -479 +477 @@
 
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg, 
+                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg,
                                                 nTuples, Cost::zero, nextExpl, results[i].explAlt );
                                 }
@@ -495 +493 @@
                                         if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
                                                 results.emplace_back(
-                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ), 
+                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ),
                                                         move( need ), move( have ), move( open ), nextArg, nTuples );
                                         }
@@ -517 +515 @@
                                 if ( expl.exprs.empty() ) {
                                         results.emplace_back(
-                                                results[i], move( env ), move( need ), move( have ), move( open ), 
+                                                results[i], move( env ), move( need ), move( have ), move( open ),
                                                 nextArg + 1, expl.cost );
-                                        
+
                                         continue;
                                 }
@@ -539 +537 @@
                                         // add new result
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ), 
+                                                i, expr, move( env ), move( need ), move( have ), move( open ),
                                                 nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                 }
@@ -548 +546 @@
                 genStart = genEnd;
 
-                return genEnd != results.size();
+                return genEnd != results.size();  // were any new results added?
         }
 
         /// Generate a cast expression from `arg` to `toType`
-        const ast::Expr * restructureCast( 
+        const ast::Expr * restructureCast(
                 ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast
         ) {
-                if ( 
-                        arg->result->size() > 1 
-                        && ! toType->isVoid() 
-                        && ! dynamic_cast< const ast::ReferenceType * >( toType ) 
+                if (
+                        arg->result->size() > 1
+                        && ! toType->isVoid()
+                        && ! dynamic_cast< const ast::ReferenceType * >( toType )
                 ) {
-                        // Argument is a tuple and the target type is neither void nor a reference. Cast each 
-                        // member of the tuple to its corresponding target type, producing the tuple of those 
-                        // cast expressions. If there are more components of the tuple than components in the 
-                        // target type, then excess components do not come out in the result expression (but 
+                        // Argument is a tuple and the target type is neither void nor a reference. Cast each
+                        // member of the tuple to its corresponding target type, producing the tuple of those
+                        // cast expressions. If there are more components of the tuple than components in the
+                        // target type, then excess components do not come out in the result expression (but
                         // UniqueExpr ensures that the side effects will still be produced)
                         if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-                                // expressions which may contain side effects require a single unique instance of 
+                                // expressions which may contain side effects require a single unique instance of
                                 // the expression
                                 arg = new ast::UniqueExpr{ arg->location, arg };
@@ -574 +572 @@
                                 // cast each component
                                 ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
-                                components.emplace_back( 
+                                components.emplace_back(
                                         restructureCast( idx, toType->getComponent( i ), isGenerated ) );
                         }
@@ -594 +592 @@
 
         /// Actually visits expressions to find their candidate interpretations
-        struct Finder final : public ast::WithShortCircuiting {
+        class Finder final : public ast::WithShortCircuiting {
+                const ast::SymbolTable & symtab;
+        public:
                 CandidateFinder & selfFinder;
-                const ast::SymbolTable & symtab;
                 CandidateList & candidates;
                 const ast::TypeEnvironment & tenv;
@@ -602 +601 @@
 
                 Finder( CandidateFinder & f )
-                : selfFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ), 
+                : symtab( f.localSyms ), selfFinder( f ), candidates( f.candidates ), tenv( f.env ),
                   targetType( f.targetType ) {}
-                
+
                 void previsit( const ast::Node * ) { visit_children = false; }
 
@@ -639 +638 @@
 
                 /// Completes a function candidate with arguments located
-                void validateFunctionCandidate( 
-                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results, 
-                        CandidateList & out 
+                void validateFunctionCandidate(
+                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
+                        CandidateList & out
                 ) {
-                        ast::ApplicationExpr * appExpr = 
+                        ast::ApplicationExpr * appExpr =
                                 new ast::ApplicationExpr{ func->expr->location, func->expr };
                         // sum cost and accumulate arguments
@@ -657 +656 @@
                         appExpr->args = move( vargs );
                         // build and validate new candidate
-                        auto newCand = 
+                        auto newCand =
                                 std::make_shared<Candidate>( appExpr, result.env, result.open, result.need, cost );
                         PRINT(
@@ -669 +668 @@
                 /// Builds a list of candidates for a function, storing them in out
                 void makeFunctionCandidates(
-                        const CandidateRef & func, const ast::FunctionType * funcType, 
+                        const CandidateRef & func, const ast::FunctionType * funcType,
                         const ExplodedArgs_new & args, CandidateList & out
                 ) {
@@ -676 +675 @@
                         ast::TypeEnvironment funcEnv{ func->env };
                         makeUnifiableVars( funcType, funcOpen, funcNeed );
-                        // add all type variables as open variables now so that those not used in the parameter 
-                        // list are still considered open
+                        // add all type variables as open variables now so that those not used in the
+                        // parameter list are still considered open
                         funcEnv.add( funcType->forall );
 
@@ -683 +682 @@
                                 // attempt to narrow based on expected target type
                                 const ast::Type * returnType = funcType->returns.front()->get_type();
-                                if ( ! unify( 
-                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab ) 
+                                if ( ! unify(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
                                 ) {
                                         // unification failed, do not pursue this candidate
@@ -698 +697 @@
                         for ( const ast::DeclWithType * param : funcType->params ) {
                                 auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
-                                // Try adding the arguments corresponding to the current parameter to the existing 
+                                // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
-                                if ( ! instantiateArgument( 
+                                if ( ! instantiateArgument(
                                         obj->type, obj->init, args, results, genStart, symtab ) ) return;
                         }
@@ -750 +749 @@
                                                         if ( expl.exprs.empty() ) {
                                                                 results.emplace_back(
-                                                                        results[i], move( env ), copy( results[i].need ), 
-                                                                        copy( results[i].have ), move( open ), nextArg + 1, 
+                                                                        results[i], move( env ), copy( results[i].need ),
+                                                                        copy( results[i].have ), move( open ), nextArg + 1,
                                                                         expl.cost );
 
@@ -760 +759 @@
                                                         results.emplace_back(
                                                                 i, expl.exprs.front(), move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost, 
+                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost,
                                                                 expl.exprs.size() == 1 ? 0 : 1, j );
                                                 }
@@ -780 +779 @@
                 /// Adds implicit struct-conversions to the alternative list
                 void addAnonConversions( const CandidateRef & cand ) {
-                        // adds anonymous member interpretations whenever an aggregate value type is seen. 
-                        // it's okay for the aggregate expression to have reference type -- cast it to the 
+                        // adds anonymous member interpretations whenever an aggregate value type is seen.
+                        // it's okay for the aggregate expression to have reference type -- cast it to the
                         // base type to treat the aggregate as the referenced value
                         ast::ptr< ast::Expr > aggrExpr( cand->expr );
                         ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
                         cand->env.apply( aggrType );
-                        
+
                         if ( aggrType.as< ast::ReferenceType >() ) {
                                 aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
@@ -799 +798 @@
 
                 /// Adds aggregate member interpretations
-                void addAggMembers( 
-                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr, 
-                        const Candidate & cand, const Cost & addedCost, const std::string & name 
+                void addAggMembers(
+                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
+                        const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
                         for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
-                                CandidateRef newCand = std::make_shared<Candidate>( 
+                                CandidateRef newCand = std::make_shared<Candidate>(
                                         cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
-                                // add anonymous member interpretations whenever an aggregate value type is seen 
+                                // add anonymous member interpretations whenever an aggregate value type is seen
                                 // as a member expression
                                 addAnonConversions( newCand );
@@ -815 +814 @@
 
                 /// Adds tuple member interpretations
-                void addTupleMembers( 
-                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand, 
-                        const Cost & addedCost, const ast::Expr * member 
+                void addTupleMembers(
+                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
+                        const Cost & addedCost, const ast::Expr * member
                 ) {
                         if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
-                                // get the value of the constant expression as an int, must be between 0 and the 
+                                // get the value of the constant expression as an int, must be between 0 and the
                                 // length of the tuple to have meaning
                                 long long val = constantExpr->intValue();
                                 if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
                                         addCandidate(
-                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val }, 
+                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
                                                 addedCost );
                                 }
@@ -837 +836 @@
                         if ( funcFinder.candidates.empty() ) return;
 
-                        std::vector< CandidateFinder > argCandidates = 
+                        std::vector< CandidateFinder > argCandidates =
                                 selfFinder.findSubExprs( untypedExpr->args );
-                        
+
                         // take care of possible tuple assignments
                         // if not tuple assignment, handled as normal function call
@@ -877 +876 @@
                                                 if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                         CandidateRef newFunc{ new Candidate{ *func } };
-                                                        newFunc->expr = 
+                                                        newFunc->expr =
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                         makeFunctionCandidates( newFunc, function, argExpansions, found );
                                                 }
-                                        } else if ( 
-                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult ) 
+                                        } else if (
+                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
                                         ) {
                                                 if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
                                                         if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                                 CandidateRef newFunc{ new Candidate{ *func } };
-                                                                newFunc->expr = 
+                                                                newFunc->expr =
                                                                         referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                                 makeFunctionCandidates( newFunc, function, argExpansions, found );
@@ -901 +900 @@
                                 std::vector< ExplodedArg > funcE;
                                 funcE.reserve( funcFinder.candidates.size() );
-                                for ( const CandidateRef & func : funcFinder ) { 
+                                for ( const CandidateRef & func : funcFinder ) {
                                         funcE.emplace_back( *func, symtab );
                                 }
@@ -913 +912 @@
                                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                                 CandidateRef newOp{ new Candidate{ *op} };
-                                                                newOp->expr = 
+                                                                newOp->expr =
                                                                         referenceToRvalueConversion( newOp->expr, newOp->cost );
                                                                 makeFunctionCandidates( newOp, function, argExpansions, found );
@@ -922 +921 @@
                         }
 
-                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error 
+                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error
                         // candidates
                         if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
@@ -934 +933 @@
                                         auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
                                         auto function = pointer->base.strict_as< ast::FunctionType >();
-                                        
+
                                         std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
                                         std::cerr << "parameters are:" << std::endl;
@@ -957 +956 @@
                         promoteCvtCost( winners );
 
-                        // function may return a struct/union value, in which case we need to add candidates 
-                        // for implicit conversions to each of the anonymous members, which must happen after 
+                        // function may return a struct/union value, in which case we need to add candidates
+                        // for implicit conversions to each of the anonymous members, which must happen after
                         // `findMinCost`, since anon conversions are never the cheapest
                         for ( const CandidateRef & c : winners ) {
@@ -966 +965 @@
 
                         if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
-                                // If resolution is unsuccessful with a target type, try again without, since it 
+                                // If resolution is unsuccessful with a target type, try again without, since it
                                 // will sometimes succeed when it wouldn't with a target type binding.
                                 // For example:
@@ -1016 +1015 @@
                                 cand->env.extractOpenVars( open );
 
-                                // It is possible that a cast can throw away some values in a multiply-valued 
-                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the 
-                                // subexpression results that are cast directly. The candidate is invalid if it 
+                                // It is possible that a cast can throw away some values in a multiply-valued
+                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
+                                // subexpression results that are cast directly. The candidate is invalid if it
                                 // has fewer results than there are types to cast to.
                                 int discardedValues = cand->expr->result->size() - toType->size();
@@ -1037 +1036 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        CandidateRef newCand = std::make_shared<Candidate>( 
-                                                restructureCast( cand->expr, toType, castExpr->isGenerated ), 
-                                                copy( cand->env ), move( open ), move( need ), cand->cost, 
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                                copy( cand->env ), move( open ), move( need ), cand->cost,
                                                 cand->cost + thisCost );
                                         inferParameters( newCand, matches );
@@ -1057 +1056 @@
                         finder.find( castExpr->arg, ResolvMode::withoutPrune() );
                         for ( CandidateRef & r : finder.candidates ) {
-                                addCandidate( 
-                                        *r, 
+                                addCandidate(
+                                        *r,
                                         new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
                         }
@@ -1067 +1066 @@
                         aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
                         for ( CandidateRef & agg : aggFinder.candidates ) {
-                                // it's okay for the aggregate expression to have reference type -- cast it to the 
+                                // it's okay for the aggregate expression to have reference type -- cast it to the
                                 // base type to treat the aggregate as the referenced value
                                 Cost addedCost = Cost::zero;
@@ -1074 +1073 @@
                                 // find member of the given type
                                 if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
-                                        addAggMembers( 
+                                        addAggMembers(
                                                 structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
-                                        addAggMembers( 
+                                        addAggMembers(
                                                 unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
@@ -1097 +1096 @@
 
                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, 
+                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
                                         cost );
                                 PRINT(
@@ -1107 +1106 @@
                                         std::cerr << std::endl;
                                 )
-                                newCand->expr = ast::mutate_field( 
-                                        newCand->expr.get(), &ast::Expr::result, 
+                                newCand->expr = ast::mutate_field(
+                                        newCand->expr.get(), &ast::Expr::result,
                                         renameTyVars( newCand->expr->result ) );
-                                // add anonymous member interpretations whenever an aggregate value type is seen 
+                                // add anonymous member interpretations whenever an aggregate value type is seen
                                 // as a name expression
                                 addAnonConversions( newCand );
@@ -1120 +1119 @@
                         // not sufficient to just pass `variableExpr` here, type might have changed since
                         // creation
-                        addCandidate( 
+                        addCandidate(
                                 new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
                 }
@@ -1130 +1129 @@
                 void postvisit( const ast::SizeofExpr * sizeofExpr ) {
                         if ( sizeofExpr->type ) {
-                                addCandidate( 
-                                        new ast::SizeofExpr{ 
-                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) }, 
+                                addCandidate(
+                                        new ast::SizeofExpr{
+                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) },
                                         tenv );
                         } else {
@@ -1141 +1140 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
-                                        SemanticError( 
+                                        SemanticError(
                                                 sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
                                 }
@@ -1154 +1153 @@
                 void postvisit( const ast::AlignofExpr * alignofExpr ) {
                         if ( alignofExpr->type ) {
-                                addCandidate( 
-                                        new ast::AlignofExpr{ 
-                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) }, 
+                                addCandidate(
+                                        new ast::AlignofExpr{
+                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) },
                                         tenv );
                         } else {
@@ -1165 +1164 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
-                                        SemanticError( 
+                                        SemanticError(
                                                 alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
                                 }
@@ -1172 +1171 @@
                                 choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
                                 choice->cost = Cost::zero;
-                                addCandidate( 
+                                addCandidate(
                                         *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
                         }
@@ -1185 +1184 @@
                         for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
-                                addCandidate( 
+                                addCandidate(
                                         new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
                         }
@@ -1218 +1217 @@
 
                                         addCandidate(
-                                                new ast::LogicalExpr{ 
+                                                new ast::LogicalExpr{
                                                         logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
                                                 move( env ), move( open ), move( need ), r1->cost + r2->cost );
@@ -1256 +1255 @@
                                                 ast::AssertionSet have;
 
-                                                // unify true and false results, then infer parameters to produce new 
+                                                // unify true and false results, then infer parameters to produce new
                                                 // candidates
                                                 ast::ptr< ast::Type > common;
-                                                if ( 
-                                                        unify( 
-                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab, 
-                                                                common ) 
+                                                if (
+                                                        unify(
+                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab,
+                                                                common )
                                                 ) {
                                                         // generate typed expression
-                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{ 
+                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
                                                                 conditionalExpr->location, r1->expr, r2->expr, r3->expr };
                                                         newExpr->result = common ? common : r2->expr->result;
                                                         // convert both options to result type
                                                         Cost cost = r1->cost + r2->cost + r3->cost;
-                                                        newExpr->arg2 = computeExpressionConversionCost( 
+                                                        newExpr->arg2 = computeExpressionConversionCost(
                                                                 newExpr->arg2, newExpr->result, symtab, env, cost );
                                                         newExpr->arg3 = computeExpressionConversionCost(
@@ -1287 +1286 @@
                         ast::TypeEnvironment env{ tenv };
                         ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, symtab, env );
-                        
+
                         CandidateFinder finder2{ symtab, env };
                         finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
@@ -1330 +1329 @@
 
                                         ast::ptr< ast::Type > common;
-                                        if ( 
-                                                unify( 
-                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab, 
-                                                        common ) 
+                                        if (
+                                                unify(
+                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab,
+                                                        common )
                                         ) {
                                                 // generate new expression
-                                                ast::RangeExpr * newExpr = 
+                                                ast::RangeExpr * newExpr =
                                                         new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
                                                 newExpr->result = common ? common : r1->expr->result;
                                                 // add candidate
                                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                                        newExpr, move( env ), move( open ), move( need ), 
+                                                        newExpr, move( env ), move( open ), move( need ),
                                                         r1->cost + r2->cost );
                                                 inferParameters( newCand, candidates );
@@ -1350 +1349 @@
 
                 void postvisit( const ast::UntypedTupleExpr * tupleExpr ) {
-                        std::vector< CandidateFinder > subCandidates = 
+                        std::vector< CandidateFinder > subCandidates =
                                 selfFinder.findSubExprs( tupleExpr->exprs );
                         std::vector< CandidateList > possibilities;
@@ -1370 +1369 @@
 
                                 addCandidate(
-                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) }, 
+                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) },
                                         move( env ), move( open ), move( need ), sumCost( subs ) );
                         }
@@ -1412 +1411 @@
                                 toType = SymTab::validateType( initExpr->location, toType, symtab );
                                 toType = adjustExprType( toType, tenv, symtab );
-                                // The call to find must occur inside this loop, otherwise polymorphic return 
-                                // types are not bound to the initialization type, since return type variables are 
-                                // only open for the duration of resolving the UntypedExpr. 
+                                // The call to find must occur inside this loop, otherwise polymorphic return
+                                // types are not bound to the initialization type, since return type variables are
+                                // only open for the duration of resolving the UntypedExpr.
                                 CandidateFinder finder{ symtab, tenv, toType };
                                 finder.find( initExpr->expr, ResolvMode::withAdjustment() );
@@ -1426 +1425 @@
                                         )
 
-                                        // It is possible that a cast can throw away some values in a multiply-valued 
-                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of 
-                                        // the subexpression results that are cast directly. The candidate is invalid 
+                                        // It is possible that a cast can throw away some values in a multiply-valued
+                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
+                                        // the subexpression results that are cast directly. The candidate is invalid
                                         // if it has fewer results than there are types to cast to.
                                         int discardedValues = cand->expr->result->size() - toType->size();
@@ -1436 +1435 @@
                                         unify( toType, cand->expr->result, env, need, have, open, symtab );
                                         Cost thisCost = castCost( cand->expr->result, toType, symtab, env );
-                                        
+
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away
                                                 thisCost.incSafe( discardedValues );
-                                                CandidateRef newCand = std::make_shared<Candidate>( 
-                                                        new ast::InitExpr{ 
-                                                                initExpr->location, restructureCast( cand->expr, toType ), 
-                                                                initAlt.designation }, 
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        new ast::InitExpr{
+                                                                initExpr->location, restructureCast( cand->expr, toType ),
+                                                                initAlt.designation },
                                                         copy( cand->env ), move( open ), move( need ), cand->cost, thisCost );
                                                 inferParameters( newCand, matches );
@@ -1469 +1468 @@
         };
 
-        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given 
+        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
         /// return type. Skips ambiguous candidates.
         CandidateList pruneCandidates( CandidateList & candidates ) {
@@ -1486 +1485 @@
                         {
                                 ast::ptr< ast::Type > newType = candidate->expr->result;
+                                assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
                                 candidate->env.apply( newType );
                                 mangleName = Mangle::mangle( newType );
@@ -1494 +1494 @@
                                 if ( candidate->cost < found->second.candidate->cost ) {
                                         PRINT(
-                                                std::cerr << "cost " << candidate->cost << " beats " 
+                                                std::cerr << "cost " << candidate->cost << " beats "
                                                         << found->second.candidate->cost << std::endl;
                                         )
@@ -1500 +1500 @@
                                         found->second = PruneStruct{ candidate };
                                 } else if ( candidate->cost == found->second.candidate->cost ) {
-                                        // if one of the candidates contains a deleted identifier, can pick the other, 
-                                        // since deleted expressions should not be ambiguous if there is another option 
+                                        // if one of the candidates contains a deleted identifier, can pick the other,
+                                        // since deleted expressions should not be ambiguous if there is another option
                                         // that is at least as good
                                         if ( findDeletedExpr( candidate->expr ) ) {
@@ -1515 +1515 @@
                                 } else {
                                         PRINT(
-                                                std::cerr << "cost " << candidate->cost << " loses to " 
+                                                std::cerr << "cost " << candidate->cost << " loses to "
                                                         << found->second.candidate->cost << std::endl;
                                         )
@@ -1530 +1530 @@
 
                         CandidateRef cand = target.second.candidate;
-                        
+
                         ast::ptr< ast::Type > newResult = cand->expr->result;
                         cand->env.applyFree( newResult );
                         cand->expr = ast::mutate_field(
                                 cand->expr.get(), &ast::Expr::result, move( newResult ) );
-                        
+
                         out.emplace_back( cand );
                 }
@@ -1558 +1558 @@
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, symtab, satisfied, errors );
+                        satisfyAssertions( candidate, localSyms, satisfied, errors );
                 }
 
@@ -1583 +1583 @@
 
                 CandidateList pruned = pruneCandidates( candidates );
-                
+
                 if ( mode.failFast && pruned.empty() ) {
                         std::ostringstream stream;
@@ -1602 +1602 @@
                 )
                 PRINT(
-                        std::cerr << "there are " << candidates.size() << " alternatives after elimination" 
+                        std::cerr << "there are " << candidates.size() << " alternatives after elimination"
                                 << std::endl;
                 )
         }
 
-        // adjust types after pruning so that types substituted by pruneAlternatives are correctly 
+        // adjust types after pruning so that types substituted by pruneAlternatives are correctly
         // adjusted
         if ( mode.adjust ) {
                 for ( CandidateRef & r : candidates ) {
-                        r->expr = ast::mutate_field( 
-                                r->expr.get(), &ast::Expr::result, 
-                                adjustExprType( r->expr->result, r->env, symtab ) );
+                        r->expr = ast::mutate_field(
+                                r->expr.get(), &ast::Expr::result,
+                                adjustExprType( r->expr->result, r->env, localSyms ) );
                 }
         }
@@ -1625 +1625 @@
 }
 
-std::vector< CandidateFinder > CandidateFinder::findSubExprs( 
-        const std::vector< ast::ptr< ast::Expr > > & xs 
+std::vector< CandidateFinder > CandidateFinder::findSubExprs(
+        const std::vector< ast::ptr< ast::Expr > > & xs
 ) {
         std::vector< CandidateFinder > out;
 
         for ( const auto & x : xs ) {
-                out.emplace_back( symtab, env );
+                out.emplace_back( localSyms, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
-                
+
                 PRINT(
                         std::cerr << "findSubExprs" << std::endl;

src/ResolvExpr/CandidateFinder.hpp

@@ -28 +28 @@
 struct CandidateFinder {
         CandidateList candidates;          ///< List of candidate resolutions
-        const ast::SymbolTable & symtab;   ///< Symbol table to lookup candidates
+        const ast::SymbolTable & localSyms;   ///< Symbol table to lookup candidates
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
 
         CandidateFinder( 
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, 
+                const ast::SymbolTable & syms, const ast::TypeEnvironment & env, 
                 const ast::Type * tt = nullptr )
-        : candidates(), symtab( symtab ), env( env ), targetType( tt ) {}
+        : candidates(), localSyms( syms ), env( env ), targetType( tt ) {}
 
         /// Fill candidates with feasible resolutions for `expr`

src/ResolvExpr/CommonType.cc

@@ -939 +939 @@
                         ast::ptr< ast::Type > result;
                         const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >();
-                        const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >();
+                        const ast::ReferenceType * ref2 = type2.as< ast::ReferenceType >();
 
                         if ( depth1 > depth2 ) {

src/ResolvExpr/ConversionCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Aug 12 10:21:00 2019
+// Last Modified On : Thr Jul  4 10:56:00 2019
 // Update Count     : 27
 //
@@ -701 +701 @@
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;
-        static const ast::BasicType integer( ast::BasicType::SignedInt );
-        cost = costCalc( &integer, dst, symtab, env );
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+        cost = costCalc( integer, dst, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -772 +772 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
+        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
+                cost = Cost::zero;
+                // +1 for zero_t ->, +1 for disambiguation
+                cost.incSafe( maxIntCost + 2 );
         }
 }
@@ -789 +793 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
-                cost = Cost::zero;
-                cost.incSafe( maxIntCost + 2 );
         }
 }

src/ResolvExpr/CurrentObject.cc

@@ -21 +21 @@
 #include <string>                      // for string, operator<<, allocator
 
+#include "AST/Copy.hpp"                // for shallowCopy
 #include "AST/Expr.hpp"                // for InitAlternative
 #include "AST/GenericSubstitution.hpp" // for genericSubstitution
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
+#include "AST/Print.hpp"                // for readonly
 #include "AST/Type.hpp"
 #include "Common/Indenter.h"           // for Indenter, operator<<
@@ -596 +598 @@
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
 
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) override {
@@ -637 +639 @@
                         auto res = eval(expr);
                         if ( ! res.second ) {
-                                SemanticError( location, 
+                                SemanticError( location,
                                         toString("Array designator must be a constant expression: ", expr ) );
                         }
@@ -644 +646 @@
 
         public:
-                ArrayIterator( const CodeLocation & loc, const ArrayType * at ) 
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at )
                 : location( loc ), array( at ), base( at->base ) {
                         PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
@@ -655 +657 @@
 
                 void setPosition( const Expr * expr ) {
-                        // need to permit integer-constant-expressions, including: integer constants, 
-                        // enumeration constants, character constants, sizeof expressions, alignof expressions, 
+                        // need to permit integer-constant-expressions, including: integer constants,
+                        // enumeration constants, character constants, sizeof expressions, alignof expressions,
                         // cast expressions
                         if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
@@ -662 +664 @@
                                         index = constExpr->intValue();
                                 } catch ( SemanticErrorException & ) {
-                                        SemanticError( expr, 
+                                        SemanticError( expr,
                                                 "Constant expression of non-integral type in array designator: " );
                                 }
                         } else if ( auto castExpr = dynamic_cast< const CastExpr * >( expr ) ) {
                                 setPosition( castExpr->arg );
-                        } else if ( 
-                                dynamic_cast< const SizeofExpr * >( expr ) 
-                                || dynamic_cast< const AlignofExpr * >( expr ) 
+                        } else if (
+                                dynamic_cast< const SizeofExpr * >( expr )
+                                || dynamic_cast< const AlignofExpr * >( expr )
                         ) {
                                 index = 0;
                         } else {
-                                assertf( false, 
+                                assertf( false,
                                         "bad designator given to ArrayIterator: %s", toString( expr ).c_str() );
                         }
                 }
 
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) override {
@@ -758 +760 @@
                 }
 
-                AggregateIterator( 
-                        const CodeLocation & loc, const std::string k, const std::string & n, const Type * i, 
+                AggregateIterator(
+                        const CodeLocation & loc, const std::string k, const std::string & n, const Type * i,
                         const MemberList & ms )
-                : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ), 
+                : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ),
                   sub( genericSubstitution( i ) ) {
                         PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
@@ -768 +770 @@
 
         public:
-                void setPosition( 
-                        std::deque< ptr< Expr > >::const_iterator begin, 
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) final {
@@ -786 +788 @@
                                         return;
                                 }
-                                assertf( false, 
+                                assertf( false,
                                         "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
                         } else {
-                                assertf( false, 
+                                assertf( false,
                                         "bad designator given to %s: %s", kind.c_str(), toString( *begin ).c_str() );
                         }
@@ -803 +805 @@
                                                 new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
                                         // need to substitute for generic types so that casts are to concrete types
+                                        alt.type = shallowCopy(alt.type.get());
                                         PRINT( std::cerr << "  type is: " << alt.type; )
                                         sub.apply( alt.type ); // also apply to designation??
@@ -842 +845 @@
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
-                                        alt.designation.get_and_mutate()->designators.emplace_front( 
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
                                                 new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
                                 }
@@ -897 +900 @@
         class TupleIterator final : public AggregateIterator {
         public:
-                TupleIterator( const CodeLocation & loc, const TupleType * inst ) 
-                : AggregateIterator( 
-                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members 
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
+                : AggregateIterator(
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
                 ) {}
 
@@ -926 +929 @@
                                 return new UnionIterator{ loc, uit };
                         } else {
-                                assertf( 
-                                        dynamic_cast< const EnumInstType * >( aggr ) 
-                                                || dynamic_cast< const TypeInstType * >( aggr ), 
+                                assertf(
+                                        dynamic_cast< const EnumInstType * >( type )
+                                                || dynamic_cast< const TypeInstType * >( type ),
                                         "Encountered unhandled ReferenceToType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
@@ -949 +952 @@
                 using DesignatorChain = std::deque< ptr< Expr > >;
                 PRINT( std::cerr << "___findNext" << std::endl; )
-                
+
                 // find all the d's
                 std::vector< DesignatorChain > desigAlts{ {} }, newDesigAlts;
@@ -1013 +1016 @@
                 // set new designators
                 assertf( ! objStack.empty(), "empty object stack when setting designation" );
-                Designation * actualDesignation = 
+                Designation * actualDesignation =
                         new Designation{ designation->location, DesignatorChain{d} };
                 objStack.back()->setPosition( d ); // destroys d

src/ResolvExpr/PolyCost.cc

@@ -58 +58 @@
 
 // TODO: When the old PolyCost is torn out get rid of the _new suffix.
-struct PolyCost_new {
+class PolyCost_new {
+        const ast::SymbolTable &symtab;
+public:
         int result;
-        const ast::SymbolTable &symtab;
         const ast::TypeEnvironment &env_;
 
-        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) :
-                result( 0 ), symtab( symtab ), env_( env ) {}
+        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
+        : symtab( symtab ), result( 0 ), env_( env ) {}
 
         void previsit( const ast::TypeInstType * type ) {

src/ResolvExpr/RenameVars.cc

@@ -19 +19 @@
 #include <utility>                 // for pair
 
+#include "AST/ForallSubstitutionTable.hpp"
 #include "AST/Pass.hpp"
 #include "AST/Type.hpp"
@@ -30 +31 @@
 #include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
 
+#include "AST/Copy.hpp"
+
 namespace ResolvExpr {
 
@@ -37 +40 @@
                 int resetCount = 0;
                 ScopedMap< std::string, std::string > nameMap;
+        public:
+                ast::ForallSubstitutionTable subs;
 
-        public:
                 void reset() {
                         level = 0;
@@ -44 +48 @@
                 }
 
-                using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator;
-
                 void rename( TypeInstType * type ) {
-                        mapConstIterator it = nameMap.find( type->name );
+                        auto it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
                                 type->name = it->second;
@@ -65 +67 @@
                                         // ditto for assertion names, the next level in
                                         level++;
-                                        // acceptAll( td->assertions, *this );
-                                } // for
-                        } // if
+                                }
+                        }
                 }
 
@@ -77 +78 @@
 
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
-                        mapConstIterator it = nameMap.find( type->name );
+                        // re-linking of base type handled by WithForallSubstitutor
+
+                        // rename
+                        auto it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
-                                ast::TypeInstType * mutType = ast::mutate( type );
-                                mutType->name = it->second;
-                    type = mutType;
+                                // unconditionally mutate because map will *always* have different name,
+                                // if this mutates, will *always* have been mutated by ForallSubstitutor above
+                                ast::TypeInstType * mut = ast::mutate( type );
+                                mut->name = it->second;
+                    type = mut;
                         }
+
                         return type;
                 }
@@ -88 +95 @@
                 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;
+                        if ( type->forall.empty() ) return type;
 
-                                        ast::TypeDecl * decl = ast::mutate( td.get() );
-                                        decl->name = newname;
-                                        td = decl;
-                                }
+                        nameMap.beginScope();
+
+                        // Load new names from this forall clause and perform renaming.
+                        NodeT * mutType = ast::mutate( type );
+                        assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        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 * mutDecl = ast::mutate( td.get() );
+                                assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+                                mutDecl->name = newname;
+                                // assertion above means `td = mutDecl;` is unnecessary
                         }
+                        // assertion above means `type = mutType;` is unnecessary
+
                         return type;
                 }
 
-                template<typename NodeT>
-                const NodeT * closeLevel( const NodeT * type ) {
-                        if ( !type->forall.empty() ) {
-                                nameMap.endScope();
-                        }
-                        return type;
+                void closeLevel( const ast::ParameterizedType * type ) {
+                        if ( type->forall.empty() ) return;
+
+                        nameMap.endScope();
                 }
         };
@@ -119 +129 @@
         RenamingData renaming;
 
-        struct RenameVars {
+        struct RenameVars_old {
                 void previsit( TypeInstType * instType ) {
                         renaming.openLevel( (Type*)instType );
@@ -130 +140 @@
                         renaming.closeLevel( type );
                 }
+        };
+
+        struct RenameVars_new /*: public ast::WithForallSubstitutor*/ {
+                #warning when old RenameVars goes away, replace hack below with global pass inheriting from WithForallSubstitutor
+                ast::ForallSubstitutionTable & subs = renaming.subs;
 
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
@@ -146 +161 @@
                         return renaming.rename( renaming.openLevel( type ) );
                 }
-                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
-                        return renaming.closeLevel( type );
+                void postvisit( const ast::ParameterizedType * type ) {
+                        renaming.closeLevel( type );
                 }
         };
@@ -154 +169 @@
 
 void renameTyVars( Type * t ) {
-        PassVisitor<RenameVars> renamer;
+        PassVisitor<RenameVars_old> renamer;
         t->accept( renamer );
 }
 
 const ast::Type * renameTyVars( const ast::Type * t ) {
-        ast::Pass<RenameVars> renamer;
-        return t->accept( renamer );
+        ast::Type *tc = ast::deepCopy(t);
+        ast::Pass<RenameVars_new> renamer;
+//      return t->accept( renamer );
+        return tc->accept( renamer );
 }
 

src/ResolvExpr/ResolveTypeof.cc

@@ -99 +99 @@
                         // replace basetypeof(<enum>) by int
                         if ( dynamic_cast<EnumInstType*>(newType) ) {
-                                Type* newerType = 
-                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt, 
+                                Type* newerType =
+                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
                                         newType->attributes };
                                 delete newType;
                                 newType = newerType;
                         }
-                        newType->get_qualifiers().val 
+                        newType->get_qualifiers().val
                                 = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
                 } else {
                         newType->get_qualifiers().val |= oldQuals;
                 }
-                
+
                 return newType;
         }
@@ -120 +120 @@
                 ResolveTypeof_new( const ast::SymbolTable & syms ) : localSymtab( syms ) {}
 
-                void premutate( const ast::TypeofType * ) { visit_children = false; }
+                void previsit( const ast::TypeofType * ) { visit_children = false; }
 
-                const ast::Type * postmutate( const ast::TypeofType * typeofType ) {
+                const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
                         // pass on null expression
                         if ( ! typeofType->expr ) return typeofType;
@@ -133 +133 @@
                                 // typeof wrapping expression
                                 ast::TypeEnvironment dummy;
-                                ast::ptr< ast::Expr > newExpr = 
+                                ast::ptr< ast::Expr > newExpr =
                                         resolveInVoidContext( typeofType->expr, localSymtab, dummy );
                                 assert( newExpr->result && ! newExpr->result->isVoid() );
@@ -143 +143 @@
                                 // replace basetypeof(<enum>) by int
                                 if ( newType.as< ast::EnumInstType >() ) {
-                                        newType = new ast::BasicType{ 
+                                        newType = new ast::BasicType{
                                                 ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
                                 }
-                                reset_qualifiers( 
-                                        newType, 
+                                reset_qualifiers(
+                                        newType,
                                         ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
                         } else {
@@ -153 +153 @@
                         }
 
-                        return newType;
+                        return newType.release();
                 }
         };

src/ResolvExpr/Resolver.cc

@@ -1054 +1054 @@
                         const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
                                 if (
-                                        castExpr->isGenerated
+                                        castExpr->isGenerated == ast::GeneratedCast
                                         && typesCompatible( castExpr->arg->result, castExpr->result )
                                 ) {
@@ -1108 +1108 @@
 
                 // set up and resolve expression cast to void
-                ast::CastExpr * untyped = new ast::CastExpr{ expr };
+                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression(
                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
@@ -1247 +1247 @@
         };
 
-        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
+        void resolve( std::list< ast::ptr< ast::Decl > >& translationUnit ) {
                 ast::Pass< Resolver_new > resolver;
                 accept_all( translationUnit, resolver );
@@ -1281 +1281 @@
                 ast::ptr< ast::FunctionDecl > ret = functionDecl;
                 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
-                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
+                        const ast::ptr< ast::DeclWithType > & d = functionDecl->type->params[i];
 
                         if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
@@ -1298 +1298 @@
                         }
                 }
-                return ret.get();
+                return ret.release();
         }
 
@@ -1321 +1321 @@
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
-                inEnumDecl = false;
+                inEnumDecl = true;
         }
 

src/ResolvExpr/SpecCost.cc

@@ -10 +10 @@
 // Created On       : Tue Oct 02 15:50:00 2018
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jun 19 10:43:00 2019
-// Update Count     : 2
-//
-
+// Last Modified On : Wed Jul  3 11:07:00 2019
+// Update Count     : 3
+//
+
+#include <cassert>
 #include <limits>
 #include <list>
@@ -129 +130 @@
                         typename std::add_pointer<ast::Type const *(typename T::value_type const &)>::type;
 
+                #warning Should use a standard maybe_accept
+                void maybe_accept( ast::Type const * type ) {
+                        if ( type ) {
+                                auto node = type->accept( *visitor );
+                                assert( node == nullptr || node == type );
+                        }
+                }
+
                 // Update the minimum to the new lowest non-none value.
                 template<typename T>
@@ -134 +143 @@
                         for ( const auto & node : list ) {
                                 count = -1;
-                                mapper( node )->accept( *visitor );
+                                maybe_accept( mapper( node ) );
                                 if ( count != -1 && count < minimum ) minimum = count;
                         }

src/ResolvExpr/Unify.cc

@@ -25 +25 @@
 #include <vector>
 
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Node.hpp"
 #include "AST/Pass.hpp"
+#include "AST/Print.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
@@ -135 +137 @@
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
 
-                return unifyExact(
-                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -148 +149 @@
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
-///   std::cerr << "first is ";
-///   first->print( std::cerr );
-///   std::cerr << std::endl << "second is ";
-///   second->print( std::cerr );
-///   std::cerr << std::endl << "newFirst is ";
-///   newFirst->print( std::cerr );
-///   std::cerr << std::endl << "newSecond is ";
-///   newSecond->print( std::cerr );
-///   std::cerr << std::endl;
+
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
@@ -170 +163 @@
                 ast::AssertionSet need, have;
 
-                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
-                env.apply( newFirst );
-                env.apply( newSecond );
-                reset_qualifiers( newFirst );
-                reset_qualifiers( newSecond );
+                ast::Type * newFirst  = shallowCopy( first  );
+                ast::Type * newSecond = shallowCopy( second );
+                newFirst ->qualifiers = {};
+                newSecond->qualifiers = {};
+                ast::ptr< ast::Type > t1_(newFirst );
+                ast::ptr< ast::Type > t2_(newSecond);
 
                 return unifyExact(
-                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                        env.apply( newFirst  ).node,
+                        env.apply( newSecond ).node,
+                        newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -326 +322 @@
 
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
-///   std::cerr << "assertion set is" << std::endl;
-///   printAssertionSet( assertions, std::cerr, 8 );
-///   std::cerr << "looking for ";
-///   assert->print( std::cerr );
-///   std::cerr << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
-///     std::cerr << "found it!" << std::endl;
                         i->second.isUsed = true;
                 } // if
@@ -1202 +1192 @@
                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
-                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
-                reset_qualifiers( t1 );
-                reset_qualifiers( t2 );
+                ast::Type * t1 = shallowCopy(type1.get());
+                ast::Type * t2 = shallowCopy(type2.get());
+                t1->qualifiers = {};
+                t2->qualifiers = {};
+                ast::ptr< ast::Type > t1_(t1);
+                ast::ptr< ast::Type > t2_(t2);
 
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
-                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
-
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
-                                common = type1;
-                                reset_qualifiers( common, q1 | q2 );
+                                t1->qualifiers = q1 | q2;
+                                common = t1;
                                 return true;
                         } else {
@@ -1219 +1210 @@
 
                 } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
-                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
-
                         // no exact unification, but common type
-                        reset_qualifiers( common, q1 | q2 );
+                        auto c = shallowCopy(common.get());
+                        c->qualifiers = q1 | q2;
+                        common = c;
                         return true;
                 } else {

src/SymTab/Autogen.h

@@ -21 +21 @@
 
 #include "AST/Decl.hpp"
+#include "AST/Eval.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
@@ -264 +265 @@
                 }
 
-                ast::ptr< ast::Expr > begin, end, cmp, update;
+                ast::ptr< ast::Expr > begin, end;
+                std::string cmp, update;
 
                 if ( forward ) {
@@ -270 +272 @@
                         begin = ast::ConstantExpr::from_int( loc, 0 );
                         end = array->dimension;
-                        cmp = new ast::NameExpr{ loc, "?<?" };
-                        update = new ast::NameExpr{ loc, "++?" };
+                        cmp = "?<?";
+                        update = "++?";
                 } 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 ) } };
+                        begin = ast::call( 
+                                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, "--?" };
+                        cmp = "?>=?";
+                        update = "--?";
                 }
 
@@ -285 +286 @@
                         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 } } };
+                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
+                
+                ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end );
+                
+                ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar );
+                
+                ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar );
                 
                 // 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 );
+                srcParam.addArrayIndex( indexVar, array->dimension );
 
                 // for stmt's body, eventually containing call
@@ -384 +382 @@
                 if ( isUnnamedBitfield( obj ) ) return {};
 
-                ast::ptr< ast::Type > addCast = nullptr;
+                ast::ptr< ast::Type > addCast;
                 if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
                         assert( dstParam->result );

src/SynTree/Statement.h

@@ -502 +502 @@
 class ImplicitCtorDtorStmt : public Statement {
   public:
-        // Non-owned pointer to the constructor/destructor statement
+        // the constructor/destructor call statement; owned here for a while, eventually transferred elsewhere
         Statement * callStmt;
 

src/Tuples/Explode.cc

@@ -129 +129 @@
                         for ( const ast::Expr * expr : tupleExpr->exprs ) {
                                 exprs.emplace_back( applyCast( expr, false ) );
-                                //exprs.emplace_back( ast::ptr< ast::Expr >( applyCast( expr, false ) ) );
                         }
                         if ( first ) {

src/Tuples/Explode.h

@@ -210 +210 @@
                         }
                         // Cast a reference away to a value-type to allow further explosion.
-                        if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
+                        if ( local->result.as< ast::ReferenceType >() ) {
                                 local = new ast::CastExpr{ local, tupleType };
                         }
@@ -220 +220 @@
                                 // delete idx;
                         }
-                        // delete local;
                 }
         } else {

src/Tuples/TupleAssignment.cc

@@ -465 +465 @@
                                         // resolve ctor/dtor for the new object
                                         ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit(
-                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.localSyms );
                                         // remove environments from subexpressions of stmtExpr
                                         ast::Pass< EnvRemover > rm{ env };
@@ -560 +560 @@
                                         // 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 };
+                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.localSyms, env };
                                         finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
                                         assert( finder.candidates.size() == 1 );
@@ -609 +609 @@
                                         // 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 );
+                                        explode( *lhsCand, crntFinder.localSyms, back_inserter(lhs), true );
                                         for ( ResolvExpr::CandidateRef & cand : lhs ) {
                                                 // each LHS value must be a reference - some come in with a cast, if not
@@ -629 +629 @@
                                                         if ( isTuple( rhsCand->expr ) ) {
                                                                 // multiple assignment
-                                                                explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                                explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                                 matcher.reset(
                                                                         new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -648 +648 @@
                                                         // multiple assignment
                                                         ResolvExpr::CandidateList rhs;
-                                                        explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                        explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                         matcher.reset(
                                                                 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -678 +678 @@
                                 )
 
-                                ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env };
+                                ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env };
 
                                 try {

src/main.cc

@@ -29 +29 @@
 #include <string>                           // for char_traits, operator<<
 
+#include "AST/Convert.hpp"
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
@@ -313 +314 @@
                 } // if
 
-                assertTopLvalue( translationUnit );
-
-                PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                // PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                {
+                        auto transUnit = convert( move( translationUnit ) );
+                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        translationUnit = convert( move( transUnit ) );
+                }
+
                 if ( exprp ) {
                         dump( translationUnit );