Changes in / [83b52f1:96ac72c0]

Files:

• Jenkinsfile (deleted)
• Jenkinsfile_disabled (added)
• src/AST/Attribute.hpp (modified) (1 diff)
• src/AST/Convert.cpp (modified) (1 diff)
• 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) (3 diffs)
• src/AST/Expr.hpp (modified) (1 diff)
• 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) (7 diffs)
• src/AST/Pass.hpp (modified) (6 diffs)
• src/AST/Pass.impl.hpp (modified) (12 diffs)
• src/AST/Pass.proto.hpp (modified) (3 diffs)
• src/AST/Stmt.hpp (modified) (1 diff)
• src/AST/Type.cpp (modified) (8 diffs)
• src/AST/Type.hpp (modified) (12 diffs)
• src/AST/TypeSubstitution.cpp (modified) (6 diffs)
• src/AST/TypeSubstitution.hpp (modified) (1 diff)
• 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/CandidateFinder.cpp (modified) (8 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (1 diff)
• src/ResolvExpr/CommonType.cc (modified) (1 diff)
• src/ResolvExpr/ConversionCost.cc (modified) (3 diffs)
• src/ResolvExpr/PolyCost.cc (modified) (1 diff)
• src/ResolvExpr/RenameVars.cc (modified) (11 diffs)
• src/ResolvExpr/ResolveTypeof.cc (modified) (1 diff)
• src/ResolvExpr/Resolver.cc (modified) (4 diffs)
• src/ResolvExpr/SpecCost.cc (modified) (3 diffs)
• src/SymTab/Autogen.h (modified) (5 diffs)
• 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);
         }

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 "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
 #include "Stmt.hpp"
@@ -51 +52 @@
         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 +73 @@
         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,

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;

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;
                 }
@@ -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 );
@@ -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 {

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/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() ) {
@@ -168 +160 @@
                 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

@@ -155 +155 @@
                 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;

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

@@ -168 +168 @@
         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) \
@@ -585 +586 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
+        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \
@@ -759 +761 @@
         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)
@@ -1212 +1216 @@
 @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/CandidateFinder.cpp

@@ -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 {
@@ -548 +546 @@
                 genStart = genEnd;
 
-                return genEnd != results.size();
+                return genEnd != results.size();  // were any new results added?
         }
 
@@ -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 ) {}
                 
@@ -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 );
 
@@ -1558 +1557 @@
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, symtab, satisfied, errors );
+                        satisfyAssertions( candidate, localSyms, satisfied, errors );
                 }
 
@@ -1613 +1612 @@
                         r->expr = ast::mutate_field( 
                                 r->expr.get(), &ast::Expr::result, 
-                                adjustExprType( r->expr->result, r->env, symtab ) );
+                                adjustExprType( r->expr->result, r->env, localSyms ) );
                 }
         }
@@ -1631 +1630 @@
 
         for ( const auto & x : xs ) {
-                out.emplace_back( symtab, env );
+                out.emplace_back( localSyms, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
                 

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 Jun 24 13:33:00 2019
-// Update Count     : 26
+// Last Modified On : Thr Jul  4 10:56:00 2019
+// Update Count     : 27
 //
 
@@ -764 +764 @@
                         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 );
         }
 }
@@ -781 +785 @@
                         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/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;
+                        
+                        nameMap.beginScope();
 
-                                        ast::TypeDecl * decl = ast::mutate( td.get() );
-                                        decl->name = newname;
-                                        td = decl;
-                                }
+                        // 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

@@ -153 +153 @@
                         }
 
-                        return newType;
+                        return newType.release();
                 }
         };

src/ResolvExpr/Resolver.cc

@@ -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();
         }
 

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/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/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
@@ -302 +303 @@
                 } // if
 
-                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 );