Changes in / [7030dab:057298e]

Files:

• Jenkinsfile (added)
• Jenkinsfile_disabled (deleted)
• src/AST/Attribute.hpp (modified) (1 diff)
• src/AST/CVQualifiers.hpp (modified) (2 diffs)
• src/AST/Convert.cpp (modified) (2 diffs)
• 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) (14 diffs)
• src/AST/Expr.hpp (modified) (11 diffs)
• 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) (9 diffs)
• src/AST/Pass.hpp (modified) (6 diffs)
• src/AST/Pass.impl.hpp (modified) (13 diffs)
• src/AST/Pass.proto.hpp (modified) (4 diffs)
• src/AST/Stmt.hpp (modified) (2 diffs)
• src/AST/Type.cpp (modified) (8 diffs)
• src/AST/Type.hpp (modified) (15 diffs)
• src/AST/TypeEnvironment.hpp (modified) (6 diffs)
• src/AST/TypeSubstitution.cpp (modified) (6 diffs)
• src/AST/TypeSubstitution.hpp (modified) (4 diffs)
• src/AST/module.mk (modified) (1 diff)
• src/Common/ScopedMap.h (modified) (1 diff)
• src/Makefile.in (modified) (4 diffs)
• src/ResolvExpr/AdjustExprType.cc (modified) (1 diff)
• src/ResolvExpr/Candidate.hpp (modified) (2 diffs)
• src/ResolvExpr/CandidateFinder.cpp (modified) (92 diffs)
• src/ResolvExpr/CandidateFinder.hpp (modified) (4 diffs)
• src/ResolvExpr/CastCost.cc (modified) (7 diffs)
• src/ResolvExpr/CommonType.cc (modified) (1 diff)
• src/ResolvExpr/ConversionCost.cc (modified) (16 diffs)
• src/ResolvExpr/ConversionCost.h (modified) (5 diffs)
• src/ResolvExpr/CurrentObject.cc (modified) (15 diffs)
• src/ResolvExpr/PolyCost.cc (modified) (1 diff)
• src/ResolvExpr/RenameVars.cc (modified) (11 diffs)
• src/ResolvExpr/ResolveTypeof.cc (modified) (5 diffs)
• src/ResolvExpr/Resolver.cc (modified) (6 diffs)
• src/ResolvExpr/SatisfyAssertions.cpp (modified) (5 diffs)
• src/ResolvExpr/SatisfyAssertions.hpp (modified) (1 diff)
• src/ResolvExpr/SpecCost.cc (modified) (3 diffs)
• src/ResolvExpr/Unify.cc (modified) (9 diffs)
• src/ResolvExpr/typeops.h (modified) (3 diffs)
• src/SymTab/Autogen.h (modified) (5 diffs)
• src/SynTree/Statement.h (modified) (1 diff)
• src/Tuples/Explode.cc (modified) (1 diff)
• src/Tuples/Explode.h (modified) (2 diffs)
• src/Tuples/TupleAssignment.cc (modified) (6 diffs)
• src/Tuples/TupleExpansion.cc (modified) (1 diff)
• src/main.cc (modified) (2 diffs)
• tests/resolutionErrors.cfa (deleted)

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/CVQualifiers.hpp

@@ -27 +27 @@
                 Restrict = 1 << 1,
                 Volatile = 1 << 2,
-                Mutex    = 1 << 3,
-                Atomic   = 1 << 4,
-                NumQualifiers = 5
+                Lvalue   = 1 << 3,
+                Mutex    = 1 << 4,
+                Atomic   = 1 << 5,
+                NumQualifiers = 6
         };
 
         /// Mask for equivalence-preserving qualfiers
-        enum { EquivQualifiers = ~Restrict };
+        enum { EquivQualifiers = ~(Restrict | Lvalue) };
 
         /// Underlying data for qualifiers
@@ -43 +44 @@
                                 bool is_restrict : 1;
                                 bool is_volatile : 1;
+                                bool is_lvalue   : 1;
                                 bool is_mutex    : 1;
                                 bool is_atomic   : 1;

src/AST/Convert.cpp

@@ -620 +620 @@
 
                 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);
         }
@@ -2128 +2117 @@
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
-                                GET_ACCEPT_1(aggregate, Expr),
-                                ast::MemberExpr::NoOpConstructionChosen
+                                GET_ACCEPT_1(aggregate, Expr)
                         )
                 );

src/AST/Decl.cpp

@@ -50 +50 @@
 
 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

@@ -33 +33 @@
 
 // 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 {
@@ -90 +88 @@
         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;
@@ -113 +111 @@
 
         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 ); }
@@ -135 +133 @@
 
         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; }
@@ -152 +150 @@
         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() {}
 
@@ -189 +186 @@
         };
 
-        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 ) {}
+        TypeDecl( const CodeLocation & loc, const std::string & name, Storage::Classes storage, Type * b,
+                          Kind k, bool s, Type * i = nullptr )
+                : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == Ttype || s ),
+                init( i ) {}
 
         const char * typeString() const override;

src/AST/Expr.cpp

@@ -20 +20 @@
 #include <vector>
 
-#include "Copy.hpp"                // for shallowCopy
-#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
-#include "LinkageSpec.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
@@ -30 +27 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "InitTweak/InitTweak.h"   // for getFunction, getPointerBase
+#include "InitTweak/InitTweak.h"   // for getPointerBase
 #include "ResolvExpr/typeops.h"    // for extractResultType
 #include "Tuples/Tuples.h"         // for makeTupleType
 
 namespace ast {
-
-namespace {
-        std::set<std::string> const lvalueFunctionNames = {"*?", "?[?]"};
-}
-
-// --- Expr
-bool Expr::get_lvalue() const {
-        return false;
-}
 
 // --- ApplicationExpr
@@ -58 +46 @@
 }
 
-bool ApplicationExpr::get_lvalue() const {
-        if ( const DeclWithType * func = InitTweak::getFunction( this ) ) {
-                return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name );
-        }
-        return false;
-}
-
 // --- UntypedExpr
 
@@ -70 +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 );
@@ -82 +65 @@
                         // base type
                         ret->result = base;
+                        add_qualifiers( ret->result, CV::Lvalue );
                 }
         }
         return ret;
-}
-
-bool UntypedExpr::get_lvalue() const {
-        std::string fname = InitTweak::getFunctionName( this );
-        return lvalueFunctionNames.count( fname );
 }
 
@@ -95 +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,
@@ -127 +108 @@
 AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
         if ( arg->result ) {
-                if ( arg->get_lvalue() ) {
+                if ( arg->result->is_lvalue() ) {
                         // lvalue, retains all levels of reference, and gains a pointer inside the references
                         Type * res = addrType( arg->result );
+                        res->set_lvalue( false ); // result of & is never an lvalue
                         result = res;
                 } else {
@@ -136 +118 @@
                                         dynamic_cast< const ReferenceType * >( arg->result.get() ) ) {
                                 Type * res = addrType( refType->base );
+                                res->set_lvalue( false ); // result of & is never an lvalue
                                 result = res;
                         } else {
@@ -156 +139 @@
 : Expr( loc, new VoidType{} ), arg( a ), isGenerated( g ) {}
 
-bool CastExpr::get_lvalue() const {
-        // This is actually wrong by C, but it works with our current set-up.
-        return arg->get_lvalue();
-}
-
 // --- KeywordCastExpr
 
 const char * KeywordCastExpr::targetString() const {
         return AggregateDecl::aggrString( target );
-}
-
-// --- UntypedMemberExpr
-
-bool UntypedMemberExpr::get_lvalue() const {
-        return aggregate->get_lvalue();
 }
 
@@ -181 +153 @@
         assert( aggregate->result );
 
-        // Deep copy on result type avoids mutation on transitively multiply referenced object.
-        //
-        // Example, adapted from parts of builtins and bootloader:
-        //
-        // forall(dtype T)
-        // struct __Destructor {
-        //   T * object;
-        //   void (*dtor)(T *);
-        // };
-        //
-        // forall(dtype S)
-        // void foo(__Destructor(S) &d) {
-        //   if (d.dtor) {  // here
-        //   }
-        // }
-        //
-        // Let e be the "d.dtor" guard espression, which is MemberExpr after resolve.  Let d be the
-        // declaration of member __Destructor.dtor (an ObjectDecl), as accessed via the top-level
-        // declaration of __Destructor.  Consider the types e.result and d.type.  In the old AST, one
-        // is a clone of the other.  Ordinary new-AST use would set them up as a multiply-referenced
-        // object.
-        //
-        // e.result: PointerType
-        // .base: FunctionType
-        // .params.front(): ObjectDecl, the anonymous parameter of type T*
-        // .type: PointerType
-        // .base: TypeInstType
-        // let x = that
-        // let y = similar, except start from d.type
-        //
-        // Consider two code lines down, genericSubstitution(...).apply(result).
-        //
-        // Applying this chosen-candidate's type substitution means modifying x, substituting
-        // S for T.  This mutation should affect x and not y.
-
-        result = deepCopy(mem->get_type());
-
+        // take ownership of member type
+        result = mem->get_type();
         // substitute aggregate generic parameters into member type
         genericSubstitution( aggregate->result ).apply( result );
-        // ensure appropriate restrictions from aggregate type
-        add_qualifiers( result, aggregate->result->qualifiers );
-}
-
-MemberExpr::MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-    MemberExpr::NoOpConstruction overloadSelector )
-: Expr( loc ), member( mem ), aggregate( agg ) {
-        assert( member );
-        assert( aggregate );
-        assert( aggregate->result );
-        (void) overloadSelector;
-}
-
-bool MemberExpr::get_lvalue() const {
-        // This is actually wrong by C, but it works with our current set-up.
-        return true;
+        // ensure lvalue and appropriate restrictions from aggregate type
+        add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
 }
 
@@ -247 +170 @@
         assert( var );
         assert( var->get_type() );
-        result = shallowCopy( var->get_type() );
-}
-
-bool VariableExpr::get_lvalue() const {
-        // It isn't always an lvalue, but it is never an rvalue.
-        return true;
+        result = var->get_type();
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -338 +257 @@
         const CodeLocation & loc, const Expr * a1, const Expr * a2, LogicalFlag ia )
 : Expr( loc, new BasicType{ BasicType::SignedInt } ), arg1( a1 ), arg2( a2 ), isAnd( ia ) {}
-
-// --- CommaExpr
-bool CommaExpr::get_lvalue() const {
-        // This is wrong by C, but the current implementation uses it.
-        // (ex: Specialize, Lvalue and Box)
-        return arg2->get_lvalue();
-}
 
 // --- ConstructorExpr
@@ -364 +276 @@
         assert( t && i );
         result = t;
-}
-
-bool CompoundLiteralExpr::get_lvalue() const {
-        return true;
+        add_qualifiers( result, CV::Lvalue );
 }
 
@@ -384 +293 @@
         // like MemberExpr, TupleIndexExpr is always an lvalue
         result = type->types[ index ];
-}
-
-bool TupleIndexExpr::get_lvalue() const {
-        return tuple->get_lvalue();
+        add_qualifiers( result, CV::Lvalue );
 }
 

src/AST/Expr.hpp

@@ -31 +31 @@
 
 // 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;
@@ -188 +185 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
-        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -205 +201 @@
         ApplicationExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} );
 
-        bool get_lvalue() const final;
-
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -221 +215 @@
         UntypedExpr( const CodeLocation & loc, const Expr * f, std::vector<ptr<Expr>> && as = {} )
         : Expr( loc ), func( f ), args( std::move(as) ) {}
-
-        bool get_lvalue() const final;
 
         /// Creates a new dereference expression
@@ -299 +291 @@
         CastExpr( const Expr * a ) : CastExpr( a->location, a, GeneratedCast ) {}
 
-        bool get_lvalue() const final;
-
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -348 +338 @@
         : Expr( loc ), member( mem ), aggregate( agg ) { assert( aggregate ); }
 
-        bool get_lvalue() const final;
-
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -364 +352 @@
         MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg );
 
-        bool get_lvalue() const final;
-
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
         MemberExpr * clone() const override { return new MemberExpr{ *this }; }
         MUTATE_FRIEND
-
-        // Custructor overload meant only for AST conversion
-        enum NoOpConstruction { NoOpConstructionChosen };
-        MemberExpr( const CodeLocation & loc, const DeclWithType * mem, const Expr * agg,
-            NoOpConstruction overloadSelector );
-        friend class ::ConverterOldToNew;
-        friend class ::ConverterNewToOld;
 };
 
@@ -386 +365 @@
         VariableExpr( const CodeLocation & loc );
         VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        bool get_lvalue() const final;
 
         /// generates a function pointer for a given function
@@ -555 +532 @@
 
         CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
-        : Expr( loc ), arg1( a1 ), arg2( a2 ) {
-                this->result = a2->result;
-        }
-
-        bool get_lvalue() const final;
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -632 +605 @@
         CompoundLiteralExpr( const CodeLocation & loc, const Type * t, const Init * i );
 
-        bool get_lvalue() const final;
-
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
 private:
@@ -689 +660 @@
 
         TupleIndexExpr( const CodeLocation & loc, const Expr * t, unsigned i );
-
-        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Init.hpp

@@ -25 +25 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND \
-    template<typename node_t> friend node_t * mutate(const node_t * node); \
-        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;
                 }
@@ -96 +94 @@
         assertf(
                 node->weak_count == 0,
-                "Error: mutating node with weak references to it will invalidate some references"
+                "Error: mutating node with weak references to it will invalided some references"
         );
         return node->clone();
@@ -106 +104 @@
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
-
+        
         // mutate and return
         node_t * ret = mutate( node );
@@ -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 >
@@ -205 +202 @@
         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
@@ -217 +210 @@
         /// 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;
         };
@@ -224 +217 @@
         /// 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;
         };
 
@@ -330 +314 @@
         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 );
@@ -966 +951 @@
         // For now this isn't visited, it is unclear if this causes problem
         // if all tests are known to pass, remove this code
-        VISIT(
-                maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
-        )
+        // VISIT(
+        //      maybe_accept( node, &ImplicitCtorDtorStmt::callStmt );
+        // )
 
         VISIT_END( Stmt, node );
@@ -1694 +1679 @@
         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 );
@@ -1714 +1698 @@
         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 );
         })
@@ -1728 +1711 @@
         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 );
@@ -1746 +1728 @@
         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 );
@@ -1761 +1742 @@
         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 );
@@ -1777 +1757 @@
 
         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 );
         )
 
@@ -1932 +1907 @@
                                 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 });
                         }
@@ -1948 +1923 @@
                                 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();
                 }
@@ -311 +311 @@
                 SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
                 SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
-                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
+                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
 
                 // A few extra functions have more complicated behaviour, they are hand written
@@ -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 {
@@ -414 +412 @@
 class ImplicitCtorDtorStmt final : public Stmt {
 public:
-        ptr<Stmt> callStmt;
+        readonly<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,

src/AST/Type.cpp

@@ -21 +21 @@
 
 #include "Decl.hpp"
-#include "ForallSubstitutor.hpp" // for substituteForall
 #include "Init.hpp"
-#include "Common/utility.h"      // for copy, move
 #include "InitTweak/InitTweak.h" // for getPointerBase
 #include "Tuples/Tuples.h"       // for isTtype
@@ -92 +90 @@
 // GENERATED END
 
-// --- 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 {
@@ -125 +106 @@
 
 // --- 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" );
@@ -150 +118 @@
 // --- 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; }
@@ -158 +126 @@
 // --- 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; }
@@ -166 +134 @@
 // --- 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; }
@@ -174 +142 @@
 // --- 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 ) {
@@ -197 +158 @@
 
 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

@@ -29 +29 @@
 
 // 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 {
@@ -50 +44 @@
         bool is_volatile() const { return qualifiers.is_volatile; }
         bool is_restrict() const { return qualifiers.is_restrict; }
+        bool is_lvalue() const { return qualifiers.is_lvalue; }
         bool is_mutex() const { return qualifiers.is_mutex; }
         bool is_atomic() const { return qualifiers.is_atomic; }
@@ -56 +51 @@
         Type * set_volatile( bool v ) { qualifiers.is_volatile = v; return this; }
         Type * set_restrict( bool v ) { qualifiers.is_restrict = v; return this; }
+        Type * set_lvalue( bool v ) { qualifiers.is_lvalue = v; return this; }
         Type * set_mutex( bool v ) { qualifiers.is_mutex = v; return this; }
         Type * set_atomic( bool v ) { qualifiers.is_atomic = v; return this; }
@@ -167 +163 @@
         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) {}
 
@@ -269 +265 @@
 /// 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>>;
@@ -283 +276 @@
         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:
@@ -315 +301 @@
         : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
 
-        FunctionType( const FunctionType & o );
-
         /// true if either the parameters or return values contain a tttype
         bool isTtype() const;
@@ -330 +314 @@
 /// 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;
@@ -338 +319 @@
         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
@@ -359 +338 @@
         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;
@@ -381 +359 @@
         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;
@@ -403 +380 @@
         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;
@@ -425 +401 @@
         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
@@ -449 +424 @@
         TypeDecl::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 ) {}
@@ -456 +430 @@
                 std::vector<ptr<Attribute>> && as = {} )
         : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
-
-        TypeInstType( const TypeInstType & o );
 
         /// sets `base`, updating `kind` correctly

src/AST/TypeEnvironment.hpp

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

src/AST/TypeSubstitution.cpp

@@ -92 +92 @@
 namespace {
         struct EnvTrimmer {
-                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() ) {
@@ -159 +167 @@
         } else {
                 subCount++;
-                return i->second;
-        } // if
-}
-
-void TypeSubstitution::Substituter::previsit( const ParameterizedType * ptype ) {
+                delete nameExpr;
+                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

@@ -44 +44 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass >
-        struct ApplyResult {
-                const SynTreeClass * node;
-                int count;
-        };
-
-        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
-        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
+        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
+        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
 
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                auto ret = apply(p);
-                input = ret.node;
-                return ret.count;
+                int ret = apply(p);
+                input = p;
+                return ret;
         }
 
@@ -64 +58 @@
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                auto ret = applyFree(p);
-                input = ret.node;
-                return ret.count;
+                int ret = applyFree(p);
+                input = p;
+                return ret;
         }
 
@@ -161 +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;
@@ -181 +179 @@
 
 template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
+int TypeSubstitution::apply( const SynTreeClass *& input ) const {
         assert( input );
         Pass<Substituter> sub( *this, false );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.pass.subCount };
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 
 template< typename SynTreeClass >
-TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
+int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
         assert( input );
         Pass<Substituter> sub( *this, true );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-        return { input, sub.pass.subCount };
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 

src/AST/module.mk

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

src/Common/ScopedMap.h

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

src/Makefile.in

@@ -169 +169 @@
         AST/Convert.$(OBJEXT) AST/Decl.$(OBJEXT) \
         AST/DeclReplacer.$(OBJEXT) AST/Expr.$(OBJEXT) \
-        AST/ForallSubstitutionTable.$(OBJEXT) \
         AST/GenericSubstitution.$(OBJEXT) AST/Init.$(OBJEXT) \
         AST/LinkageSpec.$(OBJEXT) AST/Node.$(OBJEXT) \
@@ -590 +589 @@
         AST/DeclReplacer.cpp \
         AST/Expr.cpp \
-        AST/ForallSubstitutionTable.cpp \
         AST/GenericSubstitution.cpp \
         AST/Init.cpp \
@@ -767 +765 @@
         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)
@@ -1222 +1218 @@
 @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/Candidate.hpp

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

src/ResolvExpr/CandidateFinder.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  1 14:55:00 2019
-// Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Jun 5 14:30:00 2019
+// Update Count     : 1
 //
 
@@ -54 +54 @@
                 return new ast::CastExpr{ expr, expr->result->stripReferences() };
         }
-
+        
         return expr;
 }
@@ -61 +61 @@
 UniqueId globalResnSlot = 0;
 
-Cost computeConversionCost(
-        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+Cost computeConversionCost( 
+        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, 
+        const ast::TypeEnvironment & env 
 ) {
         PRINT(
@@ -74 +74 @@
                 std::cerr << std::endl;
         )
-        Cost convCost = conversionCost( argType, paramType, argIsLvalue, symtab, env );
+        Cost convCost = conversionCost( argType, paramType, symtab, env );
         PRINT(
                 std::cerr << std::endl << "cost is " << convCost << std::endl;
@@ -107 +107 @@
 
         /// Computes conversion cost for a given expression to a given type
-        const ast::Expr * computeExpressionConversionCost(
-                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
+        const ast::Expr * computeExpressionConversionCost( 
+                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost 
         ) {
-                Cost convCost = computeConversionCost(
-                                arg->result, paramType, arg->get_lvalue(), symtab, env );
+                Cost convCost = computeConversionCost( arg->result, paramType, symtab, env );
                 outCost += convCost;
 
-                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
-                // conversion. Ignore poly cost for now, since this requires resolution of the cast to
+                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires 
+                // conversion. Ignore poly cost for now, since this requires resolution of the cast to 
                 // infer parameters and this does not currently work for the reason stated below
                 Cost tmpCost = convCost;
@@ -124 +123 @@
                         return new ast::CastExpr{ arg, newType };
 
-                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not
-                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
+                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not 
+                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent, 
                         // once this is fixed it should be possible to resolve the cast.
-                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
-                        // but it shouldn't be because this makes the conversion from DT* to DT* since
+                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable, 
+                        // but it shouldn't be because this makes the conversion from DT* to DT* since 
                         // commontype(zero_t, DT*) is DT*, rather than nothing
 
                         // CandidateFinder finder{ symtab, env };
                         // finder.find( arg, ResolvMode::withAdjustment() );
-                        // assertf( finder.candidates.size() > 0,
+                        // assertf( finder.candidates.size() > 0, 
                         //      "Somehow castable expression failed to find alternatives." );
-                        // assertf( finder.candidates.size() == 1,
+                        // assertf( finder.candidates.size() == 1, 
                         //      "Somehow got multiple alternatives for known cast expression." );
                         // return finder.candidates.front()->expr;
@@ -144 +143 @@
 
         /// Computes conversion cost for a given candidate
-        Cost computeApplicationConversionCost(
-                CandidateRef cand, const ast::SymbolTable & symtab
+        Cost computeApplicationConversionCost( 
+                CandidateRef cand, const ast::SymbolTable & symtab 
         ) {
                 auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >();
@@ -168 +167 @@
                                 if ( function->isVarArgs ) {
                                         convCost.incUnsafe();
-                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
+                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: " 
                                                 << convCost << std::endl; ; )
                                         // convert reference-typed expressions into value-typed expressions
-                                        cand->expr = ast::mutate_field_index(
-                                                appExpr, &ast::ApplicationExpr::args, i,
+                                        cand->expr = ast::mutate_field_index( 
+                                                appExpr, &ast::ApplicationExpr::args, i, 
                                                 referenceToRvalueConversion( args[i], convCost ) );
                                         continue;
@@ -181 +180 @@
                                 // Default arguments should be free - don't include conversion cost.
                                 // Unwrap them here because they are not relevant to the rest of the system
-                                cand->expr = ast::mutate_field_index(
+                                cand->expr = ast::mutate_field_index( 
                                         appExpr, &ast::ApplicationExpr::args, i, def->expr );
                                 ++param;
@@ -189 +188 @@
                         // mark conversion cost and also specialization cost of param type
                         const ast::Type * paramType = (*param)->get_type();
-                        cand->expr = ast::mutate_field_index(
-                                appExpr, &ast::ApplicationExpr::args, i,
-                                computeExpressionConversionCost(
+                        cand->expr = ast::mutate_field_index( 
+                                appExpr, &ast::ApplicationExpr::args, i, 
+                                computeExpressionConversionCost( 
                                         args[i], paramType, symtab, cand->env, convCost ) );
                         convCost.decSpec( specCost( paramType ) );
@@ -199 +198 @@
                 if ( param != params.end() ) return Cost::infinity;
 
-                // specialization cost of return types can't be accounted for directly, it disables
+                // specialization cost of return types can't be accounted for directly, it disables 
                 // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
                 //
@@ -216 +215 @@
         }
 
-        void makeUnifiableVars(
-                const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars,
-                ast::AssertionSet & need
+        void makeUnifiableVars( 
+                const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars, 
+                ast::AssertionSet & need 
         ) {
                 for ( const ast::TypeDecl * tyvar : type->forall ) {
@@ -255 +254 @@
 
                 ArgPack()
-                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
+                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ), 
                   tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-
+                
+                ArgPack( 
+                        const ast::TypeEnvironment & env, const ast::AssertionSet & need, 
+                        const ast::AssertionSet & have, const ast::OpenVarSet & open )
+                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ), 
+                  open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
+                
                 ArgPack(
-                        const ast::TypeEnvironment & env, const ast::AssertionSet & need,
-                        const ast::AssertionSet & have, const ast::OpenVarSet & open )
-                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
-                  open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
-
-                ArgPack(
-                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
-                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
-                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
+                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env, 
+                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open, 
+                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero, 
                         unsigned nextExpl = 0, unsigned explAlt = 0 )
                 : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ),
                   have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
                   nextExpl( nextExpl ), explAlt( explAlt ) {}
-
+                
                 ArgPack(
-                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
+                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need, 
                         ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
-                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ),
-                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ),
+                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ), 
+                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ), 
                   tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
-
+                
                 /// true if this pack is in the middle of an exploded argument
                 bool hasExpl() const { return nextExpl > 0; }
@@ -287 +286 @@
                         return args[ nextArg-1 ][ explAlt ];
                 }
-
+                
                 /// Ends a tuple expression, consolidating the appropriate args
                 void endTuple( const std::vector< ArgPack > & packs ) {
@@ -308 +307 @@
 
         /// Instantiates an argument to match a parameter, returns false if no matching results left
-        bool instantiateArgument(
-                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
-                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
-                unsigned nTuples = 0
+        bool instantiateArgument( 
+                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args, 
+                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab, 
+                unsigned nTuples = 0 
         ) {
                 if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) {
@@ -319 +318 @@
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
                                 // ^^^ need to handle the case where a tuple has a default argument
-                                if ( ! instantiateArgument(
+                                if ( ! instantiateArgument( 
                                         type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
                                 nTuples = 0;
@@ -330 +329 @@
                 } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) {
                         // paramType is a ttype, consumes all remaining arguments
-
+                        
                         // completed tuples; will be spliced to end of results to finish
                         std::vector< ArgPack > finalResults{};
@@ -343 +342 @@
                                 for ( std::size_t i = genStart; i < genEnd; ++i ) {
                                         unsigned nextArg = results[i].nextArg;
-
+                                        
                                         // use next element of exploded tuple if present
                                         if ( results[i].hasExpl() ) {
@@ -353 +352 @@
                                                 results.emplace_back(
                                                         i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
-                                                        copy( results[i].need ), copy( results[i].have ),
+                                                        copy( results[i].need ), copy( results[i].have ), 
                                                         copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl,
                                                         results[i].explAlt );
@@ -371 +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 {
@@ -399 +400 @@
 
                                                 // check unification for ttype before adding to final
-                                                if (
-                                                        unify(
+                                                if ( 
+                                                        unify( 
                                                                 ttype, argType, newResult.env, newResult.need, newResult.have,
-                                                                newResult.open, symtab )
+                                                                newResult.open, symtab ) 
                                                 ) {
                                                         finalResults.emplace_back( move( newResult ) );
@@ -423 +424 @@
                                                 if ( expl.exprs.empty() ) {
                                                         results.emplace_back(
-                                                                results[i], move( env ), copy( results[i].need ),
+                                                                results[i], move( env ), copy( results[i].need ), 
                                                                 copy( results[i].have ), move( open ), nextArg + 1, expl.cost );
-
+                                                        
                                                         continue;
                                                 }
@@ -431 +432 @@
                                                 // add new result
                                                 results.emplace_back(
-                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ),
-                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples,
+                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ), 
+                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples, 
                                                         expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                         }
@@ -478 +479 @@
 
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg,
+                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg, 
                                                 nTuples, Cost::zero, nextExpl, results[i].explAlt );
                                 }
@@ -494 +495 @@
                                         if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
                                                 results.emplace_back(
-                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ),
+                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ), 
                                                         move( need ), move( have ), move( open ), nextArg, nTuples );
                                         }
@@ -516 +517 @@
                                 if ( expl.exprs.empty() ) {
                                         results.emplace_back(
-                                                results[i], move( env ), move( need ), move( have ), move( open ),
+                                                results[i], move( env ), move( need ), move( have ), move( open ), 
                                                 nextArg + 1, expl.cost );
-
+                                        
                                         continue;
                                 }
@@ -538 +539 @@
                                         // add new result
                                         results.emplace_back(
-                                                i, expr, move( env ), move( need ), move( have ), move( open ),
+                                                i, expr, move( env ), move( need ), move( have ), move( open ), 
                                                 nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                 }
@@ -547 +548 @@
                 genStart = genEnd;
 
-                return genEnd != results.size();  // were any new results added?
+                return genEnd != results.size();
         }
 
         /// Generate a cast expression from `arg` to `toType`
-        const ast::Expr * restructureCast(
+        const ast::Expr * restructureCast( 
                 ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast
         ) {
-                if (
-                        arg->result->size() > 1
-                        && ! toType->isVoid()
-                        && ! dynamic_cast< const ast::ReferenceType * >( toType )
+                if ( 
+                        arg->result->size() > 1 
+                        && ! toType->isVoid() 
+                        && ! dynamic_cast< const ast::ReferenceType * >( toType ) 
                 ) {
-                        // Argument is a tuple and the target type is neither void nor a reference. Cast each
-                        // member of the tuple to its corresponding target type, producing the tuple of those
-                        // cast expressions. If there are more components of the tuple than components in the
-                        // target type, then excess components do not come out in the result expression (but
+                        // Argument is a tuple and the target type is neither void nor a reference. Cast each 
+                        // member of the tuple to its corresponding target type, producing the tuple of those 
+                        // cast expressions. If there are more components of the tuple than components in the 
+                        // target type, then excess components do not come out in the result expression (but 
                         // UniqueExpr ensures that the side effects will still be produced)
                         if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
-                                // expressions which may contain side effects require a single unique instance of
+                                // expressions which may contain side effects require a single unique instance of 
                                 // the expression
                                 arg = new ast::UniqueExpr{ arg->location, arg };
@@ -573 +574 @@
                                 // cast each component
                                 ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
-                                components.emplace_back(
+                                components.emplace_back( 
                                         restructureCast( idx, toType->getComponent( i ), isGenerated ) );
                         }
@@ -593 +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;
                 ast::ptr< ast::Type > & targetType;
 
-                enum Errors {
-                        NotFound,
-                        NoMatch,
-                        ArgsToFew,
-                        ArgsToMany,
-                        RetsToFew,
-                        RetsToMany,
-                        NoReason
-                };
-
-                struct {
-                        Errors code = NotFound;
-                } reason;
-
                 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 ) {}
-
+                
                 void previsit( const ast::Node * ) { visit_children = false; }
 
@@ -625 +611 @@
                 void addCandidate( Args &&... args ) {
                         candidates.emplace_back( new Candidate{ std::forward<Args>( args )... } );
-                        reason.code = NoReason;
                 }
 
@@ -654 +639 @@
 
                 /// Completes a function candidate with arguments located
-                void validateFunctionCandidate(
-                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
-                        CandidateList & out
+                void validateFunctionCandidate( 
+                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results, 
+                        CandidateList & out 
                 ) {
-                        ast::ApplicationExpr * appExpr =
+                        ast::ApplicationExpr * appExpr = 
                                 new ast::ApplicationExpr{ func->expr->location, func->expr };
                         // sum cost and accumulate arguments
@@ -672 +657 @@
                         appExpr->args = move( vargs );
                         // build and validate new candidate
-                        auto newCand =
+                        auto newCand = 
                                 std::make_shared<Candidate>( appExpr, result.env, result.open, result.need, cost );
                         PRINT(
@@ -684 +669 @@
                 /// Builds a list of candidates for a function, storing them in out
                 void makeFunctionCandidates(
-                        const CandidateRef & func, const ast::FunctionType * funcType,
+                        const CandidateRef & func, const ast::FunctionType * funcType, 
                         const ExplodedArgs_new & args, CandidateList & out
                 ) {
@@ -691 +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 );
 
@@ -698 +683 @@
                                 // attempt to narrow based on expected target type
                                 const ast::Type * returnType = funcType->returns.front()->get_type();
-                                if ( ! unify(
-                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                                if ( ! unify( 
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab ) 
                                 ) {
                                         // unification failed, do not pursue this candidate
@@ -713 +698 @@
                         for ( const ast::DeclWithType * param : funcType->params ) {
                                 auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
-                                // Try adding the arguments corresponding to the current parameter to the existing
+                                // Try adding the arguments corresponding to the current parameter to the existing 
                                 // matches
-                                if ( ! instantiateArgument(
+                                if ( ! instantiateArgument( 
                                         obj->type, obj->init, args, results, genStart, symtab ) ) return;
                         }
@@ -765 +750 @@
                                                         if ( expl.exprs.empty() ) {
                                                                 results.emplace_back(
-                                                                        results[i], move( env ), copy( results[i].need ),
-                                                                        copy( results[i].have ), move( open ), nextArg + 1,
+                                                                        results[i], move( env ), copy( results[i].need ), 
+                                                                        copy( results[i].have ), move( open ), nextArg + 1, 
                                                                         expl.cost );
 
@@ -775 +760 @@
                                                         results.emplace_back(
                                                                 i, expl.exprs.front(), move( env ), copy( results[i].need ),
-                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost,
+                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost, 
                                                                 expl.exprs.size() == 1 ? 0 : 1, j );
                                                 }
@@ -795 +780 @@
                 /// Adds implicit struct-conversions to the alternative list
                 void addAnonConversions( const CandidateRef & cand ) {
-                        // adds anonymous member interpretations whenever an aggregate value type is seen.
-                        // it's okay for the aggregate expression to have reference type -- cast it to the
+                        // adds anonymous member interpretations whenever an aggregate value type is seen. 
+                        // it's okay for the aggregate expression to have reference type -- cast it to the 
                         // base type to treat the aggregate as the referenced value
                         ast::ptr< ast::Expr > aggrExpr( cand->expr );
                         ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
                         cand->env.apply( aggrType );
-
+                        
                         if ( aggrType.as< ast::ReferenceType >() ) {
                                 aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
@@ -814 +799 @@
 
                 /// Adds aggregate member interpretations
-                void addAggMembers(
-                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
-                        const Candidate & cand, const Cost & addedCost, const std::string & name
+                void addAggMembers( 
+                        const ast::ReferenceToType * aggrInst, const ast::Expr * expr, 
+                        const Candidate & cand, const Cost & addedCost, const std::string & name 
                 ) {
                         for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
-                                CandidateRef newCand = std::make_shared<Candidate>(
+                                CandidateRef newCand = std::make_shared<Candidate>( 
                                         cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
-                                // add anonymous member interpretations whenever an aggregate value type is seen
+                                // add anonymous member interpretations whenever an aggregate value type is seen 
                                 // as a member expression
                                 addAnonConversions( newCand );
@@ -830 +815 @@
 
                 /// Adds tuple member interpretations
-                void addTupleMembers(
-                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
-                        const Cost & addedCost, const ast::Expr * member
+                void addTupleMembers( 
+                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand, 
+                        const Cost & addedCost, const ast::Expr * member 
                 ) {
                         if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
-                                // get the value of the constant expression as an int, must be between 0 and the
+                                // get the value of the constant expression as an int, must be between 0 and the 
                                 // length of the tuple to have meaning
                                 long long val = constantExpr->intValue();
                                 if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
                                         addCandidate(
-                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
+                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val }, 
                                                 addedCost );
                                 }
@@ -852 +837 @@
                         if ( funcFinder.candidates.empty() ) return;
 
-                        reason.code = NoMatch;
-
-                        std::vector< CandidateFinder > argCandidates =
+                        std::vector< CandidateFinder > argCandidates = 
                                 selfFinder.findSubExprs( untypedExpr->args );
-
+                        
                         // take care of possible tuple assignments
                         // if not tuple assignment, handled as normal function call
@@ -894 +877 @@
                                                 if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                         CandidateRef newFunc{ new Candidate{ *func } };
-                                                        newFunc->expr =
+                                                        newFunc->expr = 
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                         makeFunctionCandidates( newFunc, function, argExpansions, found );
                                                 }
-                                        } else if (
-                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
+                                        } else if ( 
+                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult ) 
                                         ) {
                                                 if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
                                                         if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                                 CandidateRef newFunc{ new Candidate{ *func } };
-                                                                newFunc->expr =
+                                                                newFunc->expr = 
                                                                         referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                                 makeFunctionCandidates( newFunc, function, argExpansions, found );
@@ -918 +901 @@
                                 std::vector< ExplodedArg > funcE;
                                 funcE.reserve( funcFinder.candidates.size() );
-                                for ( const CandidateRef & func : funcFinder ) {
+                                for ( const CandidateRef & func : funcFinder ) { 
                                         funcE.emplace_back( *func, symtab );
                                 }
@@ -930 +913 @@
                                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                                 CandidateRef newOp{ new Candidate{ *op} };
-                                                                newOp->expr =
+                                                                newOp->expr = 
                                                                         referenceToRvalueConversion( newOp->expr, newOp->cost );
                                                                 makeFunctionCandidates( newOp, function, argExpansions, found );
@@ -939 +922 @@
                         }
 
-                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error
+                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error 
                         // candidates
                         if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
@@ -951 +934 @@
                                         auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
                                         auto function = pointer->base.strict_as< ast::FunctionType >();
-
+                                        
                                         std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
                                         std::cerr << "parameters are:" << std::endl;
@@ -974 +957 @@
                         promoteCvtCost( winners );
 
-                        // function may return a struct/union value, in which case we need to add candidates
-                        // for implicit conversions to each of the anonymous members, which must happen after
+                        // function may return a struct/union value, in which case we need to add candidates 
+                        // for implicit conversions to each of the anonymous members, which must happen after 
                         // `findMinCost`, since anon conversions are never the cheapest
                         for ( const CandidateRef & c : winners ) {
@@ -983 +966 @@
 
                         if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
-                                // If resolution is unsuccessful with a target type, try again without, since it
+                                // If resolution is unsuccessful with a target type, try again without, since it 
                                 // will sometimes succeed when it wouldn't with a target type binding.
                                 // For example:
@@ -1000 +983 @@
                 /// true if expression is an lvalue
                 static bool isLvalue( const ast::Expr * x ) {
-                        return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() );
+                        return x->result && ( x->result->is_lvalue() || x->result.as< ast::ReferenceType >() );
                 }
 
@@ -1006 +989 @@
                         CandidateFinder finder{ symtab, tenv };
                         finder.find( addressExpr->arg );
-
-                        if( finder.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
-
                         for ( CandidateRef & r : finder.candidates ) {
                                 if ( ! isLvalue( r->expr ) ) continue;
@@ -1031 +1009 @@
                         finder.find( castExpr->arg, ResolvMode::withAdjustment() );
 
-                        if( !finder.candidates.empty() ) reason.code = NoMatch;
-
                         CandidateList matches;
                         for ( CandidateRef & cand : finder.candidates ) {
@@ -1040 +1016 @@
                                 cand->env.extractOpenVars( open );
 
-                                // It is possible that a cast can throw away some values in a multiply-valued
-                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
-                                // subexpression results that are cast directly. The candidate is invalid if it
+                                // It is possible that a cast can throw away some values in a multiply-valued 
+                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the 
+                                // subexpression results that are cast directly. The candidate is invalid if it 
                                 // has fewer results than there are types to cast to.
                                 int discardedValues = cand->expr->result->size() - toType->size();
@@ -1049 +1025 @@
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
-                                Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                symtab, cand->env );
+                                Cost thisCost = castCost( cand->expr->result, toType, symtab, cand->env );
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
@@ -1062 +1037 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        CandidateRef newCand = std::make_shared<Candidate>(
-                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
-                                                copy( cand->env ), move( open ), move( need ), cand->cost,
+                                        CandidateRef newCand = std::make_shared<Candidate>( 
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ), 
+                                                copy( cand->env ), move( open ), move( need ), cand->cost, 
                                                 cand->cost + thisCost );
                                         inferParameters( newCand, matches );
@@ -1082 +1057 @@
                         finder.find( castExpr->arg, ResolvMode::withoutPrune() );
                         for ( CandidateRef & r : finder.candidates ) {
-                                addCandidate(
-                                        *r,
+                                addCandidate( 
+                                        *r, 
                                         new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
                         }
@@ -1092 +1067 @@
                         aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
                         for ( CandidateRef & agg : aggFinder.candidates ) {
-                                // it's okay for the aggregate expression to have reference type -- cast it to the
+                                // it's okay for the aggregate expression to have reference type -- cast it to the 
                                 // base type to treat the aggregate as the referenced value
                                 Cost addedCost = Cost::zero;
@@ -1099 +1074 @@
                                 // find member of the given type
                                 if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
-                                        addAggMembers(
+                                        addAggMembers( 
                                                 structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
-                                        addAggMembers(
+                                        addAggMembers( 
                                                 unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
@@ -1117 +1092 @@
                         std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name );
                         PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
-                        if( declList.empty() ) return;
-
-                        reason.code = NoMatch;
-
                         for ( auto & data : declList ) {
                                 Cost cost = Cost::zero;
@@ -1126 +1097 @@
 
                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
+                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero, 
                                         cost );
                                 PRINT(
@@ -1136 +1107 @@
                                         std::cerr << std::endl;
                                 )
-                                newCand->expr = ast::mutate_field(
-                                        newCand->expr.get(), &ast::Expr::result,
+                                newCand->expr = ast::mutate_field( 
+                                        newCand->expr.get(), &ast::Expr::result, 
                                         renameTyVars( newCand->expr->result ) );
-                                // add anonymous member interpretations whenever an aggregate value type is seen
+                                // add anonymous member interpretations whenever an aggregate value type is seen 
                                 // as a name expression
                                 addAnonConversions( newCand );
@@ -1149 +1120 @@
                         // not sufficient to just pass `variableExpr` here, type might have changed since
                         // creation
-                        addCandidate(
+                        addCandidate( 
                                 new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
                 }
@@ -1159 +1130 @@
                 void postvisit( const ast::SizeofExpr * sizeofExpr ) {
                         if ( sizeofExpr->type ) {
-                                addCandidate(
-                                        new ast::SizeofExpr{
-                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) },
+                                addCandidate( 
+                                        new ast::SizeofExpr{ 
+                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) }, 
                                         tenv );
                         } else {
@@ -1170 +1141 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
-                                        SemanticError(
+                                        SemanticError( 
                                                 sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
                                 }
@@ -1183 +1154 @@
                 void postvisit( const ast::AlignofExpr * alignofExpr ) {
                         if ( alignofExpr->type ) {
-                                addCandidate(
-                                        new ast::AlignofExpr{
-                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) },
+                                addCandidate( 
+                                        new ast::AlignofExpr{ 
+                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) }, 
                                         tenv );
                         } else {
@@ -1194 +1165 @@
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
-                                        SemanticError(
+                                        SemanticError( 
                                                 alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
                                 }
@@ -1201 +1172 @@
                                 choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
                                 choice->cost = Cost::zero;
-                                addCandidate(
+                                addCandidate( 
                                         *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
                         }
@@ -1214 +1185 @@
                         for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
-                                addCandidate(
+                                addCandidate( 
                                         new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
                         }
@@ -1235 +1206 @@
                         finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
                         if ( finder2.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
 
                         for ( const CandidateRef & r1 : finder1.candidates ) {
@@ -1249 +1218 @@
 
                                         addCandidate(
-                                                new ast::LogicalExpr{
+                                                new ast::LogicalExpr{ 
                                                         logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
                                                 move( env ), move( open ), move( need ), r1->cost + r2->cost );
@@ -1271 +1240 @@
                         finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                         if ( finder3.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
 
                         for ( const CandidateRef & r1 : finder1.candidates ) {
@@ -1289 +1256 @@
                                                 ast::AssertionSet have;
 
-                                                // unify true and false results, then infer parameters to produce new
+                                                // unify true and false results, then infer parameters to produce new 
                                                 // candidates
                                                 ast::ptr< ast::Type > common;
-                                                if (
-                                                        unify(
-                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab,
-                                                                common )
+                                                if ( 
+                                                        unify( 
+                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab, 
+                                                                common ) 
                                                 ) {
                                                         // generate typed expression
-                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
+                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{ 
                                                                 conditionalExpr->location, r1->expr, r2->expr, r3->expr };
                                                         newExpr->result = common ? common : r2->expr->result;
                                                         // convert both options to result type
                                                         Cost cost = r1->cost + r2->cost + r3->cost;
-                                                        newExpr->arg2 = computeExpressionConversionCost(
+                                                        newExpr->arg2 = computeExpressionConversionCost( 
                                                                 newExpr->arg2, newExpr->result, symtab, env, cost );
                                                         newExpr->arg3 = computeExpressionConversionCost(
@@ -1320 +1287 @@
                         ast::TypeEnvironment env{ tenv };
                         ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, symtab, env );
-
+                        
                         CandidateFinder finder2{ symtab, env };
                         finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
@@ -1350 +1317 @@
                         finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
                         if ( finder2.candidates.empty() ) return;
-
-                        reason.code = NoMatch;
 
                         for ( const CandidateRef & r1 : finder1.candidates ) {
@@ -1365 +1330 @@
 
                                         ast::ptr< ast::Type > common;
-                                        if (
-                                                unify(
-                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab,
-                                                        common )
+                                        if ( 
+                                                unify( 
+                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab, 
+                                                        common ) 
                                         ) {
                                                 // generate new expression
-                                                ast::RangeExpr * newExpr =
+                                                ast::RangeExpr * newExpr = 
                                                         new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
                                                 newExpr->result = common ? common : r1->expr->result;
                                                 // add candidate
                                                 CandidateRef newCand = std::make_shared<Candidate>(
-                                                        newExpr, move( env ), move( open ), move( need ),
+                                                        newExpr, move( env ), move( open ), move( need ), 
                                                         r1->cost + r2->cost );
                                                 inferParameters( newCand, candidates );
@@ -1385 +1350 @@
 
                 void postvisit( const ast::UntypedTupleExpr * tupleExpr ) {
-                        std::vector< CandidateFinder > subCandidates =
+                        std::vector< CandidateFinder > subCandidates = 
                                 selfFinder.findSubExprs( tupleExpr->exprs );
                         std::vector< CandidateList > possibilities;
@@ -1405 +1370 @@
 
                                 addCandidate(
-                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) },
+                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) }, 
                                         move( env ), move( open ), move( need ), sumCost( subs ) );
                         }
@@ -1447 +1412 @@
                                 toType = SymTab::validateType( initExpr->location, toType, symtab );
                                 toType = adjustExprType( toType, tenv, symtab );
-                                // The call to find must occur inside this loop, otherwise polymorphic return
-                                // types are not bound to the initialization type, since return type variables are
-                                // only open for the duration of resolving the UntypedExpr.
+                                // The call to find must occur inside this loop, otherwise polymorphic return 
+                                // types are not bound to the initialization type, since return type variables are 
+                                // only open for the duration of resolving the UntypedExpr. 
                                 CandidateFinder finder{ symtab, tenv, toType };
                                 finder.find( initExpr->expr, ResolvMode::withAdjustment() );
                                 for ( CandidateRef & cand : finder.candidates ) {
-                                        if(reason.code == NotFound) reason.code = NoMatch;
-
                                         ast::TypeEnvironment env{ cand->env };
                                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
@@ -1463 +1426 @@
                                         )
 
-                                        // It is possible that a cast can throw away some values in a multiply-valued
-                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
-                                        // the subexpression results that are cast directly. The candidate is invalid
+                                        // It is possible that a cast can throw away some values in a multiply-valued 
+                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of 
+                                        // the subexpression results that are cast directly. The candidate is invalid 
                                         // if it has fewer results than there are types to cast to.
                                         int discardedValues = cand->expr->result->size() - toType->size();
@@ -1472 +1435 @@
                                         // unification run for side-effects
                                         unify( toType, cand->expr->result, env, need, have, open, symtab );
-                                        Cost thisCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
-                                                        symtab, env );
-
+                                        Cost thisCost = castCost( cand->expr->result, toType, symtab, env );
+                                        
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away
                                                 thisCost.incSafe( discardedValues );
-                                                CandidateRef newCand = std::make_shared<Candidate>(
-                                                        new ast::InitExpr{
-                                                                initExpr->location, restructureCast( cand->expr, toType ),
-                                                                initAlt.designation },
+                                                CandidateRef newCand = std::make_shared<Candidate>( 
+                                                        new ast::InitExpr{ 
+                                                                initExpr->location, restructureCast( cand->expr, toType ), 
+                                                                initAlt.designation }, 
                                                         copy( cand->env ), move( open ), move( need ), cand->cost, thisCost );
                                                 inferParameters( newCand, matches );
@@ -1507 +1469 @@
         };
 
-        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
+        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given 
         /// return type. Skips ambiguous candidates.
         CandidateList pruneCandidates( CandidateList & candidates ) {
@@ -1524 +1486 @@
                         {
                                 ast::ptr< ast::Type > newType = candidate->expr->result;
-                                assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
                                 candidate->env.apply( newType );
                                 mangleName = Mangle::mangle( newType );
@@ -1533 +1494 @@
                                 if ( candidate->cost < found->second.candidate->cost ) {
                                         PRINT(
-                                                std::cerr << "cost " << candidate->cost << " beats "
+                                                std::cerr << "cost " << candidate->cost << " beats " 
                                                         << found->second.candidate->cost << std::endl;
                                         )
@@ -1539 +1500 @@
                                         found->second = PruneStruct{ candidate };
                                 } else if ( candidate->cost == found->second.candidate->cost ) {
-                                        // if one of the candidates contains a deleted identifier, can pick the other,
-                                        // since deleted expressions should not be ambiguous if there is another option
+                                        // if one of the candidates contains a deleted identifier, can pick the other, 
+                                        // since deleted expressions should not be ambiguous if there is another option 
                                         // that is at least as good
                                         if ( findDeletedExpr( candidate->expr ) ) {
@@ -1554 +1515 @@
                                 } else {
                                         PRINT(
-                                                std::cerr << "cost " << candidate->cost << " loses to "
+                                                std::cerr << "cost " << candidate->cost << " loses to " 
                                                         << found->second.candidate->cost << std::endl;
                                         )
@@ -1569 +1530 @@
 
                         CandidateRef cand = target.second.candidate;
-
+                        
                         ast::ptr< ast::Type > newResult = cand->expr->result;
                         cand->env.applyFree( newResult );
                         cand->expr = ast::mutate_field(
                                 cand->expr.get(), &ast::Expr::result, move( newResult ) );
-
+                        
                         out.emplace_back( cand );
                 }
@@ -1588 +1549 @@
 
         if ( mode.failFast && candidates.empty() ) {
-                switch(finder.pass.reason.code) {
-                case Finder::NotFound:
-                        { SemanticError( expr, "No alternatives for expression " ); break; }
-                case Finder::NoMatch:
-                        { SemanticError( expr, "Invalid application of existing declaration(s) in expression " ); break; }
-                case Finder::ArgsToFew:
-                case Finder::ArgsToMany:
-                case Finder::RetsToFew:
-                case Finder::RetsToMany:
-                case Finder::NoReason:
-                default:
-                        { SemanticError( expr->location, "No reasonable alternatives for expression : reasons unkown" ); }
-                }
+                SemanticError( expr, "No reasonable alternatives for expression " );
         }
 
@@ -1609 +1558 @@
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
-                        satisfyAssertions( candidate, localSyms, satisfied, errors );
+                        satisfyAssertions( candidate, symtab, satisfied, errors );
                 }
 
@@ -1634 +1583 @@
 
                 CandidateList pruned = pruneCandidates( candidates );
-
+                
                 if ( mode.failFast && pruned.empty() ) {
                         std::ostringstream stream;
@@ -1653 +1602 @@
                 )
                 PRINT(
-                        std::cerr << "there are " << candidates.size() << " alternatives after elimination"
+                        std::cerr << "there are " << candidates.size() << " alternatives after elimination" 
                                 << std::endl;
                 )
         }
 
-        // adjust types after pruning so that types substituted by pruneAlternatives are correctly
+        // adjust types after pruning so that types substituted by pruneAlternatives are correctly 
         // adjusted
         if ( mode.adjust ) {
                 for ( CandidateRef & r : candidates ) {
-                        r->expr = ast::mutate_field(
-                                r->expr.get(), &ast::Expr::result,
-                                adjustExprType( r->expr->result, r->env, localSyms ) );
+                        r->expr = ast::mutate_field( 
+                                r->expr.get(), &ast::Expr::result, 
+                                adjustExprType( r->expr->result, r->env, symtab ) );
                 }
         }
@@ -1676 +1625 @@
 }
 
-std::vector< CandidateFinder > CandidateFinder::findSubExprs(
-        const std::vector< ast::ptr< ast::Expr > > & xs
+std::vector< CandidateFinder > CandidateFinder::findSubExprs( 
+        const std::vector< ast::ptr< ast::Expr > > & xs 
 ) {
         std::vector< CandidateFinder > out;
 
         for ( const auto & x : xs ) {
-                out.emplace_back( localSyms, env );
+                out.emplace_back( symtab, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
-
+                
                 PRINT(
                         std::cerr << "findSubExprs" << std::endl;

src/ResolvExpr/CandidateFinder.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  1  9:51:00 2019
-// Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Wed Jun 5 14:30:00 2019
+// Update Count     : 1
 //
 
@@ -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,
+        CandidateFinder( 
+                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`
@@ -49 +49 @@
         iterator begin() { return candidates.begin(); }
         const_iterator begin() const { return candidates.begin(); }
-
+        
         iterator end() { return candidates.end(); }
         const_iterator end() const { return candidates.end(); }
@@ -55 +55 @@
 
 /// Computes conversion cost between two types
-Cost computeConversionCost(
-        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+Cost computeConversionCost( 
+        const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab, 
+        const ast::TypeEnvironment & env );
 
 } // namespace ResolvExpr

src/ResolvExpr/CastCost.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 06:57:43 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  4 15:00:00 2019
-// Update Count     : 9
+// Last Modified On : Thu Aug  8 16:12:00 2019
+// Update Count     : 8
 //
 
@@ -142 +142 @@
 
                 CastCost_new(
-                        const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
+                        const ast::Type * dst, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costFunc )
-                : ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {}
+                : ConversionCost_new( dst, symtab, env, costFunc ) {}
 
                 void postvisit( const ast::BasicType * basicType ) {
@@ -152 +152 @@
                                 cost = Cost::unsafe;
                         } else {
-                                cost = conversionCost( basicType, dst, srcIsLvalue, symtab, env );
+                                cost = conversionCost( basicType, dst, symtab, env );
                         }
                 }
@@ -183 +183 @@
                 }
         };
-
-        #warning For overload resolution between the two versions.
-        int localPtrsCastable(const ast::Type * t1, const ast::Type * t2,
-                        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) {
-                return ptrsCastable( t1, t2, symtab, env );
-        }
-        Cost localCastCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-        ) { return castCost( src, dst, srcIsLvalue, symtab, env ); }
 } // anonymous namespace
 
-
-
 Cost castCost(
-        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
 ) {
         if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -205 +193 @@
                         // check cast cost against bound type, if present
                         if ( eqvClass->bound ) {
-                                return castCost( src, eqvClass->bound, srcIsLvalue, symtab, env );
+                                return castCost( src, eqvClass->bound, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -213 +201 @@
                         auto type = strict_dynamic_cast< const ast::TypeDecl * >( named );
                         if ( type->base ) {
-                                return castCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
+                                return castCost( src, type->base, symtab, env ) + Cost::safe;
                         }
                 }
@@ -236 +224 @@
                 #warning cast on ptrsCastable artifact of having two functions, remove when port done
                 return convertToReferenceCost(
-                        src, refType, srcIsLvalue, symtab, env, localPtrsCastable );
+                        src, refType, symtab, env,
+                        ( int (*)(
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                                const ast::TypeEnvironment & )
+                        ) ptrsCastable );
         } else {
                 #warning cast on castCost artifact of having two functions, remove when port done
-                ast::Pass< CastCost_new > converter(
-                        dst, srcIsLvalue, symtab, env, localCastCost );
+                ast::Pass< CastCost_new > converter{
+                        dst, symtab, env,
+                        ( Cost (*)(
+                                const ast::Type *, const ast::Type *, const ast::SymbolTable &,
+                                const ast::TypeEnvironment & )
+                        ) castCost };
                 src->accept( converter );
                 return converter.pass.cost;

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 : Fri Oct  4 14:45:00 2019
-// Update Count     : 28
+// Last Modified On : Mon Aug 12 10:21:00 2019
+// Update Count     : 27
 //
 
@@ -497 +497 @@
         }
 
-namespace {
-        # warning For overload resolution between the two versions.
-        int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
-                        const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
-                return ptrsAssignable( t1, t2, env );
-        }
-        Cost localConversionCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-        ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
-}
+static int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
+                const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
+        return ptrsAssignable( t1, t2, env );
+}
+
+// TODO: This is used for overload resolution. It might be able to be dropped once the old system
+// is removed.
+static Cost localConversionCost(
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
+) { return conversionCost( src, dst, symtab, env ); }
 
 Cost conversionCost(
-        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+        const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
                         if ( eqv->bound ) {
-                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
+                                return conversionCost(src, eqv->bound, symtab, env );
                         } else {
                                 return Cost::infinity;
@@ -524 +524 @@
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
-                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, symtab, env ) + Cost::safe;
                         }
                 }
@@ -534 +534 @@
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
-                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
         } else {
-                ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
+                ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
                 src->accept( converter );
                 return converter.pass.cost;
@@ -542 +542 @@
 }
 
-static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+                NumCostCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
-                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
-                        srcIsLvalue, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
+                        dst, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -554 +554 @@
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
-                        srcIsLvalue, (diff + 1), symtab, env, func );
+                        (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
@@ -579 +579 @@
                         }
                 } else {
-                        ast::Pass<ConversionCost_new> converter( dst, srcIsLvalue, symtab, env, localConversionCost );
+                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
                         src->accept( converter );
                         return converter.pass.cost;
@@ -588 +588 @@
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
-                        if ( srcIsLvalue ) {
+                        if ( src->is_lvalue() ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
@@ -607 +607 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
-                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
-                PtrsCalculation func ) {
+            const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                NumCostCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
-        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
 }
 
@@ -667 +667 @@
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
-        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
+        cost = costCalc( refType->base, dst, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
@@ -701 +701 @@
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;
-        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
-        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
+        static const ast::BasicType integer( ast::BasicType::SignedInt );
+        cost = costCalc( &integer, dst, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
@@ -714 +714 @@
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
         if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
-                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
+                cost = costCalc( eqv->bound, dst, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
@@ -724 +724 @@
                 assertf( type, "Unexpected typedef.");
                 if ( type->base ) {
-                        cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
                 }
         }
@@ -737 +737 @@
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
-                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;
@@ -772 +772 @@
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
                 }
-        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
-                cost = Cost::zero;
-                // +1 for zero_t ->, +1 for disambiguation
-                cost.incSafe( maxIntCost + 2 );
         }
 }
@@ -793 +789 @@
                         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/ConversionCost.h

@@ -10 +10 @@
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  4 14:59:00 2019
-// Update Count     : 7
+// Last Modified On : Thu Aug  8 16:13:00 2019
+// Update Count     : 6
 //
 
@@ -74 +74 @@
 
 // Some function pointer types, differ in return type.
-using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *, bool,
+using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
-using PtrsCalculation = std::function<int(const ast::Type *, const ast::Type *,
+using NumCostCalculation = std::function<int(const ast::Type *, const ast::Type *,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
 
@@ -83 +83 @@
 protected:
         const ast::Type * dst;
-        bool srcIsLvalue;
         const ast::SymbolTable & symtab;
         const ast::TypeEnvironment & env;
@@ -90 +89 @@
         Cost cost;
 
-        ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
+        ConversionCost_new( const ast::Type * dst, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costCalc ) :
-                dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ),
-                costCalc( costCalc ), cost( Cost::infinity )
+                dst( dst ), symtab( symtab ), env( env ), costCalc( costCalc ), cost( Cost::infinity )
         {}
 
@@ -116 +114 @@
 
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest,
-        bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env,
-        PtrsCalculation func );
+        const ast::SymbolTable & indexer, const ast::TypeEnvironment & env, NumCostCalculation func );
 
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

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

src/ResolvExpr/PolyCost.cc

@@ -58 +58 @@
 
 // TODO: When the old PolyCost is torn out get rid of the _new suffix.
-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;
+                        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;
 
-                        nameMap.beginScope();
-
-                        // Load new names from this forall clause and perform renaming.
-                        NodeT * mutType = ast::mutate( type );
-                        assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
-                        for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
-                                std::ostringstream output;
-                                output << "_" << resetCount << "_" << level << "_" << td->name;
-                                std::string newname =  output.str();
-                                nameMap[ td->name ] = newname;
-                                ++level;
-
-                                ast::TypeDecl * mutDecl = ast::mutate( td.get() );
-                                assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
-                                mutDecl->name = newname;
-                                // assertion above means `td = mutDecl;` is unnecessary
+                                        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

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

src/ResolvExpr/Resolver.cc

@@ -1074 +1074 @@
                         const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
                                 if (
-                                        castExpr->isGenerated == ast::GeneratedCast
+                                        castExpr->isGenerated
                                         && typesCompatible( castExpr->arg->result, castExpr->result )
                                 ) {
@@ -1128 +1128 @@
 
                 // 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() );
@@ -1267 +1267 @@
         };
 
-        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 );
@@ -1301 +1301 @@
                 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 >() ) {
@@ -1318 +1318 @@
                         }
                 }
-                return ret.release();
+                return ret.get();
         }
 
@@ -1341 +1341 @@
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
-                inEnumDecl = true;
+                inEnumDecl = false;
         }
 

src/ResolvExpr/SatisfyAssertions.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Mon Jun 10 17:45:00 2019
-// Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  1 13:56:00 2019
-// Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Mon Jun 10 17:45:00 2019
+// Update Count     : 1
 //
 
@@ -299 +299 @@
                         Cost cost;
 
-                        OutType(
-                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
+                        OutType( 
+                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o, 
                                 const std::vector< DeferRef > & as, const ast::SymbolTable & symtab )
                         : env( e ), open( o ), assns( as ), cost( Cost::zero ) {
@@ -306 +306 @@
                                 for ( const DeferRef & assn : assns ) {
                                         // compute conversion cost from satisfying decl to assertion
-                                        cost += computeConversionCost(
-                                                assn.match.adjType, assn.decl->get_type(), false, symtab, env );
-
+                                        cost += computeConversionCost( 
+                                                assn.match.adjType, assn.decl->get_type(), symtab, env );
+                                        
                                         // mark vars+specialization on function-type assertions
-                                        const ast::FunctionType * func =
+                                        const ast::FunctionType * func = 
                                                 GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                         if ( ! func ) continue;
@@ -317 +317 @@
                                                 cost.decSpec( specCost( param->get_type() ) );
                                         }
-
+                                        
                                         cost.incVar( func->forall.size() );
-
+                                        
                                         for ( const ast::TypeDecl * td : func->forall ) {
                                                 cost.decSpec( td->assertions.size() );
@@ -329 +329 @@
                 };
 
-                CandidateEnvMerger(
-                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
+                CandidateEnvMerger( 
+                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open, 
                         const ast::SymbolTable & syms )
                 : crnt(), envs{ env }, opens{ open }, symtab( syms ) {}

src/ResolvExpr/SatisfyAssertions.hpp

@@ -28 +28 @@
 
 /// Recursively satisfies all assertions provided in a candidate; returns true if succeeds
-void satisfyAssertions(
-        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
+void satisfyAssertions( 
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out, 
         std::vector<std::string> & errors );
 

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/ResolvExpr/Unify.cc

@@ -25 +25 @@
 #include <vector>
 
-#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Node.hpp"
 #include "AST/Pass.hpp"
-#include "AST/Print.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
@@ -137 +135 @@
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
 
-                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -149 +148 @@
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
-
+///   std::cerr << "first is ";
+///   first->print( std::cerr );
+///   std::cerr << std::endl << "second is ";
+///   second->print( std::cerr );
+///   std::cerr << std::endl << "newFirst is ";
+///   newFirst->print( std::cerr );
+///   std::cerr << std::endl << "newSecond is ";
+///   newSecond->print( std::cerr );
+///   std::cerr << std::endl;
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
@@ -163 +170 @@
                 ast::AssertionSet need, have;
 
-                ast::Type * newFirst  = shallowCopy( first  );
-                ast::Type * newSecond = shallowCopy( second );
-                newFirst ->qualifiers = {};
-                newSecond->qualifiers = {};
-                ast::ptr< ast::Type > t1_(newFirst );
-                ast::ptr< ast::Type > t2_(newSecond);
+                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
 
                 return unifyExact(
-                        env.apply( newFirst  ).node,
-                        env.apply( newSecond ).node,
-                        newEnv, need, have, open, noWiden(), symtab );
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
         }
 
@@ -322 +326 @@
 
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
+///   std::cerr << "assertion set is" << std::endl;
+///   printAssertionSet( assertions, std::cerr, 8 );
+///   std::cerr << "looking for ";
+///   assert->print( std::cerr );
+///   std::cerr << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
+///     std::cerr << "found it!" << std::endl;
                         i->second.isUsed = true;
                 } // if
@@ -933 +943 @@
 
         private:
-                // Returns: other, cast as XInstType
-                // Assigns this->result: whether types are compatible (up to generic parameters)
-                template< typename XInstType >
-                const XInstType * handleRefType( const XInstType * inst, const ast::Type * other ) {
+                template< typename RefType >
+                const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
                         // check that the other type is compatible and named the same
-                        auto otherInst = dynamic_cast< const XInstType * >( other );
-                        this->result = otherInst && inst->name == otherInst->name;
+                        auto otherInst = dynamic_cast< const RefType * >( other );
+                        result = otherInst && inst->name == otherInst->name;
                         return otherInst;
                 }
@@ -960 +968 @@
                 }
 
-                template< typename XInstType >
-                void handleGenericRefType( const XInstType * inst, const ast::Type * other ) {
+                template< typename RefType >
+                void handleGenericRefType( const RefType * inst, const ast::Type * other ) {
                         // check that other type is compatible and named the same
-                        const XInstType * otherInst = handleRefType( inst, other );
-                        if ( ! this->result ) return;
+                        const RefType * inst2 = handleRefType( inst, other );
+                        if ( ! inst2 ) return;
 
                         // check that parameters of types unify, if any
                         const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
-                        const std::vector< ast::ptr< ast::Expr > > & params2 = otherInst->params;
+                        const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params;
 
                         auto it = params.begin();
@@ -1194 +1202 @@
                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
-                ast::Type * t1 = shallowCopy(type1.get());
-                ast::Type * t2 = shallowCopy(type2.get());
-                t1->qualifiers = {};
-                t2->qualifiers = {};
-                ast::ptr< ast::Type > t1_(t1);
-                ast::ptr< ast::Type > t2_(t2);
+                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
+                reset_qualifiers( t1 );
+                reset_qualifiers( t2 );
 
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
-                                t1->qualifiers = q1 | q2;
-                                common = t1;
+                                common = type1;
+                                reset_qualifiers( common, q1 | q2 );
                                 return true;
                         } else {
@@ -1212 +1219 @@
 
                 } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
+                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
+
                         // no exact unification, but common type
-                        auto c = shallowCopy(common.get());
-                        c->qualifiers = q1 | q2;
-                        common = c;
+                        reset_qualifiers( common, q1 | q2 );
                         return true;
                 } else {

src/ResolvExpr/typeops.h

@@ -10 +10 @@
 // Created On       : Sun May 17 07:28:22 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Tue Oct  1 09:45:00 2019
-// Update Count     : 6
+// Last Modified On : Thu Aug  8 16:36:00 2019
+// Update Count     : 5
 //
 
@@ -83 +83 @@
                 const SymTab::Indexer & indexer, const TypeEnvironment & env );
         Cost castCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+                const ast::TypeEnvironment & env );
 
         // in ConversionCost.cc
@@ -90 +90 @@
                 const SymTab::Indexer & indexer, const TypeEnvironment & env );
         Cost conversionCost(
-                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
+                const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
+                const ast::TypeEnvironment & env );
 
         // in AlternativeFinder.cc

src/SymTab/Autogen.h

@@ -21 +21 @@
 
 #include "AST/Decl.hpp"
-#include "AST/Eval.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
@@ -266 +265 @@
                 }
 
-                ast::ptr< ast::Expr > begin, end;
-                std::string cmp, update;
+                ast::ptr< ast::Expr > begin, end, cmp, update;
 
                 if ( forward ) {
@@ -273 +271 @@
                         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, "--?" };
                 }
 
@@ -287 +286 @@
                         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
@@ -383 +385 @@
                 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/SynTree/Statement.h

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

src/Tuples/Explode.cc

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

src/Tuples/Explode.h

@@ -210 +210 @@
                         }
                         // Cast a reference away to a value-type to allow further explosion.
-                        if ( 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/Tuples/TupleExpansion.cc

@@ -323 +323 @@
                 std::vector<ast::ptr<ast::Type>> types;
                 ast::CV::Qualifiers quals{
-                        ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict |
+                        ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Lvalue |
                         ast::CV::Atomic | ast::CV::Mutex };
 

src/main.cc

@@ -31 +31 @@
 using namespace std;
 
-#include "AST/Convert.hpp"
+
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
@@ -339 +339 @@
                 } // 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 );