Changeset eef8dfb for src/AST

Timestamp:

Jan 7, 2021, 2:55:57 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

58fe85a

Parents:

bdfc032 (diff), 44e37ef (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into dkobets-vector

Location:

src/AST

Files:

• Attribute.hpp (modified) (1 diff)
• CVQualifiers.hpp (modified) (2 diffs)
• Convert.cpp (modified) (42 diffs)
• Convert.hpp (modified) (1 diff)
• Copy.hpp (added)
• Decl.cpp (modified) (1 diff)
• Decl.hpp (modified) (8 diffs)
• DeclReplacer.cpp (modified) (3 diffs)
• DeclReplacer.hpp (modified) (1 diff)
• Eval.hpp (added)
• Expr.cpp (modified) (13 diffs)
• Expr.hpp (modified) (23 diffs)
• Fwd.hpp (modified) (4 diffs)
• GenericSubstitution.cpp (modified) (2 diffs)
• Init.hpp (modified) (5 diffs)
• Node.cpp (modified) (4 diffs)
• Node.hpp (modified) (12 diffs)
• Pass.hpp (modified) (11 diffs)
• Pass.impl.hpp (modified) (124 diffs)
• Pass.proto.hpp (modified) (13 diffs)
• Print.cpp (modified) (11 diffs)
• Stmt.hpp (modified) (3 diffs)
• SymbolTable.cpp (modified) (12 diffs)
• SymbolTable.hpp (modified) (5 diffs)
• TranslationUnit.hpp (added)
• Type.cpp (modified) (7 diffs)
• Type.hpp (modified) (13 diffs)
• TypeEnvironment.cpp (modified) (20 diffs)
• TypeEnvironment.hpp (modified) (9 diffs)
• TypeSubstitution.cpp (modified) (9 diffs)
• TypeSubstitution.hpp (modified) (9 diffs)
• Visitor.hpp (modified) (1 diff)
• module.mk (modified) (1 diff)
• porting.md (modified) (6 diffs)

src/AST/Attribute.hpp

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

src/AST/CVQualifiers.hpp

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

src/AST/Convert.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 09 15::37::05 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 11 21:39:32 2019
-// Update Count     : 33
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Nov 12 10:07:00 2020
+// Update Count     : 34
 //
 
@@ -20 +20 @@
 
 #include "AST/Attribute.hpp"
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
 #include "AST/Stmt.hpp"
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -46 +48 @@
 
 //================================================================================================
-namespace {
+namespace ast {
 
 // This is to preserve the FindSpecialDecls hack. It does not (and perhaps should not)
 // allow us to use the same stratagy in the new ast.
-ast::Type * sizeType = nullptr;
-ast::FunctionDecl * dereferenceOperator = nullptr;
-ast::StructDecl   * dtorStruct = nullptr;
-ast::FunctionDecl * dtorStructDestroy = nullptr;
+// xxx - since convert back pass works, this concern seems to be unnecessary.
+
+// these need to be accessed in new FixInit now
+ast::ptr<ast::Type> sizeType = nullptr;
+const ast::FunctionDecl * dereferenceOperator = nullptr;
+const ast::StructDecl   * dtorStruct = nullptr;
+const ast::FunctionDecl * dtorStructDestroy = nullptr;
 
 }
@@ -62 +67 @@
         using Cache = std::unordered_map< const ast::Node *, BaseSyntaxNode * >;
         Cache cache;
+
+        // Statements can no longer be shared.
+        // however, since StmtExprResult is now implemented, need to still maintain
+        // readonly references.
+        Cache readonlyCache;
 
         template<typename T>
@@ -153 +163 @@
         }
 
-        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {
-                auto&& bfwd = get<Expression>().accept1( node->bitfieldWidth );
-                auto&& type = get<Type>().accept1( node->type );
-                auto&& init = get<Initializer>().accept1( node->init );
-                auto&& attr = get<Attribute>().acceptL( node->attributes );
+        const ast::DeclWithType * visit( const ast::ObjectDecl * node ) override final {        
                 if ( inCache( node ) ) {
                         return nullptr;
                 }
+                auto bfwd = get<Expression>().accept1( node->bitfieldWidth );
+                auto type = get<Type>().accept1( node->type );
+                auto attr = get<Attribute>().acceptL( node->attributes );
+
                 auto decl = new ObjectDecl(
                         node->name,
@@ -166 +176 @@
                         LinkageSpec::Spec( node->linkage.val ),
                         bfwd,
-                        type,
-                        init,
+                        type->clone(),
+                        nullptr, // prevent infinite loop
                         attr,
                         Type::FuncSpecifiers( node->funcSpec.val )
                 );
-                return declWithTypePostamble( decl, node );
+
+                // handles the case where node->init references itself
+                // xxx - does it really happen?
+                declWithTypePostamble(decl, node);
+                auto init = get<Initializer>().accept1( node->init );
+                decl->init = init;
+
+                this->node = decl;
+                return nullptr;
         }
 
         const ast::DeclWithType * visit( const ast::FunctionDecl * node ) override final {
                 if ( inCache( node ) ) return nullptr;
+
+                // function decl contains real variables that the type must use.
+                // the structural change means function type in and out of decl
+                // must be handled **differently** on convert back to old.
+                auto ftype = new FunctionType(
+                        cv(node->type),
+                        (bool)node->type->isVarArgs
+                );
+                ftype->returnVals = get<DeclarationWithType>().acceptL(node->returns);
+                ftype->parameters = get<DeclarationWithType>().acceptL(node->params);
+
+                ftype->forall = get<TypeDecl>().acceptL( node->type_params );
+                if (!node->assertions.empty()) {
+                        assert(!ftype->forall.empty());
+                        // find somewhere to place assertions back, for convenience it is the last slot
+                        ftype->forall.back()->assertions = get<DeclarationWithType>().acceptL(node->assertions);
+                }
+
+                visitType(node->type, ftype);
+
                 auto decl = new FunctionDecl(
                         node->name,
                         Type::StorageClasses( node->storage.val ),
                         LinkageSpec::Spec( node->linkage.val ),
-                        get<FunctionType>().accept1( node->type ),
+                        ftype,
+                        //get<FunctionType>().accept1( node->type ),
                         {},
                         get<Attribute>().acceptL( node->attributes ),
@@ -188 +227 @@
                 decl->statements = get<CompoundStmt>().accept1( node->stmts );
                 decl->withExprs = get<Expression>().acceptL( node->withExprs );
-                if ( dereferenceOperator == node ) {
+                if ( ast::dereferenceOperator == node ) {
                         Validate::dereferenceOperator = decl;
                 }
-                if ( dtorStructDestroy == node ) {
+                if ( ast::dtorStructDestroy == node ) {
                         Validate::dtorStructDestroy = decl;
                 }
@@ -199 +238 @@
         const ast::Decl * namedTypePostamble( NamedTypeDecl * decl, const ast::NamedTypeDecl * node ) {
                 // base comes from constructor
-                decl->parameters = get<TypeDecl>().acceptL( node->params );
                 decl->assertions = get<DeclarationWithType>().acceptL( node->assertions );
                 declPostamble( decl, node );
@@ -250 +288 @@
                 );
 
-                if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
                 }
@@ -303 +341 @@
 
         const ast::Stmt * stmtPostamble( Statement * stmt, const ast::Stmt * node ) {
-                cache.emplace( node, stmt );
+                // force statements in old tree to be unique.
+                // cache.emplace( node, stmt );
+                readonlyCache.emplace( node, stmt );
                 stmt->location = node->location;
                 stmt->labels = makeLabelL( stmt, node->labels );
@@ -320 +360 @@
                 if ( inCache( node ) ) return nullptr;
                 auto stmt = new ExprStmt( nullptr );
-                cache.emplace( node, stmt );
                 stmt->expr = get<Expression>().accept1( node->expr );
                 return stmtPostamble( stmt, node );
@@ -493 +532 @@
         }
 
+        const ast::Stmt * visit(const ast::SuspendStmt * node ) override final {
+                if ( inCache( node ) ) return nullptr;
+                auto stmt = new SuspendStmt();
+                stmt->then   = get<CompoundStmt>().accept1( node->then   );
+                switch(node->type) {
+                        case ast::SuspendStmt::None     : stmt->type = SuspendStmt::None     ; break;
+                        case ast::SuspendStmt::Coroutine: stmt->type = SuspendStmt::Coroutine; break;
+                        case ast::SuspendStmt::Generator: stmt->type = SuspendStmt::Generator; break;
+                }
+                return stmtPostamble( stmt, node );
+        }
+
         const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 if ( inCache( node ) ) return nullptr;
@@ -556 +607 @@
 
                 for (decltype(src->begin()) src_i = src->begin(); src_i != src->end(); src_i++) {
-                        rslt->add( src_i->first,
+                        rslt->add( src_i->first.typeString(),
                                    get<Type>().accept1(src_i->second) );
-                }
-
-                for (decltype(src->beginVar()) src_i = src->beginVar(); src_i != src->endVar(); src_i++) {
-                        rslt->addVar( src_i->first,
-                                      get<Expression>().accept1(src_i->second) );
                 }
 
@@ -575 +621 @@
                 assert( tgtResnSlots.empty() );
 
-                if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
+                if ( srcInferred.data.inferParams ) {
                         const ast::InferredParams &srcParams = srcInferred.inferParams();
                         for (auto & srcParam : srcParams) {
@@ -581 +627 @@
                                         srcParam.second.decl,
                                         get<Declaration>().accept1(srcParam.second.declptr),
-                                        get<Type>().accept1(srcParam.second.actualType),
-                                        get<Type>().accept1(srcParam.second.formalType),
-                                        get<Expression>().accept1(srcParam.second.expr)
+                                        get<Type>().accept1(srcParam.second.actualType)->clone(),
+                                        get<Type>().accept1(srcParam.second.formalType)->clone(),
+                                        get<Expression>().accept1(srcParam.second.expr)->clone()
                                 ));
                                 assert(res.second);
                         }
-                } else if ( srcInferred.mode == ast::Expr::InferUnion::Slots  ) {
+                }
+                if ( srcInferred.data.resnSlots ) {
                         const ast::ResnSlots &srcSlots = srcInferred.resnSlots();
                         for (auto srcSlot : srcSlots) {
@@ -608 +655 @@
 
                 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);
         }
@@ -680 +738 @@
                         new KeywordCastExpr(
                                 get<Expression>().accept1(node->arg),
-                                castTarget
+                                castTarget,
+                                {node->concrete_target.field, node->concrete_target.getter}
                         )
                 );
@@ -967 +1026 @@
 
         const ast::Expr * visit( const ast::StmtExpr * node ) override final {
+                auto stmts = node->stmts;
+                // disable sharing between multiple StmtExprs explicitly.
+                // this should no longer be true.
+
                 auto rslt = new StmtExpr(
-                        get<CompoundStmt>().accept1(node->stmts)
+                        get<CompoundStmt>().accept1(stmts)
                 );
 
                 rslt->returnDecls = get<ObjectDecl>().acceptL(node->returnDecls);
                 rslt->dtors       = get<Expression>().acceptL(node->dtors);
+                if (node->resultExpr) {
+                        // this MUST be found by children visit
+                        rslt->resultExpr  = strict_dynamic_cast<ExprStmt *>(readonlyCache.at(node->resultExpr));
+                }
 
                 auto expr = visitBaseExpr( node, rslt );
@@ -989 +1056 @@
 
                 auto expr = visitBaseExpr( node, rslt );
-                this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
         }
@@ -1079 +1146 @@
                 auto type = new BasicType{ cv( node ), (BasicType::Kind)(unsigned)node->kind };
                 // I believe this should always be a BasicType.
-                if ( sizeType == node ) {
+                if ( ast::sizeType == node ) {
                         Validate::SizeType = type;
                 }
@@ -1121 +1188 @@
 
         const ast::Type * visit( const ast::FunctionType * node ) override final {
+                static std::string dummy_paramvar_prefix = "__param_";
+                static std::string dummy_returnvar_prefix = "__retval_";
+
                 auto ty = new FunctionType {
                         cv( node ),
                         (bool)node->isVarArgs
                 };
-                ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
-                ty->parameters = get<DeclarationWithType>().acceptL( node->params );
-                ty->forall = get<TypeDecl>().acceptL( node->forall );
+                auto returns = get<Type>().acceptL(node->returns);
+                auto params = get<Type>().acceptL(node->params);
+
+                int ret_index = 0;
+                for (auto t: returns) {
+                        // xxx - LinkageSpec shouldn't matter but needs to be something
+                        ObjectDecl * dummy = new ObjectDecl(dummy_returnvar_prefix + std::to_string(ret_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->returnVals.push_back(dummy);
+                }
+                int param_index = 0;
+                for (auto t: params) {
+                        ObjectDecl * dummy = new ObjectDecl(dummy_paramvar_prefix + std::to_string(param_index++), {}, LinkageSpec::C, nullptr, t, nullptr);
+                        ty->parameters.push_back(dummy);
+                }
+
+                // ty->returnVals = get<DeclarationWithType>().acceptL( node->returns );
+                // ty->parameters = get<DeclarationWithType>().acceptL( node->params );
+
+                auto types = get<TypeInstType>().acceptL( node->forall );
+                for (auto t : types) {
+                        auto newT = new TypeDecl(*t->baseType);
+                        newT->name = t->name; // converted by typeString()
+                        for (auto asst : newT->assertions) delete asst;
+                        newT->assertions.clear();
+                        ty->forall.push_back(newT);
+                }
+                auto assts = get<VariableExpr>().acceptL( node->assertions );
+                if (!assts.empty()) {
+                        assert(!types.empty());
+                        for (auto asst : assts) {
+                                auto newDecl = new ObjectDecl(*strict_dynamic_cast<ObjectDecl*>(asst->var));
+                                delete newDecl->type;
+                                newDecl->type = asst->result->clone();
+                                newDecl->storageClasses.is_extern = true; // hack
+                                ty->forall.back()->assertions.push_back(newDecl);
+                        }
+                }
+
                 return visitType( node, ty );
         }
 
-        const ast::Type * postvisit( const ast::ReferenceToType * old, ReferenceToType * ty ) {
-                ty->forall = get<TypeDecl>().acceptL( old->forall );
+        const ast::Type * postvisit( const ast::BaseInstType * old, ReferenceToType * ty ) {
                 ty->parameters = get<Expression>().acceptL( old->params );
                 ty->hoistType = old->hoistType;
@@ -1215 +1319 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->name,
+                                node->typeString(),
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
@@ -1222 +1326 @@
                         ty = new TypeInstType{
                                 cv( node ),
-                                node->name,
+                                node->typeString(),
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
@@ -1319 +1423 @@
 };
 
-std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit ) {
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit ) {
         ConverterNewToOld c;
         std::list< Declaration * > decls;
-        for(auto d : translationUnit) {
+        for(auto d : translationUnit.decls) {
                 decls.emplace_back( c.decl( d ) );
         }
@@ -1343 +1447 @@
         ast::Node * node = nullptr;
         /// cache of nodes that might be referenced by readonly<> for de-duplication
-        std::unordered_map< const BaseSyntaxNode *, ast::Node * > cache = {};
+        /// in case that some nodes are dropped by conversion (due to possible structural change)
+        /// use smart pointers in cache value to prevent accidental invalidation.
+        /// at conversion stage, all created nodes are guaranteed to be unique, therefore
+        /// const_casting out of smart pointers is permitted.
+        std::unordered_map< const BaseSyntaxNode *, ast::readonly<ast::Node> > cache = {};
 
         // Local Utilities:
@@ -1416 +1524 @@
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
-                node = it->second;
+                node = const_cast<ast::Node *>(it->second.get());
                 return true;
         }
@@ -1455 +1563 @@
         virtual void visit( const FunctionDecl * old ) override final {
                 if ( inCache( old ) ) return;
+                auto paramVars = GET_ACCEPT_V(type->parameters, DeclWithType);
+                auto returnVars = GET_ACCEPT_V(type->returnVals, DeclWithType);
+                auto forall = GET_ACCEPT_V(type->forall, TypeDecl);
+
+                // function type is now derived from parameter decls instead of storing them
+
+                /*
+                auto ftype = new ast::FunctionType((ast::ArgumentFlag)old->type->isVarArgs, cv(old->type));
+                ftype->params.reserve(paramVars.size());
+                ftype->returns.reserve(returnVars.size());
+
+                for (auto & v: paramVars) {
+                        ftype->params.emplace_back(v->get_type());
+                }
+                for (auto & v: returnVars) {
+                        ftype->returns.emplace_back(v->get_type());
+                }
+                ftype->forall = std::move(forall);
+                */
+
+                // can function type have attributes? seems not to be the case.
+                // visitType(old->type, ftype);
+
+                // collect assertions and put directly in FunctionDecl
+                std::vector<ast::ptr<ast::DeclWithType>> assertions;
+                for (auto & param: forall) {
+                        for (auto & asst: param->assertions) {
+                                assertf(asst->unique(), "newly converted decl must be unique");
+                                assertions.emplace_back(asst);
+                        }
+                        auto mut = param.get_and_mutate();
+                        assertf(mut == param, "newly converted decl must be unique");
+                        mut->assertions.clear();
+                }
+
                 auto decl = new ast::FunctionDecl{
                         old->location,
                         old->name,
-                        GET_ACCEPT_1(type, FunctionType),
+                        // GET_ACCEPT_1(type, FunctionType),
+                        std::move(forall),
+                        std::move(paramVars),
+                        std::move(returnVars),
                         {},
                         { old->storageClasses.val },
                         { old->linkage.val },
                         GET_ACCEPT_V(attributes, Attribute),
-                        { old->get_funcSpec().val }
+                        { old->get_funcSpec().val },
+                        old->type->isVarArgs
                 };
+
+                // decl->type = ftype;
                 cache.emplace( old, decl );
+
+                decl->assertions = std::move(assertions);
                 decl->withExprs = GET_ACCEPT_V(withExprs, Expr);
                 decl->stmts = GET_ACCEPT_1(statements, CompoundStmt);
@@ -1478 +1629 @@
 
                 if ( Validate::dereferenceOperator == old ) {
-                        dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
                 }
 
                 if ( Validate::dtorStructDestroy == old ) {
-                        dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
                 }
         }
@@ -1507 +1658 @@
 
                 if ( Validate::dtorStruct == old ) {
-                        dtorStruct = decl;
+                        ast::dtorStruct = decl;
                 }
         }
@@ -1584 +1735 @@
                 cache.emplace( old, decl );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
-                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -1600 +1750 @@
                 );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
-                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
@@ -1859 +2008 @@
         }
 
+        virtual void visit( const SuspendStmt * old ) override final {
+                if ( inCache( old ) ) return;
+                ast::SuspendStmt::Type type;
+                switch (old->type) {
+                        case SuspendStmt::Coroutine: type = ast::SuspendStmt::Coroutine; break;
+                        case SuspendStmt::Generator: type = ast::SuspendStmt::Generator; break;
+                        case SuspendStmt::None     : type = ast::SuspendStmt::None     ; break;
+                        default: abort();
+                }
+                this->node = new ast::SuspendStmt(
+                        old->location,
+                        GET_ACCEPT_1(then  , CompoundStmt),
+                        type,
+                        GET_LABELS_V(old->labels)
+                );
+                cache.emplace( old, this->node );
+        }
+
         virtual void visit( const WaitForStmt * old ) override final {
                 if ( inCache( old ) ) return;
@@ -1932 +2099 @@
         }
 
+        // TypeSubstitution shouldn't exist yet in old.
         ast::TypeSubstitution * convertTypeSubstitution(const TypeSubstitution * old) {
-
+                
                 if (!old) return nullptr;
-
+                if (old->empty()) return nullptr;
+                assert(false);
+
+                /*
                 ast::TypeSubstitution *rslt = new ast::TypeSubstitution();
 
@@ -1943 +2114 @@
                 }
 
-                for (decltype(old->beginVar()) old_i = old->beginVar(); old_i != old->endVar(); old_i++) {
-                        rslt->addVar( old_i->first,
-                                      getAccept1<ast::Expr>(old_i->second) );
-                }
-
                 return rslt;
+                */
         }
 
@@ -1956 +2123 @@
 
                 assert( oldInferParams.empty() || oldResnSlots.empty() );
-                assert( newInferred.mode == ast::Expr::InferUnion::Empty );
+                // assert( newInferred.mode == ast::Expr::InferUnion::Empty );
 
                 if ( !oldInferParams.empty() ) {
@@ -2039 +2206 @@
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
-                                castTarget
+                                castTarget,
+                                {old->concrete_target.field, old->concrete_target.getter}
                         )
                 );
@@ -2087 +2255 @@
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
-                                GET_ACCEPT_1(aggregate, Expr)
+                                GET_ACCEPT_1(aggregate, Expr),
+                                ast::MemberExpr::NoOpConstructionChosen
                         )
                 );
@@ -2419 +2588 @@
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
-                        sizeType = type;
+                        ast::sizeType = type;
                 }
                 visitType( old, type );
@@ -2464 +2633 @@
                         cv( old )
                 };
-                ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
-                ty->params = GET_ACCEPT_V( parameters, DeclWithType );
-                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
+                auto returnVars = GET_ACCEPT_V(returnVals, DeclWithType);
+                auto paramVars = GET_ACCEPT_V(parameters, DeclWithType);
+                // ty->returns = GET_ACCEPT_V( returnVals, DeclWithType );
+                // ty->params = GET_ACCEPT_V( parameters, DeclWithType );
+                for (auto & v: returnVars) {
+                        ty->returns.emplace_back(v->get_type());
+                }
+                for (auto & v: paramVars) {
+                        ty->params.emplace_back(v->get_type());
+                }
+                // xxx - when will this be non-null?
+                // will have to create dangling (no-owner) decls to be pointed to
+                auto foralls = GET_ACCEPT_V( forall, TypeDecl );
+
+                for (auto & param : foralls) {
+                        ty->forall.emplace_back(new ast::TypeInstType(param->name, param));
+                        for (auto asst : param->assertions) {
+                                ty->assertions.emplace_back(new ast::VariableExpr({}, asst));
+                        }
+                }
                 visitType( old, ty );
         }
 
-        void postvisit( const ReferenceToType * old, ast::ReferenceToType * ty ) {
-                ty->forall = GET_ACCEPT_V( forall, TypeDecl );
+        void postvisit( const ReferenceToType * old, ast::BaseInstType * ty ) {
                 ty->params = GET_ACCEPT_V( parameters, Expr );
                 ty->hoistType = old->hoistType;
@@ -2616 +2801 @@
                         old->location,
                         GET_ACCEPT_1(value, Expr),
-                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
+                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::NoConstruct
                 );
         }
@@ -2625 +2810 @@
                         GET_ACCEPT_V(initializers, Init),
                         GET_ACCEPT_V(designations, Designation),
-                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
+                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::NoConstruct
                 );
         }
@@ -2656 +2841 @@
 #undef GET_ACCEPT_1
 
-std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit ) {
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit ) {
         ConverterOldToNew c;
-        std::list< ast::ptr< ast::Decl > > decls;
+        ast::TranslationUnit unit;
+        if (Validate::SizeType) {
+                // this should be a BasicType.
+                auto old = strict_dynamic_cast<BasicType *>(Validate::SizeType);
+                ast::sizeType = new ast::BasicType{ (ast::BasicType::Kind)(unsigned)old->kind };
+        }
+
         for(auto d : translationUnit) {
                 d->accept( c );
-                decls.emplace_back( c.decl() );
+                unit.decls.emplace_back( c.decl() );
         }
         deleteAll(translationUnit);
-        return decls;
+
+        // Load the local static varables into the global store.
+        unit.global.sizeType = ast::sizeType;
+        unit.global.dereference = ast::dereferenceOperator;
+        unit.global.dtorStruct = ast::dtorStruct;
+        unit.global.dtorDestroy = ast::dtorStructDestroy;
+
+        return unit;
 }

src/AST/Convert.hpp

@@ -18 +18 @@
 #include <list>
 
-#include "AST/Node.hpp"
-
 class Declaration;
 namespace ast {
-        class Decl;
+        struct TranslationUnit;
 };
 
-std::list< Declaration * > convert( const std::list< ast::ptr< ast::Decl > > && translationUnit );
-std::list< ast::ptr< ast::Decl > > convert( const std::list< Declaration * > && translationUnit );
+std::list< Declaration * > convert( const ast::TranslationUnit && translationUnit );
+ast::TranslationUnit convert( const std::list< Declaration * > && translationUnit );

src/AST/Decl.cpp

@@ -49 +49 @@
 // --- FunctionDecl
 
+FunctionDecl::FunctionDecl( const CodeLocation & loc, const std::string & name, 
+        std::vector<ptr<TypeDecl>>&& forall,
+        std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
+        CompoundStmt * stmts, Storage::Classes storage, Linkage::Spec linkage,
+        std::vector<ptr<Attribute>>&& attrs, Function::Specs fs, bool isVarArgs)
+: DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        type_params(std::move(forall)), stmts( stmts ) {
+        FunctionType * ftype = new FunctionType(static_cast<ArgumentFlag>(isVarArgs));
+        for (auto & param : this->params) {
+                ftype->params.emplace_back(param->get_type());
+        }
+        for (auto & ret : this->returns) {
+                ftype->returns.emplace_back(ret->get_type());
+        }
+        for (auto & tp : this->type_params) {
+                ftype->forall.emplace_back(new TypeInstType(tp->name, tp));
+        }
+        this->type = ftype;
+}
+
+
 const Type * FunctionDecl::get_type() const { return type.get(); }
-void FunctionDecl::set_type(Type * t) { type = strict_dynamic_cast< FunctionType* >( t ); }
+void FunctionDecl::set_type( const Type * t ) {
+        type = strict_dynamic_cast< const FunctionType * >( t );
+}
 
 // --- TypeDecl

src/AST/Decl.hpp

@@ -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);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
@@ -77 +79 @@
         ptr<Expr> asmName;
         bool isDeleted = false;
+        bool isTypeFixed = false;
 
         DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
@@ -88 +91 @@
         virtual const Type * get_type() const = 0;
         /// Set type of this declaration. May be verified by subclass
-        virtual void set_type(Type *) = 0;
+        virtual void set_type( const Type * ) = 0;
 
         const DeclWithType * accept( Visitor & v ) const override = 0;
@@ -111 +114 @@
 
         const Type* get_type() const override { return type; }
-        void set_type( Type * ty ) override { type = ty; }
+        void set_type( const Type * ty ) override { type = ty; }
 
         const DeclWithType * accept( Visitor& v ) const override { return v.visit( this ); }
@@ -122 +125 @@
 class FunctionDecl : public DeclWithType {
 public:
+        std::vector<ptr<DeclWithType>> params;
+        std::vector<ptr<DeclWithType>> returns;
+        std::vector<ptr<TypeDecl>> type_params;
+        std::vector<ptr<DeclWithType>> assertions;
+        // declared type, derived from parameter declarations
         ptr<FunctionType> type;
         ptr<CompoundStmt> stmts;
         std::vector< ptr<Expr> > withExprs;
 
-        FunctionDecl( const CodeLocation & loc, const std::string & name, FunctionType * type,
+
+        FunctionDecl( const CodeLocation & loc, const std::string & name, std::vector<ptr<TypeDecl>>&& forall,
+                std::vector<ptr<DeclWithType>>&& params, std::vector<ptr<DeclWithType>>&& returns,
                 CompoundStmt * stmts, Storage::Classes storage = {}, Linkage::Spec linkage = Linkage::C,
-                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {})
-        : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), type( type ),
-          stmts( stmts ) {}
+                std::vector<ptr<Attribute>>&& attrs = {}, Function::Specs fs = {}, bool isVarArgs = false);
+        // : DeclWithType( loc, name, storage, linkage, std::move(attrs), fs ), params(std::move(params)), returns(std::move(returns)),
+        //  stmts( stmts ) {}
 
         const Type * get_type() const override;
-        void set_type(Type * t) override;
+        void set_type( const Type * t ) override;
 
         bool has_body() const { return stmts; }
@@ -147 +157 @@
 public:
         ptr<Type> base;
-        std::vector<ptr<TypeDecl>> params;
         std::vector<ptr<DeclWithType>> assertions;
 
-        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() {}
+        NamedTypeDecl(
+                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
+                const Type * b, Linkage::Spec spec = Linkage::Cforall )
+        : Decl( loc, name, storage, spec ), base( b ), assertions() {}
 
         /// Produces a name for the kind of alias
@@ -186 +196 @@
         };
 
-        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 ) {}
+        TypeDecl(
+                const CodeLocation & loc, const std::string & name, Storage::Classes storage,
+                const Type * b, TypeDecl::Kind k, bool s, const Type * i = nullptr )
+        : NamedTypeDecl( loc, name, storage, b ), kind( k ), sized( k == TypeDecl::Ttype || s ),
+          init( i ) {}
 
         const char * typeString() const override;
@@ -259 +270 @@
 
         bool is_coroutine() { return kind == Coroutine; }
-        bool is_monitor() { return kind == Monitor; }
-        bool is_thread() { return kind == Thread; }
+        bool is_generator() { return kind == Generator; }
+        bool is_monitor  () { return kind == Monitor  ; }
+        bool is_thread   () { return kind == Thread   ; }
 
         const Decl * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/DeclReplacer.cpp

@@ -38 +38 @@
                         const ast::TypeInstType * previsit( const ast::TypeInstType * );
                 };
+
+                struct VarExprReplacer {
+                private:
+                        const ExprMap & exprMap;
+                        
+                public:
+                        VarExprReplacer(const ExprMap & exprMap): exprMap (exprMap) {}
+
+                        const Expr * postvisit (const VariableExpr *);
+                };
         }
 
@@ -54 +64 @@
                 DeclMap declMap;
                 return replace( node, declMap, typeMap, debug );
+        }
+
+        const ast::Node * replace( const ast::Node * node, const ExprMap & exprMap) {
+                Pass<VarExprReplacer> replacer = {exprMap};
+                return node->accept( replacer );
         }
 
@@ -88 +103 @@
                         return ninst;
                 }
+
+                const Expr * VarExprReplacer::postvisit( const VariableExpr * expr ) {
+                        if (!exprMap.count(expr->var)) return expr;
+
+                        return exprMap.at(expr->var);
+                }
+
         }
 }

src/AST/DeclReplacer.hpp

@@ -23 +23 @@
         class DeclWithType;
         class TypeDecl;
+        class Expr;
 
         namespace DeclReplacer {
                 using DeclMap = std::unordered_map< const DeclWithType *, const DeclWithType * >;
                 using TypeMap = std::unordered_map< const TypeDecl *, const TypeDecl * >;
+                using ExprMap = std::unordered_map< const DeclWithType *, const Expr * >;
 
                 const Node * replace( const Node * node, const DeclMap & declMap, bool debug = false );
                 const Node * replace( const Node * node, const TypeMap & typeMap, bool debug = false );
                 const Node * replace( const Node * node, const DeclMap & declMap, const TypeMap & typeMap, bool debug = false );
+                const Node * replace( const Node * node, const ExprMap & exprMap);
         }
 }

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"
@@ -27 +30 @@
 #include "Common/SemanticError.h"
 #include "GenPoly/Lvalue.h"        // for referencesPermissable
-#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "InitTweak/InitTweak.h"   // for getFunction, 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
@@ -46 +58 @@
 }
 
+bool ApplicationExpr::get_lvalue() const {
+        if ( const DeclWithType * func = InitTweak::getFunction( this ) ) {
+                return func->linkage == Linkage::Intrinsic && lvalueFunctionNames.count( func->name );
+        }
+        return false;
+}
+
 // --- UntypedExpr
 
-UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, Expr * arg ) {
+UntypedExpr * UntypedExpr::createDeref( const CodeLocation & loc, const Expr * arg ) {
         assert( arg );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "*?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ arg } }
-        };
+        UntypedExpr * ret = call( loc, "*?", arg );
         if ( const Type * ty = arg->result ) {
                 const Type * base = InitTweak::getPointerBase( ty );
@@ -65 +82 @@
                         // base type
                         ret->result = base;
-                        add_qualifiers( ret->result, CV::Lvalue );
                 }
         }
@@ -71 +87 @@
 }
 
-UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs ) {
+bool UntypedExpr::get_lvalue() const {
+        std::string fname = InitTweak::getFunctionName( this );
+        return lvalueFunctionNames.count( fname );
+}
+
+UntypedExpr * UntypedExpr::createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs ) {
         assert( lhs && rhs );
 
-        UntypedExpr * ret = new UntypedExpr{
-                loc, new NameExpr{loc, "?=?"}, std::vector<ptr<Expr>>{ ptr<Expr>{ lhs }, ptr<Expr>{ rhs } }
-        };
+        UntypedExpr * ret = call( loc, "?=?", lhs, rhs );
         if ( lhs->result && rhs->result ) {
                 // if both expressions are typed, assumes that this assignment is a C bitwise assignment,
@@ -83 +102 @@
         }
         return ret;
+}
+
+// --- VariableExpr
+
+VariableExpr::VariableExpr( const CodeLocation & loc )
+: Expr( loc ), var( nullptr ) {}
+
+VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
+: Expr( loc ), var( v ) {
+        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;
+}
+
+VariableExpr * VariableExpr::functionPointer(
+                const CodeLocation & loc, const FunctionDecl * decl ) {
+        // wrap usually-determined result type in a pointer
+        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
+        funcExpr->result = new PointerType{ funcExpr->result };
+        return funcExpr;
 }
 
@@ -108 +152 @@
 AddressExpr::AddressExpr( const CodeLocation & loc, const Expr * a ) : Expr( loc ), arg( a ) {
         if ( arg->result ) {
-                if ( arg->result->is_lvalue() ) {
+                if ( arg->get_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 {
@@ -118 +161 @@
                                         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 {
@@ -139 +181 @@
 : 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();
 }
 
@@ -153 +206 @@
         assert( aggregate->result );
 
-        // take ownership of member type
         result = mem->get_type();
+
         // substitute aggregate generic parameters into member type
         genericSubstitution( aggregate->result ).apply( result );
-        // ensure lvalue and appropriate restrictions from aggregate type
-        add_qualifiers( result, aggregate->result->qualifiers | CV::Lvalue );
-}
-
-// --- VariableExpr
-
-VariableExpr::VariableExpr( const CodeLocation & loc )
-: Expr( loc ), var( nullptr ) {}
-
-VariableExpr::VariableExpr( const CodeLocation & loc, const DeclWithType * v )
-: Expr( loc ), var( v ) {
-        assert( var );
-        assert( var->get_type() );
-        result = var->get_type();
-        add_qualifiers( result, CV::Lvalue );
-}
-
-VariableExpr * VariableExpr::functionPointer(
-                const CodeLocation & loc, const FunctionDecl * decl ) {
-        // wrap usually-determined result type in a pointer
-        VariableExpr * funcExpr = new VariableExpr{ loc, decl };
-        funcExpr->result = new PointerType{ funcExpr->result };
-        return funcExpr;
+        // 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;
 }
 
@@ -258 +304 @@
 : 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
 
@@ -276 +329 @@
         assert( t && i );
         result = t;
-        add_qualifiers( result, CV::Lvalue );
+}
+
+bool CompoundLiteralExpr::get_lvalue() const {
+        return true;
 }
 
@@ -293 +349 @@
         // like MemberExpr, TupleIndexExpr is always an lvalue
         result = type->types[ index ];
-        add_qualifiers( result, CV::Lvalue );
+}
+
+bool TupleIndexExpr::get_lvalue() const {
+        return tuple->get_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);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
+
 
 class ConverterOldToNew;
@@ -42 +45 @@
 struct ParamEntry {
         UniqueId decl;
-        ptr<Decl> declptr;
+        readonly<Decl> declptr;
         ptr<Type> actualType;
         ptr<Type> formalType;
@@ -62 +65 @@
 class Expr : public ParseNode {
 public:
-        /// Saves space (~16 bytes) by combining ResnSlots and InferredParams
+        /*
+         * NOTE: the union approach is incorrect until the case of
+         * partial resolution in InferMatcher is eliminated.
+         * it is reverted to allow unresolved and resolved parameters
+         * to coexist in an expression node.
+         */
         struct InferUnion {
+                // mode is now unused
                 enum { Empty, Slots, Params } mode;
-                union data_t {
-                        char def;
-                        ResnSlots resnSlots;
-                        InferredParams inferParams;
-
-                        data_t() : def('\0') {}
-                        ~data_t() {}
+                struct data_t {
+                        // char def;
+                        ResnSlots * resnSlots;
+                        InferredParams * inferParams;
+
+                        data_t(): resnSlots(nullptr), inferParams(nullptr) {}
+                        data_t(const data_t &other) = delete;
+                        ~data_t() {
+                                delete resnSlots;
+                                delete inferParams;
+                        }
                 } data;
 
                 /// initializes from other InferUnion
                 void init_from( const InferUnion& o ) {
-                        switch ( o.mode ) {
-                        case Empty:  return;
-                        case Slots:  new(&data.resnSlots) ResnSlots{ o.data.resnSlots }; return;
-                        case Params: new(&data.inferParams) InferredParams{ o.data.inferParams }; return;
+                        if (o.data.resnSlots) {
+                                data.resnSlots = new ResnSlots(*o.data.resnSlots);
+                        }
+                        if (o.data.inferParams) {
+                                data.inferParams = new InferredParams(*o.data.inferParams);
                         }
                 }
@@ -85 +99 @@
                 /// initializes from other InferUnion (move semantics)
                 void init_from( InferUnion&& o ) {
-                        switch ( o.mode ) {
-                        case Empty:  return;
-                        case Slots:  new(&data.resnSlots) ResnSlots{ std::move(o.data.resnSlots) }; return;
-                        case Params:
-                                new(&data.inferParams) InferredParams{ std::move(o.data.inferParams) }; return;
-                        }
-                }
-
-                /// clears variant fields
-                void reset() {
-                        switch( mode ) {
-                        case Empty:  return;
-                        case Slots:  data.resnSlots.~ResnSlots(); return;
-                        case Params: data.inferParams.~InferredParams(); return;
-                        }
+                        data.resnSlots = o.data.resnSlots;
+                        data.inferParams = o.data.inferParams;
+                        o.data.resnSlots = nullptr;
+                        o.data.inferParams = nullptr;
                 }
 
@@ -107 +110 @@
                 InferUnion& operator= ( const InferUnion& ) = delete;
                 InferUnion& operator= ( InferUnion&& ) = delete;
-                ~InferUnion() { reset(); }
+
+                bool hasSlots() const { return data.resnSlots; }
+                bool hasParams() const { return data.inferParams; }
 
                 ResnSlots& resnSlots() {
-                        switch (mode) {
-                        case Empty: new(&data.resnSlots) ResnSlots{}; mode = Slots; // fallthrough
-                        case Slots: return data.resnSlots;
-                        case Params: assertf(false, "Cannot return to resnSlots from Params"); abort();
+                        if (!data.resnSlots) {
+                                data.resnSlots = new ResnSlots();
                         }
-                        assertf(false, "unreachable");
+                        return *data.resnSlots;
                 }
 
                 const ResnSlots& resnSlots() const {
-                        if (mode == Slots) {
-                                return data.resnSlots;
+                        if (data.resnSlots) {
+                                return *data.resnSlots;
                         }
                         assertf(false, "Mode was not already resnSlots");
@@ -127 +130 @@
 
                 InferredParams& inferParams() {
-                        switch (mode) {
-                        case Slots: data.resnSlots.~ResnSlots(); // fallthrough
-                        case Empty: new(&data.inferParams) InferredParams{}; mode = Params; // fallthrough
-                        case Params: return data.inferParams;
+                        if (!data.inferParams) {
+                                data.inferParams = new InferredParams();
                         }
-                        assertf(false, "unreachable");
+                        return *data.inferParams;
                 }
 
                 const InferredParams& inferParams() const {
-                        if (mode == Params) {
-                                return data.inferParams;
+                        if (data.inferParams) {
+                                return *data.inferParams;
                         }
                         assertf(false, "Mode was not already Params");
@@ -143 +144 @@
                 }
 
-                void set_inferParams( InferredParams && ps ) {
-                        switch(mode) {
-                        case Slots:
-                                data.resnSlots.~ResnSlots();
-                                // fallthrough
-                        case Empty:
-                                new(&data.inferParams) InferredParams{ std::move( ps ) };
-                                mode = Params;
-                                break;
-                        case Params:
-                                data.inferParams = std::move( ps );
-                                break;
-                        }
+                void set_inferParams( InferredParams * ps ) {
+                        delete data.resnSlots;
+                        data.resnSlots = nullptr;
+                        delete data.inferParams;
+                        data.inferParams = ps;
                 }
 
@@ -161 +154 @@
                 /// and the other is in `Params`.
                 void splice( InferUnion && o ) {
-                        if ( o.mode == Empty ) return;
-                        if ( mode == Empty ) { init_from( o ); return; }
-                        assert( mode == o.mode && "attempt to splice incompatible InferUnion" );
-
-                        if ( mode == Slots ){
-                                data.resnSlots.insert(
-                                        data.resnSlots.end(), o.data.resnSlots.begin(), o.data.resnSlots.end() );
-                        } else if ( mode == Params ) {
-                                for ( const auto & p : o.data.inferParams ) {
-                                        data.inferParams[p.first] = std::move(p.second);
+                        if (o.data.resnSlots) {
+                                if (data.resnSlots) {
+                                        data.resnSlots->insert(
+                                                data.resnSlots->end(), o.data.resnSlots->begin(), o.data.resnSlots->end() );
+                                        delete o.data.resnSlots;
                                 }
-                        } else assertf(false, "invalid mode");
+                                else {
+                                        data.resnSlots = o.data.resnSlots;
+                                }
+                                o.data.resnSlots = nullptr;
+                        }
+
+                        if (o.data.inferParams) {
+                                if (data.inferParams) {
+                                        for ( const auto & p : *o.data.inferParams ) {
+                                                (*data.inferParams)[p.first] = std::move(p.second);
+                                        }
+                                        delete o.data.inferParams;
+                                }
+                                else {
+                                        data.inferParams = o.data.inferParams;
+                                }
+                                o.data.inferParams = nullptr;
+                        }
                 }
         };
@@ -185 +190 @@
 
         Expr * set_extension( bool ex ) { extension = ex; return this; }
+        virtual bool get_lvalue() const;
 
         virtual const Expr * accept( Visitor & v ) const override = 0;
@@ -201 +207 @@
         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:
@@ -216 +224 @@
         : Expr( loc ), func( f ), args( std::move(as) ) {}
 
+        bool get_lvalue() const final;
+
         /// Creates a new dereference expression
-        static UntypedExpr * createDeref( const CodeLocation & loc, Expr * arg );
+        static UntypedExpr * createDeref( const CodeLocation & loc, const Expr * arg );
         /// Creates a new assignment expression
-        static UntypedExpr * createAssign( const CodeLocation & loc, Expr * lhs, Expr * rhs );
+        static UntypedExpr * createAssign( const CodeLocation & loc, const Expr * lhs, const Expr * rhs );
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -241 +251 @@
 };
 
+/// A reference to a named variable.
+class VariableExpr final : public Expr {
+public:
+        readonly<DeclWithType> var;
+
+        VariableExpr( const CodeLocation & loc );
+        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
+
+        bool get_lvalue() const final;
+
+        /// generates a function pointer for a given function
+        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
+
+        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        VariableExpr * clone() const override { return new VariableExpr{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Address-of expression `&e`
 class AddressExpr final : public Expr {
@@ -271 +300 @@
 };
 
-/// Whether a cast existed in the program source or not
+/// Inidicates whether the cast is introduced by the CFA type system.
+/// GeneratedCast for casts that the resolver introduces to force a return type
+/// ExplicitCast for casts from user code
+/// ExplicitCast for casts from desugaring advanced CFA features into simpler CFA
+/// example
+///   int * p;     // declaration
+///   (float *) p; // use, with subject cast
+/// subject cast being GeneratedCast means we are considering an interpretation with a type mismatch
+/// subject cast being ExplicitCast means someone in charge wants it that way
 enum GeneratedFlag { ExplicitCast, GeneratedCast };
 
@@ -291 +328 @@
         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:
@@ -301 +340 @@
 public:
         ptr<Expr> arg;
+        struct Concrete {
+                std::string field;
+                std::string getter;
+
+                Concrete() = default;
+                Concrete(const Concrete &) = default;
+        };
         ast::AggregateDecl::Aggregate target;
+        Concrete concrete_target;
+
 
         KeywordCastExpr( const CodeLocation & loc, const Expr * a, ast::AggregateDecl::Aggregate t )
         : Expr( loc ), arg( a ), target( t ) {}
 
+        KeywordCastExpr( const CodeLocation & loc, const Expr * a, ast::AggregateDecl::Aggregate t, const Concrete & ct )
+        : Expr( loc ), arg( a ), target( t ), concrete_target( ct ) {}
+
         /// Get a name for the target type
         const char * targetString() const;
@@ -338 +389 @@
         : 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:
@@ -352 +405 @@
         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
-};
-
-/// A reference to a named variable.
-class VariableExpr final : public Expr {
-public:
-        readonly<DeclWithType> var;
-
-        VariableExpr( const CodeLocation & loc );
-        VariableExpr( const CodeLocation & loc, const DeclWithType * v );
-
-        /// generates a function pointer for a given function
-        static VariableExpr * functionPointer( const CodeLocation & loc, const FunctionDecl * decl );
-
-        const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        VariableExpr * clone() const override { return new VariableExpr{ *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 +431 @@
                 const CodeLocation & loc, const Type * ty, const std::string & r,
                         std::optional<unsigned long long> i )
-        : Expr( loc, ty ), rep( r ), ival( i ) {}
+        : Expr( loc, ty ), rep( r ), ival( i ), underlyer(ty) {}
 
         /// Gets the integer value of this constant, if one is appropriate to its type.
@@ -532 +577 @@
 
         CommaExpr( const CodeLocation & loc, const Expr * a1, const Expr * a2 )
-        : Expr( loc ), arg1( a1 ), arg2( a2 ) {}
+        : Expr( loc ), arg1( a1 ), arg2( a2 ) {
+                this->result = a2->result;
+        }
+
+        bool get_lvalue() const final;
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -577 +626 @@
 
         ImplicitCopyCtorExpr( const CodeLocation& loc, const ApplicationExpr * call )
-        : Expr( loc, call->result ) { assert( call ); }
+        : Expr( loc, call->result ), callExpr(call) { assert( call ); assert(call->result); }
 
         const Expr * accept( Visitor & v ) const override { return v.visit( this ); }
@@ -605 +654 @@
         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:
@@ -660 +711 @@
 
         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 ); }
@@ -698 +751 @@
         std::vector<ptr<Expr>> dtors;              ///< destructor(s) for return variable(s)
 
+        readonly<ExprStmt> resultExpr;
+
         StmtExpr( const CodeLocation & loc, const CompoundStmt * ss );
 

src/AST/Fwd.hpp

@@ -10 +10 @@
 // Created On       : Wed May  8 16:05:00 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jun 24 09:48:00 2019
-// Update Count     : 1
+// Last Modified On : Thr Jul 23 14:15:00 2020
+// Update Count     : 2
 //
 
@@ -53 +53 @@
 class CatchStmt;
 class FinallyStmt;
+class SuspendStmt;
 class WaitForStmt;
 class WithStmt;
@@ -106 +107 @@
 class QualifiedType;
 class FunctionType;
-class ReferenceToType;
-class StructInstType;
-class UnionInstType;
-class EnumInstType;
+class BaseInstType;
+template<typename decl_t> class SueInstType;
+using StructInstType = SueInstType<StructDecl>;
+using UnionInstType = SueInstType<UnionDecl>;
+using EnumInstType = SueInstType<EnumDecl>;
 class TraitInstType;
 class TypeInstType;
@@ -135 +137 @@
 typedef unsigned int UniqueId;
 
+struct TranslationUnit;
+// TODO: Get from the TranslationUnit:
+extern ptr<Type> sizeType;
+extern const FunctionDecl * dereferenceOperator;
+extern const StructDecl   * dtorStruct;
+extern const FunctionDecl * dtorStructDestroy;
+
 }

src/AST/GenericSubstitution.cpp

@@ -42 +42 @@
         private:
                 // make substitution for generic type
-                void makeSub( const ReferenceToType * ty ) {
+                void makeSub( const BaseInstType * ty ) {
                         visit_children = false;
                         const AggregateDecl * aggr = ty->aggr();
@@ -62 +62 @@
         Pass<GenericSubstitutionBuilder> builder;
         maybe_accept( ty, builder );
-        return std::move(builder.pass.sub);
+        return std::move(builder.core.sub);
 }
 

src/AST/Init.hpp

@@ -25 +25 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
@@ -48 +50 @@
 
 /// Flag for whether to construct from initialzier
-enum ConstructFlag { DoConstruct, MaybeConstruct };
+enum ConstructFlag { NoConstruct, MaybeConstruct };
 
 /// Object initializer base class
@@ -69 +71 @@
         ptr<Expr> value;
 
-        SingleInit( const CodeLocation & loc, const Expr * val, ConstructFlag mc = DoConstruct )
+        SingleInit( const CodeLocation & loc, const Expr * val, ConstructFlag mc = NoConstruct )
         : Init( loc, mc ), value( val ) {}
 
@@ -88 +90 @@
 
         ListInit( const CodeLocation & loc, std::vector<ptr<Init>> && is,
-                std::vector<ptr<Designation>> && ds = {}, ConstructFlag mc = DoConstruct );
+                std::vector<ptr<Designation>> && ds = {}, ConstructFlag mc = NoConstruct );
 
         using iterator = std::vector<ptr<Init>>::iterator;
@@ -116 +118 @@
         ConstructorInit( 
                 const CodeLocation & loc, const Stmt * ctor, const Stmt * dtor, const Init * init )
-        : Init( loc, DoConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}
+        : Init( loc, MaybeConstruct ), ctor( ctor ), dtor( dtor ), init( init ) {}
 
         const Init * accept( Visitor & v ) const override { return v.visit( this ); }

src/AST/Node.cpp

@@ -9 +9 @@
 // Author           : Thierry Delisle
 // Created On       : Thu May 16 14:16:00 2019
-// Last Modified By :
-// Last Modified On :
-// Update Count     :
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Jun  5 10:21:00 2020
+// Update Count     : 1
 //
 
@@ -17 +17 @@
 #include "Fwd.hpp"
 
+#include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
 
@@ -29 +30 @@
 #include "Print.hpp"
 
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_inc( const node_t * node ) { node->increment(ref_t); }
-
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_dec( const node_t * node ) { node->decrement(ref_t); }
-
-template< typename node_t, enum ast::Node::ref_type ref_t >
-void ast::ptr_base<node_t, ref_t>::_check() const { if(node) assert(node->was_ever_strong == false || node->strong_count > 0); }
+/// MEMORY DEBUG -- allows breaking on ref-count changes of dynamically chosen object.
+/// Process to use in GDB:
+///   break ast::Node::_trap()
+///   run
+///   set variable MEM_TRAP_OBJ = <target>
+///   disable <first breakpoint>
+///   continue
+void * MEM_TRAP_OBJ = nullptr;
+
+void _trap( const void * node ) {
+        if ( node == MEM_TRAP_OBJ ) std::raise(SIGTRAP);
+}
+
+[[noreturn]] static inline void strict_fail(const ast::Node * node) {
+        assertf(node, "strict_as had nullptr input.");
+        const ast::ParseNode * parse = dynamic_cast<const ast::ParseNode *>( node );
+        if ( nullptr == parse ) {
+                assertf(nullptr, "%s (no location)", toString(node).c_str());
+        } else if ( parse->location.isUnset() ) {
+                assertf(nullptr, "%s (unset location)", toString(node).c_str());
+        } else {
+                assertf(nullptr, "%s (at %s:%d)", toString(node).c_str(),
+                        parse->location.filename.c_str(), parse->location.first_line);
+        }
+}
+
+template< typename node_t, enum ast::Node::ref_type ref_t >
+void ast::ptr_base<node_t, ref_t>::_strict_fail() const {
+        strict_fail(node);
+}
+
+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 >
@@ -226 +266 @@
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::FunctionType, ast::Node::ref_type::strong >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::weak >;
-template class ast::ptr_base< ast::ReferenceToType, ast::Node::ref_type::strong >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::weak >;
+template class ast::ptr_base< ast::BaseInstType, ast::Node::ref_type::strong >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::weak >;
 template class ast::ptr_base< ast::StructInstType, ast::Node::ref_type::strong >;

src/AST/Node.hpp

@@ -10 +10 @@
 // Created On       : Wed May 8 10:27:04 2019
 // Last Modified By : Andrew Beach
-// Last Modified On : Mon Jun  3 13:26:00 2019
-// Update Count     : 5
+// Last Modified On : Fri Jun 5 9:47:00 2020
+// Update Count     : 6
 //
 
@@ -38 +38 @@
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
-        virtual ~Node() = default;
+        virtual ~Node() {}
 
         virtual const Node * accept( Visitor & v ) const = 0;
@@ -49 +49 @@
 
         bool unique() const { return strong_count == 1; }
+        bool isManaged() const {return strong_count > 0; }
 
 private:
@@ -57 +58 @@
         template<typename node_t>
         friend node_t * mutate(const node_t * node);
+        template<typename node_t>
+        friend node_t * shallowCopy(const node_t * node);
 
         mutable size_t strong_count = 0;
@@ -69 +72 @@
         }
 
-        void decrement(ast::Node::ref_type ref) const {
+        void decrement(ast::Node::ref_type ref, bool do_delete = true) const {
                 switch (ref) {
                         case ref_type::strong: strong_count--; break;
@@ -75 +78 @@
                 }
 
-                if(!strong_count && !weak_count) {
+                if( do_delete && !strong_count && !weak_count) {
                         delete this;
                 }
@@ -94 +97 @@
         assertf(
                 node->weak_count == 0,
-                "Error: mutating node with weak references to it will invalided some references"
+                "Error: mutating node with weak references to it will invalidate some references"
         );
         return node->clone();
@@ -104 +107 @@
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
-        
+
         // mutate and return
         node_t * ret = mutate( node );
@@ -123 +126 @@
         (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;
 }
 
@@ -217 +229 @@
         const node_t & operator* () const { _check(); return *node; }
         explicit operator bool() const { _check(); return node; }
-        operator const node_t * () const { _check(); return node; }
+        operator const node_t * () const & { _check(); return node; }
+        operator const node_t * () && = delete;
+
+        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
@@ -223 +245 @@
         const o_node_t * as() const { _check(); return dynamic_cast<const o_node_t *>(node); }
 
-        /// wrapper for convenient access to strict_dynamic_cast
+        /// Wrapper that makes sure dynamic_cast returns non-null.
         template<typename o_node_t>
-        const o_node_t * strict_as() const { _check(); return strict_dynamic_cast<const o_node_t *>(node); }
+        const o_node_t * strict_as() const {
+                if (const o_node_t * ret = as<o_node_t>()) return ret;
+                _strict_fail();
+        }
+
+        /// Wrapper that makes sure dynamic_cast does not fail.
+        template<typename o_node_t, decltype(nullptr) null>
+        const o_node_t * strict_as() const { return node ? strict_as<o_node_t>() : nullptr; }
 
         /// Returns a mutable version of the pointer in this node.
@@ -244 +273 @@
 
         void _inc( const node_t * other );
-        void _dec( const node_t * other );
+        void _dec( const node_t * other, bool do_delete = true );
         void _check() const;
+        void _strict_fail() const __attribute__((noreturn));
 
         const node_t * node;

src/AST/Pass.hpp

@@ -8 +8 @@
 //
 // Author           : Thierry Delisle
-// Created On       : Thu May 09 15::37::05 2019
+// Created On       : Thu May 09 15:37:05 2019
 // Last Modified By :
 // Last Modified On :
@@ -46 +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
+// | PureVisitor           - makes the visitor pure, it never modifies nodes in place and always
+//                           clones nodes it needs to make changes to
+// | WithConstTypeSubstitution - provides polymorphic const TypeSubstitution * typeSubs 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
+//
+// Other Special Members:
+// | result                - Either a method that takes no parameters or a field. If a method (or
+//                           callable field) get_result calls it, otherwise the value is returned.
 //-------------------------------------------------------------------------------------------------
-template< typename pass_t >
+template< typename core_t >
 class Pass final : public ast::Visitor {
 public:
+        using core_type = core_t;
+        using type = Pass<core_t>;
+
         /// Forward any arguments to the pass constructor
         /// Propagate 'this' if necessary
         template< typename... Args >
         Pass( Args &&... args)
-                : pass( std::forward<Args>( args )... )
+                : core( std::forward<Args>( args )... )
         {
                 // After the pass is constructed, check if it wants the have a pointer to the wrapping visitor
-                typedef Pass<pass_t> this_t;
-                this_t * const * visitor = __pass::visitor(pass, 0);
+                type * const * visitor = __pass::visitor(core, 0);
                 if(visitor) {
-                        *const_cast<this_t **>( visitor ) = this;
+                        *const_cast<type **>( visitor ) = this;
                 }
         }
@@ -82 +90 @@
         virtual ~Pass() = default;
 
-        /// Storage for the actual pass
-        pass_t pass;
+        /// Storage for the actual pass.
+        core_t core;
+
+        /// If the core defines a result, call it if possible, otherwise return it.
+        inline auto get_result() -> decltype( __pass::get_result( core, '0' ) ) {
+                return __pass::get_result( core, '0' );
+        }
+
+        /// Construct and run a pass on a translation unit.
+        template< typename... Args >
+        static void run( TranslationUnit & decls, Args &&... args ) {
+                Pass<core_t> visitor( std::forward<Args>( args )... );
+                accept_all( decls, visitor );
+        }
+
+        /// Contruct and run a pass on a pointer to extract a value.
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node, Args&&... args ) {
+                Pass<core_t> visitor( std::forward<Args>( args )... );
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
+
+        // Versions of the above for older compilers.
+        template< typename... Args >
+        static void run( TranslationUnit & decls ) {
+                Pass<core_t> visitor;
+                accept_all( decls, visitor );
+        }
+
+        template< typename node_type, typename... Args >
+        static auto read( node_type const * node ) {
+                Pass<core_t> visitor;
+                node_type const * temp = node->accept( visitor );
+                assert( temp == node );
+                return visitor.get_result();
+        }
 
         /// Visit function declarations
@@ -111 +155 @@
         const ast::Stmt *             visit( const ast::CatchStmt            * ) override final;
         const ast::Stmt *             visit( const ast::FinallyStmt          * ) override final;
+        const ast::Stmt *             visit( const ast::SuspendStmt          * ) override final;
         const ast::Stmt *             visit( const ast::WaitForStmt          * ) override final;
         const ast::Decl *             visit( const ast::WithStmt             * ) override final;
@@ -178 +223 @@
         const ast::TypeSubstitution * visit( const ast::TypeSubstitution     * ) override final;
 
-        template<typename pass_type>
-        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<pass_type>& visitor );
+        template<typename core_type>
+        friend void accept_all( std::list< ptr<Decl> > & decls, Pass<core_type>& visitor );
+
+        bool isInFunction() const {
+                return inFunction;
+        }
+
 private:
 
-        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(pass, 0); return ptr ? *ptr : true; }
+        bool __visit_children() { __pass::bool_ref * ptr = __pass::visit_children(core, 0); return ptr ? *ptr : true; }
 
 private:
         const ast::Stmt * call_accept( const ast::Stmt * );
         const ast::Expr * call_accept( const ast::Expr * );
+
+        // requests WithStmtsToAdd directly add to this statement, as if it is a compound.
+
+        const ast::Stmt * call_accept_as_compound(const ast::Stmt *);
 
         template< typename node_t >
@@ -206 +260 @@
         void maybe_accept(const node_t * &, child_t parent_t::* child);
 
+        template<typename node_t, typename parent_t, typename child_t>
+        void maybe_accept_as_compound(const node_t * &, child_t parent_t::* child);
+
 private:
         /// Internal RAII guard for symbol table features
         struct guard_symtab {
-                guard_symtab( Pass<pass_t> & pass ): pass( pass ) { __pass::symtab::enter(pass, 0); }
-                ~guard_symtab()                                   { __pass::symtab::leave(pass, 0); }
-                Pass<pass_t> & pass;
+                guard_symtab( Pass<core_t> & pass ): pass( pass ) { __pass::symtab::enter(pass.core, 0); }
+                ~guard_symtab()                                   { __pass::symtab::leave(pass.core, 0); }
+                Pass<core_t> & pass;
         };
 
         /// Internal RAII guard for scope features
         struct guard_scope {
-                guard_scope( Pass<pass_t> & pass ): pass( pass ) { __pass::scope::enter(pass, 0); }
-                ~guard_scope()                                   { __pass::scope::leave(pass, 0); }
-                Pass<pass_t> & pass;
+                guard_scope( Pass<core_t> & pass ): pass( pass ) { __pass::scope::enter(pass.core, 0); }
+                ~guard_scope()                                   { __pass::scope::leave(pass.core, 0); }
+                Pass<core_t> & pass;
+        };
+
+        /// Internal RAII guard for forall substitutions
+        struct guard_forall_subs {
+                guard_forall_subs( Pass<core_t> & pass, const FunctionType * type )
+                : pass( pass ), type( type ) { __pass::forall::enter(pass.core, 0, type ); }
+                ~guard_forall_subs()         { __pass::forall::leave(pass.core, 0, type ); }
+                Pass<core_t> & pass;
+                const FunctionType * type;
         };
 
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
 };
 
 /// Apply a pass to an entire translation unit
-template<typename pass_t>
-void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<pass_t> & visitor );
+template<typename core_t>
+void accept_all( std::list< ast::ptr<ast::Decl> > &, ast::Pass<core_t> & visitor );
+
+template<typename core_t>
+void accept_all( ast::TranslationUnit &, ast::Pass<core_t> & visitor );
 
 //-------------------------------------------------------------------------------------------------
@@ -233 +303 @@
 //-------------------------------------------------------------------------------------------------
 
-/// Keep track of the polymorphic const TypeSubstitution * env for the current expression
+/// If used the visitor will always clone nodes.
+struct PureVisitor {};
+
+/// Keep track of the polymorphic const TypeSubstitution * typeSubs for the current expression.
 struct WithConstTypeSubstitution {
-        const TypeSubstitution * env = nullptr;
+        const TypeSubstitution * typeSubs = nullptr;
 };
 
@@ -267 +340 @@
         };
 
-        template< typename pass_t>
-        friend auto __pass::at_cleanup( pass_t & pass, int ) -> decltype( &pass.at_cleanup );
+        template< typename core_t>
+        friend auto __pass::at_cleanup( core_t & core, int ) -> decltype( &core.at_cleanup );
 public:
 
@@ -304 +377 @@
 
 /// Used to get a pointer to the pass with its wrapped type
-template<typename pass_t>
+template<typename core_t>
 struct WithVisitorRef {
-        Pass<pass_t> * const visitor = nullptr;
+        Pass<core_t> * const visitor = nullptr;
+
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };
 
@@ -313 +390 @@
         SymbolTable symtab;
 };
+
 }
 
@@ -320 +398 @@
 extern struct PassVisitorStats {
         size_t depth = 0;
-        Stats::Counters::MaxCounter<double> * max = nullptr;
-        Stats::Counters::AverageCounter<double> * avg = nullptr;
+        Stats::Counters::MaxCounter<double> * max;
+        Stats::Counters::AverageCounter<double> * avg;
 } pass_visitor_stats;
 }

src/AST/Pass.impl.hpp

@@ -20 +20 @@
 #include <unordered_map>
 
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 
@@ -25 +26 @@
         using namespace ast; \
         /* back-up the visit children */ \
-        __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(pass, 0) ); \
+        __attribute__((unused)) ast::__pass::visit_children_guard guard1( ast::__pass::visit_children(core, 0) ); \
         /* setup the scope for passes that want to run code at exit */ \
-        __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (pass, 0) ); \
+        __attribute__((unused)) ast::__pass::guard_value          guard2( ast::__pass::at_cleanup    (core, 0) ); \
+        /* begin tracing memory allocation if requested by this pass */ \
+        __pass::beginTrace( core, 0 ); \
         /* call the implementation of the previsit of this pass */ \
-        __pass::previsit( pass, node, 0 );
+        __pass::previsit( core, node, 0 );
 
 #define VISIT( code... ) \
@@ -40 +43 @@
 #define VISIT_END( type, node ) \
         /* call the implementation of the postvisit of this pass */ \
-        auto __return = __pass::postvisit( pass, node, 0 ); \
+        auto __return = __pass::postvisit( core, node, 0 ); \
         assertf(__return, "post visit should never return null"); \
+        /* end tracing memory allocation if requested by this pass */ \
+        __pass::endTrace( core, 0 ); \
         return __return;
 
@@ -53 +58 @@
 
 namespace ast {
+        template<typename node_t>
+        node_t * shallowCopy( const node_t * node );
+
         namespace __pass {
                 // Check if this is either a null pointer or a pointer to an empty container
@@ -60 +68 @@
                 }
 
+                template< typename core_t, typename node_t >
+                static inline node_t* mutate(const node_t *node) {
+                        return std::is_base_of<PureVisitor, core_t>::value ? ::ast::shallowCopy(node) : ::ast::mutate(node);
+                }
+
                 //------------------------------
                 template<typename it_t, template <class...> class container_t>
@@ -119 +132 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< typename node_t >
-        auto ast::Pass< pass_t >::call_accept( const node_t * node )
+        auto ast::Pass< core_t >::call_accept( const node_t * node )
                 -> typename std::enable_if<
                                 !std::is_base_of<ast::Expr, node_t>::value &&
@@ -127 +140 @@
                         , decltype( node->accept(*this) )
                 >::type
-
         {
                 __pedantic_pass_assert( __visit_children() );
-                __pedantic_pass_assert( expr );
+                __pedantic_pass_assert( node );
 
                 static_assert( !std::is_base_of<ast::Expr, node_t>::value, "ERROR");
@@ -138 +150 @@
         }
 
-        template< typename pass_t >
-        const ast::Expr * ast::Pass< pass_t >::call_accept( const ast::Expr * expr ) {
+        template< typename core_t >
+        const ast::Expr * ast::Pass< core_t >::call_accept( const ast::Expr * expr ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( expr );
 
-                const ast::TypeSubstitution ** env_ptr = __pass::env( pass, 0);
-                if ( env_ptr && expr->env ) {
-                        *env_ptr = expr->env;
+                const ast::TypeSubstitution ** typeSubs_ptr = __pass::typeSubs( core, 0 );
+                if ( typeSubs_ptr && expr->env ) {
+                        *typeSubs_ptr = expr->env;
                 }
 
@@ -151 +163 @@
         }
 
-        template< typename pass_t >
-        const ast::Stmt * ast::Pass< pass_t >::call_accept( const ast::Stmt * stmt ) {
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept( const ast::Stmt * stmt ) {
                 __pedantic_pass_assert( __visit_children() );
                 __pedantic_pass_assert( stmt );
 
+                return stmt->accept( *this );
+        }
+
+        template< typename core_t >
+        const ast::Stmt * ast::Pass< core_t >::call_accept_as_compound( const ast::Stmt * stmt ) {
+                __pedantic_pass_assert( __visit_children() );
+                __pedantic_pass_assert( stmt );
+
                 // add a few useful symbols to the scope
                 using __pass::empty;
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
-                auto decls_before = __pass::declsToAddBefore( pass, 0);
-                auto decls_after  = __pass::declsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
+                auto decls_before = __pass::declsToAddBefore( core, 0);
+                auto decls_after  = __pass::declsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::env( pass, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env         ( __pass::typeSubs( core, 0 ) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
@@ -202 +222 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< template <class...> class container_t >
-        container_t< ptr<Stmt> > ast::Pass< pass_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
+        container_t< ptr<Stmt> > ast::Pass< core_t >::call_accept( const container_t< ptr<Stmt> > & statements ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( statements.empty() ) return {};
@@ -215 +235 @@
 
                 // get the stmts/decls that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
-                auto decls_before = __pass::declsToAddBefore( pass, 0);
-                auto decls_after  = __pass::declsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
+                auto decls_before = __pass::declsToAddBefore( core, 0);
+                auto decls_after  = __pass::declsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
@@ -268 +288 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template< template <class...> class container_t, typename node_t >
-        container_t< ast::ptr<node_t> > ast::Pass< pass_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
+        container_t< ast::ptr<node_t> > ast::Pass< core_t >::call_accept( const container_t< ast::ptr<node_t> > & container ) {
                 __pedantic_pass_assert( __visit_children() );
                 if( container.empty() ) return {};
@@ -299 +319 @@
         }
 
-        template< typename pass_t >
+        template< typename core_t >
         template<typename node_t, typename parent_t, typename child_t>
-        void ast::Pass< pass_t >::maybe_accept(
+        void ast::Pass< core_t >::maybe_accept(
                 const node_t * & parent,
                 child_t parent_t::*child
@@ -317 +337 @@
 
                 if( __pass::differs(old_val, new_val) ) {
-                        auto new_parent = mutate(parent);
+                        auto new_parent = __pass::mutate<core_t>(parent);
+                        new_parent->*child = new_val;
+                        parent = new_parent;
+                }
+        }
+
+        template< typename core_t >
+        template<typename node_t, typename parent_t, typename child_t>
+        void ast::Pass< core_t >::maybe_accept_as_compound(
+                const node_t * & parent,
+                child_t parent_t::*child
+        ) {
+                static_assert( std::is_base_of<parent_t, node_t>::value, "Error deducing member object" );
+
+                if(__pass::skip(parent->*child)) return;
+                const auto & old_val = __pass::get(parent->*child, 0);
+
+                static_assert( !std::is_same<const ast::Node * &, decltype(old_val)>::value, "ERROR");
+
+                auto new_val = call_accept_as_compound( old_val );
+
+                static_assert( !std::is_same<const ast::Node *, decltype(new_val)>::value || std::is_same<int, decltype(old_val)>::value, "ERROR");
+
+                if( __pass::differs(old_val, new_val) ) {
+                        auto new_parent = __pass::mutate<core_t>(parent);
                         new_parent->*child = new_val;
                         parent = new_parent;
@@ -333 +377 @@
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
-template< typename pass_t >
-inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< pass_t > & visitor ) {
+template< typename core_t >
+inline void ast::accept_all( std::list< ast::ptr<ast::Decl> > & decls, ast::Pass< core_t > & visitor ) {
         // We are going to aggregate errors for all these statements
         SemanticErrorException errors;
@@ -342 +386 @@
 
         // get the stmts/decls that will need to be spliced in
-        auto decls_before = __pass::declsToAddBefore( visitor.pass, 0);
-        auto decls_after  = __pass::declsToAddAfter ( visitor.pass, 0);
+        auto decls_before = __pass::declsToAddBefore( visitor.core, 0);
+        auto decls_after  = __pass::declsToAddAfter ( visitor.core, 0);
 
         // update pass statitistics
@@ -363 +407 @@
                 }
                 catch( SemanticErrorException &e ) {
-                        errors.append( e );
+                        if (__pass::on_error (visitor.core, *i, 0))
+                                errors.append( e );
                 }
 
@@ -371 +416 @@
         pass_visitor_stats.depth--;
         if ( !errors.isEmpty() ) { throw errors; }
+}
+
+template< typename core_t >
+inline void ast::accept_all( ast::TranslationUnit & unit, ast::Pass< core_t > & visitor ) {
+        return ast::accept_all( unit.decls, visitor );
 }
 
@@ -392 +442 @@
 //--------------------------------------------------------------------------
 // ObjectDecl
-template< typename pass_t >
-const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::ObjectDecl * node ) {
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::ObjectDecl * node ) {
         VISIT_START( node );
 
@@ -406 +456 @@
         )
 
-        __pass::symtab::addId( pass, 0, node );
+        __pass::symtab::addId( core, 0, node );
 
         VISIT_END( DeclWithType, node );
@@ -413 +463 @@
 //--------------------------------------------------------------------------
 // FunctionDecl
-template< typename pass_t >
-const ast::DeclWithType * ast::Pass< pass_t >::visit( const ast::FunctionDecl * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addId( pass, 0, node );
+template< typename core_t >
+const ast::DeclWithType * ast::Pass< core_t >::visit( const ast::FunctionDecl * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addId( core, 0, node );
 
         VISIT(maybe_accept( node, &FunctionDecl::withExprs );)
@@ -425 +475 @@
                 // shadow with exprs and not the other way around.
                 guard_symtab guard { *this };
-                __pass::symtab::addWith( pass, 0, node->withExprs, node );
+                __pass::symtab::addWith( core, 0, node->withExprs, node );
                 {
                         guard_symtab guard { *this };
                         // implicit add __func__ identifier as specified in the C manual 6.4.2.2
-                        static ast::ObjectDecl func(
-                                node->location, "__func__",
-                                new ast::ArrayType(
-                                        new ast::BasicType( ast::BasicType::Char, ast::CV::Qualifiers( ast::CV::Const ) ),
+                        static ast::ptr< ast::ObjectDecl > func{ new ast::ObjectDecl{ 
+                                CodeLocation{}, "__func__",
+                                new ast::ArrayType{
+                                        new ast::BasicType{ ast::BasicType::Char, ast::CV::Const },
                                         nullptr, VariableLen, DynamicDim
-                                )
-                        );
-                        __pass::symtab::addId( pass, 0, &func );
+                                }
+                        } };
+                        __pass::symtab::addId( core, 0, func );
                         VISIT(
-                                maybe_accept( node, &FunctionDecl::type );
-                                // function body needs to have the same scope as parameters - CompoundStmt will not enter
-                                // a new scope if inFunction is true
+                                // parameter declarations
+                                maybe_accept( node, &FunctionDecl::params );
+                                maybe_accept( node, &FunctionDecl::returns );
+                                // type params and assertions
+                                maybe_accept( node, &FunctionDecl::type_params );
+                                maybe_accept( node, &FunctionDecl::assertions );
+                                // First remember that we are now within a function.
                                 ValueGuard< bool > oldInFunction( inFunction );
                                 inFunction = true;
+                                // The function body needs to have the same scope as parameters.
+                                // A CompoundStmt will not enter a new scope if atFunctionTop is true.
+                                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                                atFunctionTop = true;
                                 maybe_accept( node, &FunctionDecl::stmts );
                                 maybe_accept( node, &FunctionDecl::attributes );
@@ -454 +512 @@
 //--------------------------------------------------------------------------
 // StructDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::StructDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::StructDecl * node ) {
         VISIT_START( node );
 
         // make up a forward declaration and add it before processing the members
         // needs to be on the heap because addStruct saves the pointer
-        __pass::symtab::addStructFwd( pass, 0, node );
+        __pass::symtab::addStructFwd( core, 0, node );
 
         VISIT({
@@ -469 +527 @@
 
         // this addition replaces the forward declaration
-        __pass::symtab::addStruct( pass, 0, node );
+        __pass::symtab::addStruct( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -476 +534 @@
 //--------------------------------------------------------------------------
 // UnionDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::UnionDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::UnionDecl * node ) {
         VISIT_START( node );
 
         // make up a forward declaration and add it before processing the members
-        __pass::symtab::addUnionFwd( pass, 0, node );
+        __pass::symtab::addUnionFwd( core, 0, node );
 
         VISIT({
@@ -489 +547 @@
         })
 
-        __pass::symtab::addUnion( pass, 0, node );
+        __pass::symtab::addUnion( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -496 +554 @@
 //--------------------------------------------------------------------------
 // EnumDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::EnumDecl * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addEnum( pass, 0, node );
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::EnumDecl * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addEnum( core, 0, node );
 
         VISIT(
@@ -513 +571 @@
 //--------------------------------------------------------------------------
 // TraitDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TraitDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TraitDecl * node ) {
         VISIT_START( node );
 
@@ -523 +581 @@
         })
 
-        __pass::symtab::addTrait( pass, 0, node );
+        __pass::symtab::addTrait( core, 0, node );
 
         VISIT_END( Decl, node );
@@ -530 +588 @@
 //--------------------------------------------------------------------------
 // TypeDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypeDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TypeDecl * node ) {
         VISIT_START( node );
 
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &TypeDecl::params );
                 maybe_accept( node, &TypeDecl::base   );
         })
@@ -543 +600 @@
         // note that assertions come after the type is added to the symtab, since they are not part of the type proper
         // and may depend on the type itself
-        __pass::symtab::addType( pass, 0, node );
+        __pass::symtab::addType( core, 0, node );
 
         VISIT(
@@ -559 +616 @@
 //--------------------------------------------------------------------------
 // TypedefDecl
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::TypedefDecl * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::TypedefDecl * node ) {
         VISIT_START( node );
 
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &TypedefDecl::params );
                 maybe_accept( node, &TypedefDecl::base   );
         })
 
-        __pass::symtab::addType( pass, 0, node );
+        __pass::symtab::addType( core, 0, node );
 
         VISIT( maybe_accept( node, &TypedefDecl::assertions ); )
@@ -578 +634 @@
 //--------------------------------------------------------------------------
 // AsmDecl
-template< typename pass_t >
-const ast::AsmDecl * ast::Pass< pass_t >::visit( const ast::AsmDecl * node ) {
+template< typename core_t >
+const ast::AsmDecl * ast::Pass< core_t >::visit( const ast::AsmDecl * node ) {
         VISIT_START( node );
 
@@ -591 +647 @@
 //--------------------------------------------------------------------------
 // StaticAssertDecl
-template< typename pass_t >
-const ast::StaticAssertDecl * ast::Pass< pass_t >::visit( const ast::StaticAssertDecl * node ) {
+template< typename core_t >
+const ast::StaticAssertDecl * ast::Pass< core_t >::visit( const ast::StaticAssertDecl * node ) {
         VISIT_START( node );
 
@@ -605 +661 @@
 //--------------------------------------------------------------------------
 // CompoundStmt
-template< typename pass_t >
-const ast::CompoundStmt * ast::Pass< pass_t >::visit( const ast::CompoundStmt * node ) {
-        VISIT_START( node );
-        VISIT({
-                // do not enter a new scope if inFunction is true - needs to check old state before the assignment
-                auto guard1 = makeFuncGuard( [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::enter(pass, 0);
-                }, [this, inFunction = this->inFunction]() {
-                        if ( ! inFunction ) __pass::symtab::leave(pass, 0);
+template< typename core_t >
+const ast::CompoundStmt * ast::Pass< core_t >::visit( const ast::CompoundStmt * node ) {
+        VISIT_START( node );
+        VISIT(
+                // Do not enter (or leave) a new scope if atFunctionTop. Remember to save the result.
+                auto guard1 = makeFuncGuard( [this, enterScope = !this->atFunctionTop]() {
+                        if ( enterScope ) {
+                                __pass::symtab::enter(core, 0);
+                                __pass::scope::enter(core, 0);
+                        }
+                }, [this, leaveScope = !this->atFunctionTop]() {
+                        if ( leaveScope ) {
+                                __pass::symtab::leave(core, 0);
+                                __pass::scope::leave(core, 0);
+                        }
                 });
-                ValueGuard< bool > guard2( inFunction );
+                ValueGuard< bool > guard2( atFunctionTop );
+                atFunctionTop = false;
                 guard_scope guard3 { *this };
-                inFunction = false;
                 maybe_accept( node, &CompoundStmt::kids );
-        })
+        )
         VISIT_END( CompoundStmt, node );
 }
@@ -625 +687 @@
 //--------------------------------------------------------------------------
 // ExprStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ExprStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ExprStmt * node ) {
         VISIT_START( node );
 
@@ -638 +700 @@
 //--------------------------------------------------------------------------
 // AsmStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::AsmStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::AsmStmt * node ) {
         VISIT_START( node )
 
@@ -654 +716 @@
 //--------------------------------------------------------------------------
 // DirectiveStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DirectiveStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::DirectiveStmt * node ) {
         VISIT_START( node )
 
@@ -663 +725 @@
 //--------------------------------------------------------------------------
 // IfStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::IfStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::IfStmt * node ) {
         VISIT_START( node );
 
@@ -672 +734 @@
                 maybe_accept( node, &IfStmt::inits    );
                 maybe_accept( node, &IfStmt::cond     );
-                maybe_accept( node, &IfStmt::thenPart );
-                maybe_accept( node, &IfStmt::elsePart );
+                maybe_accept_as_compound( node, &IfStmt::thenPart );
+                maybe_accept_as_compound( node, &IfStmt::elsePart );
         })
 
@@ -681 +743 @@
 //--------------------------------------------------------------------------
 // WhileStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WhileStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WhileStmt * node ) {
         VISIT_START( node );
 
@@ -690 +752 @@
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
-                maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 
@@ -698 +760 @@
 //--------------------------------------------------------------------------
 // ForStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ForStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ForStmt * node ) {
         VISIT_START( node );
 
@@ -705 +767 @@
                 // for statements introduce a level of scope (for the initialization)
                 guard_symtab guard { *this };
+                // xxx - old ast does not create WithStmtsToAdd scope for loop inits. should revisit this later.
                 maybe_accept( node, &ForStmt::inits );
                 maybe_accept( node, &ForStmt::cond  );
                 maybe_accept( node, &ForStmt::inc   );
-                maybe_accept( node, &ForStmt::body  );
+                maybe_accept_as_compound( node, &ForStmt::body  );
         })
 
@@ -716 +779 @@
 //--------------------------------------------------------------------------
 // SwitchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::SwitchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::SwitchStmt * node ) {
         VISIT_START( node );
 
@@ -730 +793 @@
 //--------------------------------------------------------------------------
 // CaseStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CaseStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CaseStmt * node ) {
         VISIT_START( node );
 
@@ -744 +807 @@
 //--------------------------------------------------------------------------
 // BranchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::BranchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::BranchStmt * node ) {
         VISIT_START( node );
         VISIT_END( Stmt, node );
@@ -752 +815 @@
 //--------------------------------------------------------------------------
 // ReturnStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ReturnStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ReturnStmt * node ) {
         VISIT_START( node );
 
@@ -765 +828 @@
 //--------------------------------------------------------------------------
 // ThrowStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ThrowStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ThrowStmt * node ) {
         VISIT_START( node );
 
@@ -779 +842 @@
 //--------------------------------------------------------------------------
 // TryStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::TryStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::TryStmt * node ) {
         VISIT_START( node );
 
@@ -794 +857 @@
 //--------------------------------------------------------------------------
 // CatchStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::CatchStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::CatchStmt * node ) {
         VISIT_START( node );
 
@@ -803 +866 @@
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
-                maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 
@@ -811 +874 @@
 //--------------------------------------------------------------------------
 // FinallyStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::FinallyStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::FinallyStmt * node ) {
         VISIT_START( node );
 
@@ -823 +886 @@
 
 //--------------------------------------------------------------------------
+// FinallyStmt
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::SuspendStmt * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                maybe_accept( node, &SuspendStmt::then   );
+        )
+
+        VISIT_END( Stmt, node );
+}
+
+//--------------------------------------------------------------------------
 // WaitForStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::WaitForStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::WaitForStmt * node ) {
         VISIT_START( node );
                 // for( auto & clause : node->clauses ) {
@@ -862 +938 @@
 
                 if(mutated) {
-                        auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->clauses = std::move( new_clauses );
                         node = n;
@@ -872 +948 @@
                         auto nval = call_accept( node->field ); \
                         if(nval != node->field ) { \
-                                auto nparent = mutate(node); \
+                                auto nparent = __pass::mutate<core_t>(node); \
                                 nparent->field = nval; \
                                 node = nparent; \
@@ -893 +969 @@
 //--------------------------------------------------------------------------
 // WithStmt
-template< typename pass_t >
-const ast::Decl * ast::Pass< pass_t >::visit( const ast::WithStmt * node ) {
+template< typename core_t >
+const ast::Decl * ast::Pass< core_t >::visit( const ast::WithStmt * node ) {
         VISIT_START( node );
 
@@ -902 +978 @@
                         // catch statements introduce a level of scope (for the caught exception)
                         guard_symtab guard { *this };
-                        __pass::symtab::addWith( pass, 0, node->exprs, node );
+                        __pass::symtab::addWith( core, 0, node->exprs, node );
                         maybe_accept( node, &WithStmt::stmt );
                 }
@@ -911 +987 @@
 //--------------------------------------------------------------------------
 // NullStmt
-template< typename pass_t >
-const ast::NullStmt * ast::Pass< pass_t >::visit( const ast::NullStmt * node ) {
+template< typename core_t >
+const ast::NullStmt * ast::Pass< core_t >::visit( const ast::NullStmt * node ) {
         VISIT_START( node );
         VISIT_END( NullStmt, node );
@@ -919 +995 @@
 //--------------------------------------------------------------------------
 // DeclStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::DeclStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::DeclStmt * node ) {
         VISIT_START( node );
 
@@ -932 +1008 @@
 //--------------------------------------------------------------------------
 // ImplicitCtorDtorStmt
-template< typename pass_t >
-const ast::Stmt * ast::Pass< pass_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
+template< typename core_t >
+const ast::Stmt * ast::Pass< core_t >::visit( const ast::ImplicitCtorDtorStmt * node ) {
         VISIT_START( node );
 
         // 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 );
@@ -947 +1023 @@
 //--------------------------------------------------------------------------
 // ApplicationExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ApplicationExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ApplicationExpr * node ) {
         VISIT_START( node );
 
@@ -965 +1041 @@
 //--------------------------------------------------------------------------
 // UntypedExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedExpr * node ) {
         VISIT_START( node );
 
@@ -983 +1059 @@
 //--------------------------------------------------------------------------
 // NameExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::NameExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::NameExpr * node ) {
         VISIT_START( node );
 
@@ -997 +1073 @@
 //--------------------------------------------------------------------------
 // CastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CastExpr * node ) {
         VISIT_START( node );
 
@@ -1013 +1089 @@
 //--------------------------------------------------------------------------
 // KeywordCastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::KeywordCastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::KeywordCastExpr * node ) {
         VISIT_START( node );
 
@@ -1029 +1105 @@
 //--------------------------------------------------------------------------
 // VirtualCastExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::VirtualCastExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::VirtualCastExpr * node ) {
         VISIT_START( node );
 
@@ -1045 +1121 @@
 //--------------------------------------------------------------------------
 // AddressExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AddressExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AddressExpr * node ) {
         VISIT_START( node );
 
@@ -1061 +1137 @@
 //--------------------------------------------------------------------------
 // LabelAddressExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::LabelAddressExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::LabelAddressExpr * node ) {
         VISIT_START( node );
 
@@ -1075 +1151 @@
 //--------------------------------------------------------------------------
 // UntypedMemberExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedMemberExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedMemberExpr * node ) {
         VISIT_START( node );
 
@@ -1092 +1168 @@
 //--------------------------------------------------------------------------
 // MemberExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::MemberExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::MemberExpr * node ) {
         VISIT_START( node );
 
@@ -1108 +1184 @@
 //--------------------------------------------------------------------------
 // VariableExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::VariableExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::VariableExpr * node ) {
         VISIT_START( node );
 
@@ -1122 +1198 @@
 //--------------------------------------------------------------------------
 // ConstantExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstantExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstantExpr * node ) {
         VISIT_START( node );
 
@@ -1136 +1212 @@
 //--------------------------------------------------------------------------
 // SizeofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::SizeofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::SizeofExpr * node ) {
         VISIT_START( node );
 
@@ -1156 +1232 @@
 //--------------------------------------------------------------------------
 // AlignofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AlignofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AlignofExpr * node ) {
         VISIT_START( node );
 
@@ -1176 +1252 @@
 //--------------------------------------------------------------------------
 // UntypedOffsetofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedOffsetofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedOffsetofExpr * node ) {
         VISIT_START( node );
 
@@ -1192 +1268 @@
 //--------------------------------------------------------------------------
 // OffsetofExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetofExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetofExpr * node ) {
         VISIT_START( node );
 
@@ -1208 +1284 @@
 //--------------------------------------------------------------------------
 // OffsetPackExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::OffsetPackExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::OffsetPackExpr * node ) {
         VISIT_START( node );
 
@@ -1224 +1300 @@
 //--------------------------------------------------------------------------
 // LogicalExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::LogicalExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::LogicalExpr * node ) {
         VISIT_START( node );
 
@@ -1241 +1317 @@
 //--------------------------------------------------------------------------
 // ConditionalExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConditionalExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConditionalExpr * node ) {
         VISIT_START( node );
 
@@ -1259 +1335 @@
 //--------------------------------------------------------------------------
 // CommaExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CommaExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CommaExpr * node ) {
         VISIT_START( node );
 
@@ -1276 +1352 @@
 //--------------------------------------------------------------------------
 // TypeExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TypeExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TypeExpr * node ) {
         VISIT_START( node );
 
@@ -1292 +1368 @@
 //--------------------------------------------------------------------------
 // AsmExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::AsmExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::AsmExpr * node ) {
         VISIT_START( node );
 
@@ -1309 +1385 @@
 //--------------------------------------------------------------------------
 // ImplicitCopyCtorExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ImplicitCopyCtorExpr * node ) {
         VISIT_START( node );
 
@@ -1325 +1401 @@
 //--------------------------------------------------------------------------
 // ConstructorExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::ConstructorExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::ConstructorExpr * node ) {
         VISIT_START( node );
 
@@ -1341 +1417 @@
 //--------------------------------------------------------------------------
 // CompoundLiteralExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::CompoundLiteralExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::CompoundLiteralExpr * node ) {
         VISIT_START( node );
 
@@ -1357 +1433 @@
 //--------------------------------------------------------------------------
 // RangeExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::RangeExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::RangeExpr * node ) {
         VISIT_START( node );
 
@@ -1374 +1450 @@
 //--------------------------------------------------------------------------
 // UntypedTupleExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedTupleExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedTupleExpr * node ) {
         VISIT_START( node );
 
@@ -1390 +1466 @@
 //--------------------------------------------------------------------------
 // TupleExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleExpr * node ) {
         VISIT_START( node );
 
@@ -1406 +1482 @@
 //--------------------------------------------------------------------------
 // TupleIndexExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleIndexExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleIndexExpr * node ) {
         VISIT_START( node );
 
@@ -1422 +1498 @@
 //--------------------------------------------------------------------------
 // TupleAssignExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::TupleAssignExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::TupleAssignExpr * node ) {
         VISIT_START( node );
 
@@ -1438 +1514 @@
 //--------------------------------------------------------------------------
 // StmtExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::StmtExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::StmtExpr * node ) {
         VISIT_START( node );
 
         VISIT(// don't want statements from outer CompoundStmts to be added to this StmtExpr
                 // get the stmts that will need to be spliced in
-                auto stmts_before = __pass::stmtsToAddBefore( pass, 0);
-                auto stmts_after  = __pass::stmtsToAddAfter ( pass, 0);
+                auto stmts_before = __pass::stmtsToAddBefore( core, 0);
+                auto stmts_after  = __pass::stmtsToAddAfter ( core, 0);
 
                 // These may be modified by subnode but most be restored once we exit this statemnet.
-                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::env( pass, 0) );
+                ValueGuardPtr< const ast::TypeSubstitution * > __old_env( __pass::typeSubs( core, 0 ) );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_before) >::type > __old_decls_before( stmts_before );
                 ValueGuardPtr< typename std::remove_pointer< decltype(stmts_after ) >::type > __old_decls_after ( stmts_after  );
@@ -1466 +1542 @@
 //--------------------------------------------------------------------------
 // UniqueExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UniqueExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UniqueExpr * node ) {
         VISIT_START( node );
 
@@ -1482 +1558 @@
 //--------------------------------------------------------------------------
 // UntypedInitExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::UntypedInitExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::UntypedInitExpr * node ) {
         VISIT_START( node );
 
@@ -1499 +1575 @@
 //--------------------------------------------------------------------------
 // InitExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::InitExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::InitExpr * node ) {
         VISIT_START( node );
 
@@ -1516 +1592 @@
 //--------------------------------------------------------------------------
 // DeletedExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::DeletedExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DeletedExpr * node ) {
         VISIT_START( node );
 
@@ -1533 +1609 @@
 //--------------------------------------------------------------------------
 // DefaultArgExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::DefaultArgExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::DefaultArgExpr * node ) {
         VISIT_START( node );
 
@@ -1549 +1625 @@
 //--------------------------------------------------------------------------
 // GenericExpr
-template< typename pass_t >
-const ast::Expr * ast::Pass< pass_t >::visit( const ast::GenericExpr * node ) {
+template< typename core_t >
+const ast::Expr * ast::Pass< core_t >::visit( const ast::GenericExpr * node ) {
         VISIT_START( node );
 
@@ -1578 +1654 @@
 
                 if(mutated) {
-                        auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->associations = std::move( new_kids );
                         node = n;
@@ -1589 +1665 @@
 //--------------------------------------------------------------------------
 // VoidType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::VoidType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::VoidType * node ) {
         VISIT_START( node );
 
@@ -1598 +1674 @@
 //--------------------------------------------------------------------------
 // BasicType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::BasicType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::BasicType * node ) {
         VISIT_START( node );
 
@@ -1607 +1683 @@
 //--------------------------------------------------------------------------
 // PointerType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::PointerType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::PointerType * node ) {
         VISIT_START( node );
 
@@ -1621 +1697 @@
 //--------------------------------------------------------------------------
 // ArrayType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ArrayType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ArrayType * node ) {
         VISIT_START( node );
 
@@ -1635 +1711 @@
 //--------------------------------------------------------------------------
 // ReferenceType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ReferenceType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ReferenceType * node ) {
         VISIT_START( node );
 
@@ -1648 +1724 @@
 //--------------------------------------------------------------------------
 // QualifiedType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::QualifiedType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::QualifiedType * node ) {
         VISIT_START( node );
 
@@ -1662 +1738 @@
 //--------------------------------------------------------------------------
 // FunctionType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::FunctionType * node ) {
-        VISIT_START( node );
-
-        VISIT(
-                maybe_accept( node, &FunctionType::forall  );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::FunctionType * node ) {
+        VISIT_START( node );
+
+        VISIT({
+                // guard_forall_subs forall_guard { *this, node };
+                // mutate_forall( node );
+                maybe_accept( node, &FunctionType::assertions );
                 maybe_accept( node, &FunctionType::returns );
                 maybe_accept( node, &FunctionType::params  );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1677 +1755 @@
 //--------------------------------------------------------------------------
 // StructInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::StructInstType * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addStruct( pass, 0, node->name );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::StructInstType * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addStruct( core, 0, node->name );
 
         VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &StructInstType::forall );
                 maybe_accept( node, &StructInstType::params );
         })
@@ -1694 +1771 @@
 //--------------------------------------------------------------------------
 // UnionInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::UnionInstType * node ) {
-        VISIT_START( node );
-
-        __pass::symtab::addStruct( pass, 0, node->name );
-
-        {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::UnionInstType * node ) {
+        VISIT_START( node );
+
+        __pass::symtab::addUnion( core, 0, node->name );
+
+        VISIT({
                 guard_symtab guard { *this };
-                maybe_accept( node, &UnionInstType::forall );
                 maybe_accept( node, &UnionInstType::params );
-        }
+        })
 
         VISIT_END( Type, node );
@@ -1711 +1787 @@
 //--------------------------------------------------------------------------
 // EnumInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::EnumInstType * node ) {
-        VISIT_START( node );
-
-        VISIT(
-                maybe_accept( node, &EnumInstType::forall );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::EnumInstType * node ) {
+        VISIT_START( node );
+
+        VISIT({
                 maybe_accept( node, &EnumInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1725 +1800 @@
 //--------------------------------------------------------------------------
 // TraitInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TraitInstType * node ) {
-        VISIT_START( node );
-
-        VISIT(
-                maybe_accept( node, &TraitInstType::forall );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TraitInstType * node ) {
+        VISIT_START( node );
+
+        VISIT({
                 maybe_accept( node, &TraitInstType::params );
-        )
+        })
 
         VISIT_END( Type, node );
@@ -1739 +1813 @@
 //--------------------------------------------------------------------------
 // TypeInstType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeInstType * node ) {
-        VISIT_START( node );
-
-        VISIT(
-                maybe_accept( node, &TypeInstType::forall );
-                maybe_accept( node, &TypeInstType::params );
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TypeInstType * node ) {
+        VISIT_START( node );
+
+        VISIT(
+                {
+                        maybe_accept( node, &TypeInstType::params );
+                }
+                // ensure that base re-bound if doing substitution
+                __pass::forall::replace( core, 0, node );
         )
 
@@ -1753 +1830 @@
 //--------------------------------------------------------------------------
 // TupleType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TupleType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TupleType * node ) {
         VISIT_START( node );
 
@@ -1767 +1844 @@
 //--------------------------------------------------------------------------
 // TypeofType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::TypeofType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::TypeofType * node ) {
         VISIT_START( node );
 
@@ -1780 +1857 @@
 //--------------------------------------------------------------------------
 // VarArgsType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::VarArgsType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::VarArgsType * node ) {
         VISIT_START( node );
 
@@ -1789 +1866 @@
 //--------------------------------------------------------------------------
 // ZeroType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::ZeroType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::ZeroType * node ) {
         VISIT_START( node );
 
@@ -1798 +1875 @@
 //--------------------------------------------------------------------------
 // OneType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::OneType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::OneType * node ) {
         VISIT_START( node );
 
@@ -1807 +1884 @@
 //--------------------------------------------------------------------------
 // GlobalScopeType
-template< typename pass_t >
-const ast::Type * ast::Pass< pass_t >::visit( const ast::GlobalScopeType * node ) {
+template< typename core_t >
+const ast::Type * ast::Pass< core_t >::visit( const ast::GlobalScopeType * node ) {
         VISIT_START( node );
 
@@ -1817 +1894 @@
 //--------------------------------------------------------------------------
 // Designation
-template< typename pass_t >
-const ast::Designation * ast::Pass< pass_t >::visit( const ast::Designation * node ) {
+template< typename core_t >
+const ast::Designation * ast::Pass< core_t >::visit( const ast::Designation * node ) {
         VISIT_START( node );
 
@@ -1828 +1905 @@
 //--------------------------------------------------------------------------
 // SingleInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::SingleInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::SingleInit * node ) {
         VISIT_START( node );
 
@@ -1841 +1918 @@
 //--------------------------------------------------------------------------
 // ListInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::ListInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::ListInit * node ) {
         VISIT_START( node );
 
@@ -1855 +1932 @@
 //--------------------------------------------------------------------------
 // ConstructorInit
-template< typename pass_t >
-const ast::Init * ast::Pass< pass_t >::visit( const ast::ConstructorInit * node ) {
+template< typename core_t >
+const ast::Init * ast::Pass< core_t >::visit( const ast::ConstructorInit * node ) {
         VISIT_START( node );
 
@@ -1870 +1947 @@
 //--------------------------------------------------------------------------
 // Attribute
-template< typename pass_t >
-const ast::Attribute * ast::Pass< pass_t >::visit( const ast::Attribute * node  )  {
+template< typename core_t >
+const ast::Attribute * ast::Pass< core_t >::visit( const ast::Attribute * node  )  {
         VISIT_START( node );
 
@@ -1883 +1960 @@
 //--------------------------------------------------------------------------
 // TypeSubstitution
-template< typename pass_t >
-const ast::TypeSubstitution * ast::Pass< pass_t >::visit( const ast::TypeSubstitution * node ) {
+template< typename core_t >
+const ast::TypeSubstitution * ast::Pass< core_t >::visit( const ast::TypeSubstitution * node ) {
         VISIT_START( node );
 
@@ -1890 +1967 @@
                 {
                         bool mutated = false;
-                        std::unordered_map< std::string, ast::ptr< ast::Type > > new_map;
+                        std::unordered_map< ast::TypeInstType::TypeEnvKey, ast::ptr< ast::Type > > new_map;
                         for ( const auto & p : node->typeEnv ) {
                                 guard_symtab guard { *this };
                                 auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = false;
+                                if (new_node != p.second) mutated = true;
                                 new_map.insert({ p.first, new_node });
                         }
                         if (mutated) {
-                                auto new_node = mutate( node );
+                                auto new_node = __pass::mutate<core_t>( node );
                                 new_node->typeEnv.swap( new_map );
                                 node = new_node;
                         }
                 }
-
-                {
-                        bool mutated = false;
-                        std::unordered_map< std::string, ast::ptr< ast::Expr > > new_map;
-                        for ( const auto & p : node->varEnv ) {
-                                guard_symtab guard { *this };
-                                auto new_node = p.second->accept( *this );
-                                if (new_node != p.second) mutated = false;
-                                new_map.insert({ p.first, new_node });
-                        }
-                        if (mutated) {
-                                auto new_node = mutate( node );
-                                new_node->varEnv.swap( new_map );
-                                node = new_node;
-                        }
-                }
         )
 

src/AST/Pass.proto.hpp

@@ -17 +17 @@
 // IWYU pragma: private, include "Pass.hpp"
 
+#include "Common/Stats/Heap.h"
+
 namespace ast {
-template<typename pass_type>
+template<typename core_t>
 class Pass;
+
+struct TranslationUnit;
+
+struct PureVisitor;
 
 namespace __pass {
@@ -82 +88 @@
                 };
 
-                std::stack< cleanup_t > cleanups;
+                std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
         };
 
@@ -111 +117 @@
         /// "Short hand" to check if this is a valid previsit function
         /// Mostly used to make the static_assert look (and print) prettier
-        template<typename pass_t, typename node_t>
+        template<typename core_t, typename node_t>
         struct is_valid_previsit {
-                using ret_t = decltype( ((pass_t*)nullptr)->previsit( (const node_t *)nullptr ) );
+                using ret_t = decltype( ((core_t*)nullptr)->previsit( (const node_t *)nullptr ) );
 
                 static constexpr bool value = std::is_void< ret_t >::value ||
@@ -127 +133 @@
         template<>
         struct __assign<true> {
-                template<typename pass_t, typename node_t>
-                static inline void result( pass_t & pass, const node_t * & node ) {
-                        pass.previsit( node );
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        core.previsit( node );
                 }
         };
@@ -135 +141 @@
         template<>
         struct __assign<false> {
-                template<typename pass_t, typename node_t>
-                static inline void result( pass_t & pass, const node_t * & node ) {
-                        node = pass.previsit( node );
+                template<typename core_t, typename node_t>
+                static inline void result( core_t & core, const node_t * & node ) {
+                        node = core.previsit( node );
                         assertf(node, "Previsit must not return NULL");
                 }
@@ -150 +156 @@
         template<>
         struct __return<true> {
-                template<typename pass_t, typename node_t>
-                static inline const node_t * result( pass_t & pass, const node_t * & node ) {
-                        pass.postvisit( node );
+                template<typename core_t, typename node_t>
+                static inline const node_t * result( core_t & core, const node_t * & node ) {
+                        core.postvisit( node );
                         return node;
                 }
@@ -159 +165 @@
         template<>
         struct __return<false> {
-                template<typename pass_t, typename node_t>
-                static inline auto result( pass_t & pass, const node_t * & node ) {
-                        return pass.postvisit( node );
+                template<typename core_t, typename node_t>
+                static inline auto result( core_t & core, const node_t * & node ) {
+                        return core.postvisit( node );
                 }
         };
@@ -180 +186 @@
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         // PreVisit : may mutate the pointer passed in if the node is mutated in the previsit call
-        template<typename pass_t, typename node_t>
-        static inline auto previsit( pass_t & pass, const node_t * & node, int ) -> decltype( pass.previsit( node ), void() ) {
+        template<typename core_t, typename node_t>
+        static inline auto previsit( core_t & core, const node_t * & node, int ) -> decltype( core.previsit( node ), void() ) {
                 static_assert(
-                        is_valid_previsit<pass_t, node_t>::value,
+                        is_valid_previsit<core_t, node_t>::value,
                         "Previsit may not change the type of the node. It must return its paremeter or void."
                 );
@@ -189 +195 @@
                 __assign<
                         std::is_void<
-                                decltype( pass.previsit( node ) )
+                                decltype( core.previsit( node ) )
                         >::value
-                >::result( pass, node );
-        }
-
-        template<typename pass_t, typename node_t>
-        static inline auto previsit( pass_t &, const node_t *, long ) {}
+                >::result( core, node );
+        }
+
+        template<typename core_t, typename node_t>
+        static inline auto previsit( core_t &, const node_t *, long ) {}
 
         // PostVisit : never mutates the passed pointer but may return a different node
-        template<typename pass_t, typename node_t>
-        static inline auto postvisit( pass_t & pass, const node_t * node, int ) ->
-                decltype( pass.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
+        template<typename core_t, typename node_t>
+        static inline auto postvisit( core_t & core, const node_t * node, int ) ->
+                decltype( core.postvisit( node ), node->accept( *(Visitor*)nullptr ) )
         {
                 return __return<
                         std::is_void<
-                                decltype( pass.postvisit( node ) )
+                                decltype( core.postvisit( node ) )
                         >::value
-                >::result( pass, node );
-        }
-
-        template<typename pass_t, typename node_t>
-        static inline const node_t * postvisit( pass_t &, const node_t * node, long ) { return node; }
+                >::result( core, node );
+        }
+
+        template<typename core_t, typename node_t>
+        static inline const node_t * postvisit( core_t &, const node_t * node, long ) { return node; }
 
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
@@ -225 +231 @@
         // The type is not strictly enforced but does match the accessory
         #define FIELD_PTR( name, default_type ) \
-        template< typename pass_t > \
-        static inline auto name( pass_t & pass, int ) -> decltype( &pass.name ) { return &pass.name; } \
+        template< typename core_t > \
+        static inline auto name( core_t & core, int ) -> decltype( &core.name ) { return &core.name; } \
         \
-        template< typename pass_t > \
-        static inline default_type * name( pass_t &, long ) { return nullptr; }
+        template< typename core_t > \
+        static inline default_type * name( core_t &, long ) { return nullptr; }
 
         // List of fields and their expected types
-        FIELD_PTR( env, const ast::TypeSubstitution * )
+        FIELD_PTR( typeSubs, const ast::TypeSubstitution * )
         FIELD_PTR( stmtsToAddBefore, std::list< ast::ptr< ast::Stmt > > )
         FIELD_PTR( stmtsToAddAfter , std::list< ast::ptr< ast::Stmt > > )
@@ -239 +245 @@
         FIELD_PTR( visit_children, __pass::bool_ref )
         FIELD_PTR( at_cleanup, __pass::at_cleanup_t )
-        FIELD_PTR( visitor, ast::Pass<pass_t> * const )
+        FIELD_PTR( visitor, ast::Pass<core_t> * const )
 
         // Remove the macro to make sure we don't clash
         #undef FIELD_PTR
+
+        template< typename core_t >
+        static inline auto beginTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_push(core_t::traceId);
+        }
+
+        template< typename core_t >
+        static inline auto endTrace(core_t &, int) -> decltype( core_t::traceId, void() ) {
+                // Stats::Heap::stacktrace_pop();
+        }
+
+        template< typename core_t >
+        static void beginTrace(core_t &, long) {}
+
+        template< typename core_t >
+        static void endTrace(core_t &, long) {}
+
+        // Allows visitor to handle an error on top-level declarations, and possibly suppress the error.
+        // If onError() returns false, the error will be ignored. By default, it returns true.
+
+        template< typename core_t >
+        static bool on_error (core_t &, ptr<Decl> &, long) { return true; }
+
+        template< typename core_t >
+        static auto on_error (core_t & core, ptr<Decl> & decl, int) -> decltype(core.on_error(decl)) {
+                return core.on_error(decl);
+        }
 
         // Another feature of the templated visitor is that it calls beginScope()/endScope() for compound statement.
@@ -248 +281 @@
         // detect it using the same strategy
         namespace scope {
-                template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.beginScope(), void() ) {
-                        pass.beginScope();
-                }
-
-                template<typename pass_t>
-                static inline void enter( pass_t &, long ) {}
-
-                template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.endScope(), void() ) {
-                        pass.endScope();
-                }
-
-                template<typename pass_t>
-                static inline void leave( pass_t &, long ) {}
-        };
-
-        // Finally certain pass desire an up to date symbol table automatically
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.beginScope(), void() ) {
+                        core.beginScope();
+                }
+
+                template<typename core_t>
+                static inline void enter( core_t &, long ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.endScope(), void() ) {
+                        core.endScope();
+                }
+
+                template<typename core_t>
+                static inline void leave( core_t &, long ) {}
+        } // namespace scope
+
+        // Certain passes desire an up to date symbol table automatically
         // detect the presence of a member name `symtab` and call all the members appropriately
         namespace symtab {
                 // Some simple scoping rules
-                template<typename pass_t>
-                static inline auto enter( pass_t & pass, int ) -> decltype( pass.symtab.enterScope(), void() ) {
-                        pass.symtab.enterScope();
-                }
-
-                template<typename pass_t>
-                static inline auto enter( pass_t &, long ) {}
-
-                template<typename pass_t>
-                static inline auto leave( pass_t & pass, int ) -> decltype( pass.symtab.leaveScope(), void() ) {
-                        pass.symtab.leaveScope();
-                }
-
-                template<typename pass_t>
-                static inline auto leave( pass_t &, long ) {}
+                template<typename core_t>
+                static inline auto enter( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.enterScope();
+                }
+
+                template<typename core_t>
+                static inline auto enter( core_t &, long ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int ) -> decltype( core.symtab, void() ) {
+                        core.symtab.leaveScope();
+                }
+
+                template<typename core_t>
+                static inline auto leave( core_t &, long ) {}
 
                 // The symbol table has 2 kind of functions mostly, 1 argument and 2 arguments
                 // Create macro to condense these common patterns
                 #define SYMTAB_FUNC1( func, type ) \
-                template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type arg ) -> decltype( pass.symtab.func( arg ), void() ) {\
-                        pass.symtab.func( arg ); \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type arg ) -> decltype( core.symtab.func( arg ), void() ) {\
+                        core.symtab.func( arg ); \
                 } \
                 \
-                template<typename pass_t> \
-                static inline void func( pass_t &, long, type ) {}
+                template<typename core_t> \
+                static inline void func( core_t &, long, type ) {}
 
                 #define SYMTAB_FUNC2( func, type1, type2 ) \
-                template<typename pass_t> \
-                static inline auto func( pass_t & pass, int, type1 arg1, type2 arg2 ) -> decltype( pass.symtab.func( arg1, arg2 ), void () ) {\
-                        pass.symtab.func( arg1, arg2 ); \
+                template<typename core_t> \
+                static inline auto func( core_t & core, int, type1 arg1, type2 arg2 ) -> decltype( core.symtab.func( arg1, arg2 ), void () ) {\
+                        core.symtab.func( arg1, arg2 ); \
                 } \
                         \
-                template<typename pass_t> \
-                static inline void func( pass_t &, long, type1, type2 ) {}
+                template<typename core_t> \
+                static inline void func( core_t &, long, type1, type2 ) {}
 
                 SYMTAB_FUNC1( addId     , const DeclWithType *  );
@@ -311 +344 @@
                 SYMTAB_FUNC1( addUnion  , const UnionDecl *     );
                 SYMTAB_FUNC1( addTrait  , const TraitDecl *     );
-                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Node * );
+                SYMTAB_FUNC2( addWith   , const std::vector< ptr<Expr> > &, const Decl * );
 
                 // A few extra functions have more complicated behaviour, they are hand written
-                template<typename pass_t>
-                static inline auto addStructFwd( pass_t & pass, int, const ast::StructDecl * decl ) -> decltype( pass.symtab.addStruct( decl ), void() ) {
+                template<typename core_t>
+                static inline auto addStructFwd( core_t & core, int, const ast::StructDecl * decl ) -> decltype( core.symtab.addStruct( decl ), void() ) {
                         ast::StructDecl * fwd = new ast::StructDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.symtab.addStruct( fwd );
-                }
-
-                template<typename pass_t>
-                static inline void addStructFwd( pass_t &, long, const ast::StructDecl * ) {}
-
-                template<typename pass_t>
-                static inline auto addUnionFwd( pass_t & pass, int, const ast::UnionDecl * decl ) -> decltype( pass.symtab.addUnion( decl ), void() ) {
+                        core.symtab.addStruct( fwd );
+                }
+
+                template<typename core_t>
+                static inline void addStructFwd( core_t &, long, const ast::StructDecl * ) {}
+
+                template<typename core_t>
+                static inline auto addUnionFwd( core_t & core, int, const ast::UnionDecl * decl ) -> decltype( core.symtab.addUnion( decl ), void() ) {
                         UnionDecl * fwd = new UnionDecl( decl->location, decl->name );
                         fwd->params = decl->params;
-                        pass.symtab.addUnion( fwd );
-                }
-
-                template<typename pass_t>
-                static inline void addUnionFwd( pass_t &, long, const ast::UnionDecl * ) {}
-
-                template<typename pass_t>
-                static inline auto addStruct( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addStruct( str ), void() ) {
-                        if ( ! pass.symtab.lookupStruct( str ) ) {
-                                pass.symtab.addStruct( str );
+                        core.symtab.addUnion( fwd );
+                }
+
+                template<typename core_t>
+                static inline void addUnionFwd( core_t &, long, const ast::UnionDecl * ) {}
+
+                template<typename core_t>
+                static inline auto addStruct( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addStruct( str ), void() ) {
+                        if ( ! core.symtab.lookupStruct( str ) ) {
+                                core.symtab.addStruct( str );
                         }
                 }
 
-                template<typename pass_t>
-                static inline void addStruct( pass_t &, long, const std::string & ) {}
-
-                template<typename pass_t>
-                static inline auto addUnion( pass_t & pass, int, const std::string & str ) -> decltype( pass.symtab.addUnion( str ), void() ) {
-                        if ( ! pass.symtab.lookupUnion( str ) ) {
-                                pass.symtab.addUnion( str );
+                template<typename core_t>
+                static inline void addStruct( core_t &, long, const std::string & ) {}
+
+                template<typename core_t>
+                static inline auto addUnion( core_t & core, int, const std::string & str ) -> decltype( core.symtab.addUnion( str ), void() ) {
+                        if ( ! core.symtab.lookupUnion( str ) ) {
+                                core.symtab.addUnion( str );
                         }
                 }
 
-                template<typename pass_t>
-                static inline void addUnion( pass_t &, long, const std::string & ) {}
+                template<typename core_t>
+                static inline void addUnion( core_t &, long, const std::string & ) {}
 
                 #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 core_t>
+                static inline auto enter( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) core.subs.beginScope();
+                }
+
+                template<typename core_t>
+                static inline auto enter( core_t &, long, const ast::FunctionType * ) {}
+
+                template<typename core_t>
+                static inline auto leave( core_t & core, int, const ast::FunctionType * type )
+                -> decltype( core.subs, void() ) {
+                        if ( ! type->forall.empty() ) { core.subs.endScope(); }
+                }
+
+                template<typename core_t>
+                static inline auto leave( core_t &, long, const ast::FunctionType * ) {}
+
+                // Replaces a TypeInstType's base TypeDecl according to the table
+                template<typename core_t>
+                static inline auto replace( core_t & core, int, const ast::TypeInstType *& inst )
+                -> decltype( core.subs, void() ) {
+                        inst = ast::mutate_field(
+                                inst, &ast::TypeInstType::base, core.subs.replace( inst->base ) );
+                }
+
+                template<typename core_t>
+                static inline auto replace( core_t &, long, const ast::TypeInstType *& ) {}
+
+        } // namespace forall
+
+        template<typename core_t>
+        static inline auto get_result( core_t & core, char ) -> decltype( core.result() ) {
+                return core.result();
+        }
+
+        template<typename core_t>
+        static inline auto get_result( core_t & core, int ) -> decltype( core.result ) {
+                return core.result;
+        }
+
+        template<typename core_t>
+        static inline void get_result( core_t &, long ) {}
+} // namespace __pass
+} // namespace ast

src/AST/Print.cpp

@@ -21 +21 @@
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
+#include "CompilationState.h"
 
 #include "Common/utility.h" // for group_iterate
@@ -29 +30 @@
 
 template <typename C, typename... T>
-constexpr auto make_array(T&&... values) ->
-        array<C,sizeof...(T)>
+constexpr array<C,sizeof...(T)> make_array(T&&... values)
 {
         return array<C,sizeof...(T)>{
@@ -129 +129 @@
 
         void print( const ast::Expr::InferUnion & inferred, unsigned level = 0 ) {
-                switch ( inferred.mode ) {
-                case ast::Expr::InferUnion::Empty: return;
-                case ast::Expr::InferUnion::Slots: {
-                        os << indent << "with " << inferred.data.resnSlots.size()
+                if (inferred.data.resnSlots && !inferred.data.resnSlots->empty()) {
+                        os << indent << "with " << inferred.data.resnSlots->size()
                            << " pending inference slots" << endl;
-                        return;
-                }
-                case ast::Expr::InferUnion::Params: {
+                }
+                if (inferred.data.inferParams && !inferred.data.inferParams->empty()) {
                         os << indent << "with inferred parameters " << level << ":" << endl;
                         ++indent;
-                        for ( const auto & i : inferred.data.inferParams ) {
+                        for ( const auto & i : *inferred.data.inferParams ) {
                                 os << indent;
-                                short_print( Decl::fromId( i.second.decl ) );
+                                short_print( i.second.declptr );
                                 os << endl;
                                 print( i.second.expr->inferred, level+1 );
                         }
                         --indent;
-                        return;
-                }
-                }
-        }
-
-        void print( const ast::ParameterizedType::ForallList & forall ) {
+                }
+        }
+
+        void print( const ast::FunctionType::ForallList & forall ) {
                 if ( forall.empty() ) return;
                 os << "forall" << endl;
                 ++indent;
                 printAll( forall );
+                os << indent;
+                --indent;
+        }
+
+        void print( const ast::FunctionType::AssertionList & assts ) {
+                if (assts.empty()) return;
+                os << "with assertions" << endl;
+                ++indent;
+                printAll(assts);
                 os << indent;
                 --indent;
@@ -210 +214 @@
 
         void preprint( const ast::NamedTypeDecl * node ) {
-                if ( ! node->name.empty() ) os << node->name << ": ";
+                if ( ! node->name.empty() ) {
+                        os << node->name << ": ";
+                }
 
                 if ( ! short_mode && node->linkage != Linkage::Cforall ) {
@@ -226 +232 @@
                 }
 
-                if ( ! node->params.empty() ) {
-                        os << endl << indent << "... with parameters" << endl;
-                        ++indent;
-                        printAll( node->params );
-                        --indent;
-                }
-
-                if ( ! short_mode && ! node->assertions.empty() ) {
+                if ( ! node->assertions.empty() ) {
                         os << endl << indent << "... with assertions" << endl;
                         ++indent;
@@ -244 +243 @@
                 print( node->inferred );
 
+                if ( node->result ) {
+                        os << endl << indent << "... with resolved type:" << endl;
+                        ++indent;
+                        os << indent;
+                        node->result->accept( *this );
+                        --indent;
+                }
+
                 if ( node->env ) {
                         os << endl << indent << "... with environment:" << endl;
@@ -260 +267 @@
         }
 
-        void preprint( const ast::ParameterizedType * node ) {
+        void preprint( const ast::FunctionType * node ) {
                 print( node->forall );
+                print( node->assertions );
                 print( node->qualifiers );
         }
 
-        void preprint( const ast::ReferenceToType * node ) {
-                print( node->forall );
+        void preprint( const ast::BaseInstType * node ) {
                 print( node->attributes );
                 print( node->qualifiers );
@@ -678 +685 @@
         }
 
+        virtual const ast::Stmt * visit( const ast::SuspendStmt * node ) override final {
+                os << "Suspend Statement";
+                switch (node->type) {
+                        case ast::SuspendStmt::None     : os << " with implicit target"; break;
+                        case ast::SuspendStmt::Generator: os << " for generator"; break;
+                        case ast::SuspendStmt::Coroutine: os << " for coroutine"; break;
+                }
+                os << endl;
+
+                ++indent;
+                if(node->then) {
+                        os << indent << " with post statement :" << endl;
+                        safe_print( node->then );
+                }
+                ++indent;
+
+                return node;
+        }
+
         virtual const ast::Stmt * visit( const ast::WaitForStmt * node ) override final {
                 os << "Waitfor Statement" << endl;
@@ -823 +849 @@
         virtual const ast::Expr * visit( const ast::CastExpr * node ) override final {
                 ++indent;
-                os << (node->isGenerated ? "Generated" : "Explicit") << " cast of:" << endl << indent;
+                os << (node->isGenerated ? "Generated" : "Explicit") << " Cast of:" << endl << indent;
                 safe_print( node->arg );
                 os << endl << indent-1 << "... to:";
@@ -1358 +1384 @@
         virtual const ast::Type * visit( const ast::TypeInstType * node ) override final {
                 preprint( node );
-                os << "instance of type " << node->name
+                const auto & _name = deterministic_output && isUnboundType(node) ? "[unbound]" : node->typeString();
+                os << "instance of type " << _name
                    << " (" << (node->kind == ast::TypeDecl::Ftype ? "" : "not ") << "function type)";
                 print( node->params );
@@ -1484 +1511 @@
                 os << indent << "Types:" << endl;
                 for ( const auto& i : *node ) {
-                        os << indent+1 << i.first << " -> ";
+                        os << indent+1 << i.first.typeString() << " -> ";
                         indent += 2;
                         safe_print( i.second );
-                        indent -= 2;
-                        os << endl;
-                }
-                os << indent << "Non-types:" << endl;
-                for ( auto i = node->beginVar(); i != node->endVar(); ++i ) {
-                        os << indent+1 << i->first << " -> ";
-                        indent += 2;
-                        safe_print( i->second );
                         indent -= 2;
                         os << endl;

src/AST/Stmt.hpp

@@ -27 +27 @@
 
 // Must be included in *all* AST classes; should be #undef'd at the end of the file
-#define MUTATE_FRIEND template<typename node_t> friend node_t * mutate(const node_t * node);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
@@ -342 +344 @@
 };
 
+/// Suspend statement
+class SuspendStmt final : public Stmt {
+public:
+        ptr<CompoundStmt> then;
+        enum Type { None, Coroutine, Generator } type = None;
+
+        SuspendStmt( const CodeLocation & loc, const CompoundStmt * then, Type type, std::vector<Label> && labels = {} )
+        : Stmt(loc, std::move(labels)), then(then), type(type) {}
+
+        const Stmt * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SuspendStmt * clone() const override { return new SuspendStmt{ *this }; }
+        MUTATE_FRIEND
+};
+
 /// Wait for concurrency statement `when (...) waitfor (... , ...) ... timeout(...) ... else ...`
 class WaitForStmt final : public Stmt {
@@ -397 +414 @@
 class ImplicitCtorDtorStmt final : public Stmt {
 public:
-        readonly<Stmt> callStmt;
+        ptr<Stmt> callStmt;
 
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,

src/AST/SymbolTable.cpp

@@ -95 +95 @@
 }
 
+SymbolTable::SpecialFunctionKind SymbolTable::getSpecialFunctionKind(const std::string & name) {
+        if (name == "?{}") return CTOR;
+        if (name == "^?{}") return DTOR;
+        if (name == "?=?") return ASSIGN;
+        return NUMBER_OF_KINDS;
+}
+
 std::vector<SymbolTable::IdData> SymbolTable::lookupId( const std::string &id ) const {
+        static Stats::Counters::CounterGroup * name_lookup_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Name Lookup Stats");
+        static std::map<std::string, Stats::Counters::SimpleCounter *> lookups_by_name;
+        static std::map<std::string, Stats::Counters::SimpleCounter *> candidates_by_name;
+
+        SpecialFunctionKind kind = getSpecialFunctionKind(id);
+        if (kind != NUMBER_OF_KINDS) return specialLookupId(kind);
+
         ++*stats().lookup_calls;
         if ( ! idTable ) return {};
@@ -107 +121 @@
                 out.push_back( decl.second );
         }
+
+        if (Stats::Counters::enabled) {
+                if (! lookups_by_name.count(id)) {
+                        // leaks some strings, but it is because Counters do not hold them
+                        auto lookupCounterName = new std::string(id + "%count");
+                        auto candidatesCounterName = new std::string(id + "%candidate");
+                        lookups_by_name.emplace(id, new Stats::Counters::SimpleCounter(lookupCounterName->c_str(), name_lookup_stats));
+                        candidates_by_name.emplace(id, new Stats::Counters::SimpleCounter(candidatesCounterName->c_str(), name_lookup_stats));
+                }
+                (*lookups_by_name[id]) ++;
+                *candidates_by_name[id] += out.size();
+        }
+
+        return out;
+}
+
+std::vector<SymbolTable::IdData> SymbolTable::specialLookupId( SymbolTable::SpecialFunctionKind kind, const std::string & otypeKey ) const {
+        static Stats::Counters::CounterGroup * special_stats = Stats::Counters::build<Stats::Counters::CounterGroup>("Special Lookups");
+        static Stats::Counters::SimpleCounter * stat_counts[3] = {
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - count", special_stats),
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - count", special_stats),
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - count", special_stats)
+        };
+
+        static Stats::Counters::SimpleCounter * stat_candidates[3] = {
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("constructor - candidates", special_stats),
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("destructor - candidates", special_stats),
+                Stats::Counters::build<Stats::Counters::SimpleCounter>("assignment - candidates", special_stats)
+        };
+
+        static Stats::Counters::SimpleCounter * num_lookup_with_key 
+                = Stats::Counters::build<Stats::Counters::SimpleCounter>("keyed lookups", special_stats);
+        static Stats::Counters::SimpleCounter * num_lookup_without_key 
+                = Stats::Counters::build<Stats::Counters::SimpleCounter>("unkeyed lookups", special_stats);
+
+        assert (kind != NUMBER_OF_KINDS);
+        ++*stats().lookup_calls;
+        if ( ! specialFunctionTable[kind] ) return {};
+
+        std::vector<IdData> out;
+
+        if (otypeKey.empty()) { // returns everything
+                ++*num_lookup_without_key;
+                for (auto & table : *specialFunctionTable[kind]) {
+                        for (auto & decl : *table.second) {
+                                out.push_back(decl.second);
+                        }
+                }
+        }
+        else {
+                ++*num_lookup_with_key;
+                ++*stats().map_lookups;
+                auto decls = specialFunctionTable[kind]->find(otypeKey);
+                if (decls == specialFunctionTable[kind]->end()) return {};
+
+                for (auto decl : *(decls->second)) {
+                        out.push_back(decl.second);
+                }
+        }
+
+        ++*stat_counts[kind];
+        *stat_candidates[kind] += out.size();
+
         return out;
 }
@@ -313 +390 @@
                 if ( ! expr->result ) continue;
                 const Type * resTy = expr->result->stripReferences();
-                auto aggrType = dynamic_cast< const ReferenceToType * >( resTy );
+                auto aggrType = dynamic_cast< const BaseInstType * >( resTy );
                 assertf( aggrType, "WithStmt expr has non-aggregate type: %s",
                         toString( expr->result ).c_str() );
@@ -335 +412 @@
 }
 
-void SymbolTable::addFunctionType( const FunctionType * ftype ) {
-        addTypes( ftype->forall );
-        addIds( ftype->returns );
-        addIds( ftype->params );
-}
+
+void SymbolTable::addFunction( const FunctionDecl * func ) {
+        for (auto & td : func->type_params) {
+                addType(td);
+        }
+        for (auto & asst : func->assertions) {
+                addId(asst);
+        }
+        // addTypes( func->type->forall );
+        addIds( func->returns );
+        addIds( func->params );
+}
+
 
 void SymbolTable::lazyInitScope() {
@@ -364 +449 @@
 namespace {
         /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
-        std::string getOtypeKey( const FunctionDecl * function ) {
-                const auto & params = function->type->params;
+        std::string getOtypeKey( const FunctionType * ftype, bool stripParams = true ) {
+                const auto & params = ftype->params;
                 assert( ! params.empty() );
                 // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                const Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                const Type * base = InitTweak::getPointerBase( params.front() );
                 assert( base );
-                return Mangle::mangle( base );
+                if (stripParams) {
+                        if (dynamic_cast<const PointerType *>(base)) return Mangle::Encoding::pointer;
+                        return Mangle::mangle( base, Mangle::Type | Mangle::NoGenericParams );
+                }
+                else
+                        return Mangle::mangle( base );  
         }
 
@@ -378 +468 @@
                         const DeclWithType * decl, const std::string & otypeKey ) {
                 auto func = dynamic_cast< const FunctionDecl * >( decl );
-                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                if ( ! func || otypeKey != getOtypeKey( func->type, false ) ) return nullptr;
                 return func;
         }
@@ -403 +493 @@
         bool dataIsUserDefinedFunc = ! function->linkage.is_overrideable;
         bool dataIsCopyFunc = InitTweak::isCopyFunction( function );
-        std::string dataOtypeKey = getOtypeKey( function );
+        std::string dataOtypeKey = getOtypeKey( function->type, false ); // requires exact match to override autogen
 
         if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
@@ -575 +665 @@
                 const DeclWithType * decl, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
                 const Decl * deleter ) {
+        SpecialFunctionKind kind = getSpecialFunctionKind(decl->name);
+        if (kind == NUMBER_OF_KINDS) { // not a special decl
+                addId(decl, decl->name, idTable, handleConflicts, baseExpr, deleter);
+        }
+        else {
+                std::string key;
+                if (auto func = dynamic_cast<const FunctionDecl *>(decl)) {
+                        key = getOtypeKey(func->type);
+                }
+                else if (auto obj = dynamic_cast<const ObjectDecl *>(decl)) {
+                        key = getOtypeKey(obj->type.strict_as<PointerType>()->base.strict_as<FunctionType>());
+                }
+                else {
+                        assertf(false, "special decl with non-function type");
+                }
+                addId(decl, key, specialFunctionTable[kind], handleConflicts, baseExpr, deleter);
+        }
+}
+
+void SymbolTable::addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & table, SymbolTable::OnConflict handleConflicts, const Expr * baseExpr,
+                const Decl * deleter ) {
         ++*stats().add_calls;
         const std::string &name = decl->name;
@@ -605 +717 @@
         // ensure tables exist and add identifier
         MangleTable::Ptr mangleTable;
-        if ( ! idTable ) {
-                idTable = IdTable::new_ptr();
+        if ( ! table ) {
+                table = IdTable::new_ptr();
                 mangleTable = MangleTable::new_ptr();
         } else {
                 ++*stats().map_lookups;
-                auto decls = idTable->find( name );
-                if ( decls == idTable->end() ) {
+                auto decls = table->find( lookupKey );
+                if ( decls == table->end() ) {
                         mangleTable = MangleTable::new_ptr();
                 } else {
@@ -626 +738 @@
                                                 lazyInitScope();
                                                 *stats().map_mutations += 2;
-                                                idTable = idTable->set(
-                                                        name,
+                                                table = table->set(
+                                                        lookupKey,
                                                         mangleTable->set(
                                                                 mangleName,
@@ -642 +754 @@
         IdData data{ decl, baseExpr, deleter, scope };
         // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
-        if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+        if (table != idTable) { // adding to special table
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+        }
         *stats().map_mutations += 2;
-        idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
+        table = table->set( lookupKey, mangleTable->set( mangleName, std::move(data) ) );
 }
 
@@ -654 +768 @@
                         if ( dwt->name == "" ) {
                                 const Type * t = dwt->get_type()->stripReferences();
-                                if ( auto rty = dynamic_cast<const ReferenceToType *>( t ) ) {
+                                if ( auto rty = dynamic_cast<const BaseInstType *>( t ) ) {
                                         if ( ! dynamic_cast<const StructInstType *>(rty)
                                                 && ! dynamic_cast<const UnionInstType *>(rty) ) continue;

src/AST/SymbolTable.hpp

@@ -33 +33 @@
 class SymbolTable final : public std::enable_shared_from_this<ast::SymbolTable> {
 public:
+        /// special functions stored in dedicated tables, with different lookup keys
+        enum SpecialFunctionKind {CTOR, DTOR, ASSIGN, NUMBER_OF_KINDS};
+        static SpecialFunctionKind getSpecialFunctionKind(const std::string & name);
+
         /// Stored information about a declaration
         struct IdData {
@@ -77 +81 @@
         UnionTable::Ptr unionTable;    ///< union namespace
         TraitTable::Ptr traitTable;    ///< trait namespace
+        IdTable::Ptr specialFunctionTable[NUMBER_OF_KINDS];
+
+        // using SpecialFuncTable = PersistentMap< std::string, IdTable::Ptr >; // fname (ctor/dtor/assign) - otypekey
+        // SpecialFuncTable::Ptr specialFuncTable;
 
         using Ptr = std::shared_ptr<const SymbolTable>;
@@ -95 +103 @@
         /// Gets all declarations with the given ID
         std::vector<IdData> lookupId( const std::string &id ) const;
+        /// Gets special functions associated with a type; if no key is given, returns everything
+        std::vector<IdData> specialLookupId( SpecialFunctionKind kind, const std::string & otypeKey = "" ) const;
         /// Gets the top-most type declaration with the given ID
         const NamedTypeDecl * lookupType( const std::string &id ) const;
@@ -145 +155 @@
 
         /// convenience function for adding all of the declarations in a function type to the indexer
-        void addFunctionType( const FunctionType * ftype );
+        void addFunction( const FunctionDecl * );
 
 private:
@@ -186 +196 @@
                 const Decl * deleter = nullptr );
 
+        /// common code for addId when special decls are placed into separate tables
+        void addId(
+                const DeclWithType * decl, const std::string & lookupKey, IdTable::Ptr & idTable, OnConflict handleConflicts, 
+                const Expr * baseExpr = nullptr, const Decl * deleter = nullptr);
+        
         /// adds all of the members of the Aggregate (addWith helper)
         void addMembers( const AggregateDecl * aggr, const Expr * expr, OnConflict handleConflicts );

src/AST/Type.cpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Mon May 13 15:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sun Dec 15 16:56:28 2019
-// Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jul 23 14:16:00 2020
+// Update Count     : 5
 //
 
@@ -22 +22 @@
 #include "Decl.hpp"
 #include "Init.hpp"
+#include "Common/utility.h"      // for copy, move
 #include "InitTweak/InitTweak.h" // for getPointerBase
 #include "Tuples/Tuples.h"       // for isTtype
@@ -91 +92 @@
 
 // --- FunctionType
-
 namespace {
-        bool containsTtype( const std::vector<ptr<DeclWithType>> & l ) {
+        bool containsTtype( const std::vector<ptr<Type>> & l ) {
                 if ( ! l.empty() ) {
-                        return Tuples::isTtype( l.back()->get_type() );
+                        return Tuples::isTtype( l.back() );
                 }
                 return false;
@@ -105 +105 @@
 }
 
-// --- ReferenceToType
-std::vector<readonly<Decl>> ReferenceToType::lookup( const std::string& name ) const {
+std::vector<readonly<Decl>> BaseInstType::lookup( const std::string& name ) const {
         assertf( aggr(), "Must have aggregate to perform lookup" );
 
@@ -116 +115 @@
 }
 
-// --- StructInstType
+// --- SueInstType (StructInstType, UnionInstType, EnumInstType)
 
-StructInstType::StructInstType( const StructDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
+template<typename decl_t>
+SueInstType<decl_t>::SueInstType(
+        const decl_t * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
-bool StructInstType::isComplete() const { return base ? base->body : false; }
+template<typename decl_t>
+SueInstType<decl_t>::SueInstType(
+        const base_type * b, std::vector<ptr<Expr>> && params,
+        CV::Qualifiers q, std::vector<ptr<Attribute>> && as )
+: BaseInstType( b->name, std::move(params), q, std::move(as) ), base( b ) {}
 
-// --- UnionInstType
+template<typename decl_t>
+bool SueInstType<decl_t>::isComplete() const {
+        return base ? base->body : false;
+}
 
-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; }
-
-// --- EnumInstType
-
-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; }
+template class SueInstType<StructDecl>;
+template class SueInstType<UnionDecl>;
+template class SueInstType<EnumDecl>;
 
 // --- TraitInstType
 
-TraitInstType::TraitInstType( const TraitDecl * b, CV::Qualifiers q,
-        std::vector<ptr<Attribute>>&& as )
-: ReferenceToType( b->name, q, std::move(as) ), base( b ) {}
-
-// --- TypeInstType
+TraitInstType::TraitInstType(
+        const TraitDecl * b, CV::Qualifiers q, std::vector<ptr<Attribute>>&& as )
+: BaseInstType( b->name, q, move(as) ), base( b ) {}
 
 void TypeInstType::set_base( const TypeDecl * b ) {
@@ -158 +153 @@
 
 TupleType::TupleType( std::vector<ptr<Type>> && ts, CV::Qualifiers q )
-: Type( q ), types( std::move(ts) ), members() {
+: Type( q ), types( move(ts) ), members() {
         // This constructor is awkward. `TupleType` needs to contain objects so that members can be
         // named, but members without initializer nodes end up getting constructors, which breaks
@@ -173 +168 @@
         for ( const Type * ty : types ) {
                 members.emplace_back( new ObjectDecl{
-                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, MaybeConstruct ),
+                        CodeLocation{}, "", ty, new ListInit( CodeLocation{}, {}, {}, NoConstruct ),
                         Storage::Classes{}, Linkage::Cforall } );
         }
+}
+
+bool isUnboundType(const Type * type) {
+        if (auto typeInst = dynamic_cast<const TypeInstType *>(type)) {
+                // xxx - look for a type name produced by renameTyVars.
+
+                // TODO: once TypeInstType representation is updated, it should properly check
+                // if the context id is filled. this is a temporary hack for now
+                return typeInst->formal_usage > 0;
+        }
+        return false;
 }
 

src/AST/Type.hpp

@@ -9 +9 @@
 // Author           : Aaron B. Moss
 // Created On       : Thu May 9 10:00:00 2019
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Dec 11 21:56:46 2019
-// Update Count     : 5
+// Last Modified By : Andrew Beach
+// Last Modified On : Thu Jul 23 14:15:00 2020
+// Update Count     : 6
 //
 
@@ -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);
+#define MUTATE_FRIEND \
+    template<typename node_t> friend node_t * mutate(const node_t * node); \
+        template<typename node_t> friend node_t * shallowCopy(const node_t * node);
 
 namespace ast {
+
+template< typename T > class Pass;
 
 class Type : public Node {
@@ -44 +48 @@
         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; }
@@ -51 +54 @@
         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; }
@@ -163 +165 @@
         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) {}
 
@@ -263 +265 @@
 };
 
-/// Base type for potentially forall-qualified types
-class ParameterizedType : public Type {
-public:
-        using ForallList = std::vector<ptr<TypeDecl>>;
-
-        ForallList forall;
-
-        ParameterizedType( ForallList&& fs = {}, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
-        : Type(q, std::move(as)), forall(std::move(fs)) {}
-
-        ParameterizedType( CV::Qualifiers q, std::vector<ptr<Attribute>> && as = {} )
-        : Type(q, std::move(as)), forall() {}
-
-private:
-        virtual ParameterizedType * clone() const override = 0;
-        MUTATE_FRIEND
-};
-
 /// Function variable arguments flag
 enum ArgumentFlag { FixedArgs, VariableArgs };
 
 /// Type of a function `[R1, R2](*)(P1, P2, P3)`
-class FunctionType final : public ParameterizedType {
-public:
-        std::vector<ptr<DeclWithType>> returns;
-        std::vector<ptr<DeclWithType>> params;
+class FunctionType final : public Type {
+public:
+        using ForallList = std::vector<ptr<TypeInstType>>;
+        using AssertionList = std::vector<ptr<VariableExpr>>;
+        ForallList forall;
+        AssertionList assertions;
+
+        std::vector<ptr<Type>> returns;
+        std::vector<ptr<Type>> params;
 
         /// Does the function accept a variable number of arguments following the arguments specified
@@ -299 +287 @@
 
         FunctionType( ArgumentFlag va = FixedArgs, CV::Qualifiers q = {} )
-        : ParameterizedType(q), returns(), params(), isVarArgs(va) {}
+        : Type(q), returns(), params(), isVarArgs(va) {}
+
+        FunctionType( const FunctionType & o ) = default;
 
         /// true if either the parameters or return values contain a tttype
@@ -313 +303 @@
 
 /// base class for types that refer to types declared elsewhere (aggregates and typedefs)
-class ReferenceToType : public ParameterizedType {
+class BaseInstType : public Type {
 public:
         std::vector<ptr<Expr>> params;
@@ -319 +309 @@
         bool hoistType = false;
 
-        ReferenceToType( const std::string& n, CV::Qualifiers q = {},
-                std::vector<ptr<Attribute>> && as = {} )
-        : ParameterizedType(q, std::move(as)), params(), name(n) {}
+        BaseInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : Type(q, std::move(as)), params(), name(n) {}
+
+        BaseInstType(
+                const std::string& n, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : Type(q, std::move(as)), params(std::move(params)), name(n) {}
+
+        BaseInstType( const BaseInstType & o ) = default;
 
         /// Gets aggregate declaration this type refers to
@@ -329 +326 @@
 
 private:
-        virtual ReferenceToType * clone() const override = 0;
-        MUTATE_FRIEND
-};
-
-/// instance of struct type
-class StructInstType final : public ReferenceToType {
-public:
-        readonly<StructDecl> base;
-
-        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 = {} );
+        virtual BaseInstType * clone() const override = 0;
+        MUTATE_FRIEND
+};
+
+// Common implementation for the SUE instance types. Not to be used directly.
+template<typename decl_t>
+class SueInstType final : public BaseInstType {
+public:
+        using base_type = decl_t;
+        readonly<decl_t> base;
+
+        SueInstType(
+                const std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : BaseInstType( n, q, std::move(as) ), base() {}
+
+        SueInstType(
+                const base_type * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
+
+        SueInstType(
+                const base_type * b, std::vector<ptr<Expr>> && params,
+                CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         bool isComplete() const override;
 
-        const StructDecl * aggr() const override { return base; }
-
-        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        StructInstType * clone() const override { return new StructInstType{ *this }; }
-        MUTATE_FRIEND
-};
-
-/// instance of union type
-class UnionInstType final : public ReferenceToType {
-public:
-        readonly<UnionDecl> base;
-
-        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 = {} );
-
-        bool isComplete() const override;
-
-        const UnionDecl * aggr() const override { return base; }
-
-        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        UnionInstType * clone() const override { return new UnionInstType{ *this }; }
-        MUTATE_FRIEND
-};
-
-/// instance of enum type
-class EnumInstType final : public ReferenceToType {
-public:
-        readonly<EnumDecl> base;
-
-        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 = {} );
-
-        bool isComplete() const override;
-
-        const EnumDecl * aggr() const override { return base; }
-
-        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
-private:
-        EnumInstType * clone() const override { return new EnumInstType{ *this }; }
-        MUTATE_FRIEND
-};
-
-/// instance of trait type
-class TraitInstType final : public ReferenceToType {
+        const decl_t * aggr() const override { return base; }
+
+        const Type * accept( Visitor & v ) const override { return v.visit( this ); }
+private:
+        SueInstType<decl_t> * clone() const override { return new SueInstType<decl_t>{ *this }; }
+        MUTATE_FRIEND
+};
+
+/// An instance of a struct type.
+using StructInstType = SueInstType<StructDecl>;
+
+/// An instance of a union type.
+using UnionInstType = SueInstType<UnionDecl>;
+
+/// An instance of an enum type.
+using EnumInstType = SueInstType<EnumDecl>;
+
+/// An instance of a trait type.
+class TraitInstType final : public BaseInstType {
 public:
         readonly<TraitDecl> base;
 
-        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 std::string& n, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} )
+        : BaseInstType( n, q, std::move(as) ), base() {}
+
+        TraitInstType(
+                const TraitDecl * b, CV::Qualifiers q = {}, std::vector<ptr<Attribute>> && as = {} );
 
         // not meaningful for TraitInstType
@@ -419 +391 @@
 
 /// instance of named type alias (typedef or variable)
-class TypeInstType final : public ReferenceToType {
+class TypeInstType final : public BaseInstType {
 public:
         readonly<TypeDecl> base;
+        // previously from renameTyVars; now directly use integer fields instead of synthesized strings
+        // a nonzero value of formal_usage indicates a formal type (only used in function type)
+        // a zero value of formal_usage indicates an actual type (referenced inside body of parametric structs and functions)
         TypeDecl::Kind kind;
-
-        TypeInstType( const std::string& n, const TypeDecl * b, CV::Qualifiers q = {},
+        int formal_usage = 0;
+        int expr_id = 0;
+
+        // compact representation used for map lookups.
+        struct TypeEnvKey { 
+                const TypeDecl * base;
+                int formal_usage;
+                int expr_id;
+
+                TypeEnvKey() = default;
+                TypeEnvKey(const TypeDecl * base, int formal_usage = 0, int expr_id = 0): base(base), formal_usage(formal_usage), expr_id(expr_id) {}
+                TypeEnvKey(const TypeInstType & inst): base(inst.base), formal_usage(inst.formal_usage), expr_id(inst.expr_id) {}
+                std::string typeString() const { return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + base->name; }
+                bool operator==(const TypeEnvKey & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+
+        };
+
+        bool operator==(const TypeInstType & other) const { return base == other.base && formal_usage == other.formal_usage && expr_id == other.expr_id; }
+
+        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 ) {}
+        : BaseInstType( n, q, std::move(as) ), base( b ), kind( b->kind ) {}
         TypeInstType( const std::string& n, TypeDecl::Kind k, CV::Qualifiers q = {},
                 std::vector<ptr<Attribute>> && as = {} )
-        : ReferenceToType( n, q, std::move(as) ), base(), kind( k ) {}
+        : BaseInstType( n, q, std::move(as) ), base(), kind( k ) {}
+
+        TypeInstType( const TypeInstType & o ) = default;
+
+        TypeInstType( const TypeEnvKey & key )
+        : BaseInstType(key.base->name), base(key.base), kind(key.base->kind), formal_usage(key.formal_usage), expr_id(key.expr_id) {}
 
         /// sets `base`, updating `kind` correctly
@@ -440 +439 @@
 
         const Type * accept( Visitor & v ) const override { return v.visit( this ); }
+
+        std::string typeString() const { 
+                if (formal_usage > 0) return std::string("_") + std::to_string(formal_usage) + "_" + std::to_string(expr_id) + "_" + name; 
+                else return name;
+        }
 private:
         TypeInstType * clone() const override { return new TypeInstType{ *this }; }
@@ -531 +535 @@
 };
 
+bool isUnboundType(const Type * type);
+
+}
+
+namespace std {
+        template<>
+        struct hash<typename ast::TypeInstType::TypeEnvKey> {
+                size_t operator() (const ast::TypeInstType::TypeEnvKey & x) const {
+                        const size_t p = 1000007;
+                        size_t res = reinterpret_cast<size_t>(x.base);
+                        res = p * res + x.formal_usage;
+                        res = p * res + x.expr_id;
+                        return res;
+                } 
+        };
 }
 

src/AST/TypeEnvironment.cpp

@@ -34 +34 @@
 #include "ResolvExpr/Unify.h"      // for unifyInexact
 #include "Tuples/Tuples.h"         // for isTtype
+#include "CompilationState.h"
 
 using ResolvExpr::WidenMode;
@@ -51 +52 @@
         for ( const auto & i : open ) {
                 if ( first ) { first = false; } else { out << ' '; }
-                out << i.first << "(" << i.second << ")";
+                out << i.first.typeString() << "(" << i.second << ")";
         }
 }
 
 void print( std::ostream & out, const EqvClass & clz, Indenter indent ) {
-        out << "( ";
-        std::copy( clz.vars.begin(), clz.vars.end(), std::ostream_iterator< std::string >( out, " " ) );
+        out << "(";
+        bool first = true;
+        for(const auto & var : clz.vars) {
+                if(first) first = false;
+                else out << " ";
+
+                if( deterministic_output ) out << "[unbound]";
+                else out << "_" << var.formal_usage << "_" << var.expr_id << "_";
+
+                out << var.base->name;
+        }
         out << ")";
-        
+
         if ( clz.bound ) {
                 out << " -> ";
@@ -72 +82 @@
 }
 
-const EqvClass * TypeEnvironment::lookup( const std::string & var ) const {
+const EqvClass * TypeEnvironment::lookup( const TypeInstType::TypeEnvKey & var ) const {
         for ( ClassList::const_iterator i = env.begin(); i != env.end(); ++i ) {
                 if ( i->vars.find( var ) != i->vars.end() ) return &*i;
@@ -92 +102 @@
                                 }
                         }
-                        
+
                         i = next;  // go to next node even if this removed
                 }
@@ -98 +108 @@
 }
 
-void TypeEnvironment::add( const ParameterizedType::ForallList & tyDecls ) {
-        for ( const TypeDecl * tyDecl : tyDecls ) {
+void TypeEnvironment::add( const FunctionType::ForallList & tyDecls ) {
+        for ( auto & tyDecl : tyDecls ) {
                 env.emplace_back( tyDecl );
         }
@@ -112 +122 @@
 void TypeEnvironment::writeToSubstitution( TypeSubstitution & sub ) const {
         for ( const auto & clz : env ) {
-                std::string clzRep;
+                TypeInstType::TypeEnvKey clzRep;
+                bool first = true;
                 for ( const auto & var : clz.vars ) {
                         if ( clz.bound ) {
                                 sub.add( var, clz.bound );
-                        } else if ( clzRep.empty() ) {
+                        } else if ( first ) {
                                 clzRep = var;
+                                first = false;
                         } else {
-                                sub.add( var, new TypeInstType{ clzRep, clz.data.kind } );
+                                sub.add( var, new TypeInstType{ clzRep } );
                         }
                 }
@@ -134 +146 @@
         struct Occurs : public ast::WithVisitorRef<Occurs> {
                 bool result;
-                std::set< std::string > vars;
+                std::unordered_set< TypeInstType::TypeEnvKey > vars;
                 const TypeEnvironment & tenv;
 
-                Occurs( const std::string & var, const TypeEnvironment & env )
+                Occurs( const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env )
                 : result( false ), vars(), tenv( env ) {
                         if ( const EqvClass * clz = tenv.lookup( var ) ) {
@@ -147 +159 @@
 
                 void previsit( const TypeInstType * typeInst ) {
-                        if ( vars.count( typeInst->name ) ) {
+                        if ( vars.count( *typeInst ) ) {
                                 result = true;
-                        } else if ( const EqvClass * clz = tenv.lookup( typeInst->name ) ) {
+                        } else if ( const EqvClass * clz = tenv.lookup( *typeInst ) ) {
                                 if ( clz->bound ) {
                                         clz->bound->accept( *visitor );
@@ -158 +170 @@
 
         /// true if `var` occurs in `ty` under `env`
-        bool occurs( const Type * ty, const std::string & var, const TypeEnvironment & env ) {
+        bool occurs( const Type * ty, const TypeInstType::TypeEnvKey & var, const TypeEnvironment & env ) {
                 Pass<Occurs> occur{ var, env };
                 maybe_accept( ty, occur );
-                return occur.pass.result;
-        }
-}
-
-bool TypeEnvironment::combine( 
+                return occur.core.result;
+        }
+}
+
+bool TypeEnvironment::combine(
                 const TypeEnvironment & o, OpenVarSet & open, const SymbolTable & symtab ) {
         // short-circuit easy cases
@@ -199 +211 @@
                                 auto st = internal_lookup( *vt );
                                 if ( st == env.end() ) {
-                                        // unbound, safe to add if occurs 
+                                        // unbound, safe to add if occurs
                                         if ( r.bound && occurs( r.bound, *vt, *this ) ) return false;
                                         r.vars.emplace( *vt );
@@ -266 +278 @@
 }
 
-bool TypeEnvironment::bindVar( 
-                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen, 
-                const SymbolTable & symtab 
+bool TypeEnvironment::bindVar(
+                const TypeInstType * typeInst, const Type * bindTo, const TypeDecl::Data & data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, WidenMode widen,
+                const SymbolTable & symtab
 ) {
         // remove references from bound type, so that type variables can only bind to value types
         ptr<Type> target = bindTo->stripReferences();
-        auto tyvar = open.find( typeInst->name );
+        auto tyvar = open.find( *typeInst );
         assert( tyvar != open.end() );
         if ( ! tyVarCompatible( tyvar->second, target ) ) return false;
-        if ( occurs( target, typeInst->name, *this ) ) return false;
-
-        auto it = internal_lookup( typeInst->name );
+        if ( occurs( target, *typeInst, *this ) ) return false;
+
+        auto it = internal_lookup( *typeInst );
         if ( it != env.end() ) {
                 if ( it->bound ) {
@@ -286 +298 @@
                         ptr<Type> newType = it->bound;
                         reset_qualifiers( newType, typeInst->qualifiers );
-                        if ( unifyInexact( 
-                                        newType, target, *this, need, have, open, 
+                        if ( unifyInexact(
+                                        newType, target, *this, need, have, open,
                                         widen & WidenMode{ it->allowWidening, true }, symtab, common ) ) {
                                 if ( common ) {
@@ -300 +312 @@
                 }
         } else {
-                env.emplace_back( 
-                        typeInst->name, target, widen.first && widen.second, data );
+                env.emplace_back(
+                        *typeInst, target, widen.first && widen.second, data );
         }
         return true;
 }
 
-bool TypeEnvironment::bindVarToVar( 
-                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data, 
-                AssertionSet & need, AssertionSet & have, const OpenVarSet & open, 
-                WidenMode widen, const SymbolTable & symtab 
+bool TypeEnvironment::bindVarToVar(
+                const TypeInstType * var1, const TypeInstType * var2, TypeDecl::Data && data,
+                AssertionSet & need, AssertionSet & have, const OpenVarSet & open,
+                WidenMode widen, const SymbolTable & symtab
 ) {
-        auto c1 = internal_lookup( var1->name );
-        auto c2 = internal_lookup( var2->name );
-        
+        auto c1 = internal_lookup( *var1 );
+        auto c2 = internal_lookup( *var2 );
+
         // exit early if variables already bound together
         if ( c1 != env.end() && c1 == c2 ) {
@@ -326 +338 @@
         if ( c1 != env.end() ) {
                 if ( c1->bound ) {
-                        if ( occurs( c1->bound, var2->name, *this ) ) return false;
+                        if ( occurs( c1->bound, *var2, *this ) ) return false;
                         type1 = c1->bound;
                 }
@@ -333 +345 @@
         if ( c2 != env.end() ) {
                 if ( c2->bound ) {
-                        if ( occurs( c2->bound, var1->name, *this ) ) return false;
+                        if ( occurs( c2->bound, *var1, *this ) ) return false;
                         type2 = c2->bound;
                 }
@@ -371 +383 @@
         } else if ( c1 != env.end() ) {
                 // var2 unbound, add to env[c1]
-                c1->vars.emplace( var2->name );
+                c1->vars.emplace( *var2 );
                 c1->allowWidening = widen1;
                 c1->data.isComplete |= data.isComplete;
         } else if ( c2 != env.end() ) {
                 // var1 unbound, add to env[c2]
-                c2->vars.emplace( var1->name );
+                c2->vars.emplace( *var1 );
                 c2->allowWidening = widen2;
                 c2->data.isComplete |= data.isComplete;
         } else {
                 // neither var bound, create new class
-                env.emplace_back( var1->name, var2->name, widen1 && widen2, data );
+                env.emplace_back( *var1, *var2, widen1 && widen2, data );
         }
 
@@ -396 +408 @@
 }
 
-bool TypeEnvironment::mergeBound( 
+bool TypeEnvironment::mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
         if ( from.bound ) {
@@ -406 +418 @@
                         AssertionSet need, have;
 
-                        if ( unifyInexact( 
+                        if ( unifyInexact(
                                         toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
                                 // unifies, set common type if necessary
@@ -424 +436 @@
 }
 
-bool TypeEnvironment::mergeClasses( 
+bool TypeEnvironment::mergeClasses(
         ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
 ) {
@@ -445 +457 @@
 }
 
-TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const std::string & var ) {
+TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const TypeInstType::TypeEnvKey & var ) {
         for ( ClassList::iterator i = env.begin(); i != env.end(); ++i ) {
                 if ( i->vars.count( var ) ) return i;

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 {
-        bool operator()( const DeclWithType * d1, const DeclWithType * d2 ) const {
-                int cmp = d1->name.compare( d2->name );
-                return cmp < 0 || ( cmp == 0 && d1->get_type() < d2->get_type() );
+        bool operator()( const VariableExpr * d1, const VariableExpr * d2 ) const {
+                int cmp = d1->var->name.compare( d2->var->name );
+                return cmp < 0 || ( cmp == 0 && d1->result < d2->result );
         }
 };
@@ -70 +70 @@
 
 /// Set of assertions pending satisfaction
-using AssertionSet = std::map< readonly<DeclWithType>, AssertionSetValue, AssertCompare >;
+using AssertionSet = std::map< const VariableExpr *, AssertionSetValue, AssertCompare >;
 
 /// Set of open variables
-using OpenVarSet = std::unordered_map< std::string, TypeDecl::Data >;
+using OpenVarSet = std::unordered_map< TypeInstType::TypeEnvKey, TypeDecl::Data >;
 
 /// Merges one set of open vars into another
@@ -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 {
-        std::set< std::string > vars;
+        std::unordered_set< TypeInstType::TypeEnvKey > vars;
         ptr<Type> bound;
         bool allowWidening;
@@ -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 ) {}
 
         /// Singleton class constructor from TypeDecl
-        EqvClass( const TypeDecl * decl )
-        : vars{ decl->name }, bound(), allowWidening( true ), data( decl ) {}
+        EqvClass( const TypeInstType * inst )
+        : vars{ *inst }, bound(), allowWidening( true ), data( inst->base ) {}
 
         /// Singleton class constructor from substitution
-        EqvClass( const std::string & v, const Type * b )
+        EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b )
         : vars{ v }, bound( b ), allowWidening( false ), data( TypeDecl::Dtype, false ) {}
 
         /// Single-var constructor (strips qualifiers from bound type)
-        EqvClass( const std::string & v, const Type * b, bool w, const TypeDecl::Data & d )
+        EqvClass( const TypeInstType::TypeEnvKey & v, const Type * b, bool w, const TypeDecl::Data & d )
         : vars{ v }, bound( b ), allowWidening( w ), data( d ) {
                 reset_qualifiers( bound );
@@ -115 +115 @@
 
         /// Double-var constructor
-        EqvClass( const std::string & v, const std::string & u, bool w, const TypeDecl::Data & d )
+        EqvClass( const TypeInstType::TypeEnvKey & v, const TypeInstType::TypeEnvKey & u, bool w, const TypeDecl::Data & d )
         : vars{ v, u }, bound(), allowWidening( w ), data( d ) {}
 
@@ -131 +131 @@
 public:
         /// Finds the equivalence class containing a variable; nullptr for none such
-        const EqvClass * lookup( const std::string & var ) const;
+        const EqvClass * lookup( const TypeInstType::TypeEnvKey & var ) const;
 
         /// Add a new equivalence class for each type variable
-        void add( const ParameterizedType::ForallList & tyDecls );
+        void add( const FunctionType::ForallList & tyDecls );
 
         /// Add a new equivalence class for each branch of the substitution, checking for conflicts
@@ -142 +142 @@
         void writeToSubstitution( TypeSubstitution & sub ) const;
 
-        template< typename node_t, enum Node::ref_type ref_t >
-        int apply( ptr_base< node_t, ref_t > & type ) const {
+        template< typename node_t >
+        auto apply( node_t && type ) const {
                 TypeSubstitution sub;
                 writeToSubstitution( sub );
-                return sub.apply( type );
-        }
-
-        template< typename node_t, enum Node::ref_type ref_t >
-        int applyFree( ptr_base< node_t, ref_t > & type ) const {
+                return sub.apply( std::forward<node_t>(type) );
+        }
+
+        template< typename node_t >
+        auto applyFree( node_t && type ) const {
                 TypeSubstitution sub;
                 writeToSubstitution( sub );
-                return sub.applyFree( type );
+                return sub.applyFree( std::forward<node_t>(type) );
         }
 
@@ -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 );
 
         /// Private lookup API; returns array index of string, or env.size() for not found
-        ClassList::iterator internal_lookup( const std::string & );
+        ClassList::iterator internal_lookup( const TypeInstType::TypeEnvKey & );
 };
 

src/AST/TypeSubstitution.cpp

@@ -19 +19 @@
 namespace ast {
 
+
+// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
+
 TypeSubstitution::TypeSubstitution() {
 }
@@ -36 +39 @@
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
-        dest.varEnv.clear();
         dest.add( src );
 }
@@ -44 +46 @@
                 typeEnv[ i->first ] = i->second;
         } // for
-        for ( VarEnvType::const_iterator i = other.varEnv.begin(); i != other.varEnv.end(); ++i ) {
-                varEnv[ i->first ] = i->second;
-        } // for
 }
 
-void TypeSubstitution::add( std::string formalType, const Type *actualType ) {
-        typeEnv[ formalType ] = actualType;
+void TypeSubstitution::add( const TypeInstType * formalType, const Type *actualType ) {
+        typeEnv[ *formalType ] = actualType;
 }
 
-void TypeSubstitution::addVar( std::string formalExpr, const Expr *actualExpr ) {
-        varEnv[ formalExpr ] = actualExpr;
+void TypeSubstitution::add( const TypeInstType::TypeEnvKey & key, const Type * actualType) {
+        typeEnv[ key ] = actualType;
 }
 
-void TypeSubstitution::remove( std::string formalType ) {
-        TypeEnvType::iterator i = typeEnv.find( formalType );
+void TypeSubstitution::remove( const TypeInstType * formalType ) {
+        TypeEnvType::iterator i = typeEnv.find( *formalType );
         if ( i != typeEnv.end() ) {
-                typeEnv.erase( formalType );
+                typeEnv.erase( *formalType );
         } // if
 }
 
-const Type *TypeSubstitution::lookup( std::string formalType ) const {
-        TypeEnvType::const_iterator i = typeEnv.find( formalType );
+const Type *TypeSubstitution::lookup( const TypeInstType * formalType ) const {
+        TypeEnvType::const_iterator i = typeEnv.find( *formalType );
 
         // break on not in substitution set
@@ -72 +71 @@
         // attempt to transitively follow TypeInstType links.
         while ( const TypeInstType *actualType = i->second.as<TypeInstType>()) {
-                const std::string& typeName = actualType->name;
-
                 // break cycles in the transitive follow
-                if ( formalType == typeName ) break;
+                if ( *formalType == *actualType ) break;
 
                 // Look for the type this maps to, returning previous mapping if none-such
-                i = typeEnv.find( typeName );
+                i = typeEnv.find( *actualType );
                 if ( i == typeEnv.end() ) return actualType;
         }
@@ -87 +84 @@
 
 bool TypeSubstitution::empty() const {
-        return typeEnv.empty() && varEnv.empty();
+        return typeEnv.empty();
 }
 
 namespace {
         struct EnvTrimmer {
-                ptr<TypeSubstitution> env;
+                const TypeSubstitution * env;
                 TypeSubstitution * newEnv;
                 EnvTrimmer( const TypeSubstitution * env, TypeSubstitution * newEnv ) : env( env ), newEnv( newEnv ){}
-                void previsit( TypeDecl * tyDecl ) {
+                void previsit( FunctionType * ftype ) {
                         // transfer known bindings for seen type variables
-                        if ( const Type * t = env->lookup( tyDecl->name ) ) {
-                                newEnv->add( tyDecl->name, t );
+                        for (auto & formal : ftype->forall) {
+                                if ( const Type * t = env->lookup( formal ) ) {
+                                        newEnv->add( formal, t );
+                                }
                         }
                 }
@@ -108 +107 @@
         if ( env ) {
                 TypeSubstitution * newEnv = new TypeSubstitution();
-#if TIME_TO_CONVERT_PASSES
                 Pass<EnvTrimmer> trimmer( env, newEnv );
                 expr->accept( trimmer );
-#else
-                (void)expr;
-                (void)env;
-#endif
                 return newEnv;
         }
@@ -121 +115 @@
 
 void TypeSubstitution::normalize() {
-#if TIME_TO_CONVERT_PASSES
-        PassVisitor<Substituter> sub( *this, true );
+        Pass<Substituter> sub( *this, true );
         do {
-                sub.pass.subCount = 0;
-                sub.pass.freeOnly = true;
+                sub.core.subCount = 0;
+                sub.core.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                        i->second = i->second->acceptMutator( sub );
+                        i->second = i->second->accept( sub );
                 }
-        } while ( sub.pass.subCount );
-#endif
+        } while ( sub.core.subCount );
 }
 
-#if TIME_TO_CONVERT_PASSES
-
-Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
+const Type * TypeSubstitution::Substituter::postvisit( const TypeInstType *inst ) {
+        BoundVarsType::const_iterator bound = boundVars.find( *inst );
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->name );
+        TypeEnvType::const_iterator i = sub.typeEnv.find( *inst );
         if ( i == sub.typeEnv.end() ) {
                 return inst;
@@ -146 +136 @@
                 // Note: this does not prevent cycles in the general case, so it may be necessary to do something more sophisticated here.
                 // TODO: investigate preventing type variables from being bound to themselves in the first place.
-                if ( TypeInstType * replacement = i->second.as<TypeInstType>() ) {
-                        if ( inst->name == replacement->name ) {
+                if ( const TypeInstType * replacement = i->second.as<TypeInstType>() ) {
+                        if ( *inst == *replacement ) {
                                 return inst;
                         }
@@ -153 +143 @@
                 // std::cerr << "found " << inst->name << ", replacing with " << i->second << std::endl;
                 subCount++;
-                Type * newtype = i->second->clone();
-                newtype->get_qualifiers() |= inst->get_qualifiers();
-                delete inst;
-                // Note: need to recursively apply substitution to the new type because normalize does not substitute bound vars, but bound vars must be substituted when not in freeOnly mode.
-                return newtype->acceptMutator( *visitor );
+                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
 }
 
-Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
-        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
-        if ( i == sub.varEnv.end() ) {
-                return nameExpr;
-        } else {
-                subCount++;
-                delete nameExpr;
-                return i->second->clone();
-        } // if
-}
-
-void TypeSubstitution::Substituter::premutate( Type * type ) {
+void TypeSubstitution::Substituter::previsit( const FunctionType * ptype ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
+                for ( auto & tyvar : ptype->forall ) {
+                                boundVars.insert( *tyvar );
                 } // for
         } // if
 }
 
-template< typename TypeClass >
-void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
+/*
+void TypeSubstitution::Substituter::handleAggregateType( const BaseInstType * type ) {
         GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar)->name );
-                } // for
                 // bind type variables from generic type instantiations
-                std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
-                if ( baseParameters && ! type->parameters.empty() ) {
-                        for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
-                                boundVars.insert( (*tyvar)->name );
-                        } // for
-                } // if
+                if ( auto decl = type->aggr() ) {
+                        if ( ! type->params.empty() ) {
+                                for ( const TypeDecl * tyvar : decl->params ) {
+                                        boundVars.insert( *tyvar );
+                                } // for
+                        } // if
+                }
         } // if
 }
 
-void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
+void TypeSubstitution::Substituter::previsit( const StructInstType * aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
 
-void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
+void TypeSubstitution::Substituter::previsit( const UnionInstType *aggregateUseType ) {
         handleAggregateType( aggregateUseType );
 }
-
-#endif
+*/
 
 } // namespace ast

src/AST/TypeSubstitution.hpp

@@ -44 +44 @@
         TypeSubstitution &operator=( const TypeSubstitution &other );
 
-        template< typename SynTreeClass > int apply( const SynTreeClass *& input ) const;
-        template< typename SynTreeClass > int applyFree( const SynTreeClass *& input ) const;
+        template< typename SynTreeClass >
+        struct ApplyResult {
+                ast::ptr<SynTreeClass> node;
+                int count;
+        };
+
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> apply( const SynTreeClass * input ) const;
+        template< typename SynTreeClass > ApplyResult<SynTreeClass> applyFree( const SynTreeClass * input ) const;
 
         template< typename node_t, enum Node::ref_type ref_t >
         int apply( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = apply(p);
-                input = p;
-                return ret;
+                auto ret = apply(p);
+                input = ret.node;
+                return ret.count;
         }
 
@@ -58 +64 @@
         int applyFree( ptr_base< node_t, ref_t > & input ) const {
                 const node_t * p = input.get();
-                int ret = applyFree(p);
-                input = p;
-                return ret;
+                auto ret = applyFree(p);
+                input = ret.node;
+                return ret.count;
         }
 
-        void add( std::string formalType, const Type *actualType );
+        void add( const TypeInstType * formalType, const Type *actualType );
+        void add( const TypeInstType::TypeEnvKey & key, const Type *actualType );
         void add( const TypeSubstitution &other );
-        void remove( std::string formalType );
-        const Type *lookup( std::string formalType ) const;
+        void remove( const TypeInstType * formalType );
+        const Type *lookup( const TypeInstType * formalType ) const;
         bool empty() const;
-
-        void addVar( std::string formalExpr, const Expr *actualExpr );
 
         template< typename FormalIterator, typename ActualIterator >
@@ -92 +97 @@
         void initialize( const TypeSubstitution &src, TypeSubstitution &dest );
 
-        template<typename pass_type>
+        template<typename core_t>
         friend class Pass;
 
-        typedef std::unordered_map< std::string, ptr<Type> > TypeEnvType;
-        typedef std::unordered_map< std::string, ptr<Expr> > VarEnvType;
+        typedef std::unordered_map< TypeInstType::TypeEnvKey, ptr<Type> > TypeEnvType;
         TypeEnvType typeEnv;
-        VarEnvType varEnv;
 
   public:
@@ -107 +110 @@
         auto   end() const -> decltype( typeEnv.  end() ) { return typeEnv.  end(); }
 
-        auto beginVar()       -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar()       -> decltype( varEnv.  end() ) { return varEnv.  end(); }
-        auto beginVar() const -> decltype( varEnv.begin() ) { return varEnv.begin(); }
-        auto   endVar() const -> decltype( varEnv.  end() ) { return varEnv.  end(); }
 };
 
+// this is the only place where type parameters outside a function formal may be substituted.
 template< typename FormalIterator, typename ActualIterator >
 void TypeSubstitution::add( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
@@ -123 +123 @@
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
-                                        typeEnv[ formal->name ] = actual->type;
+                                        typeEnv[ formal ] = actual->type;
                                 } // if
                         } else {
@@ -129 +129 @@
                         } // if
                 } else {
-                        // TODO: type check the formal and actual parameters
-                        if ( (*formalIt)->name != "" ) {
-                                varEnv[ (*formalIt)->name ] = *actualIt;
-                        } // if
+                        
                 } // if
         } // for
 }
+
+
 
 template< typename FormalIterator, typename ActualIterator >
@@ -142 +141 @@
 }
 
+
 } // namespace ast
 
@@ -147 +147 @@
 // PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
 #include "Pass.hpp"
+#include "Copy.hpp"
 
 namespace ast {
 
 // definitition must happen after PassVisitor is included so that WithGuards can be used
-struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter> {
+struct TypeSubstitution::Substituter : public WithGuards, public WithVisitorRef<Substituter>, public PureVisitor {
+                static size_t traceId;
 
                 Substituter( const TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
 
-#if TIME_TO_CONVERT_PASSES
-
-                Type * postmutate( TypeInstType * aggregateUseType );
-                Expression * postmutate( NameExpr * nameExpr );
+                const Type * postvisit( const TypeInstType * aggregateUseType );
 
                 /// Records type variable bindings from forall-statements
-                void premutate( Type * type );
+                void previsit( const FunctionType * type );
                 /// Records type variable bindings from forall-statements and instantiations of generic types
-                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+                // void handleAggregateType( const BaseInstType * type );
 
-                void premutate( StructInstType * aggregateUseType );
-                void premutate( UnionInstType * aggregateUseType );
-
-#endif
+                // void previsit( const StructInstType * aggregateUseType );
+                // void previsit( const UnionInstType * aggregateUseType );
 
                 const TypeSubstitution & sub;
                 int subCount = 0;
                 bool freeOnly;
-                typedef std::unordered_set< std::string > BoundVarsType;
+                typedef std::unordered_set< TypeInstType::TypeEnvKey > BoundVarsType;
                 BoundVarsType boundVars;
 
@@ -179 +176 @@
 
 template< typename SynTreeClass >
-int TypeSubstitution::apply( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::apply( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, false );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.core.subCount };
 }
 
 template< typename SynTreeClass >
-int TypeSubstitution::applyFree( const SynTreeClass *& input ) const {
+TypeSubstitution::ApplyResult<SynTreeClass> TypeSubstitution::applyFree( const SynTreeClass * input ) const {
         assert( input );
         Pass<Substituter> sub( *this, true );
         input = strict_dynamic_cast< const SynTreeClass * >( input->accept( sub ) );
-///     std::cerr << "substitution result is: ";
-///     newType->print( std::cerr );
-///     std::cerr << std::endl;
-        return sub.pass.subCount;
+        return { input, sub.core.subCount };
 }
 

src/AST/Visitor.hpp

@@ -47 +47 @@
     virtual const ast::Stmt *             visit( const ast::CatchStmt            * ) = 0;
     virtual const ast::Stmt *             visit( const ast::FinallyStmt          * ) = 0;
+    virtual const ast::Stmt *             visit( const ast::SuspendStmt          * ) = 0;
     virtual const ast::Stmt *             visit( const ast::WaitForStmt          * ) = 0;
     virtual const ast::Decl *             visit( const ast::WithStmt             * ) = 0;

src/AST/module.mk

@@ -17 +17 @@
 SRC_AST = \
         AST/AssertAcyclic.cpp \
+        AST/AssertAcyclic.hpp \
         AST/Attribute.cpp \
+        AST/Attribute.hpp \
+        AST/Bitfield.hpp \
+        AST/Chain.hpp \
         AST/Convert.cpp \
+        AST/Convert.hpp \
+        AST/Copy.hpp \
+        AST/CVQualifiers.hpp \
         AST/Decl.cpp \
+        AST/Decl.hpp \
         AST/DeclReplacer.cpp \
+        AST/DeclReplacer.hpp \
+        AST/Eval.hpp \
         AST/Expr.cpp \
+        AST/Expr.hpp \
+        AST/FunctionSpec.hpp \
+        AST/Fwd.hpp \
         AST/GenericSubstitution.cpp \
+        AST/GenericSubstitution.hpp \
         AST/Init.cpp \
+        AST/Init.hpp \
+        AST/Label.hpp \
         AST/LinkageSpec.cpp \
+        AST/LinkageSpec.hpp \
         AST/Node.cpp \
+        AST/Node.hpp \
+        AST/ParseNode.hpp \
         AST/Pass.cpp \
+        AST/Pass.hpp \
+        AST/Pass.impl.hpp \
+        AST/Pass.proto.hpp \
         AST/Print.cpp \
+        AST/Print.hpp \
         AST/Stmt.cpp \
+        AST/Stmt.hpp \
+        AST/StorageClasses.hpp \
         AST/SymbolTable.cpp \
+        AST/SymbolTable.hpp \
+        AST/TranslationUnit.hpp \
         AST/Type.cpp \
+        AST/Type.hpp \
         AST/TypeEnvironment.cpp \
-        AST/TypeSubstitution.cpp
+        AST/TypeEnvironment.hpp \
+        AST/TypeSubstitution.cpp \
+        AST/TypeSubstitution.hpp \
+        AST/Visitor.hpp
 
 SRC += $(SRC_AST)

src/AST/porting.md

@@ -30 +30 @@
   * Base nodes now override `const Node * accept( Visitor & v ) const = 0` with, e.g. `const Stmt * accept( Visitor & v ) const override = 0`
 * `PassVisitor` is replaced with `ast::Pass`
+  * Most one shot uses can use `ast::Pass::run` and `ast::Pass::read`.
+
+`WithConstTypeSubstitution`
+* `env` => `typeSubs`
 
 ## Structural Changes ##
@@ -47 +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);
+    or equilant.
+* You should use the `mutate` function where possible as it avoids extra copies.
+  * If you must copy use `shallowCopy` or `deepCopy` as required.
 
 All leaves of the `Node` inheritance tree are now declared `final`
@@ -141 +150 @@
   * allows `newObject` as just default settings
 
+`FunctionDecl`
+* `params` and `returns` added.
+  * Contain the declarations of the parameters and return variables.
+  * Types should match (even be shared with) the fields of `type`.
+
 `NamedTypeDecl`
 * `parameters` => `params`
@@ -149 +163 @@
 `AggregateDecl`
 * `parameters` => `params`
+
+`StructDecl`
+* `makeInst` replaced by better constructor on `StructInstType`.
 
 `Expr`
@@ -240 +257 @@
 * **TODO** move `kind`, `typeNames` into code generator
 
-`ReferenceToType`
+`ReferenceToType` => `BaseInstType`
 * deleted `get_baseParameters()` from children
   * replace with `aggr() ? aggr()->params : nullptr`
@@ -256 +273 @@
 * `returnVals` => `returns`
 * `parameters` => `params`
+  * Both now just point at types.
 * `bool isVarArgs;` => `enum ArgumentFlag { FixedArgs, VariableArgs }; ArgumentFlag isVarArgs;`
+
+`SueInstType`
+* Template class, with specializations and using to implement some other types:
+  * `StructInstType`, `UnionInstType` & `EnumInstType`
 
 `TypeInstType`