Changes in / [96ac72c0:83b52f1]

Files:

• Jenkinsfile (added)
• Jenkinsfile_disabled (deleted)
• src/AST/Attribute.hpp (modified) (1 diff)
• src/AST/Convert.cpp (modified) (1 diff)
• src/AST/Copy.hpp (deleted)
• src/AST/Decl.cpp (modified) (1 diff)
• src/AST/Decl.hpp (modified) (6 diffs)
• src/AST/Eval.hpp (deleted)
• src/AST/Expr.cpp (modified) (3 diffs)
• src/AST/Expr.hpp (modified) (1 diff)
• src/AST/ForallSubstitutionTable.cpp (deleted)
• src/AST/ForallSubstitutionTable.hpp (deleted)
• src/AST/ForallSubstitutor.hpp (deleted)
• 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( const Type * t ) {
-        type = strict_dynamic_cast< const FunctionType * >( t );
-}
+void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< 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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
@@ -89 +87 @@
         virtual const Type * get_type() const = 0;
         /// Set type of this declaration. May be verified by subclass
-        virtual void set_type( const Type * ) = 0;
+        virtual void set_type(Type *) = 0;
 
         const DeclWithType * accept( Visitor & v ) const override = 0;
@@ -112 +110 @@
 
         const Type* get_type() const override { return type; }
-        void set_type( const Type * ty ) override { type = ty; }
+        void set_type( Type * ty ) override { type = ty; }
 
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
@@ -134 +132 @@
 
         const Type * get_type() const override;
-        void set_type( const Type * t ) override;
+        void set_type(Type * t) override;
 
         bool has_body() const { return stmts; }
@@ -151 +149 @@
         std::vector<ptr<DeclWithType>> assertions;
 
-        NamedTypeDecl( 
-                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
-                const Type * b, Linkage::Spec spec = Linkage::Cforall )
+        NamedTypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
+                Type* b, Linkage::Spec spec = Linkage::Cforall )
         : Decl( loc, name, storage, spec ), base( b ), params(), assertions() {}
 
@@ -188 +185 @@
         };
 
-        TypeDecl( 
-                const CodeLocation & loc, const std::string & name, Storage::Classes storage, 
-                const Type * b, TypeVar::Kind k, bool s, const Type * i = nullptr )
+        TypeDecl( const CodeLocation& loc, const std::string& name, Storage::Classes storage, Type* b,
+                TypeVar::Kind k, bool s, 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"
@@ -52 +51 @@
         assert( arg );
 
-        UntypedExpr * ret = call( loc, "*?", arg );
+        UntypedExpr * ret = new UntypedExpr{
+                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
+        };
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -73 +74 @@
         assert( lhs && rhs );
 
-        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
+        UntypedExpr * ret = new UntypedExpr{
+                loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ 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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
-
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {

src/AST/Node.cpp

@@ -17 +17 @@
 #include "Fwd.hpp"
 
-#include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
 
@@ -30 +29 @@
 #include "Print.hpp"
 
-/// 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 >
+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); }
 
 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() {}
+        virtual ~Node() = default;
 
         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;
@@ -71 +69 @@
         }
 
-        void decrement(ast::Node::ref_type ref, bool do_delete = true) const {
+        void decrement(ast::Node::ref_type ref) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -77 +75 @@
                 }
 
-                if( do_delete && !strong_count && !weak_count) {
+                if(!strong_count && !weak_count) {
                         delete this;
                 }
@@ -125 +123 @@
         (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;
 }
 
@@ -230 +219 @@
         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>
@@ -264 +244 @@
 
         void _inc( const node_t * other );
-        void _dec( const node_t * other, bool do_delete = true );
+        void _dec( const node_t * other );
         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"
@@ -48 +46 @@
 //
 // 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
-// | WithForallSubstitutor - maintains links between TypeInstType and TypeDecl under mutation
+// | 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
 //-------------------------------------------------------------------------------------------------
 template< typename pass_t >
@@ -204 +201 @@
         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
@@ -216 +209 @@
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass.pass, 0); }
+                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
                 Pass<pass_t> & pass;
         };
@@ -223 +216 @@
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass.pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass.pass, 0); }
+                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(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;
         };
 
@@ -329 +313 @@
         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( node );
+                __pedantic_pass_assert( expr );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -322 +323 @@
         }
 
-
-        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 );
-                }
-        }
 }
 
@@ -444 +429 @@
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
-                                CodeLocation{}, "__func__",
-                                new ast::ArrayType{
-                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
+                        static ast::ObjectDecl func(
+                                node->location, "__func__",
+                                new ast::ArrayType(
+                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
                                         nullptr, VariableLen, DynamicDim
-                                }
-                        } };
-                        __pass::symtab::addId( pass, 0, func );
+                                )
+                        );
+                        __pass::symtab::addId( pass, 0, &func );
                         VISIT(
                                 maybe_accept( node, &FunctionDecl::type );
@@ -625 +610 @@
         VISIT({
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                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);
+                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);
                 });
                 ValueGuard< bool > guard2( inFunction );
@@ -1682 +1667 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &FunctionType::forall  );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1702 +1686 @@
         VISIT({
                 guard_symtab guard { *this };
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+                maybe_accept( node, &StructInstType::forall );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1716 +1699 @@
         VISIT_START( node );
 
-        __pass::symtab::addUnion( pass, 0, node->name );
-
-        VISIT({
+        __pass::symtab::addStruct( pass, 0, node->name );
+
+        {
                 guard_symtab guard { *this };
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+                maybe_accept( node, &UnionInstType::forall );
                 maybe_accept( node, &UnionInstType::params );
-        })
+        }
 
         VISIT_END( Type, node );
@@ -1734 +1716 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &EnumInstType::forall );
                 maybe_accept( node, &EnumInstType::params );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1749 +1730 @@
         VISIT_START( node );
 
-        VISIT({
-                guard_forall_subs forall_guard { *this, node };
-                mutate_forall( node );
+        VISIT(
+                maybe_accept( node, &TraitInstType::forall );
                 maybe_accept( node, &TraitInstType::params );
-        })
+        )
 
         VISIT_END( Type, node );
@@ -1765 +1745 @@
 
         VISIT(
-                {
-                        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 );
+                maybe_accept( node, &TypeInstType::forall );
+                maybe_accept( node, &TypeInstType::params );
         )
 
@@ -1920 +1895 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
+                                if (new_node != p.second) mutated = false;
                                 new_map.insert({ p.first, new_node });
                         }
@@ -1936 +1911 @@
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = true;
+                                if (new_node != p.second) mutated = false;
                                 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 ) {}
-        } // namespace scope
-
-        // Certain passes desire an up to date symbol table automatically
+        };
+
+        // Finally certain pass 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, void() ) {
+                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
                         pass.symtab.enterScope();
                 }
@@ -278 +278 @@
 
                 template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab, void() ) {
+                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), 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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(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
@@ -93 +91 @@
 );
 
-// --- 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 {
@@ -126 +107 @@
 
 // --- 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" );
@@ -151 +119 @@
 // --- StructInstType
 
-StructInstType::StructInstType( 
-        const StructDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
 bool StructInstType::isComplete() const { return base ? base->body : false; }
@@ -159 +127 @@
 // --- UnionInstType
 
-UnionInstType::UnionInstType( 
-        const UnionDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+UnionInstType::UnionInstType( const UnionDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
 bool UnionInstType::isComplete() const { return base ? base->body : false; }
@@ -167 +135 @@
 // --- EnumInstType
 
-EnumInstType::EnumInstType( 
-        const EnumDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+EnumInstType::EnumInstType( const EnumDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
 
 bool EnumInstType::isComplete() const { return base ? base->body : false; }
@@ -175 +143 @@
 // --- TraitInstType
 
-TraitInstType::TraitInstType( 
-        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, move(as) ), base( b ) {}
+TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q,
+        std::vector<ptr<Attribute>>&& as )
+: ReferenceToType( b->name, q, std::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 ) {
@@ -198 +159 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( move(ts) ), members() {
+: Type( q ), types( std::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); \
-        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
 
 namespace ast {
-
-template< typename T > class Pass;
-
-struct ForallSubstitutor;
 
 class Type : public Node {
@@ -170 +164 @@
         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) {}
 
@@ -272 +266 @@
 /// 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>>;
@@ -286 +277 @@
         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:
@@ -318 +302 @@
         : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
 
-        FunctionType( const FunctionType & o );
-
         /// true if either the parameters or return values contain a tttype
         bool isTtype() const;
@@ -333 +315 @@
 /// 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;
@@ -341 +320 @@
         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
@@ -362 +339 @@
         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;
@@ -384 +360 @@
         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;
@@ -406 +381 @@
         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;
@@ -428 +402 @@
         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
@@ -452 +425 @@
         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 {
-                const TypeSubstitution * env;
+                ptr<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;
         }
@@ -116 +121 @@
 
 void TypeSubstitution::normalize() {
-        Pass<Substituter> sub( *this, true );
+#if TIME_TO_CONVERT_PASSES
+        PassVisitor<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->accept( sub );
+                        i->second = i->second->acceptMutator( sub );
                 }
         } while ( sub.pass.subCount );
-}
-
-const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
+#endif
+}
+
+#if TIME_TO_CONVERT_PASSES
+
+Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
         BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
@@ -137 +146 @@
                 // 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 ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
+                if ( TypeInstType * replacement = i->second.as<TypeInstType>() ) {
                         if ( inst->name == replacement->name ) {
                                 return inst;
@@ -144 +153 @@
                 // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
-                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 ) {
+                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 ) {
         VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
         if ( i == sub.varEnv.end() ) {
@@ -160 +168 @@
                 subCount++;
                 delete nameExpr;
-                return i->second;
-        } // if
-}
-
-void TypeSubstitution::Substituter::previsit( const ParameterizedType * ptype ) {
+                return i->second->clone();
+        } // if
+}
+
+void TypeSubstitution::Substituter::premutate( Type * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( const TypeDecl * tyvar : ptype->forall ) {
-                                boundVars.insert( tyvar->name );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
         } // if
 }
 
-void TypeSubstitution::Substituter::handleAggregateType( const ReferenceToType * type ) {
+template< typename TypeClass >
+void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( const TypeDecl * tyvar : type->forall ) {
-                        boundVars.insert( tyvar->name );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
                 // bind type variables from generic type instantiations
-                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 ) {
+                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 ) {
         handleAggregateType( aggregateUseType );
 }
 
-void TypeSubstitution::Substituter::previsit( const UnionInstType *aggregateUseType ) {
+void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
+
+#endif
 
 } // namespace ast

src/AST/TypeSubstitution.hpp

@@ -155 +155 @@
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
-                const Type * postvisit( const TypeInstType * aggregateUseType );
-                const Expr * postvisit( const NameExpr * nameExpr );
+#if TIME_TO_CONVERT_PASSES
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Expression * postmutate( NameExpr * nameExpr );
 
                 /// Records type variable bindings from forall-statements
-                void previsit( const ParameterizedType * type );
+                void premutate( Type * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                void handleAggregateType( const ReferenceToType * type );
-
-                void previsit( const StructInstType * aggregateUseType );
-                void previsit( const UnionInstType * aggregateUseType );
+                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+
+                void premutate( StructInstType * aggregateUseType );
+                void premutate( UnionInstType * aggregateUseType );
+
+#endif
 
                 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) \
@@ -586 +585 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
-        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \
@@ -761 +759 @@
         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)
@@ -1216 +1212 @@
 @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 {
-        class AdjustExprType_new final : public ast::WithShortCircuiting {
+        struct AdjustExprType_new final : public ast::WithShortCircuiting {
+                const ast::TypeEnvironment & tenv;
                 const ast::SymbolTable & symtab;
-        public:
-                const ast::TypeEnvironment & tenv;
 
                 AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
-                : symtab( syms ), tenv( e ) {}
+                : tenv( e ), symtab( syms ) {}
 
-                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; }
+                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; }
 
-                const ast::Type * postvisit( const ast::ArrayType * at ) {
+                const ast::Type * postmutate( const ast::ArrayType * at ) {
                         return new ast::PointerType{ at->base, at->qualifiers };
                 }
 
-                const ast::Type * postvisit( const ast::FunctionType * ft ) {
+                const ast::Type * postmutate( const ast::FunctionType * ft ) {
                         return new ast::PointerType{ ft };
                 }
 
-                const ast::Type * postvisit( const ast::TypeInstType * inst ) {
+                const ast::Type * postmutate( 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;
-                                                        newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} };
+                                                        std::vector< ast::ptr< ast::Expr > > emptyList;
+                                                        newResult.expr = 
+                                                                new ast::TupleExpr{ CodeLocation{}, move( emptyList ) };
                                                         argType = newResult.expr->result;
                                                 } else {
@@ -546 +548 @@
                 genStart = genEnd;
 
-                return genEnd != results.size();  // were any new results added?
+                return genEnd != results.size();
         }
 
@@ -592 +594 @@
 
         /// Actually visits expressions to find their candidate interpretations
-        class Finder final : public ast::WithShortCircuiting {
+        struct Finder final : public ast::WithShortCircuiting {
+                CandidateFinder & selfFinder;
                 const ast::SymbolTable & symtab;
-        public:
-                CandidateFinder & selfFinder;
                 CandidateList & candidates;
                 const ast::TypeEnvironment & tenv;
@@ -601 +602 @@
 
                 Finder( CandidateFinder & f )
-                : symtab( f.localSyms ), selfFinder( f ), candidates( f.candidates ), tenv( f.env ), 
+                : selfFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ), 
                   targetType( f.targetType ) {}
                 
@@ -675 +676 @@
                         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 );
 
@@ -1557 +1558 @@
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, localSyms, satisfied, errors );
+                        satisfyAssertions( candidate, symtab, satisfied, errors );
                 }
 
@@ -1612 +1613 @@
                         r->expr = ast::mutate_field( 
                                 r->expr.get(), &ast::Expr::result, 
-                                adjustExprType( r->expr->result, r->env, localSyms ) );
+                                adjustExprType( r->expr->result, r->env, symtab ) );
                 }
         }
@@ -1630 +1631 @@
 
         for ( const auto & x : xs ) {
-                out.emplace_back( localSyms, env );
+                out.emplace_back( symtab, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
                 

src/ResolvExpr/CandidateFinder.hpp

@@ -28 +28 @@
 struct CandidateFinder {
         CandidateList candidates;          ///< List of candidate resolutions
-        const ast::SymbolTable & localSyms;   ///< Symbol table to lookup candidates
+        const ast::SymbolTable & symtab;   ///< 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 & syms, const ast::TypeEnvironment & env, 
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, 
                 const ast::Type * tt = nullptr )
-        : candidates(), localSyms( syms ), env( env ), targetType( tt ) {}
+        : candidates(), symtab( symtab ), 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 = type2.as< ast::ReferenceType >();
+                        const ast::ReferenceType * ref2 = type1.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 : Thr Jul  4 10:56:00 2019
-// Update Count     : 27
+// Last Modified On : Mon Jun 24 13:33:00 2019
+// Update Count     : 26
 //
 
@@ -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 );
         }
 }
@@ -785 +781 @@
                         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.
-class PolyCost_new {
+struct PolyCost_new {
+        int result;
         const ast::SymbolTable &symtab;
-public:
-        int result;
         const ast::TypeEnvironment &env_;
 
-        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
-        : symtab( symtab ), result( 0 ), env_( env ) {}
+        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) :
+                result( 0 ), symtab( symtab ), 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"
@@ -31 +30 @@
 #include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
 
-#include "AST/Copy.hpp"
-
 namespace ResolvExpr {
 
@@ -40 +37 @@
                 int resetCount = 0;
                 ScopedMap< std::string, std::string > nameMap;
+
         public:
-                ast::ForallSubstitutionTable subs;
-
                 void reset() {
                         level = 0;
@@ -48 +44 @@
                 }
 
+                using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator;
+
                 void rename( TypeInstType * type ) {
-                        auto it = nameMap.find( type->name );
+                        mapConstIterator it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
                                 type->name = it->second;
@@ -67 +65 @@
                                         // ditto for assertion names, the next level in
                                         level++;
-                                }
-                        }
+                                        // acceptAll( td->assertions, *this );
+                                } // for
+                        } // if
                 }
 
@@ -78 +77 @@
 
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
-                        // re-linking of base type handled by WithForallSubstitutor
-
-                        // rename
-                        auto it = nameMap.find( type->name );
+                        mapConstIterator it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
-                                // 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;
+                                ast::TypeInstType * mutType = ast::mutate( type );
+                                mutType->name = it->second;
+                    type = mutType;
                         }
-
                         return type;
                 }
@@ -95 +88 @@
                 template<typename NodeT>
                 const NodeT * openLevel( const NodeT * type ) {
-                        if ( type->forall.empty() ) return type;
-                        
-                        nameMap.beginScope();
+                        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;
 
-                        // 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
+                                        ast::TypeDecl * decl = ast::mutate( td.get() );
+                                        decl->name = newname;
+                                        td = decl;
+                                }
                         }
-                        // assertion above means `type = mutType;` is unnecessary
-
                         return type;
                 }
 
-                void closeLevel( const ast::ParameterizedType * type ) {
-                        if ( type->forall.empty() ) return;
-                        
-                        nameMap.endScope();
+                template<typename NodeT>
+                const NodeT * closeLevel( const NodeT * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.endScope();
+                        }
+                        return type;
                 }
         };
@@ -129 +119 @@
         RenamingData renaming;
 
-        struct RenameVars_old {
+        struct RenameVars {
                 void previsit( TypeInstType * instType ) {
                         renaming.openLevel( (Type*)instType );
@@ -140 +130 @@
                         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 ) {
@@ -161 +146 @@
                         return renaming.rename( renaming.openLevel( type ) );
                 }
-                void postvisit( const ast::ParameterizedType * type ) {
-                        renaming.closeLevel( type );
+                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
+                        return renaming.closeLevel( type );
                 }
         };
@@ -169 +154 @@
 
 void renameTyVars( Type * t ) {
-        PassVisitor<RenameVars_old> renamer;
+        PassVisitor<RenameVars> renamer;
         t->accept( renamer );
 }
 
 const ast::Type * renameTyVars( const ast::Type * t ) {
-        ast::Type *tc = ast::deepCopy(t);
-        ast::Pass<RenameVars_new> renamer;
-//      return t->accept( renamer );
-        return tc->accept( renamer );
+        ast::Pass<RenameVars> renamer;
+        return t->accept( renamer );
 }
 

src/ResolvExpr/ResolveTypeof.cc

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

src/ResolvExpr/Resolver.cc

@@ -1108 +1108 @@
 
                 // set up and resolve expression cast to void
-                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
+                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.release();
+                return ret.get();
         }
 

src/ResolvExpr/SpecCost.cc

@@ -10 +10 @@
 // Created On       : Tue Oct 02 15:50:00 2018
 // Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul  3 11:07:00 2019
-// Update Count     : 3
-//
-
-#include <cassert>
+// Last Modified On : Wed Jun 19 10:43:00 2019
+// Update Count     : 2
+//
+
 #include <limits>
 #include <list>
@@ -130 +129 @@
                         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>
@@ -143 +134 @@
                         for ( const auto & node : list ) {
                                 count = -1;
-                                maybe_accept( mapper( node ) );
+                                mapper( node )->accept( *visitor );
                                 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"
@@ -265 +264 @@
                 }
 
-                ast::ptr< ast::Expr > begin, end;
-                std::string cmp, update;
+                ast::ptr< ast::Expr > begin, end, cmp, update;
 
                 if ( forward ) {
@@ -272 +270 @@
                         begin = ast::ConstantExpr::from_int( loc, 0 );
                         end = array->dimension;
-                        cmp = "?<?";
-                        update = "++?";
+                        cmp = new ast::NameExpr{ loc, "?<?" };
+                        update = new ast::NameExpr{ loc, "++?" };
                 } else {
                         // generate: for ( int i = N-1; i >= 0; --i )
-                        begin = ast::call( 
-                                loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) );
+                        begin = new ast::UntypedExpr{ 
+                                loc, new ast::NameExpr{ loc, "?-?" }, 
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
                         end = ast::ConstantExpr::from_int( loc, 0 );
-                        cmp = "?>=?";
-                        update = "--?";
+                        cmp = new ast::NameExpr{ loc, "?>=?" };
+                        update = new ast::NameExpr{ loc, "--?" };
                 }
 
@@ -286 +285 @@
                         loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt }, 
                         new ast::SingleInit{ loc, begin } };
-                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 );
+                
+                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
+                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
+                
+                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
+                        loc, update, { new ast::VariableExpr{ loc, index } } };
+                
+                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
+                        loc, new ast::NameExpr{ loc, "?[?]" }, 
+                        { dstParam, new ast::VariableExpr{ loc, index } } };
                 
                 // srcParam must keep track of the array indices to build the source parameter and/or 
                 // array list initializer
-                srcParam.addArrayIndex( indexVar, array->dimension );
+                srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
 
                 // for stmt's body, eventually containing call
@@ -382 +384 @@
                 if ( isUnnamedBitfield( obj ) ) return {};
 
-                ast::ptr< ast::Type > addCast;
+                ast::ptr< ast::Type > addCast = nullptr;
                 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 ( local->result.as< ast::ReferenceType >() ) {
+                        if ( dynamic_cast< const ast::ReferenceType *>( local->result.get() ) ) {
                                 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.localSyms );
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
                                         // 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.localSyms, env };
+                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, 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.localSyms, back_inserter(lhs), true );
+                                        explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
                                         for ( ResolvExpr::CandidateRef & cand : lhs ) {
                                                 // each LHS value must be a reference - some come in with a cast, if not
@@ -629 +629 @@
                                                         if ( isTuple( rhsCand->expr ) ) {
                                                                 // multiple assignment
-                                                                explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
+                                                                explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
                                                                 matcher.reset(
                                                                         new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -648 +648 @@
                                                         // multiple assignment
                                                         ResolvExpr::CandidateList rhs;
-                                                        explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
+                                                        explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
                                                         matcher.reset(
                                                                 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
@@ -678 +678 @@
                                 )
 
-                                ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env };
+                                ResolvExpr::CandidateFinder finder{ crntFinder.symtab, 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
@@ -303 +302 @@
                 } // if
 
-                // PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
-                {
-                        auto transUnit = convert( move( translationUnit ) );
-                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
-                        translationUnit = convert( move( transUnit ) );
-                }
+                PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
                 if ( exprp ) {
                         dump( translationUnit );