Changeset 58fe85a for src

src/AST/Attribute.hpp

r3c64c668	r58fe85a
51	51	template<typename node_t>
52	52	friend node_t * mutate(const node_t * node);
	53	template<typename node_t>
	54	friend node_t * shallowCopy(const node_t * node);
53	55	};
54	56

src/AST/CVQualifiers.hpp

-              r3c64c668
+              r58fe85a
                 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
 …
                                 bool is_restrict : 1;
                                 bool is_volatile : 1;
-                                bool is_lvalue   : 1;
                                 bool is_mutex    : 1;
                                 bool is_atomic   : 1;

src/AST/Convert.cpp

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
 #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"
 …
 //================================================================================================
 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;
+}
 …
         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>
 …
+        }
+        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,
 …
                         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 ),
 …
                 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;
+                }
 …
         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 );
 …
                 );
                 if ( dtorStruct == node ) {
+                if ( ast::dtorStruct == node ) {
                         Validate::dtorStruct = decl;
+                }
 …
         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 );
 …
                 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 );
 …
+        }
+        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;
 …
                 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) );
+                }
 …
                 assert( tgtResnSlots.empty() );
                 if ( srcInferred.mode == ast::Expr::InferUnion::Params ) {
+                if ( srcInferred.data.inferParams ) {
                         const ast::InferredParams &srcParams = srcInferred.inferParams();
                         for (auto & srcParam : srcParams) {
 …
                                         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) {
 …
                 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);
+        }
 …
                         new KeywordCastExpr(
                                 get<Expression>().accept1(node->arg),
+                                castTarget
+                                castTarget,
+                                {node->concrete_target.field, node->concrete_target.getter}
+                        )
                 );
 …
         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 );
 …
                 auto expr = visitBaseExpr( node, rslt );
                 this->node = expr;
+                this->node = expr->clone();
                 return nullptr;
+        }
 …
                 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;
+                }
 …
         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;
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->name,
+                                node->typeString(),
                                 get<TypeDecl>().accept1( node->base ),
                                 get<Attribute>().acceptL( node->attributes )
 …
                         ty = new TypeInstType{
                                 cv( node ),
                                 node->name,
+                                node->typeString(),
                                 node->kind == ast::TypeDecl::Ftype,
                                 get<Attribute>().acceptL( node->attributes )
 …
 };
 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 ) );
+        }
 …
         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:
 …
                 auto it = cache.find( old );
                 if ( it == cache.end() ) return false;
                 node = it->second;
+                node = const_cast<ast::Node *>(it->second.get());
                 return true;
+        }
 …
         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);
 …
                 if ( Validate::dereferenceOperator == old ) {
                         dereferenceOperator = decl;
+                        ast::dereferenceOperator = decl;
+                }
                 if ( Validate::dtorStructDestroy == old ) {
                         dtorStructDestroy = decl;
+                        ast::dtorStructDestroy = decl;
+                }
+        }
 …
                 if ( Validate::dtorStruct == old ) {
                         dtorStruct = decl;
+                        ast::dtorStruct = decl;
+                }
+        }
 …
                 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;
 …
                 );
                 decl->assertions = GET_ACCEPT_V(assertions, DeclWithType);
-                decl->params     = GET_ACCEPT_V(parameters, TypeDecl);
                 decl->extension  = old->extension;
                 decl->uniqueId   = old->uniqueId;
 …
+        }
+        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;
 …
+        }
+        // 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();
 …
+                }
-                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;
+                */
+        }
 …
                 assert( oldInferParams.empty() || oldResnSlots.empty() );
                 assert( newInferred.mode == ast::Expr::InferUnion::Empty );
+                // assert( newInferred.mode == ast::Expr::InferUnion::Empty );
                 if ( !oldInferParams.empty() ) {
 …
                                 old->location,
                                 GET_ACCEPT_1(arg, Expr),
+                                castTarget
+                                castTarget,
+                                {old->concrete_target.field, old->concrete_target.getter}
+                        )
                 );
 …
                                 old->location,
                                 GET_ACCEPT_1(member, DeclWithType),
+                                GET_ACCEPT_1(aggregate, Expr)
+                                GET_ACCEPT_1(aggregate, Expr),
+                                ast::MemberExpr::NoOpConstructionChosen
+                        )
                 );
 …
                 // I believe this should always be a BasicType.
                 if ( Validate::SizeType == old ) {
                         sizeType = type;
+                        ast::sizeType = type;
+                }
                 visitType( old, type );
 …
                         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;
 …
                         old->location,
                         GET_ACCEPT_1(value, Expr),
                         (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
+                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::NoConstruct
                 );
+        }
 …
                         GET_ACCEPT_V(initializers, Init),
                         GET_ACCEPT_V(designations, Designation),
                         (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::DoConstruct
+                        (old->get_maybeConstructed()) ? ast::MaybeConstruct : ast::NoConstruct
                 );
+        }
 …
 #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

-              r3c64c668
+              r58fe85a
 #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

-              r3c64c668
+              r58fe85a
 // --- 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

-              r3c64c668
+              r58fe85a
 // 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 {
 …
         ptr<Expr> asmName;
         bool isDeleted = false;
+        bool isTypeFixed = false;
         DeclWithType( const CodeLocation& loc, const std::string& name, Storage::Classes storage,
 …
         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;
 …
         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 ); }
 …
 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; }
 …
 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
 …
         };
+        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;
 …
         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

-              r3c64c668
+              r58fe85a
                         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 *);
+                };
+        }
 …
                 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 );
+        }
 …
                         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

-              r3c64c668
+              r58fe85a
         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

-              r3c64c668
+              r58fe85a
 #include <vector>
+#include "Copy.hpp"                // for shallowCopy
+#include "Eval.hpp"                // for call
 #include "GenericSubstitution.hpp"
+#include "LinkageSpec.hpp"
 #include "Stmt.hpp"
 #include "Type.hpp"
 …
 #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
 …
+}
+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 );
 …
                         // base type
                         ret->result = base;
-                        add_qualifiers( ret->result, CV::Lvalue );
+                }
+        }
 …
+}
+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,
 …
+        }
         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;
+}
 …
 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 {
 …
                                         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 {
 …
 : 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();
+}
 …
         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;
+}
 …
 : 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
 …
         assert( t && i );
         result = t;
+        add_qualifiers( result, CV::Lvalue );
+}
+bool CompoundLiteralExpr::get_lvalue() const {
+        return true;
+}
 …
         // 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

-              r3c64c668
+              r58fe85a
 // 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;
 …
 struct ParamEntry {
         UniqueId decl;
         ptr<Decl> declptr;
+        readonly<Decl> declptr;
         ptr<Type> actualType;
         ptr<Type> formalType;
 …
 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);
+                        }
+                }
 …
                 /// 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;
+                }
 …
                 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");
 …
                 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");
 …
+                }
+                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;
+                }
 …
                 /// 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;
+                        }
+                }
         };
 …
         Expr * set_extension( bool ex ) { extension = ex; return this; }
+        virtual bool get_lvalue() const;
         virtual const Expr * accept( Visitor & v ) const override = 0;
 …
         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:
 …
         : 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 ); }
 …
 };
+/// 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 {
 …
 };
+/// 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 };
 …
         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:
 …
 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;
 …
         : 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:
 …
         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;
 };
 …
                 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.
 …
         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 ); }
 …
         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 ); }
 …
         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:
 …
         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 ); }
 …
         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

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
 class CatchStmt;
 class FinallyStmt;
+class SuspendStmt;
 class WaitForStmt;
 class WithStmt;
 …
 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;
 …
 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

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

src/AST/Init.hpp

-              r3c64c668
+              r58fe85a
 // 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 {
 …
 /// Flag for whether to construct from initialzier
 enum ConstructFlag { DoConstruct, MaybeConstruct };
+enum ConstructFlag { NoConstruct, MaybeConstruct };
 /// Object initializer base class
 …
         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 ) {}
 …
         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;
 …
         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

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
 #include "Fwd.hpp"
+#include <csignal>  // MEMORY DEBUG -- for raise
 #include <iostream>
 …
 #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 >
 …
 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

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
         Node& operator= (const Node&) = delete;
         Node& operator= (Node&&) = delete;
         virtual ~Node() = default;
+        virtual ~Node() {}
         virtual const Node * accept( Visitor & v ) const = 0;
 …
         bool unique() const { return strong_count == 1; }
+        bool isManaged() const {return strong_count > 0; }
 private:
 …
         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;
 …
+        }
         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;
 …
+                }
                 if(!strong_count && !weak_count) {
+                if( do_delete && !strong_count && !weak_count) {
                         delete this;
+                }
 …
         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();
 …
         // skip mutate if equivalent
         if ( node->*field == val ) return node;
         // mutate and return
         node_t * ret = mutate( node );
 …
         (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;
+}
 …
         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
 …
         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.
 …
         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

-              r3c64c668
+              r58fe85a
 //
 // 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 :
 …
 //
 // 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;
+                }
+        }
 …
         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
 …
         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;
 …
         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 >
 …
         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 );
 //-------------------------------------------------------------------------------------------------
 …
 //-------------------------------------------------------------------------------------------------
+/// 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;
 };
 …
         };
         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:
 …
 /// 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();
+        }
 };
 …
         SymbolTable symtab;
 };
+}
 …
 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

-              r3c64c668
+              r58fe85a
 #include <unordered_map>
+#include "AST/TranslationUnit.hpp"
 #include "AST/TypeSubstitution.hpp"
 …
         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... ) \
 …
 #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;
 …
 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
 …
+                }
+                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>
 …
+        }
         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 &&
 …
                         , 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");
 …
+        }
         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;
+                }
 …
+        }
         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  );
 …
+        }
         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 {};
 …
                 // 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.
 …
+        }
         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 {};
 …
+        }
         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
 …
                 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;
 …
 //------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 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;
 …
         // 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
 …
+                }
                 catch( SemanticErrorException &e ) {
+                        errors.append( e );
+                        if (__pass::on_error (visitor.core, *i, 0))
+                                errors.append( e );
+                }
 …
         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 );
+}
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
+        )
         __pass::symtab::addId( pass, 0, node );
+        __pass::symtab::addId( core, 0, node );
         VISIT_END( DeclWithType, node );
 …
 //--------------------------------------------------------------------------
 // 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 );)
 …
                 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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({
 …
         // this addition replaces the forward declaration
         __pass::symtab::addStruct( pass, 0, node );
+        __pass::symtab::addStruct( core, 0, node );
         VISIT_END( Decl, node );
 …
 //--------------------------------------------------------------------------
 // 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({
 …
         })
         __pass::symtab::addUnion( pass, 0, node );
+        __pass::symtab::addUnion( core, 0, node );
         VISIT_END( Decl, node );
 …
 //--------------------------------------------------------------------------
 // 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(
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
         })
         __pass::symtab::addTrait( pass, 0, node );
+        __pass::symtab::addTrait( core, 0, node );
         VISIT_END( Decl, node );
 …
 //--------------------------------------------------------------------------
 // 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   );
         })
 …
         // 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(
 …
 //--------------------------------------------------------------------------
 // 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 ); )
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
+}
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 )
 …
 //--------------------------------------------------------------------------
 // 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 )
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                 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 );
         })
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                 maybe_accept( node, &WhileStmt::inits );
                 maybe_accept( node, &WhileStmt::cond  );
                 maybe_accept( node, &WhileStmt::body  );
+                maybe_accept_as_compound( node, &WhileStmt::body  );
         })
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                 // 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  );
         })
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                 maybe_accept( node, &CatchStmt::decl );
                 maybe_accept( node, &CatchStmt::cond );
                 maybe_accept( node, &CatchStmt::body );
+                maybe_accept_as_compound( node, &CatchStmt::body );
         })
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
+// 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 ) {
 …
                 if(mutated) {
                         auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->clauses = std::move( new_clauses );
                         node = n;
 …
                         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; \
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                         // 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 );
+                }
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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  );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
                 if(mutated) {
                         auto n = mutate(node);
+                        auto n = __pass::mutate<core_t>(node);
                         n->associations = std::move( new_kids );
                         node = n;
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
         })
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
+        )
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
 //--------------------------------------------------------------------------
 // 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 );
 …
+                {
                         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

-              r3c64c668
+              r58fe85a
 // 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 {
 …
                 };
                 std::stack< cleanup_t > cleanups;
+                std::stack< cleanup_t, std::vector<cleanup_t> > cleanups;
         };
 …
         /// "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 ||
 …
         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 );
+                }
         };
 …
         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");
+                }
 …
         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;
+                }
 …
         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 );
+                }
         };
 …
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
         // 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."
                 );
 …
                 __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; }
         //-------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 …
         // 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 > > )
 …
         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.
 …
         // 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 *  );
 …
                 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

-              r3c64c668
+              r58fe85a
 #include "Type.hpp"
 #include "TypeSubstitution.hpp"
+#include "CompilationState.h"
 #include "Common/utility.h" // for group_iterate
 …
 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)>{
 …
         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;
 …
         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 ) {
 …
+                }
+                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;
 …
                 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;
 …
+        }
         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 );
 …
+        }
+        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;
 …
         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:";
 …
         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 );
 …
                 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

-              r3c64c668
+              r58fe85a
 // 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 {
 …
 };
+/// 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 {
 …
 class ImplicitCtorDtorStmt final : public Stmt {
 public:
         readonly<Stmt> callStmt;
+        ptr<Stmt> callStmt;
         ImplicitCtorDtorStmt( const CodeLocation & loc, const Stmt * callStmt,

src/AST/SymbolTable.cpp

-              r3c64c668
+              r58fe85a
+}
+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 {};
 …
                 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;
+}
 …
                 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() );
 …
+}
+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() {
 …
 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 );
+        }
 …
                         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;
+        }
 …
         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 ) {
 …
                 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;
 …
         // 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 {
 …
                                                 lazyInitScope();
                                                 *stats().map_mutations += 2;
                                                 idTable = idTable->set(
                                                         name,
+                                                table = table->set(
+                                                        lookupKey,
                                                         mangleTable->set(
                                                                 mangleName,
 …
         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) ) );
+}
 …
                         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

-              r3c64c668
+              r58fe85a
 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 {
 …
         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>;
 …
         /// 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;
 …
         /// 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:
 …
                 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

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
 #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
 …
 // --- 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;
 …
+}
+// --- 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" );
 …
+}
 // --- 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 ) {
 …
 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
 …
         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

-              r3c64c668
+              r58fe85a
 // 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
 //
 …
 // 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 {
 …
         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; }
 …
         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; }
 …
         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) {}
 …
 };
-/// 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
 …
         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
 …
 /// 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;
 …
         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
 …
 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
 …
 /// 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
 …
         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 }; }
 …
 };
+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

-              r3c64c668
+              r58fe85a
 #include "ResolvExpr/Unify.h"      // for unifyInexact
 #include "Tuples/Tuples.h"         // for isTtype
+#include "CompilationState.h"
 using ResolvExpr::WidenMode;
 …
         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 << " -> ";
 …
+}
 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;
 …
+                                }
+                        }
                         i = next;  // go to next node even if this removed
+                }
 …
+}
 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 );
+        }
 …
 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 } );
+                        }
+                }
 …
         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 ) ) {
 …
                 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 );
 …
         /// 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
 …
                                 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 );
 …
+}
 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 ) {
 …
                         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 ) {
 …
+                }
         } 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 ) {
 …
         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;
+                }
 …
         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;
+                }
 …
         } 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 );
+        }
 …
+}
 bool TypeEnvironment::mergeBound(
+bool TypeEnvironment::mergeBound(
                 EqvClass & to, const EqvClass & from, OpenVarSet & open, const SymbolTable & symtab ) {
         if ( from.bound ) {
 …
                         AssertionSet need, have;
                         if ( unifyInexact(
+                        if ( unifyInexact(
                                         toType, fromType, *this, need, have, open, widen, symtab, common ) ) {
                                 // unifies, set common type if necessary
 …
+}
 bool TypeEnvironment::mergeClasses(
+bool TypeEnvironment::mergeClasses(
         ClassList::iterator to, ClassList::iterator from, OpenVarSet & open, const SymbolTable & symtab
 ) {
 …
+}
 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

-              r3c64c668
+              r58fe85a
 /// 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 );
+        }
 };
 …
 /// 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
 …
 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;
 …
         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 );
 …
         /// 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 ) {}
 …
 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
 …
         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) );
+        }
 …
         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 );
 …
         /// 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

-              r3c64c668
+              r58fe85a
 namespace ast {
+// size_t TypeSubstitution::Substituter::traceId = Stats::Heap::new_stacktrace_id("TypeSubstitution");
 TypeSubstitution::TypeSubstitution() {
+}
 …
 void TypeSubstitution::initialize( const TypeSubstitution &src, TypeSubstitution &dest ) {
         dest.typeEnv.clear();
-        dest.varEnv.clear();
         dest.add( src );
+}
 …
                 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
 …
         // 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;
+        }
 …
 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 );
+                                }
+                        }
+                }
 …
         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;
+        }
 …
 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;
 …
                 // 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;
+                        }
 …
                 // 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

-              r3c64c668
+              r58fe85a
         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;
+        }
 …
         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 >
 …
         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:
 …
         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 ) {
 …
                         if ( const TypeExpr *actual = actualIt->template as<TypeExpr>() ) {
                                 if ( formal->name != "" ) {
                                         typeEnv[ formal->name ] = actual->type;
+                                        typeEnv[ formal ] = actual->type;
                                 } // if
                         } else {
 …
                         } // 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 >
 …
+}
 } // namespace ast
 …
 // 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;
 …
 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

r3c64c668	r58fe85a
47	47	virtual const ast::Stmt * visit( const ast::CatchStmt * ) = 0;
48	48	virtual const ast::Stmt * visit( const ast::FinallyStmt * ) = 0;
	49	virtual const ast::Stmt * visit( const ast::SuspendStmt * ) = 0;
49	50	virtual const ast::Stmt * visit( const ast::WaitForStmt * ) = 0;
50	51	virtual const ast::Decl * visit( const ast::WithStmt * ) = 0;

src/AST/module.mk

-              r3c64c668
+              r58fe85a
 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

-              r3c64c668
+              r58fe85a
   * 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 ##
 …
       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`
 …
   * 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`
 …
 `AggregateDecl`
 * `parameters` => `params`
+`StructDecl`
+* `makeInst` replaced by better constructor on `StructInstType`.
 `Expr`
 …
 * **TODO** move `kind`, `typeNames` into code generator
 `ReferenceToType`
+`ReferenceToType` => `BaseInstType`
 * deleted `get_baseParameters()` from children
   * replace with `aggr() ? aggr()->params : nullptr`
 …
 * `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`

src/CodeGen/CodeGenerator.cc

r3c64c668	r58fe85a
120	120	// GCC builtins should always be printed unmangled
121	121	if ( options.pretty \|\| decl->linkage.is_gcc_builtin ) return decl->name;
122		if ( decl->mangleName != "" ) {
	122	if ( LinkageSpec::isMangled(decl->linkage) && decl->mangleName != "" ) {
123	123	// need to incorporate scope level in order to differentiate names for destructors
124	124	return decl->get_scopedMangleName();

src/CodeGen/FixMain.cc

-              r3c64c668
+              r58fe85a
 #include "SynTree/Declaration.h"   // for FunctionDecl, operator<<
 #include "SynTree/Type.h"          // for FunctionType
+#include "SymTab/Mangler.h"
 namespace CodeGen {
 …
                 if( main_signature ) {
                         os << "static inline int invoke_main(int argc, char* argv[], char* envp[]) { (void)argc; (void)argv; (void)envp; return ";
+                        main_signature->mangleName = SymTab::Mangler::mangle(main_signature.get());
                         os << main_signature->get_scopedMangleName() << "(";

src/CodeGen/FixNames.cc

-              r3c64c668
+              r58fe85a
 #include "SynTree/Type.h"          // for Type, BasicType, Type::Qualifiers
 #include "SynTree/Visitor.h"       // for Visitor, acceptAll
+#include "CompilationState.h"
 namespace CodeGen {
 …
                 if ( dwt->get_name() != "" ) {
                         if ( LinkageSpec::isMangled( dwt->get_linkage() ) ) {
+                                dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
+                                if (!useNewAST) {
+                                        dwt->set_mangleName( SymTab::Mangler::mangle( dwt ) );
+                                }
                                 dwt->set_scopeLevel( scopeLevel );
                         } // if

src/CodeGen/module.mk

-              r3c64c668
+              r58fe85a
 SRC_CODEGEN = \
         CodeGen/CodeGenerator.cc \
+        CodeGen/CodeGenerator.h \
         CodeGen/FixMain.cc \
+        CodeGen/FixMain.h \
         CodeGen/GenType.cc \
+        CodeGen/OperatorTable.cc
+        CodeGen/GenType.h \
+        CodeGen/OperatorTable.cc \
+        CodeGen/OperatorTable.h \
+        CodeGen/Options.h
 SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/FixNames.cc
+SRC += $(SRC_CODEGEN) CodeGen/Generate.cc CodeGen/Generate.h CodeGen/FixNames.cc CodeGen/FixNames.h
 SRCDEMANGLE += $(SRC_CODEGEN)

src/CodeTools/TrackLoc.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Tues May 2 15:46:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Wed May 3 14:43:00 2017
 // Update Count     : 0
+// Last Modified On : Fri Nov 27 18:00:00 2020
+// Update Count     : 1
 //
 …
 #include <string>                    // for operator<<, string
 #include <typeindex>                 // for type_index
+#include <vector>                    // for vector
 #include "Common/PassVisitor.h"      // for PassVisitor
 …
                 CodeLocation *lastNode;
                 std::stack< CodeLocation * > parents;
+                std::stack< CodeLocation *, std::vector< CodeLocation * > > parents;
         public:
                 LocationPrinter(size_t printLevel) :

src/CodeTools/module.mk

-              r3c64c668
+              r58fe85a
 ###############################################################################
+SRC += CodeTools/DeclStats.cc \
+SRC += \
+        CodeTools/DeclStats.cc \
+        CodeTools/DeclStats.h \
         CodeTools/ResolvProtoDump.cc \
+        CodeTools/TrackLoc.cc
+        CodeTools/ResolvProtoDump.h \
+        CodeTools/TrackLoc.cc \
+        CodeTools/TrackLoc.h

src/Common/CodeLocation.h

-              r3c64c668
+              r58fe85a
+        }
+        bool followedBy( CodeLocation const & other, int seperation ) {
+        bool startsBefore( CodeLocation const & other ) const {
+                if( filename < other.filename ) return true;
+                if( filename > other.filename ) return false;
+                if( first_line < other.first_line ) return true;
+                if( first_line > other.first_line ) return false;
+                if( last_line < other.last_line ) return true;
+                return false;
+        }
+        bool followedBy( CodeLocation const & other, int seperation ) const {
                 return (first_line + seperation == other.first_line &&
                         filename == other.filename);
+        }
         bool operator==( CodeLocation const & other ) {
+        bool operator==( CodeLocation const & other ) const {
                 return followedBy( other, 0 );
+        }
         bool operator!=( CodeLocation const & other ) {
+        bool operator!=( CodeLocation const & other ) const {
                 return !(*this == other);
+        }

src/Common/Eval.cc

r3c64c668	r58fe85a
168	168	if (expr) {
169	169	expr->accept(ev);
170		return std::make_pair(ev.~~pass.value, ev.pass~~.valid);
	170	return std::make_pair(ev.core.value, ev.core.valid);
171	171	} else {
172	172	return std::make_pair(0, false);

src/Common/PassVisitor.h

-              r3c64c668
+              r58fe85a
         virtual void visit( FinallyStmt * finallyStmt ) override final;
         virtual void visit( const FinallyStmt * finallyStmt ) override final;
+        virtual void visit( SuspendStmt * suspendStmt ) override final;
+        virtual void visit( const SuspendStmt * suspendStmt ) override final;
         virtual void visit( WaitForStmt * waitforStmt ) override final;
         virtual void visit( const WaitForStmt * waitforStmt ) override final;
 …
         virtual Statement * mutate( CatchStmt * catchStmt ) override final;
         virtual Statement * mutate( FinallyStmt * finallyStmt ) override final;
+        virtual Statement * mutate( SuspendStmt * suspendStmt ) override final;
         virtual Statement * mutate( WaitForStmt * waitforStmt ) override final;
         virtual Declaration * mutate( WithStmt * withStmt ) override final;
 …
         virtual TypeSubstitution * mutate( TypeSubstitution * sub ) final;
+        bool isInFunction() const {
+                return inFunction;
+        }
 private:
         bool inFunction = false;
+        bool atFunctionTop = false;
         template<typename pass_t> friend void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_t >& visitor );
 …
 public:
         PassVisitor<pass_type> * const visitor = nullptr;
+        bool isInFunction() const {
+                return visitor->isInFunction();
+        }
 };

src/Common/PassVisitor.impl.h

-              r3c64c668
+              r58fe85a
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // 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;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
 …
                         indexerAddId( &func );
                         maybeAccept_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // 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;
                         maybeAccept_impl( node->statements, *this );
                         maybeAccept_impl( node->attributes, *this );
 …
                         indexerAddId( &func );
                         maybeMutate_impl( node->type, *this );
+                        // function body needs to have the same scope as parameters - CompoundStmt will not enter
+                        // a new scope if inFunction is true
+                        // 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;
                         maybeMutate_impl( node->statements, *this );
                         maybeMutate_impl( node->attributes, *this );
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->base      , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->base      , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeMutate_impl( node->parameters, *this );
                 maybeMutate_impl( node->base      , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->base      , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeAccept_impl( node->parameters, *this );
                 maybeAccept_impl( node->base      , *this );
+        }
 …
+        {
                 auto guard = makeFuncGuard( [this]() { indexerScopeEnter(); }, [this]() { indexerScopeLeave(); } );
-                maybeMutate_impl( node->parameters, *this );
                 maybeMutate_impl( node->base      , *this );
+        }
 …
         VISIT_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
+        }
 …
         VISIT_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 visitStatementList( node->kids );
+        }
 …
         MUTATE_START( node );
+        {
                 // do not enter a new scope if inFunction is true - needs to check old state before the assignment
                 ValueGuard< bool > oldInFunction( inFunction );
                 auto guard1 = makeFuncGuard( [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeEnter(); }, [this, &oldInFunction]() { if ( ! oldInFunction.old ) indexerScopeLeave(); } );
+                // Do not enter a new scope if atFunctionTop is true, don't leave one either.
+                ValueGuard< bool > oldAtFunctionTop( atFunctionTop );
+                auto guard1 = makeFuncGuard( [this, go = !atFunctionTop]() { if ( go ) indexerScopeEnter(); }, [this, go = !atFunctionTop]() { if ( go ) indexerScopeLeave(); } );
                 auto guard2 = makeFuncGuard( [this]() { call_beginScope();   }, [this]() { call_endScope();     } );
                 inFunction = false;
+                atFunctionTop = false;
                 mutateStatementList( node->kids );
+        }
 …
         maybeMutate_impl( node->block, *this );
+        MUTATE_END( Statement, node );
+}
+//--------------------------------------------------------------------------
+// SuspendStmt
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( SuspendStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->then  , *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+void PassVisitor< pass_type >::visit( const SuspendStmt * node ) {
+        VISIT_START( node );
+        maybeAccept_impl( node->then  , *this );
+        VISIT_END( node );
+}
+template< typename pass_type >
+Statement * PassVisitor< pass_type >::mutate( SuspendStmt * node ) {
+        MUTATE_START( node );
+        maybeMutate_impl( node->then  , *this );
         MUTATE_END( Statement, node );

src/Common/PassVisitor.proto.h

r3c64c668	r58fe85a
38	38	};
39	39
40		std::stack< cleanup_t > cleanups;
	40	std::stack< cleanup_t, std::vector< cleanup_t > > cleanups;
41	41	};
42	42

src/Common/ScopedMap.h

-              r3c64c668
+              r58fe85a
                 reference operator* () { return *it; }
                 pointer operator-> () { return it.operator->(); }
+                pointer operator-> () const { return it.operator->(); }
                 iterator& operator++ () {
 …
         /// Gets the note at the given scope
+        Note& getNote() { return scopes.back().note; }
+        const Note& getNote() const { return scopes.back().note; }
         Note& getNote( size_type i ) { return scopes[i].note; }
         const Note& getNote( size_type i ) const { return scopes[i].note; }

src/Common/SemanticError.cc

-              r3c64c668
+              r58fe85a
 void SemanticErrorException::print() {
         using std::to_string;
+        errors.sort([](const error & lhs, const error & rhs) -> bool {
+                if(lhs.location.startsBefore(rhs.location)) return true;
+                if(rhs.location.startsBefore(lhs.location)) return false;
+                return lhs.description < rhs.description;
+        });
         for( auto err : errors ) {
                 std::cerr << ErrorHelpers::bold() << err.location << ErrorHelpers::error_str() << ErrorHelpers::reset_font() << err.description << std::endl;

src/Common/Stats/Heap.cc

-              r3c64c668
+              r58fe85a
                 const size_t passes_size = sizeof(passes) / sizeof(passes[0]);
                 size_t       passes_cnt = 1;
+                StatBlock    stacktrace_stats[100];
+                size_t       stacktrace_stats_count = 0;
+                bool         stacktrace_stats_enabled = true;
+                size_t       trace[1000];
+                const size_t stacktrace_max_depth = sizeof(trace) / sizeof(size_t);
+                size_t       stacktrace_depth;
+                size_t new_stacktrace_id(const char * const name) {
+                        stacktrace_stats[stacktrace_stats_count].name = name;
+                        return stacktrace_stats_count++;
+                }
+                void stacktrace_push(size_t id) {
+                        ++stacktrace_depth;
+                        assertf(stacktrace_depth < stacktrace_max_depth, "Stack trace too deep: increase size of array in Heap.cc");
+                        trace[stacktrace_depth] = id;
+                }
+                void stacktrace_pop() {
+                        assertf(stacktrace_depth > 0, "Invalid stack tracing operation: trace is empty");
+                        --stacktrace_depth;
+                }
                 void newPass( const char * const name ) {
 …
                         for(size_t i = 0; i < passes_cnt; i++) {
                                 print(passes[i], nc, total_mallocs, total_frees, overall_peak);
+                        }
+                        print('-', nct);
+                        std::cerr << std::setw(nc) << "Trace";
+                        std::cerr << " |       Malloc Count |         Free Count |        Peak Allocs |" << std::endl;
+                        print('-', nct);
+                        for (size_t i = 0; i < stacktrace_stats_count; i++) {
+                                print(stacktrace_stats[i], nc, total_mallocs, total_frees, overall_peak);
+                        }
                         print('-', nct);
 …
                                                 = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
+                                }
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                }
                                 return __malloc( size );
+                        }
 …
                                         passes[passes_cnt - 1].frees++;
                                         passes[passes_cnt - 1].n_allocs--;
+                                }
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].frees++;
+                                }
                                 return __free( ptr );
 …
                                                 = std::max(passes[passes_cnt - 1].peak_allocs, passes[passes_cnt - 1].n_allocs);
+                                }
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                }
                                 return __calloc( nelem, size );
+                        }
 …
                                         passes[passes_cnt - 1].frees++;
                                 } // if
+                                if ( stacktrace_stats_enabled && stacktrace_depth > 0) {
+                                        stacktrace_stats[trace[stacktrace_depth]].mallocs++;
+                                        stacktrace_stats[trace[stacktrace_depth]].frees++;
+                                }
                                 return s;
+                        }

src/Common/Stats/Heap.h

r3c64c668	r58fe85a
20	20	void newPass( const char * const name );
21	21	void print();
	22
	23	size_t new_stacktrace_id(const char * const name);
	24	void stacktrace_push(size_t id);
	25	void stacktrace_pop();
22	26	}
23	27	}

src/Common/Stats/Stats.cc

-              r3c64c668
+              r58fe85a
+        }
+        namespace ResolveTime {
+                bool enabled = false;
+        }
         struct {
                 const char * const opt;
 …
                 { "heap"    , Heap::enabled },
                 { "time"    , Time::enabled },
+                { "resolve" , ResolveTime::enabled },
         };

src/Common/module.mk

-              r3c64c668
+              r58fe85a
 SRC_COMMON = \
       Common/Assert.cc \
+      Common/CodeLocation.h \
+      Common/CodeLocationTools.hpp \
+      Common/CodeLocationTools.cpp \
+      Common/CompilerError.h \
+      Common/Debug.h \
+      Common/ErrorObjects.h \
       Common/Eval.cc \
+      Common/Examine.cc \
+      Common/Examine.h \
+      Common/FilterCombos.h \
+      Common/Indenter.h \
       Common/PassVisitor.cc \
+      Common/PassVisitor.h \
+      Common/PassVisitor.impl.h \
+      Common/PassVisitor.proto.h \
+      Common/PersistentMap.h \
+      Common/ScopedMap.h \
       Common/SemanticError.cc \
+      Common/SemanticError.h \
+      Common/Stats.h \
+      Common/Stats/Base.h \
       Common/Stats/Counter.cc \
+      Common/Stats/Counter.h \
       Common/Stats/Heap.cc \
+      Common/Stats/Heap.h \
+      Common/Stats/ResolveTime.cc \
+      Common/Stats/ResolveTime.h \
       Common/Stats/Stats.cc \
       Common/Stats/Time.cc \
+      Common/UniqueName.cc
+      Common/Stats/Time.h \
+      Common/UnimplementedError.h \
+      Common/UniqueName.cc \
+      Common/UniqueName.h \
+      Common/utility.h \
+      Common/VectorMap.h
 SRC += $(SRC_COMMON) Common/DebugMalloc.cc

src/Common/utility.h

-              r3c64c668
+              r58fe85a
         reverse_iterate_t( T & ref ) : ref(ref) {}
+        typedef typename T::reverse_iterator iterator;
+        iterator begin() { return ref.rbegin(); }
+        iterator end() { return ref.rend(); }
+        // this does NOT work on const T!!!
+        // typedef typename T::reverse_iterator iterator;
+        auto begin() { return ref.rbegin(); }
+        auto end() { return ref.rend(); }
 };

src/CompilationState.cc

-              r3c64c668
+              r58fe85a
 //
+#include "config.h"
 int
         astp = false,
 …
         nopreludep = false,
         genproto = false,
+        deterministic_output = false,
+        useNewAST = CFA_USE_NEW_AST,
         nomainp = false,
         parsep = false,

src/CompilationState.h

r3c64c668	r58fe85a
28	28	nopreludep,
29	29	genproto,
	30	deterministic_output,
	31	useNewAST,
30	32	nomainp,
31	33	parsep,

src/Concurrency/Keywords.cc

-              r3c64c668
+              r58fe85a
 #include "Concurrency/Keywords.h"
+#include <cassert>                 // for assert
+#include <string>                  // for string, operator==
+#include "Common/PassVisitor.h"    // for PassVisitor
+#include "Common/SemanticError.h"  // for SemanticError
+#include "Common/utility.h"        // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h" // for isConstructor
+#include "InitTweak/InitTweak.h"   // for getPointerBase
+#include "SynTree/LinkageSpec.h"   // for Cforall
+#include "SynTree/Constant.h"      // for Constant
+#include "SynTree/Declaration.h"   // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"    // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"   // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"         // for Label
+#include "SynTree/Statement.h"     // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"          // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"       // for Visitor, acceptAll
+#include <cassert>                        // for assert
+#include <string>                         // for string, operator==
+#include <iostream>
+#include "Common/Examine.h"               // for isMainFor
+#include "Common/PassVisitor.h"           // for PassVisitor
+#include "Common/SemanticError.h"         // for SemanticError
+#include "Common/utility.h"               // for deleteAll, map_range
+#include "CodeGen/OperatorTable.h"        // for isConstructor
+#include "ControlStruct/LabelGenerator.h" // for LebelGenerator
+#include "InitTweak/InitTweak.h"          // for getPointerBase
+#include "SynTree/LinkageSpec.h"          // for Cforall
+#include "SynTree/Constant.h"             // for Constant
+#include "SynTree/Declaration.h"          // for StructDecl, FunctionDecl, ObjectDecl
+#include "SynTree/Expression.h"           // for VariableExpr, ConstantExpr, Untype...
+#include "SynTree/Initializer.h"          // for SingleInit, ListInit, Initializer ...
+#include "SynTree/Label.h"                // for Label
+#include "SynTree/Statement.h"            // for CompoundStmt, DeclStmt, ExprStmt
+#include "SynTree/Type.h"                 // for StructInstType, Type, PointerType
+#include "SynTree/Visitor.h"              // for Visitor, acceptAll
+#include "Virtual/Tables.h"
 class Attribute;
 namespace Concurrency {
+        inline static std::string getVTableName( std::string const & exception_name ) {
+                return exception_name.empty() ? std::string() : Virtual::vtableTypeName(exception_name);
+        }
+        // Only detects threads constructed with the keyword thread.
+        inline static bool isThread( DeclarationWithType * decl ) {
+                Type * baseType = decl->get_type()->stripDeclarator();
+                StructInstType * instType = dynamic_cast<StructInstType *>( baseType );
+                if ( nullptr == instType ) { return false; }
+                return instType->baseStruct->is_thread();
+        }
         //=============================================================================================
         // Pass declarations
 …
           public:
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name, std::string&& getter_name, std::string&& context_error, bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ), context_error( context_error ), needs_main( needs_main ), cast_target( cast_target ) {}
+                ConcurrentSueKeyword( std::string&& type_name, std::string&& field_name,
+                        std::string&& getter_name, std::string&& context_error, std::string&& exception_name,
+                        bool needs_main, AggregateDecl::Aggregate cast_target ) :
+                  type_name( type_name ), field_name( field_name ), getter_name( getter_name ),
+                  context_error( context_error ), exception_name( exception_name ),
+                  vtable_name( getVTableName( exception_name ) ),
+                  needs_main( needs_main ), cast_target( cast_target ) {}
                 virtual ~ConcurrentSueKeyword() {}
 …
                 void handle( StructDecl * );
+                void addVtableForward( StructDecl * );
                 FunctionDecl * forwardDeclare( StructDecl * );
                 ObjectDecl * addField( StructDecl * );
 …
                 const std::string getter_name;
                 const std::string context_error;
+                const std::string exception_name;
+                const std::string vtable_name;
                 bool needs_main;
                 AggregateDecl::Aggregate cast_target;
 …
                 StructDecl   * type_decl = nullptr;
                 FunctionDecl * dtor_decl = nullptr;
+                StructDecl * except_decl = nullptr;
+                StructDecl * vtable_decl = nullptr;
         };
 …
                         "get_thread",
                         "thread keyword requires threads to be in scope, add #include <thread.hfa>\n",
+                        "ThreadCancelled",
                         true,
                         AggregateDecl::Thread
 …
                         "get_coroutine",
                         "coroutine keyword requires coroutines to be in scope, add #include <coroutine.hfa>\n",
+                        "CoroutineCancelled",
                         true,
                         AggregateDecl::Coroutine
 …
+                }
         };
         //-----------------------------------------------------------------------------
 …
                         "get_monitor",
                         "monitor keyword requires monitors to be in scope, add #include <monitor.hfa>\n",
+                        "",
                         false,
                         AggregateDecl::Monitor
 …
                         mutateAll( translationUnit, impl );
+                }
+        };
+        //-----------------------------------------------------------------------------
+        //Handles generator type declarations :
+        // generator MyGenerator {                   struct MyGenerator {
+        //      int data;                                  int data;
+        //      a_struct_t more_data;                      a_struct_t more_data;
+        //                                =>             int __gen_next;
+        // };                                        };
+        //
+        class GeneratorKeyword final : public ConcurrentSueKeyword {
+          public:
+                GeneratorKeyword() : ConcurrentSueKeyword(
+                        "$generator",
+                        "__generator_state",
+                        "get_generator",
+                        "Unable to find builtin type $generator\n",
+                        "",
+                        true,
+                        AggregateDecl::Generator
+                )
+                {}
+                virtual ~GeneratorKeyword() {}
+                virtual bool is_target( StructDecl * decl ) override final { return decl->is_generator(); }
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< GeneratorKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        };
+        //-----------------------------------------------------------------------------
+        class SuspendKeyword final : public WithStmtsToAdd, public WithGuards {
+        public:
+                SuspendKeyword() = default;
+                virtual ~SuspendKeyword() = default;
+                void  premutate( FunctionDecl * );
+                DeclarationWithType * postmutate( FunctionDecl * );
+                Statement * postmutate( SuspendStmt * );
+                static void implement( std::list< Declaration * > & translationUnit ) {
+                        PassVisitor< SuspendKeyword > impl;
+                        mutateAll( translationUnit, impl );
+                }
+        private:
+                bool is_real_suspend( FunctionDecl * );
+                Statement * make_generator_suspend( SuspendStmt * );
+                Statement * make_coroutine_suspend( SuspendStmt * );
+                struct LabelPair {
+                        Label obj;
+                        int   idx;
+                };
+                LabelPair make_label() {
+                        labels.push_back( gen.newLabel("generator") );
+                        return { labels.back(), int(labels.size()) };
+                }
+                DeclarationWithType * in_generator = nullptr;
+                FunctionDecl * decl_suspend = nullptr;
+                std::vector<Label> labels;
+                ControlStruct::LabelGenerator & gen = *ControlStruct::LabelGenerator::getGenerator();
         };
 …
                 std::list<DeclarationWithType*> findMutexArgs( FunctionDecl*, bool & first );
                 void validate( DeclarationWithType * );
+                void addDtorStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatments( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addDtorStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addStatements( FunctionDecl* func, CompoundStmt *, const std::list<DeclarationWithType * > &);
+                void addThreadDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args );
                 static void implement( std::list< Declaration * > & translationUnit ) {
 …
                 StructDecl* guard_decl = nullptr;
                 StructDecl* dtor_guard_decl = nullptr;
+                StructDecl* thread_guard_decl = nullptr;
                 static std::unique_ptr< Type > generic_func;
 …
                 CoroutineKeyword        ::implement( translationUnit );
                 MonitorKeyword  ::implement( translationUnit );
+                GeneratorKeyword  ::implement( translationUnit );
+                SuspendKeyword    ::implement( translationUnit );
+        }
 …
                         handle( decl );
+                }
+                else if ( !except_decl && exception_name == decl->name && decl->body ) {
+                        except_decl = decl;
+                }
+                else if ( !vtable_decl && vtable_name == decl->name && decl->body ) {
+                        vtable_decl = decl;
+                }
+                // Might be able to get ride of is target.
+                assert( is_target(decl) == (cast_target == decl->kind) );
                 return decl;
+        }
         DeclarationWithType * ConcurrentSueKeyword::postmutate( FunctionDecl * decl ) {
+                if( !type_decl ) return decl;
+                if( !CodeGen::isDestructor( decl->name ) ) return decl;
+                auto params = decl->type->parameters;
+                if( params.size() != 1 ) return decl;
+                auto type = dynamic_cast<ReferenceType*>( params.front()->get_type() );
+                if( !type ) return decl;
+                auto stype = dynamic_cast<StructInstType*>( type->base );
+                if( !stype ) return decl;
+                if( stype->baseStruct != type_decl ) return decl;
+                if( !dtor_decl ) dtor_decl = decl;
+                if ( type_decl && isDestructorFor( decl, type_decl ) )
+                        dtor_decl = decl;
+                else if ( vtable_name.empty() )
+                        ;
+                else if( !decl->has_body() )
+                        ;
+                else if ( auto param = isMainFor( decl, cast_target ) ) {
+                        // This should never trigger.
+                        assert( vtable_decl );
+                        // Should be safe because of isMainFor.
+                        StructInstType * struct_type = static_cast<StructInstType *>(
+                                static_cast<ReferenceType *>( param->get_type() )->base );
+                        assert( struct_type );
+                        std::list< Expression * > poly_args = { new TypeExpr( struct_type->clone() ) };
+                        ObjectDecl * vtable_object = Virtual::makeVtableInstance(
+                                vtable_decl->makeInst( poly_args ), struct_type, nullptr );
+                        declsToAddAfter.push_back( vtable_object );
+                        declsToAddAfter.push_back( Virtual::makeGetExceptionFunction(
+                                vtable_object, except_decl->makeInst( std::move( poly_args ) )
+                        ) );
+                }
                 return decl;
+        }
 …
                 if( !dtor_decl ) SemanticError( decl, context_error );
+                addVtableForward( decl );
                 FunctionDecl * func = forwardDeclare( decl );
                 ObjectDecl * field = addField( decl );
                 addRoutines( field, func );
+        }
+        void ConcurrentSueKeyword::addVtableForward( StructDecl * decl ) {
+                if ( vtable_decl ) {
+                        std::list< Expression * > poly_args = {
+                                new TypeExpr( new StructInstType( noQualifiers, decl ) ),
+                        };
+                        declsToAddBefore.push_back( Virtual::makeGetExceptionForward(
+                                vtable_decl->makeInst( poly_args ),
+                                except_decl->makeInst( poly_args )
+                        ) );
+                        declsToAddBefore.push_back( Virtual::makeVtableForward(
+                                vtable_decl->makeInst( move( poly_args ) ) ) );
+                // Its only an error if we want a vtable and don't have one.
+                } else if ( ! vtable_name.empty() ) {
+                        SemanticError( decl, context_error );
+                }
+        }
 …
                                                 new CastExpr(
                                                         new VariableExpr( func->get_functionType()->get_parameters().front() ),
+                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone()
+                                                        func->get_functionType()->get_parameters().front()->get_type()->stripReferences()->clone(),
+                                                        false
+                                                )
+                                        )
 …
                 declsToAddAfter.push_back( get_decl );
+                // get_decl->fixUniqueId();
+        }
+        }
+        //=============================================================================================
+        // Suspend keyword implementation
+        //=============================================================================================
+        bool SuspendKeyword::is_real_suspend( FunctionDecl * func ) {
+                if(isMangled(func->linkage)) return false; // the real suspend isn't mangled
+                if(func->name != "__cfactx_suspend") return false; // the real suspend has a specific name
+                if(func->type->parameters.size() != 0) return false; // Too many parameters
+                if(func->type->returnVals.size() != 0) return false; // Too many return values
+                return true;
+        }
+        void SuspendKeyword::premutate( FunctionDecl * func ) {
+                GuardValue(in_generator);
+                in_generator = nullptr;
+                // Is this the real suspend?
+                if(is_real_suspend(func)) {
+                        decl_suspend = decl_suspend ? decl_suspend : func;
+                        return;
+                }
+                // Is this the main of a generator?
+                auto param = isMainFor( func, AggregateDecl::Aggregate::Generator );
+                if(!param) return;
+                if(func->type->returnVals.size() != 0) SemanticError(func->location, "Generator main must return void");
+                in_generator = param;
+                GuardValue(labels);
+                labels.clear();
+        }
+        DeclarationWithType * SuspendKeyword::postmutate( FunctionDecl * func ) {
+                if( !func->statements ) return func; // Not the actual definition, don't do anything
+                if( !in_generator     ) return func; // Not in a generator, don't do anything
+                if( labels.empty()    ) return func; // Generator has no states, nothing to do, could throw a warning
+                // This is a generator main, we need to add the following code to the top
+                // static void * __generator_labels[] = {&&s0, &&s1, ...};
+                // goto * __generator_labels[gen.__generator_state];
+                const auto & loc = func->location;
+                const auto first_label = gen.newLabel("generator");
+                // for each label add to declaration
+                std::list<Initializer*> inits = { new SingleInit( new LabelAddressExpr( first_label ) ) };
+                for(const auto & label : labels) {
+                        inits.push_back(
+                                new SingleInit(
+                                        new LabelAddressExpr( label )
+                                )
+                        );
+                }
+                auto init = new ListInit(std::move(inits), noDesignators, true);
+                labels.clear();
+                // create decl
+                auto decl = new ObjectDecl(
+                        "__generator_labels",
+                        Type::StorageClasses( Type::Static ),
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new ArrayType(
+                                Type::Qualifiers(),
+                                new PointerType(
+                                        Type::Qualifiers(),
+                                        new VoidType( Type::Qualifiers() )
+                                ),
+                                nullptr,
+                                false, false
+                        ),
+                        init
+                );
+                // create the goto
+                assert(in_generator);
+                auto go_decl = new ObjectDecl(
+                        "__generator_label",
+                        noStorageClasses,
+                        LinkageSpec::AutoGen,
+                        nullptr,
+                        new PointerType(
+                                Type::Qualifiers(),
+                                new VoidType( Type::Qualifiers() )
+                        ),
+                        new SingleInit(
+                                new UntypedExpr(
+                                        new NameExpr("?[?]"),
+                                        {
+                                                new NameExpr("__generator_labels"),
+                                                new UntypedMemberExpr(
+                                                        new NameExpr("__generator_state"),
+                                                        new VariableExpr( in_generator )
+                                                )
+                                        }
+                                )
+                        )
+                );
+                go_decl->location = loc;
+                auto go = new BranchStmt(
+                        new VariableExpr( go_decl ),
+                        BranchStmt::Goto
+                );
+                go->location = loc;
+                go->computedTarget->location = loc;
+                auto noop = new NullStmt({ first_label });
+                noop->location = loc;
+                // wrap everything in a nice compound
+                auto body = new CompoundStmt({
+                        new DeclStmt( decl ),
+                        new DeclStmt( go_decl ),
+                        go,
+                        noop,
+                        func->statements
+                });
+                body->location   = loc;
+                func->statements = body;
+                return func;
+        }
+        Statement * SuspendKeyword::postmutate( SuspendStmt * stmt ) {
+                SuspendStmt::Type type = stmt->type;
+                if(type == SuspendStmt::None) {
+                        // This suspend has a implicit target, find it
+                        type = in_generator ? SuspendStmt::Generator : SuspendStmt::Coroutine;
+                }
+                // Check that the target makes sense
+                if(!in_generator && type == SuspendStmt::Generator) SemanticError( stmt->location, "'suspend generator' must be used inside main of generator type.");
+                // Act appropriately
+                switch(type) {
+                        case SuspendStmt::Generator: return make_generator_suspend(stmt);
+                        case SuspendStmt::Coroutine: return make_coroutine_suspend(stmt);
+                        default: abort();
+                }
+        }
+        Statement * SuspendKeyword::make_generator_suspend( SuspendStmt * stmt ) {
+                assert(in_generator);
+                // Target code is :
+                //   gen.__generator_state = X;
+                //   { THEN }
+                //   return;
+                //   __gen_X:;
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                // Build the label and get its index
+                auto label = make_label();
+                // Create the context saving statement
+                auto save = new ExprStmt( new UntypedExpr(
+                        new NameExpr( "?=?" ),
+                        {
+                                new UntypedMemberExpr(
+                                        new NameExpr("__generator_state"),
+                                        new VariableExpr( in_generator )
+                                ),
+                                new ConstantExpr(
+                                        Constant::from_int( label.idx )
+                                )
+                        }
+                ));
+                assert(save->expr);
+                save->location = loc;
+                stmtsToAddBefore.push_back( save );
+                // if we have a then add it here
+                auto then = stmt->then;
+                stmt->then = nullptr;
+                delete stmt;
+                if(then) stmtsToAddBefore.push_back( then );
+                // Create the return statement
+                auto ret = new ReturnStmt( nullptr );
+                ret->location = loc;
+                stmtsToAddBefore.push_back( ret );
+                // Create the null statement with the created label
+                auto noop = new NullStmt({ label.obj });
+                noop->location = loc;
+                // Return the null statement to take the place of the previous statement
+                return noop;
+        }
+        Statement * SuspendKeyword::make_coroutine_suspend( SuspendStmt * stmt ) {
+                if(stmt->then) SemanticError( stmt->location, "Compound statement following coroutines is not implemented.");
+                // Save the location and delete the old statement, we only need the location from this point on
+                auto loc = stmt->location;
+                delete stmt;
+                // Create the call expression
+                if(!decl_suspend) SemanticError( loc, "suspend keyword applied to coroutines requires coroutines to be in scope, add #include <coroutine.hfa>\n");
+                auto expr = new UntypedExpr( VariableExpr::functionPointer( decl_suspend ) );
+                expr->location = loc;
+                // Change this statement into a regular expr
+                assert(expr);
+                auto nstmt = new ExprStmt( expr );
+                nstmt->location = loc;
+                return nstmt;
+        }
         //=============================================================================================
 …
                 bool first = false;
                 std::list<DeclarationWithType*> mutexArgs = findMutexArgs( decl, first );
                 bool isDtor = CodeGen::isDestructor( decl->name );
+                bool const isDtor = CodeGen::isDestructor( decl->name );
                 // Is this function relevant to monitors
 …
                 // Instrument the body
+                if( isDtor ) {
+                        addDtorStatments( decl, body, mutexArgs );
+                if ( isDtor && isThread( mutexArgs.front() ) ) {
+                        if( !thread_guard_decl ) {
+                                SemanticError( decl, "thread destructor requires threads to be in scope, add #include <thread.hfa>\n" );
+                        }
+                        addThreadDtorStatements( decl, body, mutexArgs );
+                }
+                else if ( isDtor ) {
+                        addDtorStatements( decl, body, mutexArgs );
+                }
                 else {
                         addStatments( decl, body, mutexArgs );
+                        addStatements( decl, body, mutexArgs );
+                }
+        }
 …
                         assert( !dtor_guard_decl );
                         dtor_guard_decl = decl;
+                }
+                else if( decl->name == "thread_dtor_guard_t" && decl->body ) {
+                        assert( !thread_guard_decl );
+                        thread_guard_decl = decl;
+                }
+        }
 …
+        }
         void MutexKeyword::addDtorStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+        void MutexKeyword::addDtorStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 Type * arg_type = args.front()->get_type()->clone();
                 arg_type->set_mutex( false );
 …
                         new SingleInit( new UntypedExpr(
                                 new NameExpr( "get_monitor" ),
                                 {  new CastExpr( new VariableExpr( args.front() ), arg_type ) }
+                                {  new CastExpr( new VariableExpr( args.front() ), arg_type, false ) }
                         ))
                 );
 …
+                                        {
                                                 new SingleInit( new AddressExpr( new VariableExpr( monitors ) ) ),
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) ),
+                                                new SingleInit( new ConstantExpr( Constant::from_bool( false ) ) )
                                         },
                                         noDesignators,
 …
                 //$monitor * __monitors[] = { get_monitor(a), get_monitor(b) };
+                body->push_front( new DeclStmt( monitors) );
+        }
+        void MutexKeyword::addStatments( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
+                body->push_front( new DeclStmt( monitors ) );
+        }
+        void MutexKeyword::addThreadDtorStatements(
+                        FunctionDecl*, CompoundStmt * body,
+                        const std::list<DeclarationWithType * > & args ) {
+                assert( args.size() == 1 );
+                DeclarationWithType * arg = args.front();
+                Type * arg_type = arg->get_type()->clone();
+                assert( arg_type->get_mutex() );
+                arg_type->set_mutex( false );
+                // thread_dtor_guard_t __guard = { this, intptr( 0 ) };
+                body->push_front(
+                        new DeclStmt( new ObjectDecl(
+                                "__guard",
+                                noStorageClasses,
+                                LinkageSpec::Cforall,
+                                nullptr,
+                                new StructInstType(
+                                        noQualifiers,
+                                        thread_guard_decl
+                                ),
+                                new ListInit(
+                                        {
+                                                new SingleInit( new CastExpr( new VariableExpr( arg ), arg_type ) ),
+                                                new SingleInit( new UntypedExpr(
+                                                        new NameExpr( "intptr" ), {
+                                                                new ConstantExpr( Constant::from_int( 0 ) ),
+                                                        }
+                                                ) ),
+                                        },
+                                        noDesignators,
+                                        true
+                                )
+                        ))
+                );
+        }
+        void MutexKeyword::addStatements( FunctionDecl* func, CompoundStmt * body, const std::list<DeclarationWithType * > & args ) {
                 ObjectDecl * monitors = new ObjectDecl(
                         "__monitors",
 …
                                         return new SingleInit( new UntypedExpr(
                                                 new NameExpr( "get_monitor" ),
                                                 {  new CastExpr( new VariableExpr( var ), type ) }
+                                                {  new CastExpr( new VariableExpr( var ), type, false ) }
                                         ) );
                                 })
 …
                                                 new SingleInit( new VariableExpr( monitors ) ),
                                                 new SingleInit( new ConstantExpr( Constant::from_ulong( args.size() ) ) ),
                                                 new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone() ) )
+                                                new SingleInit( new CastExpr( new VariableExpr( func ), generic_func->clone(), false ) )
                                         },
                                         noDesignators,
 …
 // tab-width: 4 //
 // End: //

src/Concurrency/Waitfor.cc

-              r3c64c668
+              r58fe85a
                                                                 decl_monitor
+                                                        )
+                                                )
+                                                ),
+                                                false
                                         );
 …
                         new CompoundStmt({
                                 makeAccStatement( acceptables, index, "is_dtor", detectIsDtor( clause.target.function )                                    , indexer ),
                                 makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t )                            , indexer ),
+                                makeAccStatement( acceptables, index, "func"   , new CastExpr( clause.target.function, fptr_t, false )                     , indexer ),
                                 makeAccStatement( acceptables, index, "data"   , new VariableExpr( monitors )                                              , indexer ),
                                 makeAccStatement( acceptables, index, "size"   , new ConstantExpr( Constant::from_ulong( clause.target.arguments.size() ) ), indexer ),
 …
                                                                 decl_mask
+                                                        )
+                                                )
+                                                ),
+                                                false
                                         ),
                                         timeout

src/Concurrency/module.mk

r3c64c668	r58fe85a
15	15	###############################################################################
16	16
17		SRC += Concurrency/Keywords.cc Concurrency/~~Waitfor.cc~~
	17	SRC += Concurrency/Keywords.cc Concurrency/Keywords.h Concurrency/Waitfor.cc Concurrency/Waitfor.h
18	18	SRCDEMANGLE += Concurrency/Keywords.cc
19	19

src/ControlStruct/ExceptTranslate.cc

-              r3c64c668
+              r58fe85a
 // Author           : Andrew Beach
 // Created On       : Wed Jun 14 16:49:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:15 2019
 // Update Count     : 12
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 24 11:18:00 2020
+// Update Count     : 17
 //
 …
+        }
+        class ExceptionMutatorCore : public WithGuards {
+                enum Context { NoHandler, TerHandler, ResHandler };
+                // Also need to handle goto, break & continue.
+                // They need to be cut off in a ResHandler, until we enter another
+                // loop, switch or the goto stays within the function.
+                Context cur_context;
+                // The current (innermost) termination handler exception declaration.
+                ObjectDecl * handler_except_decl;
+        class ThrowMutatorCore : public WithGuards {
+                ObjectDecl * terminate_handler_except;
+                enum Context { NoHandler, TerHandler, ResHandler } cur_context;
+                // The helper functions for code/syntree generation.
+                Statement * create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc );
+                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
+        public:
+                ThrowMutatorCore() :
+                        terminate_handler_except( nullptr ),
+                        cur_context( NoHandler )
+                {}
+                void premutate( CatchStmt *catchStmt );
+                Statement * postmutate( ThrowStmt *throwStmt );
+        };
+        // ThrowStmt Mutation Helpers
+        Statement * ThrowMutatorCore::create_either_throw(
+                        ThrowStmt * throwStmt, const char * throwFunc ) {
+                // `throwFunc`( `throwStmt->get_name()` );
+                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
+                call->get_args().push_back( throwStmt->get_expr() );
+                throwStmt->set_expr( nullptr );
+                delete throwStmt;
+                return new ExprStmt( call );
+        }
+        Statement * ThrowMutatorCore::create_terminate_rethrow(
+                        ThrowStmt *throwStmt ) {
+                // { `terminate_handler_except` = 0p; __rethrow_terminate(); }
+                assert( nullptr == throwStmt->get_expr() );
+                assert( terminate_handler_except );
+                CompoundStmt * result = new CompoundStmt();
+                result->labels =  throwStmt->labels;
+                result->push_back( new ExprStmt( UntypedExpr::createAssign(
+                        nameOf( terminate_handler_except ),
+                        new ConstantExpr( Constant::null(
+                                terminate_handler_except->get_type()->clone()
+                                ) )
+                        ) ) );
+                result->push_back( new ExprStmt(
+                        new UntypedExpr( new NameExpr( "__cfaehm_rethrow_terminate" ) )
+                        ) );
+                delete throwStmt;
+                return result;
+        }
+        // Visiting/Mutating Functions
+        void ThrowMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the statement's form.
+                ObjectDecl * decl = dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                // Also checking the type would be nice.
+                if ( !decl || !dynamic_cast<PointerType *>( decl->type ) ) {
+                        std::string kind = (CatchStmt::Terminate == catchStmt->kind) ? "catch" : "catchResume";
+                        SemanticError( catchStmt->location, kind + " must have pointer to an exception type" );
+                }
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+                        GuardValue( terminate_handler_except );
+                        terminate_handler_except = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+        Statement * ThrowMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Ignoring throwStmt->get_target() for now.
+                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throw" );
+                        } else if ( TerHandler == cur_context ) {
+                                return create_terminate_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throw in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                } else {
+                        if ( throwStmt->get_expr() ) {
+                                return create_either_throw( throwStmt, "$throwResume" );
+                        } else if ( ResHandler == cur_context ) {
+                                // This has to be handled later.
+                                return throwStmt;
+                        } else {
+                                abort("Invalid throwResume in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                }
+        }
+        class TryMutatorCore {
                 // The built in types used in translation.
                 StructDecl * except_decl;
 …
                 // The many helper functions for code/syntree generation.
-                Statement * create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt );
-                Statement * create_terminate_throw( ThrowStmt * throwStmt );
-                Statement * create_terminate_rethrow( ThrowStmt * throwStmt );
-                Statement * create_resume_throw( ThrowStmt * throwStmt );
-                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
                 CompoundStmt * take_try_block( TryStmt * tryStmt );
                 FunctionDecl * create_try_wrapper( CompoundStmt * body );
 …
                 FunctionDecl * create_finally_wrapper( TryStmt * tryStmt );
                 ObjectDecl * create_finally_hook( FunctionDecl * finally_wrapper );
+                Statement * create_resume_rethrow( ThrowStmt * throwStmt );
                 // Types used in translation, make sure to use clone.
 …
         public:
+                ExceptionMutatorCore() :
+                        cur_context( NoHandler ),
+                        handler_except_decl( nullptr ),
+                TryMutatorCore() :
                         except_decl( nullptr ), node_decl( nullptr ), hook_decl( nullptr ),
                         try_func_t( noQualifiers, false ),
 …
                 {}
-                void premutate( CatchStmt *catchStmt );
                 void premutate( StructDecl *structDecl );
+                Statement * postmutate( TryStmt *tryStmt );
                 Statement * postmutate( ThrowStmt *throwStmt );
-                Statement * postmutate( TryStmt *tryStmt );
         };
         void ExceptionMutatorCore::init_func_types() {
+        void TryMutatorCore::init_func_types() {
                 assert( except_decl );
 …
+        }
-        // ThrowStmt Mutation Helpers
-        Statement * ExceptionMutatorCore::create_given_throw(
-                        const char * throwFunc, ThrowStmt * throwStmt ) {
-                // `throwFunc`( `throwStmt->get_name` );
-                UntypedExpr * call = new UntypedExpr( new NameExpr( throwFunc ) );
-                call->get_args().push_back( throwStmt->get_expr() );
-                throwStmt->set_expr( nullptr );
-                delete throwStmt;
-                return new ExprStmt( call );
+        }
-        Statement * ExceptionMutatorCore::create_terminate_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_terminate( `throwStmt->get_name()` ); }
-                return create_given_throw( "__cfaabi_ehm__throw_terminate", throwStmt );
+        }
-        Statement * ExceptionMutatorCore::create_terminate_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // { `handler_except_decl` = NULL; __rethrow_terminate(); }
-                assert( nullptr == throwStmt->get_expr() );
-                assert( handler_except_decl );
-                CompoundStmt * result = new CompoundStmt();
-                result->labels =  throwStmt->labels;
-                result->push_back( new ExprStmt( UntypedExpr::createAssign(
-                        nameOf( handler_except_decl ),
-                        new ConstantExpr( Constant::null(
-                                new PointerType(
-                                        noQualifiers,
-                                        handler_except_decl->get_type()->clone()
+                                        )
-                                ) )
-                        ) ) );
-                result->push_back( new ExprStmt(
-                        new UntypedExpr( new NameExpr( "__cfaabi_ehm__rethrow_terminate" ) )
-                        ) );
-                delete throwStmt;
-                return result;
+        }
-        Statement * ExceptionMutatorCore::create_resume_throw(
-                        ThrowStmt *throwStmt ) {
-                // __throw_resume( `throwStmt->get_name` );
-                return create_given_throw( "__cfaabi_ehm__throw_resume", throwStmt );
+        }
-        Statement * ExceptionMutatorCore::create_resume_rethrow(
-                        ThrowStmt *throwStmt ) {
-                // return false;
-                Statement * result = new ReturnStmt(
-                        new ConstantExpr( Constant::from_bool( false ) )
-                        );
-                result->labels = throwStmt->labels;
-                delete throwStmt;
-                return result;
+        }
         // TryStmt Mutation Helpers
         CompoundStmt * ExceptionMutatorCore::take_try_block( TryStmt *tryStmt ) {
+        CompoundStmt * TryMutatorCore::take_try_block( TryStmt *tryStmt ) {
                 CompoundStmt * block = tryStmt->get_block();
                 tryStmt->set_block( nullptr );
 …
+        }
         FunctionDecl * ExceptionMutatorCore::create_try_wrapper(
+        FunctionDecl * TryMutatorCore::create_try_wrapper(
                         CompoundStmt *body ) {
 …
+        }
         FunctionDecl * ExceptionMutatorCore::create_terminate_catch(
+        FunctionDecl * TryMutatorCore::create_terminate_catch(
                         CatchList &handlers ) {
                 std::list<CaseStmt *> handler_wrappers;
 …
                         local_except->get_attributes().push_back( new Attribute(
                                 "cleanup",
                                 { new NameExpr( "__cfaabi_ehm__cleanup_terminate" ) }
+                                { new NameExpr( "__cfaehm_cleanup_terminate" ) }
                                 ) );
 …
         // Create a single check from a moddified handler.
         // except_obj is referenced, modded_handler will be freed.
         CompoundStmt * ExceptionMutatorCore::create_single_matcher(
+        CompoundStmt * TryMutatorCore::create_single_matcher(
                         DeclarationWithType * except_obj, CatchStmt * modded_handler ) {
                 // {
 …
+        }
         FunctionDecl * ExceptionMutatorCore::create_terminate_match(
+        FunctionDecl * TryMutatorCore::create_terminate_match(
                         CatchList &handlers ) {
                 // int match(exception * except) {
 …
+        }
         CompoundStmt * ExceptionMutatorCore::create_terminate_caller(
+        CompoundStmt * TryMutatorCore::create_terminate_caller(
                         FunctionDecl * try_wrapper,
                         FunctionDecl * terminate_catch,
                         FunctionDecl * terminate_match ) {
                 // { __cfaabi_ehm__try_terminate(`try`, `catch`, `match`); }
+                // { __cfaehm_try_terminate(`try`, `catch`, `match`); }
                 UntypedExpr * caller = new UntypedExpr( new NameExpr(
                         "__cfaabi_ehm__try_terminate" ) );
+                        "__cfaehm_try_terminate" ) );
                 std::list<Expression *>& args = caller->get_args();
                 args.push_back( nameOf( try_wrapper ) );
 …
+        }
         FunctionDecl * ExceptionMutatorCore::create_resume_handler(
+        FunctionDecl * TryMutatorCore::create_resume_handler(
                         CatchList &handlers ) {
                 // bool handle(exception * except) {
 …
+        }
         CompoundStmt * ExceptionMutatorCore::create_resume_wrapper(
+        CompoundStmt * TryMutatorCore::create_resume_wrapper(
                         Statement * wraps,
                         FunctionDecl * resume_handler ) {
 …
                 // struct __try_resume_node __resume_node
                 //      __attribute__((cleanup( __cfaabi_ehm__try_resume_cleanup )));
+                //      __attribute__((cleanup( __cfaehm_try_resume_cleanup )));
                 // ** unwinding of the stack here could cause problems **
                 // ** however I don't think that can happen currently **
                 // __cfaabi_ehm__try_resume_setup( &__resume_node, resume_handler );
+                // __cfaehm_try_resume_setup( &__resume_node, resume_handler );
                 std::list< Attribute * > attributes;
 …
                         std::list< Expression * > attr_params;
                         attr_params.push_back( new NameExpr(
                                 "__cfaabi_ehm__try_resume_cleanup" ) );
+                                "__cfaehm_try_resume_cleanup" ) );
                         attributes.push_back( new Attribute( "cleanup", attr_params ) );
+                }
 …
                 UntypedExpr *setup = new UntypedExpr( new NameExpr(
                         "__cfaabi_ehm__try_resume_setup" ) );
+                        "__cfaehm_try_resume_setup" ) );
                 setup->get_args().push_back( new AddressExpr( nameOf( obj ) ) );
                 setup->get_args().push_back( nameOf( resume_handler ) );
 …
+        }
         FunctionDecl * ExceptionMutatorCore::create_finally_wrapper(
+        FunctionDecl * TryMutatorCore::create_finally_wrapper(
                         TryStmt * tryStmt ) {
                 // void finally() { <finally code> }
+                // void finally() { `finally->block` }
                 FinallyStmt * finally = tryStmt->get_finally();
                 CompoundStmt * body = finally->get_block();
 …
+        }
         ObjectDecl * ExceptionMutatorCore::create_finally_hook(
+        ObjectDecl * TryMutatorCore::create_finally_hook(
                         FunctionDecl * finally_wrapper ) {
                 // struct __cfaabi_ehm__cleanup_hook __finally_hook
                 //      __attribute__((cleanup( finally_wrapper )));
+                // struct __cfaehm_cleanup_hook __finally_hook
+                //      __attribute__((cleanup( `finally_wrapper` )));
                 // Make Cleanup Attribute.
 …
+        }
+        Statement * TryMutatorCore::create_resume_rethrow( ThrowStmt *throwStmt ) {
+                // return false;
+                Statement * result = new ReturnStmt(
+                        new ConstantExpr( Constant::from_bool( false ) )
+                        );
+                result->labels = throwStmt->labels;
+                delete throwStmt;
+                return result;
+        }
         // Visiting/Mutating Functions
+        void ExceptionMutatorCore::premutate( CatchStmt *catchStmt ) {
+                // Validate the Statement's form.
+                ObjectDecl * decl =
+                        dynamic_cast<ObjectDecl *>( catchStmt->get_decl() );
+                if ( decl && true /* check decl->get_type() */ ) {
+                        // Pass.
+                } else if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        SemanticError(catchStmt->location, "catch must have exception type");
+                } else {
+                        SemanticError(catchStmt->location, "catchResume must have exception type");
+                }
+                // Track the handler context.
+                GuardValue( cur_context );
+                if ( CatchStmt::Terminate == catchStmt->get_kind() ) {
+                        cur_context = TerHandler;
+                        GuardValue( handler_except_decl );
+                        handler_except_decl = decl;
+                } else {
+                        cur_context = ResHandler;
+                }
+        }
+        void ExceptionMutatorCore::premutate( StructDecl *structDecl ) {
+        void TryMutatorCore::premutate( StructDecl *structDecl ) {
                 if ( !structDecl->has_body() ) {
                         // Skip children?
                         return;
                 } else if ( structDecl->get_name() == "__cfaabi_ehm__base_exception_t" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_base_exception_t" ) {
                         assert( nullptr == except_decl );
                         except_decl = structDecl;
                         init_func_types();
                 } else if ( structDecl->get_name() == "__cfaabi_ehm__try_resume_node" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_try_resume_node" ) {
                         assert( nullptr == node_decl );
                         node_decl = structDecl;
                 } else if ( structDecl->get_name() == "__cfaabi_ehm__cleanup_hook" ) {
+                } else if ( structDecl->get_name() == "__cfaehm_cleanup_hook" ) {
                         assert( nullptr == hook_decl );
                         hook_decl = structDecl;
+                }
+                // Later we might get the exception type as well.
+        }
+        Statement * ExceptionMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                assert( except_decl );
+                // Ignoring throwStmt->get_target() for now.
+                if ( ThrowStmt::Terminate == throwStmt->get_kind() ) {
+                        if ( throwStmt->get_expr() ) {
+                                return create_terminate_throw( throwStmt );
+                        } else if ( TerHandler == cur_context ) {
+                                return create_terminate_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throw in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                } else {
+                        if ( throwStmt->get_expr() ) {
+                                return create_resume_throw( throwStmt );
+                        } else if ( ResHandler == cur_context ) {
+                                return create_resume_rethrow( throwStmt );
+                        } else {
+                                abort("Invalid throwResume in %s at %i\n",
+                                        throwStmt->location.filename.c_str(),
+                                        throwStmt->location.first_line);
+                        }
+                }
+        }
+        Statement * ExceptionMutatorCore::postmutate( TryStmt *tryStmt ) {
+        }
+        Statement * TryMutatorCore::postmutate( TryStmt *tryStmt ) {
                 assert( except_decl );
                 assert( node_decl );
 …
+        }
+        void translateEHM( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ExceptionMutatorCore> translator;
+        Statement * TryMutatorCore::postmutate( ThrowStmt *throwStmt ) {
+                // Only valid `throwResume;` statements should remain. (2/3 checks)
+                assert( ThrowStmt::Resume == throwStmt->kind && ! throwStmt->expr );
+                return create_resume_rethrow( throwStmt );
+        }
+        void translateThrows( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<ThrowMutatorCore> translator;
                 mutateAll( translationUnit, translator );
+        }
+        void translateTries( std::list< Declaration *> & translationUnit ) {
+                PassVisitor<TryMutatorCore> translator;
+                mutateAll( translationUnit, translator );
+        }
+}

src/ControlStruct/ExceptTranslate.h

-              r3c64c668
+              r58fe85a
 // Author           : Andrew Beach
 // Created On       : Tus Jun 06 10:13:00 2017
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Jul 22 09:19:23 2017
 // Update Count     : 4
+// Last Modified By : Andrew Beach
+// Last Modified On : Tus May 19 11:47:00 2020
+// Update Count     : 5
 //
 …
 namespace ControlStruct {
+        void translateEHM( std::list< Declaration *> & translationUnit );
+        // Converts exception handling structures into their underlying C code.  Translation does use the exception
+        // handling header, make sure it is visible wherever translation occurs.
+        void translateThrows( std::list< Declaration *> & translationUnit );
+        /* Replaces all throw & throwResume statements with function calls.
+         * These still need to be resolved, so call this before the reslover.
+         */
+        void translateTries( std::list< Declaration *> & translationUnit );
+        /* Replaces all try blocks (and their many clauses) with function definitions and calls.
+         * This uses the exception built-ins to produce typed output and should take place after
+         * the resolver. It also produces virtual casts and should happen before they are expanded.
+         */
+}

src/ControlStruct/module.mk

-              r3c64c668
+              r58fe85a
 SRC_CONTROLSTRUCT = \
         ControlStruct/ForExprMutator.cc \
+        ControlStruct/ForExprMutator.h \
         ControlStruct/LabelFixer.cc \
+        ControlStruct/LabelFixer.h \
         ControlStruct/LabelGenerator.cc \
+        ControlStruct/LabelGenerator.h \
         ControlStruct/MLEMutator.cc \
+        ControlStruct/Mutate.cc
+        ControlStruct/MLEMutator.h \
+        ControlStruct/Mutate.cc \
+        ControlStruct/Mutate.h
 SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc
+SRC += $(SRC_CONTROLSTRUCT) ControlStruct/ExceptTranslate.cc ControlStruct/ExceptTranslate.h
 SRCDEMANGLE += $(SRC_CONTROLSTRUCT)

src/GenPoly/GenPoly.cc

-              r3c64c668
+              r58fe85a
+                }
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, env)) return true;
+                        }
+                        return false;
+                }
                 /// Checks a parameter list for polymorphic parameters from tyVars; will substitute according to env if present
                 bool hasPolyParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
 …
+                }
+                bool hasPolyParams( const std::vector<ast::ptr<ast::Expr>> & params, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                        for (auto &param : params) {
+                                auto paramType = param.strict_as<ast::TypeExpr>();
+                                if (isPolyType(paramType->type, tyVars, env)) return true;
+                        }
+                        return false;
+                }
                 /// Checks a parameter list for dynamic-layout parameters from tyVars; will substitute according to env if present
                 bool hasDynParams( std::list< Expression* >& params, const TyVarMap &tyVars, const TypeSubstitution *env ) {
 …
                         Type *newType = env->lookup( typeInst->get_name() );
                         if ( newType ) return newType;
+                }
+                return type;
+        }
+        const ast::Type * replaceTypeInst(const ast::Type * type, const ast::TypeSubstitution * env) {
+                if (!env) return type;
+                if (auto typeInst = dynamic_cast<const ast::TypeInstType*> (type)) {
+                        auto newType = env->lookup(typeInst);
+                        if (newType) return newType;
+                }
                 return type;
 …
+        }
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+                if ( dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return type;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return 0;
+        }
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env ) {
                 type = replaceTypeInst( type, env );
 …
+                }
                 return 0;
+        }
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env) {
+                type = replaceTypeInst( type, env );
+                if ( auto typeInst = dynamic_cast< const ast::TypeInstType * >( type ) ) {
+                        return tyVars.find(typeInst->typeString()) != tyVars.end() ? type : nullptr;
+                } else if ( auto arrayType = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        return isPolyType( arrayType->base, env );
+                } else if ( auto structType = dynamic_cast< const ast::StructInstType* >( type ) ) {
+                        if ( hasPolyParams( structType->params, env ) ) return type;
+                } else if ( auto unionType = dynamic_cast< const ast::UnionInstType* >( type ) ) {
+                        if ( hasPolyParams( unionType->params, env ) ) return type;
+                }
+                return nullptr;
+        }
 …
+        }
+        namespace {
+                // temporary hack to avoid re-implementing anything related to TyVarMap
+                // does this work? these two structs have identical definitions.
+                inline TypeDecl::Data convData(const ast::TypeDecl::Data & data) {
+                        return *reinterpret_cast<const TypeDecl::Data *>(&data);
+                }
+        }
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env ) {
                 // is parameter is not polymorphic, don't need to box
 …
+        }
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env) {
+                // is parameter is not polymorphic, don't need to box
+                if ( ! isPolyType( param, exprTyVars ) ) return false;
+                ast::ptr<ast::Type> newType = arg;
+                if ( env ) env->apply( newType );
+                // if the argument's type is polymorphic, we don't need to box again!
+                return ! isPolyType( newType );
+        }
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env ) {
                 FunctionType * function = getFunctionType( appExpr->function->result );
 …
+        }
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env) {
+                const ast::FunctionType * function = getFunctionType(appExpr->func->result);
+                assertf( function, "ApplicationExpr has non-function type: %s", toString( appExpr->func->result ).c_str() );
+                TyVarMap exprTyVars(TypeDecl::Data{});
+                makeTyVarMap(function, exprTyVars);
+                return needsBoxing(param, arg, exprTyVars, env);
+        }
         void addToTyVarMap( TypeDecl * tyVar, TyVarMap &tyVarMap ) {
                 tyVarMap.insert( tyVar->name, TypeDecl::Data{ tyVar } );
+        }
+        void addToTyVarMap( const ast::TypeInstType * tyVar, TyVarMap & tyVarMap) {
+                tyVarMap.insert(tyVar->typeString(), convData(ast::TypeDecl::Data{tyVar->base}));
+        }
 …
                 if ( PointerType *pointer = dynamic_cast< PointerType* >( type ) ) {
                         makeTyVarMap( pointer->get_base(), tyVarMap );
+                }
+        }
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap) {
+                if (auto ptype = dynamic_cast<const ast::FunctionType *>(type)) {
+                        for (auto & tyVar : ptype->forall) {
+                                assert (tyVar);
+                                addToTyVarMap(tyVar, tyVarMap);
+                        }
+                }
+                if (auto pointer = dynamic_cast<const ast::PointerType *>(type)) {
+                        makeTyVarMap(pointer->base, tyVarMap);
+                }
+        }

src/GenPoly/GenPoly.h

-              r3c64c668
+              r58fe85a
 namespace GenPoly {
         typedef ErasableScopedMap< std::string, TypeDecl::Data > TyVarMap;
         /// Replaces a TypeInstType by its referrent in the environment, if applicable
         Type* replaceTypeInst( Type* type, const TypeSubstitution* env );
 …
         /// returns polymorphic type if is polymorphic type, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const ast::TypeSubstitution * env = nullptr);
         /// returns polymorphic type if is polymorphic type in tyVars, NULL otherwise; will look up substitution in env if provided
         Type *isPolyType( Type *type, const TyVarMap &tyVars, const TypeSubstitution *env = 0 );
+        const ast::Type * isPolyType(const ast::Type * type, const TyVarMap & tyVars, const ast::TypeSubstitution * env = nullptr);
         /// returns dynamic-layout type if is dynamic-layout type in tyVars, NULL otherwise; will look up substitution in env if provided
 …
         /// true if arg requires boxing given exprTyVars
         bool needsBoxing( Type * param, Type * arg, const TyVarMap &exprTyVars, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const TyVarMap &exprTyVars, const ast::TypeSubstitution * env);
         /// true if arg requires boxing in the call to appExpr
         bool needsBoxing( Type * param, Type * arg, ApplicationExpr * appExpr, const TypeSubstitution * env );
+        bool needsBoxing( const ast::Type * param, const ast::Type * arg, const ast::ApplicationExpr * appExpr, const ast::TypeSubstitution * env);
         /// Adds the type variable `tyVar` to `tyVarMap`
 …
         /// Adds the declarations in the forall list of type (and its pointed-to type if it's a pointer type) to `tyVarMap`
         void makeTyVarMap( Type *type, TyVarMap &tyVarMap );
+        void makeTyVarMap(const ast::Type * type, TyVarMap & tyVarMap);
         /// Prints type variable map

src/GenPoly/InstantiateGeneric.cc

-              r3c64c668
+              r58fe85a
 // Author           : Aaron B. Moss
 // Created On       : Thu Aug 04 18:33:00 2016
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Thu Aug 04 18:33:00 2016
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Jul 16 10:17:00 2020
+// Update Count     : 2
 //
 #include "InstantiateGeneric.h"
 …
                 InstantiationMap< AggregateDecl, AggregateDecl > instantiations;
                 /// Set of types which are dtype-only generic (and therefore have static layout)
                 ScopedSet< AggregateDecl* > dtypeStatics;
+                std::set<AggregateDecl *> dtypeStatics;
                 /// Namer for concrete types
                 UniqueName typeNamer;
 …
+        }
+        template< typename AggrInst >
+        static AggrInst * asForward( AggrInst * decl ) {
+                if ( !decl->body ) {
+                        return nullptr;
+                }
+                decl = decl->clone();
+                decl->body = false;
+                deleteAll( decl->members );
+                decl->members.clear();
+                return decl;
+        }
         void GenericInstantiator::stripDtypeParams( AggregateDecl *base, std::list< TypeDecl* >& baseParams, const std::list< TypeExpr* >& typeSubs ) {
                 substituteMembers( base->get_members(), baseParams, typeSubs );
 …
                                 concDecl->set_body( inst->get_baseStruct()->has_body() );
                                 substituteMembers( inst->get_baseStruct()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                // Forward declare before recursion. (TODO: Only when needed, #199.)
+                                insert( inst, typeSubs, concDecl );
+                                if ( StructDecl *forwardDecl = asForward( concDecl ) ) {
+                                        declsToAddBefore.push_back( forwardDecl );
+                                }
                                 concDecl->acceptMutator( *visitor ); // recursively instantiate members
                                 declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
 …
                                 concDecl->set_body( inst->get_baseUnion()->has_body() );
                                 substituteMembers( inst->get_baseUnion()->get_members(), *inst->get_baseParameters(), typeSubs, concDecl->get_members() );
+                                insert( inst, typeSubs, concDecl ); // must insert before recursion
+                                // Forward declare before recursion. (TODO: Only when needed, #199.)
+                                insert( inst, typeSubs, concDecl );
+                                if ( UnionDecl *forwardDecl = asForward( concDecl ) ) {
+                                        declsToAddBefore.push_back( forwardDecl );
+                                }
                                 concDecl->acceptMutator( *visitor ); // recursively instantiate members
                                 declsToAddBefore.push_back( concDecl ); // must occur before declaration is added so that member instantiations appear first
 …
         void GenericInstantiator::beginScope() {
                 instantiations.beginScope();
-                dtypeStatics.beginScope();
+        }
         void GenericInstantiator::endScope() {
                 instantiations.endScope();
-                dtypeStatics.endScope();
+        }

src/GenPoly/Specialize.cc

-              r3c64c668
+              r58fe85a
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 23:40:49 2019
 // Update Count     : 32
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Jul  2 17:42:00 2020
+// Update Count     : 33
 //
 …
 namespace GenPoly {
+        struct Specialize final : public WithConstTypeSubstitution, public WithStmtsToAdd, public WithVisitorRef<Specialize> {
+        struct Specialize final : public WithConstTypeSubstitution,
+                        public WithDeclsToAdd, public WithVisitorRef<Specialize> {
                 Expression * postmutate( ApplicationExpr *applicationExpr );
                 Expression * postmutate( CastExpr *castExpr );
 …
                 thunkFunc->get_attributes().push_back( new Attribute( "unused" ) );
+                // Thunks at the global level must be static to avoid collisions between files.
+                // (Conversly thunks inside a function must be unique and not static.)
+                thunkFunc->storageClasses.is_static = !isInFunction();
                 // thread thunk parameters into call to actual function, naming thunk parameters as we go
                 UniqueName paramNamer( paramPrefix );
 …
                 } // if
+                // handle any specializations that may still be present
+                std::string oldParamPrefix = paramPrefix;
+                paramPrefix += "p";
+                // save stmtsToAddBefore in oldStmts
+                std::list< Statement* > oldStmts;
+                oldStmts.splice( oldStmts.end(), stmtsToAddBefore );
+                appExpr->acceptMutator( *visitor );
+                paramPrefix = oldParamPrefix;
+                // write any statements added for recursive specializations into the thunk body
+                thunkFunc->statements->kids.splice( thunkFunc->statements->kids.end(), stmtsToAddBefore );
+                // restore oldStmts into stmtsToAddBefore
+                stmtsToAddBefore.splice( stmtsToAddBefore.end(), oldStmts );
+                // Handle any specializations that may still be present.
+                {
+                        std::string oldParamPrefix = paramPrefix;
+                        paramPrefix += "p";
+                        std::list< Declaration * > oldDecls;
+                        oldDecls.splice( oldDecls.end(), declsToAddBefore );
+                        appExpr->acceptMutator( *visitor );
+                        // Write recursive specializations into the thunk body.
+                        for ( Declaration * decl : declsToAddBefore ) {
+                                thunkFunc->statements->kids.push_back( new DeclStmt( decl ) );
+                        }
+                        declsToAddBefore = std::move( oldDecls );
+                        paramPrefix = oldParamPrefix;
+                }
                 // add return (or valueless expression) to the thunk
 …
                 thunkFunc->statements->kids.push_back( appStmt );
                 // add thunk definition to queue of statements to add
                 stmtsToAddBefore.push_back( new DeclStmt( thunkFunc ) );
+                // Add the thunk definition (converted to DeclStmt if appproprate).
+                declsToAddBefore.push_back( thunkFunc );
                 // return address of thunk function as replacement expression
                 return new AddressExpr( new VariableExpr( thunkFunc ) );

src/GenPoly/module.mk

-              r3c64c668
+              r58fe85a
 SRC += GenPoly/Box.cc \
+       GenPoly/Box.h \
+       GenPoly/ErasableScopedMap.h \
+       GenPoly/FindFunction.cc \
+       GenPoly/FindFunction.h \
        GenPoly/GenPoly.cc \
+       GenPoly/GenPoly.h \
+       GenPoly/InstantiateGeneric.cc \
+       GenPoly/InstantiateGeneric.h \
+       GenPoly/Lvalue.cc \
+       GenPoly/Lvalue.h \
+       GenPoly/ScopedSet.h \
        GenPoly/ScrubTyVars.cc \
        GenPoly/Lvalue.cc \
+       GenPoly/ScrubTyVars.h \
        GenPoly/Specialize.cc \
+       GenPoly/FindFunction.cc \
+       GenPoly/InstantiateGeneric.cc
+       GenPoly/Specialize.h
 SRCDEMANGLE += GenPoly/GenPoly.cc GenPoly/Lvalue.cc
+SRCDEMANGLE += GenPoly/GenPoly.cc GenPoly/GenPoly.h GenPoly/Lvalue.cc GenPoly/Lvalue.h

src/InitTweak/FixGlobalInit.cc

-              r3c64c668
+              r58fe85a
 #include "SynTree/Visitor.h"       // for acceptAll, Visitor
+#include "AST/Expr.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
 namespace InitTweak {
         class GlobalFixer : public WithShortCircuiting {
 …
                 FunctionDecl * initFunction;
                 FunctionDecl * destroyFunction;
+        };
+        class GlobalFixer_new : public ast::WithShortCircuiting {
+        public:
+                void previsit (const ast::ObjectDecl *);
+                void previsit (const ast::FunctionDecl *) { visit_children = false; }
+                void previsit (const ast::StructDecl *) { visit_children = false; }
+                void previsit (const ast::UnionDecl *) { visit_children = false; }
+                void previsit (const ast::EnumDecl *) { visit_children = false; }
+                void previsit (const ast::TraitDecl *) { visit_children = false; }
+                void previsit (const ast::TypeDecl *) { visit_children = false; }
+                std::list< ast::ptr<ast::Stmt> > initStmts;
+                std::list< ast::ptr<ast::Stmt> > destroyStmts;
         };
 …
+        }
+        void fixGlobalInit(ast::TranslationUnit & translationUnit, bool inLibrary) {
+                ast::Pass<GlobalFixer_new> fixer;
+                accept_all(translationUnit, fixer);
+                if ( !fixer.core.initStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> ctorParams;
+                        if (inLibrary) ctorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto initFunction = new ast::FunctionDecl({}, "__global_init__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.initStmts)),
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("constructor", std::move(ctorParams))});
+                        translationUnit.decls.emplace_back( initFunction );
+                } // if
+                if ( !fixer.core.destroyStmts.empty() ) {
+                        std::vector<ast::ptr<ast::Expr>> dtorParams;
+                        if (inLibrary) dtorParams.emplace_back(ast::ConstantExpr::from_int({}, 200));
+                        auto destroyFunction = new ast::FunctionDecl({}, "__global_destroy__", {}, {}, {}, new ast::CompoundStmt({}, std::move(fixer.core.destroyStmts)),
+                                ast::Storage::Static, ast::Linkage::C, {new ast::Attribute("destructor", std::move(dtorParams))});
+                        translationUnit.decls.emplace_back(destroyFunction);
+                } // if
+        }
         void GlobalFixer::previsit( ObjectDecl *objDecl ) {
                 std::list< Statement * > & initStatements = initFunction->get_statements()->get_kids();
 …
                         } // if
                         if ( Statement * ctor = ctorInit->ctor ) {
+                                addDataSectonAttribute( objDecl );
                                 initStatements.push_back( ctor );
                                 objDecl->init = nullptr;
 …
+        }
+        void GlobalFixer_new::previsit(const ast::ObjectDecl * objDecl) {
+                auto mutDecl = mutate(objDecl);
+                assertf(mutDecl == objDecl, "Global object decl must be unique");
+                if ( auto ctorInit = objDecl->init.as<ast::ConstructorInit>() ) {
+                        // a decision should have been made by the resolver, so ctor and init are not both non-NULL
+                        assert( ! ctorInit->ctor || ! ctorInit->init );
+                        const ast::Stmt * dtor = ctorInit->dtor;
+                        if ( dtor && ! isIntrinsicSingleArgCallStmt( dtor ) ) {
+                                // don't need to call intrinsic dtor, because it does nothing, but
+                                // non-intrinsic dtors must be called
+                                destroyStmts.push_front( dtor );
+                                // ctorInit->dtor = nullptr;
+                        } // if
+                        if ( const ast::Stmt * ctor = ctorInit->ctor ) {
+                                addDataSectionAttribute(mutDecl);
+                                initStmts.push_back( ctor );
+                                mutDecl->init = nullptr;
+                                // ctorInit->ctor = nullptr;
+                        } else if ( const ast::Init * init = ctorInit->init ) {
+                                mutDecl->init = init;
+                                // ctorInit->init = nullptr;
+                        } else {
+                                // no constructor and no initializer, which is okay
+                                mutDecl->init = nullptr;
+                        } // if
+                        // delete ctorInit;
+                } // if
+        }
         // only modify global variables
         void GlobalFixer::previsit( FunctionDecl * ) { visit_children = false; }

src/InitTweak/FixGlobalInit.h

-              r3c64c668
+              r58fe85a
 #include <string>  // for string
+#include <AST/Fwd.hpp>
 class Declaration;
 …
         /// function is for library code.
         void fixGlobalInit( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fixGlobalInit( ast::TranslationUnit & translationUnit, bool inLibrary );
 } // namespace

src/InitTweak/FixInit.cc

-              r3c64c668
+              r58fe85a
                 };
                 struct SplitExpressions : public WithShortCircuiting, public WithTypeSubstitution, public WithStmtsToAdd {
+                struct SplitExpressions : public WithShortCircuiting, /*public WithTypeSubstitution, */public WithStmtsToAdd {
                         /// add CompoundStmts around top-level expressions so that temporaries are destroyed in the correct places.
                         static void split( std::list< Declaration * > &translationUnit );
 …
                                 if ( Statement * ctor = ctorInit->get_ctor() ) {
                                         if ( objDecl->get_storageClasses().is_static ) {
+                                                // The ojbect needs to go in the data section, regardless of dtor complexity below.
+                                                // The attribute works, and is meant to apply, both for leaving the static local alone,
+                                                // and for hoisting it out as a static global.
+                                                addDataSectonAttribute( objDecl );
                                                 // originally wanted to take advantage of gcc nested functions, but
                                                 // we get memory errors with this approach. To remedy this, the static

src/InitTweak/FixInit.h

-              r3c64c668
+              r58fe85a
 class Declaration;
+namespace ast {
+        struct TranslationUnit;
+}
 namespace InitTweak {
         /// replace constructor initializers with expression statements and unwrap basic C-style initializers
         void fix( std::list< Declaration * > & translationUnit, bool inLibrary );
+        void fix( ast::TranslationUnit & translationUnit, bool inLibrary);
 } // namespace

src/InitTweak/GenInit.cc

-              r3c64c668
+              r58fe85a
 #include "AST/Node.hpp"
 #include "AST/Stmt.hpp"
+#include "CompilationState.h"
 #include "CodeGen/OperatorTable.h"
 #include "Common/PassVisitor.h"        // for PassVisitor, WithGuards, WithShort...
 …
         };
+        struct HoistArrayDimension_NoResolve final : public WithDeclsToAdd, public WithShortCircuiting, public WithGuards {
+                /// hoist dimension from array types in object declaration so that it uses a single
+                /// const variable of type size_t, so that side effecting array dimensions are only
+                /// computed once.
+                static void hoistArrayDimension( std::list< Declaration * > & translationUnit );
+                void premutate( ObjectDecl * objectDecl );
+                DeclarationWithType * postmutate( ObjectDecl * objectDecl );
+                void premutate( FunctionDecl *functionDecl );
+                // should not traverse into any of these declarations to find objects
+                // that need to be constructed or destructed
+                void premutate( AggregateDecl * ) { visit_children = false; }
+                void premutate( NamedTypeDecl * ) { visit_children = false; }
+                void premutate( FunctionType * ) { visit_children = false; }
+                void hoist( Type * type );
+                Type::StorageClasses storageClasses;
+                bool inFunction = false;
+        };
         void genInit( std::list< Declaration * > & translationUnit ) {
+                if (!useNewAST) {
+                        HoistArrayDimension::hoistArrayDimension( translationUnit );
+                }
+                else {
+                        HoistArrayDimension_NoResolve::hoistArrayDimension( translationUnit );
+                }
                 fixReturnStatements( translationUnit );
+                HoistArrayDimension::hoistArrayDimension( translationUnit );
+                CtorDtor::generateCtorDtor( translationUnit );
+                if (!useNewAST) {
+                        CtorDtor::generateCtorDtor( translationUnit );
+                }
+        }
 …
                         arrayType->isVarLen = ! isConstExpr( arrayType->dimension );
                         // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
+                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
+                        // still try to detect constant expressions
                         if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
 …
         void HoistArrayDimension::premutate( FunctionDecl * ) {
+                GuardValue( inFunction );
+                inFunction = true;
+        }
+        // precompute array dimension expression, because constructor generation may duplicate it,
+        // which would be incorrect if it is a side-effecting computation.
+        void HoistArrayDimension_NoResolve::hoistArrayDimension( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<HoistArrayDimension_NoResolve> hoister;
+                mutateAll( translationUnit, hoister );
+        }
+        void HoistArrayDimension_NoResolve::premutate( ObjectDecl * objectDecl ) {
+                GuardValue( storageClasses );
+                storageClasses = objectDecl->get_storageClasses();
+        }
+        DeclarationWithType * HoistArrayDimension_NoResolve::postmutate( ObjectDecl * objectDecl ) {
+                hoist( objectDecl->get_type() );
+                return objectDecl;
+        }
+        void HoistArrayDimension_NoResolve::hoist( Type * type ) {
+                // if in function, generate const size_t var
+                static UniqueName dimensionName( "_array_dim" );
+                // C doesn't allow variable sized arrays at global scope or for static variables, so don't hoist dimension.
+                if ( ! inFunction ) return;
+                if ( storageClasses.is_static ) return;
+                if ( ArrayType * arrayType = dynamic_cast< ArrayType * >( type ) ) {
+                        if ( ! arrayType->get_dimension() ) return; // xxx - recursive call to hoist?
+                        // don't need to hoist dimension if it's definitely pure - only need to if there's potential for side effects.
+                        // xxx - hoisting has no side effects anyways, so don't skip since we delay resolve
+                        // still try to detect constant expressions
+                        if ( ! Tuples::maybeImpure( arrayType->dimension ) ) return;
+                        ObjectDecl * arrayDimension = new ObjectDecl( dimensionName.newName(), storageClasses, LinkageSpec::C, 0, Validate::SizeType->clone(), new SingleInit( arrayType->get_dimension() ) );
+                        arrayDimension->get_type()->set_const( true );
+                        arrayType->set_dimension( new VariableExpr( arrayDimension ) );
+                        declsToAddBefore.push_back( arrayDimension );
+                        hoist( arrayType->get_base() );
+                        return;
+                }
+        }
+        void HoistArrayDimension_NoResolve::premutate( FunctionDecl * ) {
                 GuardValue( inFunction );
                 inFunction = true;
 …
+        }
+        // why is this not just on FunctionDecl?
         void ManagedTypes::handleDWT( DeclarationWithType * dwt ) {
                 // if this function is a user-defined constructor or destructor, mark down the type as "managed"
 …
         void ManagedTypes::endScope() { managedTypes.endScope(); }
+        bool ManagedTypes_new::isManaged( const ast::Type * type ) const {
+                // references are never constructed
+                if ( dynamic_cast< const ast::ReferenceType * >( type ) ) return false;
+                if ( auto tupleType = dynamic_cast< const ast::TupleType * > ( type ) ) {
+                        // tuple is also managed if any of its components are managed
+                        for (auto & component : tupleType->types) {
+                                if (isManaged(component)) return true;
+                        }
+                }
+                // need to clear and reset qualifiers when determining if a type is managed
+                // ValueGuard< Type::Qualifiers > qualifiers( type->get_qualifiers() );
+                auto tmp = shallowCopy(type);
+                tmp->qualifiers = {};
+                // delete tmp at return
+                ast::ptr<ast::Type> guard = tmp;
+                // a type is managed if it appears in the map of known managed types, or if it contains any polymorphism (is a type variable or generic type containing a type variable)
+                return managedTypes.find( Mangle::mangle( tmp, {Mangle::NoOverrideable | Mangle::NoGenericParams | Mangle::Type} ) ) != managedTypes.end() || GenPoly::isPolyType( tmp );
+        }
+        bool ManagedTypes_new::isManaged( const ast::ObjectDecl * objDecl ) const {
+                const ast::Type * type = objDecl->type;
+                while ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        // must always construct VLAs with an initializer, since this is an error in C
+                        if ( at->isVarLen && objDecl->init ) return true;
+                        type = at->base;
+                }
+                return isManaged( type );
+        }
+        void ManagedTypes_new::handleDWT( const ast::DeclWithType * dwt ) {
+                // if this function is a user-defined constructor or destructor, mark down the type as "managed"
+                if ( ! dwt->linkage.is_overrideable && CodeGen::isCtorDtor( dwt->name ) ) {
+                        auto & params = GenPoly::getFunctionType( dwt->get_type())->params;
+                        assert( ! params.empty() );
+                        // Type * type = InitTweak::getPointerBase( params.front() );
+                        // assert( type );
+                        managedTypes.insert( Mangle::mangle( params.front(), {Mangle::NoOverrideable | Mangle::NoGenericParams | Mangle::Type} ) );
+                }
+        }
+        void ManagedTypes_new::handleStruct( const ast::StructDecl * aggregateDecl ) {
+                // don't construct members, but need to take note if there is a managed member,
+                // because that means that this type is also managed
+                for ( auto & member : aggregateDecl->members ) {
+                        if ( auto field = member.as<ast::ObjectDecl>() ) {
+                                if ( isManaged( field ) ) {
+                                        // generic parameters should not play a role in determining whether a generic type is constructed - construct all generic types, so that
+                                        // polymorphic constructors make generic types managed types
+                                        ast::StructInstType inst( aggregateDecl );
+                                        managedTypes.insert( Mangle::mangle( &inst, {Mangle::NoOverrideable | Mangle::NoGenericParams | Mangle::Type} ) );
+                                        break;
+                                }
+                        }
+                }
+        }
+        void ManagedTypes_new::beginScope() { managedTypes.beginScope(); }
+        void ManagedTypes_new::endScope() { managedTypes.endScope(); }
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg ) {
                 // call into genImplicitCall from Autogen.h to generate calls to ctor/dtor
 …
                 assert( stmts.size() <= 1 );
                 return stmts.size() == 1 ? strict_dynamic_cast< ImplicitCtorDtorStmt * >( stmts.front() ) : nullptr;
+        }
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg) {
+                assertf(objDecl, "genCtorDtor passed null objDecl");
+                InitExpander_new srcParam(arg);
+                return SymTab::genImplicitCall(srcParam, new ast::VariableExpr(loc, objDecl), loc, fname, objDecl);
+        }
 …
         // constructable object
         InitExpander_new srcParam{ objDecl->init }, nullParam{ (const ast::Init *)nullptr };
+        ast::ptr< ast::Expr > dstParam = new ast::VariableExpr(loc, objDecl);
         ast::ptr< ast::Stmt > ctor = SymTab::genImplicitCall(
                 srcParam, new ast::VariableExpr{ loc, objDecl }, loc, "?{}", objDecl );
+                srcParam, dstParam, loc, "?{}", objDecl );
         ast::ptr< ast::Stmt > dtor = SymTab::genImplicitCall(
                 nullParam, new ast::VariableExpr{ loc, objDecl }, loc, "^?{}", objDecl,
+                nullParam, dstParam, loc, "^?{}", objDecl,
                 SymTab::LoopBackward );

src/InitTweak/GenInit.h

-              r3c64c668
+              r58fe85a
         /// generates a single ctor/dtor statement using objDecl as the 'this' parameter and arg as the optional argument
         ImplicitCtorDtorStmt * genCtorDtor( const std::string & fname, ObjectDecl * objDecl, Expression * arg = nullptr );
+        ast::ptr<ast::Stmt> genCtorDtor (const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * objDecl, const ast::Expr * arg = nullptr);
         /// creates an appropriate ConstructorInit node which contains a constructor, destructor, and C-initializer
 …
                 GenPoly::ScopedSet< std::string > managedTypes;
         };
+        class ManagedTypes_new {
+        public:
+                bool isManaged( const ast::ObjectDecl * objDecl ) const ; // determine if object is managed
+                bool isManaged( const ast::Type * type ) const; // determine if type is managed
+                void handleDWT( const ast::DeclWithType * dwt ); // add type to managed if ctor/dtor
+                void handleStruct( const ast::StructDecl * aggregateDecl ); // add type to managed if child is managed
+                void beginScope();
+                void endScope();
+        private:
+                GenPoly::ScopedSet< std::string > managedTypes;
+        };
 } // namespace

src/InitTweak/InitTweak.cc

-              r3c64c668
+              r58fe85a
                 };
+                struct HasDesignations_new : public ast::WithShortCircuiting {
+                        bool result = false;
+                        void previsit( const ast::Node * ) {
+                                // short circuit if we already know there are designations
+                                if ( result ) visit_children = false;
+                        }
+                        void previsit( const ast::Designation * des ) {
+                                // short circuit if we already know there are designations
+                                if ( result ) visit_children = false;
+                                else if ( ! des->designators.empty() ) {
+                                        result = true;
+                                        visit_children = false;
+                                }
+                        }
+                };
+                struct InitDepthChecker_new : public ast::WithGuards {
+                        bool result = true;
+                        const ast::Type * type;
+                        int curDepth = 0, maxDepth = 0;
+                        InitDepthChecker_new( const ast::Type * type ) : type( type ) {
+                                const ast::Type * t = type;
+                                while ( auto at = dynamic_cast< const ast::ArrayType * >( t ) ) {
+                                        maxDepth++;
+                                        t = at->base;
+                                }
+                                maxDepth++;
+                        }
+                        void previsit( ListInit * ) {
+                                curDepth++;
+                                GuardAction( [this]() { curDepth--; } );
+                                if ( curDepth > maxDepth ) result = false;
+                        }
+                };
                 struct InitFlattener_old : public WithShortCircuiting {
                         void previsit( SingleInit * singleInit ) {
 …
+        }
+        bool isDesignated( const ast::Init * init ) {
+                ast::Pass<HasDesignations_new> finder;
+                maybe_accept( init, finder );
+                return finder.core.result;
+        }
+        bool checkInitDepth( const ast::ObjectDecl * objDecl ) {
+                ast::Pass<InitDepthChecker_new> checker( objDecl->type );
+                maybe_accept( objDecl->init.get(), checker );
+                return checker.core.result;
+        }
 std::vector< ast::ptr< ast::Expr > > makeInitList( const ast::Init * init ) {
         ast::Pass< InitFlattener_new > flattener;
         maybe_accept( init, flattener );
         return std::move( flattener.pass.argList );
+        return std::move( flattener.core.argList );
+}
 …
                         if ( auto listInit = dynamic_cast< const ast::ListInit * >( init ) ) {
                                 for ( const ast::Init * init : *listInit ) {
                                         buildCallExpr( callExpr, index, dimension, init, out );
+                                        buildCallExpr( shallowCopy(callExpr), index, dimension, init, out );
+                                }
                         } else {
                                 buildCallExpr( callExpr, index, dimension, init, out );
+                                buildCallExpr( shallowCopy(callExpr), index, dimension, init, out );
+                        }
                 } else {
 …
+        }
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func) {
+                assertf( func, "getParamThis: nullptr ftype" );
+                auto & params = func->params;
+                assertf( ! params.empty(), "getParamThis: ftype with 0 parameters: %s", toString( func ).c_str());
+                return params.front().strict_as<ast::ObjectDecl>();
+        }
         bool tryConstruct( DeclarationWithType * dwt ) {
                 ObjectDecl * objDecl = dynamic_cast< ObjectDecl * >( dwt );
 …
+        }
+        bool tryConstruct( const ast::DeclWithType * dwt ) {
+                auto objDecl = dynamic_cast< const ast::ObjectDecl * >( dwt );
+                if ( ! objDecl ) return false;
+                return (objDecl->init == nullptr ||
+                                ( objDecl->init != nullptr && objDecl->init->maybeConstructed ))
+                        && ! objDecl->storage.is_extern
+                        && isConstructable( objDecl->type );
+        }
+        bool isConstructable( const ast::Type * type ) {
+                return ! dynamic_cast< const ast::VarArgsType * >( type ) && ! dynamic_cast< const ast::ReferenceType * >( type )
+                && ! dynamic_cast< const ast::FunctionType * >( type ) && ! Tuples::isTtype( type );
+        }
         struct CallFinder_old {
                 CallFinder_old( const std::list< std::string > & names ) : names( names ) {}
 …
         struct CallFinder_new final {
                 std::vector< ast::ptr< ast::Expr > > matches;
+                std::vector< const ast::Expr * > matches;
                 const std::vector< std::string > names;
 …
+        }
         std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt ) {
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt ) {
                 ast::Pass< CallFinder_new > finder{ std::vector< std::string >{ "?{}", "^?{}" } };
                 maybe_accept( stmt, finder );
                 return std::move( finder.pass.matches );
+                return std::move( finder.core.matches );
+        }
 …
                 template <typename Predicate>
                 bool allofCtorDtor( const ast::Stmt * stmt, const Predicate & pred ) {
                         std::vector< ast::ptr< ast::Expr > > callExprs = collectCtorDtorCalls( stmt );
+                        std::vector< const ast::Expr * > callExprs = collectCtorDtorCalls( stmt );
                         return std::all_of( callExprs.begin(), callExprs.end(), pred );
+                }
 …
+        }
+        // looks like some other such codegen uses UntypedExpr and does not create fake function. should revisit afterwards
+        // following passes may accidentally resolve this expression if returned as untyped...
+        ast::Expr * createBitwiseAssignment (const ast::Expr * dst, const ast::Expr * src) {
+                static ast::ptr<ast::FunctionDecl> assign = nullptr;
+                if (!assign) {
+                        auto td = new ast::TypeDecl({}, "T", {}, nullptr, ast::TypeDecl::Dtype, true);
+                        assign = new ast::FunctionDecl({}, "?=?", {},
+                        { new ast::ObjectDecl({}, "_dst", new ast::ReferenceType(new ast::TypeInstType("T", td))),
+                          new ast::ObjectDecl({}, "_src", new ast::TypeInstType("T", td))},
+                        { new ast::ObjectDecl({}, "_ret", new ast::TypeInstType("T", td))}, nullptr, {}, ast::Linkage::Intrinsic);
+                }
+                if (dst->result.as<ast::ReferenceType>()) {
+                        for (int depth = dst->result->referenceDepth(); depth > 0; depth--) {
+                                dst = new ast::AddressExpr(dst);
+                        }
+                }
+                else {
+                        dst = new ast::CastExpr(dst, new ast::ReferenceType(dst->result, {}));
+                }
+                if (src->result.as<ast::ReferenceType>()) {
+                        for (int depth = src->result->referenceDepth(); depth > 0; depth--) {
+                                src = new ast::AddressExpr(src);
+                        }
+                }
+                return new ast::ApplicationExpr(dst->location, ast::VariableExpr::functionPointer(dst->location, assign), {dst, src});
+        }
         struct ConstExprChecker : public WithShortCircuiting {
                 // most expressions are not const expr
 …
         };
+        struct ConstExprChecker_new : public ast::WithShortCircuiting {
+                // most expressions are not const expr
+                void previsit( const ast::Expr * ) { result = false; visit_children = false; }
+                void previsit( const ast::AddressExpr *addressExpr ) {
+                        visit_children = false;
+                        const ast::Expr * arg = addressExpr->arg;
+                        // address of a variable or member expression is constexpr
+                        if ( ! dynamic_cast< const ast::NameExpr * >( arg )
+                        && ! dynamic_cast< const ast::VariableExpr * >( arg )
+                        && ! dynamic_cast< const ast::MemberExpr * >( arg )
+                        && ! dynamic_cast< const ast::UntypedMemberExpr * >( arg ) ) result = false;
+                }
+                // these expressions may be const expr, depending on their children
+                void previsit( const ast::SizeofExpr * ) {}
+                void previsit( const ast::AlignofExpr * ) {}
+                void previsit( const ast::UntypedOffsetofExpr * ) {}
+                void previsit( const ast::OffsetofExpr * ) {}
+                void previsit( const ast::OffsetPackExpr * ) {}
+                void previsit( const ast::CommaExpr * ) {}
+                void previsit( const ast::LogicalExpr * ) {}
+                void previsit( const ast::ConditionalExpr * ) {}
+                void previsit( const ast::CastExpr * ) {}
+                void previsit( const ast::ConstantExpr * ) {}
+                void previsit( const ast::VariableExpr * varExpr ) {
+                        visit_children = false;
+                        if ( auto inst = varExpr->result.as<ast::EnumInstType>() ) {
+                                long long int value;
+                                if ( inst->base->valueOf( varExpr->var, value ) ) {
+                                        // enumerators are const expr
+                                        return;
+                                }
+                        }
+                        result = false;
+                }
+                bool result = true;
+        };
         bool isConstExpr( Expression * expr ) {
                 if ( expr ) {
 …
+        }
+        bool isConstExpr( const ast::Expr * expr ) {
+                if ( expr ) {
+                        ast::Pass<ConstExprChecker_new> checker;
+                        expr->accept( checker );
+                        return checker.core.result;
+                }
+                return true;
+        }
+        bool isConstExpr( const ast::Init * init ) {
+                if ( init ) {
+                        ast::Pass<ConstExprChecker_new> checker;
+                        init->accept( checker );
+                        return checker.core.result;
+                } // if
+                // for all intents and purposes, no initializer means const expr
+                return true;
+        }
         bool isConstructor( const std::string & str ) { return str == "?{}"; }
         bool isDestructor( const std::string & str ) { return str == "^?{}"; }
 …
                 if ( ftype->params.size() != 2 ) return false;
                 const ast::Type * t1 = getPointerBase( ftype->params.front()->get_type() );
+                const ast::Type * t1 = getPointerBase( ftype->params.front() );
                 if ( ! t1 ) return false;
                 const ast::Type * t2 = ftype->params.back()->get_type();
+                const ast::Type * t2 = ftype->params.back();
                 return ResolvExpr::typesCompatibleIgnoreQualifiers( t1, t2, ast::SymbolTable{} );
 …
                 return isCopyFunction( decl, "?{}" );
+        }
+        void addDataSectonAttribute( ObjectDecl * objDecl ) {
+                Type *strLitT = new PointerType( Type::Qualifiers( ),
+                        new BasicType( Type::Qualifiers( ), BasicType::Char ) );
+                std::list< Expression * > attr_params;
+                attr_params.push_back(
+                        new ConstantExpr( Constant( strLitT, "\".data#\"", std::nullopt ) ) );
+                objDecl->attributes.push_back(new Attribute("section", attr_params));
+        }
+        void addDataSectionAttribute( ast::ObjectDecl * objDecl ) {
+                auto strLitT = new ast::PointerType(new ast::BasicType(ast::BasicType::Char));
+                objDecl->attributes.push_back(new ast::Attribute("section", {new ast::ConstantExpr(objDecl->location, strLitT, "\".data#\"", std::nullopt)}));
+        }
+}

src/InitTweak/InitTweak.h

-              r3c64c668
+              r58fe85a
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+        const ast::ObjectDecl * getParamThis(const ast::FunctionDecl * func);
         /// generate a bitwise assignment operation.
         ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
+        ast::Expr * createBitwiseAssignment( const ast::Expr * dst, const ast::Expr * src);
         /// transform Initializer into an argument list that can be passed to a call expression
 …
         /// True if the resolver should try to construct dwt
         bool tryConstruct( DeclarationWithType * dwt );
+        bool tryConstruct( const ast::DeclWithType * dwt );
         /// True if the type can have a user-defined constructor
         bool isConstructable( Type * t );
+        bool isConstructable( const ast::Type * t );
         /// True if the Initializer contains designations
         bool isDesignated( Initializer * init );
+        bool isDesignated( const ast::Init * init );
         /// True if the ObjectDecl's Initializer nesting level is not deeper than the depth of its
         /// type, where the depth of its type is the number of nested ArrayTypes + 1
         bool checkInitDepth( ObjectDecl * objDecl );
+        bool checkInitDepth( const ast::ObjectDecl * objDecl );
         /// returns the declaration of the function called by the expr (must be ApplicationExpr or UntypedExpr)
 …
         /// get all Ctor/Dtor call expressions from a Statement
         void collectCtorDtorCalls( Statement * stmt, std::list< Expression * > & matches );
         std::vector< ast::ptr< ast::Expr > > collectCtorDtorCalls( const ast::Stmt * stmt );
+        std::vector< const ast::Expr * > collectCtorDtorCalls( const ast::Stmt * stmt );
         /// get the Ctor/Dtor call expression from a Statement that looks like a generated ctor/dtor call
 …
         bool isConstExpr( Expression * expr );
         bool isConstExpr( Initializer * init );
+        bool isConstExpr( const ast::Expr * expr );
+        bool isConstExpr( const ast::Init * init );
+        /// Modifies objDecl to have:
+        ///    __attribute__((section (".data#")))
+        /// which makes gcc put the declared variable in the data section,
+        /// which is helpful for global constants on newer gcc versions,
+        /// so that CFA's generated initialization won't segfault when writing it via a const cast.
+        /// The trailing # is an injected assembly comment, to suppress the "a" in
+        ///    .section .data,"a"
+        ///    .section .data#,"a"
+        /// to avoid assembler warning "ignoring changed section attributes for .data"
+        void addDataSectonAttribute( ObjectDecl * objDecl );
+        void addDataSectionAttribute( ast::ObjectDecl * objDecl );
         class InitExpander_old {

src/InitTweak/module.mk

-              r3c64c668
+              r58fe85a
 ###############################################################################
+SRC += InitTweak/GenInit.cc \
+SRC += \
+        InitTweak/FixGlobalInit.cc \
+        InitTweak/FixGlobalInit.h \
         InitTweak/FixInit.cc \
+        InitTweak/FixGlobalInit.cc \
+        InitTweak/InitTweak.cc
+        InitTweak/FixInit.h \
+        InitTweak/GenInit.cc \
+        InitTweak/GenInit.h \
+        InitTweak/InitTweak.cc \
+        InitTweak/InitTweak.h \
+        InitTweak/FixInitNew.cpp
+SRCDEMANGLE += InitTweak/GenInit.cc \
+        InitTweak/InitTweak.cc
+SRCDEMANGLE += \
+        InitTweak/GenInit.cc \
+        InitTweak/GenInit.h \
+        InitTweak/InitTweak.cc \
+        InitTweak/InitTweak.h

src/Makefile.am

-              r3c64c668
+              r58fe85a
 SRC = main.cc \
+      CompilationState.cc \
+      CompilationState.h \
       MakeLibCfa.cc \
+      CompilationState.cc
+        MakeLibCfa.h
 SRCDEMANGLE = CompilationState.cc
 …
 ___driver_cfa_cpp_SOURCES = $(SRC)
 ___driver_cfa_cpp_LDADD = -ldl $(LIBPROFILER) $(LIBTCMALLOC)
+EXTRA_DIST = include/cassert include/optional BasicTypes-gen.cc
 AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O3 -g -std=c++14 $(TCMALLOCFLAG)

src/Parser/DeclarationNode.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:32:22 2019
 // Update Count     : 1133
+// Last Modified On : Thu Oct  8 08:03:38 2020
+// Update Count     : 1135
 //
 …
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
                                 dwt->location = cur->location;
                                 * out++ = dwt;
+                                *out++ = dwt;
                         } else if ( StructDecl * agg = dynamic_cast< StructDecl * >( decl ) ) {
                                 // e.g., int foo(struct S) {}
 …
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
                                 * out++ = obj;
+                                *out++ = obj;
                                 delete agg;
                         } else if ( UnionDecl * agg = dynamic_cast< UnionDecl * >( decl ) ) {
 …
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
                                 * out++ = obj;
+                                *out++ = obj;
                         } else if ( EnumDecl * agg = dynamic_cast< EnumDecl * >( decl ) ) {
                                 // e.g., int foo(enum E) {}
 …
                                 auto obj = new ObjectDecl( "", Type::StorageClasses(), linkage, nullptr, inst, nullptr );
                                 obj->location = cur->location;
                                 * out++ = obj;
+                                *out++ = obj;
                         } // if
                 } catch( SemanticErrorException & e ) {
 …
         // SUE's cannot have function specifiers, either
         //
         //    inlne _Noreturn struct S { ... };         // disallowed
         //    inlne _Noreturn enum   E { ... };         // disallowed
+        //    inline _Noreturn struct S { ... };                // disallowed
+        //    inline _Noreturn enum   E { ... };                // disallowed
         if ( funcSpecs.any() ) {
                 SemanticError( this, "invalid function specifier for " );

src/Parser/ExpressionNode.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Sat May 16 13:17:07 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Wed Dec 18 21:14:58 2019
 // Update Count     : 981
+// Last Modified On : Thu Aug 20 14:01:46 2020
+// Update Count     : 1076
 //
 …
 void lnthSuffix( string & str, int & type, int & ltype ) {
+        // 'u' can appear before or after length suffix
         string::size_type posn = str.find_last_of( "lL" );
         if ( posn == string::npos ) return;                                     // no suffix
+        if ( posn == str.length() - 1 ) { type = 3; return; } // no length => long
+        size_t end = str.length() - 1;
+        if ( posn == end ) { type = 3; return; }                        // no length after 'l' => long
         string::size_type next = posn + 1;                                      // advance to length
         if ( str[next] == '3' ) {                                                       // 32
 …
                 } // if
         } // if
+        // remove "lL" for these cases because it may not imply long
+        str.erase( posn );                                                                      // remove length
+        char fix = '\0';
+        if ( str[end] == 'u' || str[end] == 'U' ) fix = str[end]; // ends with 'uU' ?
+        str.erase( posn );                                                                      // remove length suffix and possibly uU
+        if ( type == 5 ) {                                                                      // L128 does not need uU
+                end = str.length() - 1;
+                if ( str[end] == 'u' || str[end] == 'U' ) str.erase( end ); // ends with 'uU' ? remove
+        } else if ( fix != '\0' ) str += fix;                           // put 'uU' back if removed
 } // lnthSuffix
 …
 } // valueToType
+static void scanbin( string & str, unsigned long long int & v ) {
+        v = 0;
+        size_t last = str.length() - 1;                                         // last subscript of constant
+        for ( unsigned int i = 2;; ) {                                          // ignore prefix
+                if ( str[i] == '1' ) v |= 1;
+                i += 1;
+          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                v <<= 1;
+        } // for
+} // scanbin
 Expression * build_constantInteger( string & str ) {
         static const BasicType::Kind kind[2][6] = {
                 // short (h) must be before char (hh) because shorter type has the longer suffix
                 { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, BasicType::SignedInt128, },
                 { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, BasicType::UnsignedInt128, },
+                { BasicType::ShortSignedInt, BasicType::SignedChar, BasicType::SignedInt, BasicType::LongSignedInt, BasicType::LongLongSignedInt, /* BasicType::SignedInt128 */ BasicType::LongLongSignedInt, },
+                { BasicType::ShortUnsignedInt, BasicType::UnsignedChar, BasicType::UnsignedInt, BasicType::LongUnsignedInt, BasicType::LongLongUnsignedInt, /* BasicType::UnsignedInt128 */ BasicType::LongLongUnsignedInt, },
         };
 …
         }; // lnthsInt
+        unsigned long long int v;                                                       // converted integral value
+        size_t last = str.length() - 1;                                         // last subscript of constant
+        Expression * ret;
+        //string fred( str );
+        string str2( "0x0" );
+        unsigned long long int v, v2 = 0;                                       // converted integral value
+        Expression * ret, * ret2;
         int type = -1;                                                                          // 0 => short, 1 => char, 2 => int, 3 => long int, 4 => long long int, 5 => int128
 …
         } // if
+        string::size_type posn;
+        // 'u' can appear before or after length suffix
+        if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
+        if ( isdigit( str[str.length() - 1] ) ) {                       // no suffix ?
+                lnthSuffix( str, type, ltype );                                 // could have length suffix
+        } else {
+                // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );                                // pointer value
+                if ( posn != string::npos ) { ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );                                // size_t
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                posn = str.rfind( "hh" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );                                               // char
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );                                // short
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );                                // int (natural number)
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+          FINI: ;
+        } // if
         // Cannot be just "0"/"1"; sscanf stops at the suffix, if any; value goes over the wall => always generate
+#if ! defined(__SIZEOF_INT128__)
+        if ( type == 5 ) SemanticError( yylloc, "int128 constant is not supported on this target " + str );
+#endif // ! __SIZEOF_INT128__
         if ( str[0] == '0' ) {                                                          // radix character ?
                 dec = false;
                 if ( checkX( str[1] ) ) {                                               // hex constant ?
+                        sscanf( (char *)str.c_str(), "%llx", &v );
+                        if ( type < 5 ) {                                                       // not L128 ?
+                                sscanf( (char *)str.c_str(), "%llx", &v );
+#if defined(__SIZEOF_INT128__)
+                        } else {                                                                        // hex int128 constant
+                                unsigned int len = str.length();
+                                if ( len > (2 + 16 + 16) ) SemanticError( yylloc, "128-bit hexadecimal constant to large " + str );
+                          if ( len <= (2 + 16) ) goto FHEX1;            // hex digits < 2^64
+                                str2 = "0x" + str.substr( len - 16 );
+                                sscanf( (char *)str2.c_str(), "%llx", &v2 );
+                                str = str.substr( 0, len - 16 );
+                          FHEX1: ;
+                                sscanf( (char *)str.c_str(), "%llx", &v );
+#endif // __SIZEOF_INT128__
+                        } // if
                         //printf( "%llx %llu\n", v, v );
                 } else if ( checkB( str[1] ) ) {                                // binary constant ?
+                        v = 0;                                                                          // compute value
+                        for ( unsigned int i = 2;; ) {                          // ignore prefix
+                                if ( str[i] == '1' ) v |= 1;
+                                i += 1;
+                          if ( i == last - 1 || (str[i] != '0' && str[i] != '1') ) break;
+                                v <<= 1;
+                        } // for
+#if defined(__SIZEOF_INT128__)
+                        unsigned int len = str.length();
+                        if ( type == 5 && len > 2 + 64 ) {
+                                if ( len > 2 + 64 + 64 ) SemanticError( yylloc, "128-bit binary constant to large " + str );
+                                str2 = "0b" + str.substr( len - 64 );
+                                str = str.substr( 0, len - 64 );
+                                scanbin( str2, v2 );
+                        } // if
+#endif // __SIZEOF_INT128__
+                        scanbin( str, v );
                         //printf( "%#llx %llu\n", v, v );
                 } else {                                                                                // octal constant
+                        sscanf( (char *)str.c_str(), "%llo", &v );
+                        if ( type < 5 ) {                                                       // not L128 ?
+                                sscanf( (char *)str.c_str(), "%llo", &v );
+#if defined(__SIZEOF_INT128__)
+                        } else {                                                                        // octal int128 constant
+                                unsigned int len = str.length();
+                                if ( len > 1 + 43 || (len == 1 + 43 && str[0] > '3') ) SemanticError( yylloc, "128-bit octal constant to large " + str );
+                                char buf[32];
+                                if ( len <= 1 + 21 ) {                                  // value < 21 octal digitis
+                                        sscanf( (char *)str.c_str(), "%llo", &v );
+                                } else {
+                                        sscanf( &str[len - 21], "%llo", &v );
+                                        __int128 val = v;                                       // accumulate bits
+                                        str[len - 21] ='\0';                            // shorten string
+                                        sscanf( &str[len == 43 ? 1 : 0], "%llo", &v );
+                                        val |= (__int128)v << 63;                       // store bits
+                                        if ( len == 1 + 43 ) {                          // most significant 2 bits ?
+                                                str[2] = '\0';                                  // shorten string
+                                                sscanf( &str[1], "%llo", &v );  // process most significant 2 bits
+                                                val |= (__int128)v << 126;              // store bits
+                                        } // if
+                                        v = val >> 64; v2 = (uint64_t)val;      // replace octal constant with 2 hex constants
+                                        sprintf( buf, "%#llx", v2 );
+                                        str2 = buf;
+                                } // if
+                                sprintf( buf, "%#llx", v );
+                                str = buf;
+#endif // __SIZEOF_INT128__
+                        } // if
                         //printf( "%#llo %llu\n", v, v );
                 } // if
         } else {                                                                                        // decimal constant ?
+                sscanf( (char *)str.c_str(), "%llu", &v );
+                if ( type < 5 ) {                                                               // not L128 ?
+                        sscanf( (char *)str.c_str(), "%llu", &v );
+#if defined(__SIZEOF_INT128__)
+                } else {                                                                                // decimal int128 constant
+                        #define P10_UINT64 10'000'000'000'000'000'000ULL // 19 zeroes
+                        unsigned int len = str.length();
+                        if ( str.length() == 39 && str > (Unsigned ? "340282366920938463463374607431768211455" : "170141183460469231731687303715884105727") )
+                                SemanticError( yylloc, "128-bit decimal constant to large " + str );
+                        char buf[32];
+                        if ( len <= 19 ) {                                                      // value < 19 decimal digitis
+                                sscanf( (char *)str.c_str(), "%llu", &v );
+                        } else {
+                                sscanf( &str[len - 19], "%llu", &v );
+                                __int128 val = v;                                               // accumulate bits
+                                str[len - 19] ='\0';                                    // shorten string
+                                sscanf( &str[len == 39 ? 1 : 0], "%llu", &v );
+                                val += (__int128)v * (__int128)P10_UINT64; // store bits
+                                if ( len == 39 ) {                                              // most significant 2 bits ?
+                                        str[1] = '\0';                                          // shorten string
+                                        sscanf( &str[0], "%llu", &v );          // process most significant 2 bits
+                                        val += (__int128)v * (__int128)P10_UINT64 * (__int128)P10_UINT64; // store bits
+                                } // if
+                                v = val >> 64; v2 = (uint64_t)val;              // replace decimal constant with 2 hex constants
+                                sprintf( buf, "%#llx", v2 );
+                                str2 = buf;
+                        } // if
+                        sprintf( buf, "%#llx", v );
+                        str = buf;
+#endif // __SIZEOF_INT128__
+                } // if
                 //printf( "%llu\n", v );
         } // if
+        string::size_type posn;
+        if ( isdigit( str[last] ) ) {                                           // no suffix ?
+                lnthSuffix( str, type, ltype );                                 // could have length suffix
+                if ( type == -1 ) {                                                             // no suffix
+                        valueToType( v, dec, type, Unsigned );
+                } // if
+        } else {
+                // At least one digit in integer constant, so safe to backup while looking for suffix.
+                posn = str.find_last_of( "pP" );
+                if ( posn != string::npos ) { valueToType( v, dec, type, Unsigned ); ltype = 5; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "zZ" );
+                if ( posn != string::npos ) { Unsigned = true; type = 2; ltype = 4; str.erase( posn, 1 ); goto FINI; }
+                // 'u' can appear before or after length suffix
+                if ( str.find_last_of( "uU" ) != string::npos ) Unsigned = true;
+                posn = str.rfind( "hh" );
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.rfind( "HH" );
+                if ( posn != string::npos ) { type = 1; str.erase( posn, 2 ); goto FINI; }
+                posn = str.find_last_of( "hH" );
+                if ( posn != string::npos ) { type = 0; str.erase( posn, 1 ); goto FINI; }
+                posn = str.find_last_of( "nN" );
+                if ( posn != string::npos ) { type = 2; str.erase( posn, 1 ); goto FINI; }
+                if ( str.rfind( "ll" ) != string::npos || str.rfind( "LL" ) != string::npos ) { type = 4; goto FINI; }
+                lnthSuffix( str, type, ltype );                                 // must be after check for "ll"
+                if ( type == -1 ) {                                                             // only 'u' suffix ?
+                        valueToType( v, dec, type, Unsigned );
+                } // if
+          FINI: ;
+        } // if
+        if ( type == -1 ) {                                                                     // no suffix => determine type from value size
+                valueToType( v, dec, type, Unsigned );
+        } // if
+        /* printf( "%s %llo %s %llo\n", str.c_str(), v, str2.c_str(), v2 ); */
         //if ( !( 0 <= type && type <= 6 ) ) { printf( "%s %lu %d %s\n", fred.c_str(), fred.length(), type, str.c_str() ); }
 …
         } else if ( ltype != -1 ) {                                                     // explicit length ?
                 if ( ltype == 6 ) {                                                             // int128, (int128)constant
+                        ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+//                      ret = new CastExpr( ret, new BasicType( Type::Qualifiers(), kind[Unsigned][type] ), false );
+                        ret2 = new ConstantExpr( Constant( new BasicType( noQualifiers, BasicType::LongLongSignedInt ), str2, v2 ) );
+                        ret = build_compoundLiteral( DeclarationNode::newBasicType( DeclarationNode::Int128 )->addType( DeclarationNode::newSignedNess( DeclarationNode::Unsigned ) ),
+                                                                                 new InitializerNode( (InitializerNode *)(new InitializerNode( new ExpressionNode( v2 == 0 ? ret2 : ret ) ))->set_last( new InitializerNode( new ExpressionNode( v2 == 0 ? ret : ret2 ) ) ), true ) );
                 } else {                                                                                // explicit length, (length_type)constant
                         ret = new CastExpr( ret, new TypeInstType( Type::Qualifiers(), lnthsInt[Unsigned][ltype], false ), false );
 …
                 if ( str[1] == '8' ) goto Default;                              // utf-8 characters => array of char
                 // lookup type of associated typedef
                 strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char16_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "char16_t", false );
                 break;
           case 'U':
                 strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "char32_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "char32_t", false );
                 break;
           case 'L':
                 strtype = new TypeInstType( Type::Qualifiers( Type::Const ), "wchar_t", false );
+                strtype = new TypeInstType( Type::Qualifiers( ), "wchar_t", false );
                 break;
           Default:                                                                                      // char default string type
           default:
                 strtype = new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char );
+                strtype = new BasicType( Type::Qualifiers( ), BasicType::Char );
         } // switch
         ArrayType * at = new ArrayType( noQualifiers, strtype,

src/Parser/ParseNode.h

-              r3c64c668
+              r58fe85a
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb  7 17:56:02 2020
 // Update Count     : 891
+// Last Modified On : Sat Oct 24 03:53:54 2020
+// Update Count     : 895
 //
 …
 class Attribute;
 class Declaration;
 class DeclarationNode;
+struct DeclarationNode;
 class DeclarationWithType;
 class ExpressionNode;
 class Initializer;
 class StatementNode;
+struct StatementNode;
 //##############################################################################
 …
 class InitializerNode : public ParseNode {
   public:
         InitializerNode( ExpressionNode *, bool aggrp = false,  ExpressionNode * des = nullptr );
+        InitializerNode( ExpressionNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( InitializerNode *, bool aggrp = false, ExpressionNode * des = nullptr );
         InitializerNode( bool isDelete );
 …
 struct TypeData;
+class DeclarationNode : public ParseNode {
+  public:
+struct DeclarationNode : public ParseNode {
         // These enumerations must harmonize with their names in DeclarationNode.cc.
         enum BasicType { Void, Bool, Char, Int, Int128,
 …
         bool get_inLine() const { return inLine; }
         DeclarationNode * set_inLine( bool inL ) { inLine = inL; return this; }
+  public:
         DeclarationNode * get_last() { return (DeclarationNode *)ParseNode::get_last(); }
 …
 //##############################################################################
+class StatementNode final : public ParseNode {
+  public:
+struct StatementNode final : public ParseNode {
         StatementNode() { stmt = nullptr; }
         StatementNode( Statement * stmt ) : stmt( stmt ) {}
 …
                 os << stmt.get() << std::endl;
+        }
+  private:
         std::unique_ptr<Statement> stmt;
 }; // StatementNode
 …
 Statement * build_finally( StatementNode * stmt );
 Statement * build_compound( StatementNode * first );
+StatementNode * maybe_build_compound( StatementNode * first );
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output = nullptr, ExpressionNode * input = nullptr, ExpressionNode * clobber = nullptr, LabelNode * gotolabels = nullptr );
 Statement * build_directive( std::string * directive );
+SuspendStmt * build_suspend( StatementNode *, SuspendStmt::Type = SuspendStmt::None);
 WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when );
 WaitForStmt * build_waitfor( ExpressionNode * target, StatementNode * stmt, ExpressionNode * when, WaitForStmt * existing );

src/Parser/StatementNode.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Sat May 16 14:59:41 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Aug  4 09:39:25 2018
 // Update Count     : 363
+// Last Modified On : Sat Oct 24 04:20:55 2020
+// Update Count     : 383
 //
 …
 } // build_finally
+SuspendStmt * build_suspend( StatementNode * then, SuspendStmt::Type type ) {
+        auto node = new SuspendStmt();
+        node->type = type;
+        std::list< Statement * > stmts;
+        buildMoveList< Statement, StatementNode >( then, stmts );
+        if(!stmts.empty()) {
+                assert( stmts.size() == 1 );
+                node->then = dynamic_cast< CompoundStmt * >( stmts.front() );
+        }
+        return node;
+}
 WaitForStmt * build_waitfor( ExpressionNode * targetExpr, StatementNode * stmt, ExpressionNode * when ) {
         auto node = new WaitForStmt();
 …
 } // build_compound
+// A single statement in a control structure is always converted to a compound statement so subsequent generated code
+// can be placed within this compound statement. Otherwise, code generation has to constantly check for a single
+// statement and wrap it into a compound statement to insert additional code. Hence, all control structures have a
+// conical form for code generation.
+StatementNode * maybe_build_compound( StatementNode * first ) {
+        // Optimization: if the control-structure statement is a compound statement, do not wrap it.
+        // e.g., if (...) {...} do not wrap the existing compound statement.
+        if ( ! dynamic_cast<CompoundStmt *>( first->stmt.get() ) ) { // unique_ptr
+                CompoundStmt * cs = new CompoundStmt();
+                buildMoveList( first, cs->get_kids() );
+                return new StatementNode( cs );
+        } // if
+        return first;
+} // maybe_build_compound
 Statement * build_asm( bool voltile, Expression * instruction, ExpressionNode * output, ExpressionNode * input, ExpressionNode * clobber, LabelNode * gotolabels ) {
         std::list< Expression * > out, in;

src/Parser/TypeData.cc

-              r3c64c668
+              r58fe85a
           case AggregateDecl::Struct:
           case AggregateDecl::Coroutine:
+          case AggregateDecl::Generator:
           case AggregateDecl::Monitor:
           case AggregateDecl::Thread:
 …
                 ret = new TypeDecl( name, scs, typebuild( td->base ), TypeDecl::Dtype, true );
         } // if
-        buildList( td->symbolic.params, ret->get_parameters() );
         buildList( td->symbolic.assertions, ret->get_assertions() );
         ret->base->attributes.splice( ret->base->attributes.end(), attributes );

src/Parser/lex.ll

-              r3c64c668
+              r58fe85a
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
  * Last Modified On : Sat Feb 15 11:05:50 2020
  * Update Count     : 737
+ * Last Modified On : Tue Oct  6 18:15:41 2020
+ * Update Count     : 743
  */
 …
 #define IDENTIFIER_RETURN()     RETURN_VAL( typedefTable.isKind( yytext ) )
 #ifdef HAVE_KEYWORDS_FLOATXX                                                            // GCC >= 7 => keyword, otherwise typedef
+#ifdef HAVE_KEYWORDS_FLOATXX                                                    // GCC >= 7 => keyword, otherwise typedef
 #define FLOATXX(v) KEYWORD_RETURN(v);
 #else
 #define FLOATXX(v) IDENTIFIER_RETURN();
+#define FLOATXX(v) IDENTIFIER_RETURN();
 #endif // HAVE_KEYWORDS_FLOATXX
 …
 __restrict__    { KEYWORD_RETURN(RESTRICT); }                   // GCC
 return                  { KEYWORD_RETURN(RETURN); }
         /* resume                       { KEYWORD_RETURN(RESUME); }                             // CFA */
+ /* resume                      { KEYWORD_RETURN(RESUME); }                             // CFA */
 short                   { KEYWORD_RETURN(SHORT); }
 signed                  { KEYWORD_RETURN(SIGNED); }
 …
 _Static_assert  { KEYWORD_RETURN(STATICASSERT); }               // C11
 struct                  { KEYWORD_RETURN(STRUCT); }
+        /* suspend                      { KEYWORD_RETURN(SUSPEND); }                    // CFA */
+suspend                 { KEYWORD_RETURN(SUSPEND); }                    // CFA
 switch                  { KEYWORD_RETURN(SWITCH); }
 thread                  { KEYWORD_RETURN(THREAD); }                             // C11

src/Parser/module.mk

-              r3c64c668
+              r58fe85a
 BUILT_SOURCES = Parser/parser.hh
 AM_YFLAGS = -d -t -v
+AM_YFLAGS = -d -t -v -Wno-yacc
 SRC += \
 …
        Parser/ExpressionNode.cc \
        Parser/InitializerNode.cc \
+       Parser/lex.ll \
        Parser/ParseNode.cc \
+       Parser/ParseNode.h \
+       Parser/parser.yy \
+       Parser/ParserTypes.h \
+       Parser/parserutility.cc \
+       Parser/parserutility.h \
        Parser/StatementNode.cc \
        Parser/TypeData.cc \
+       Parser/TypeData.h \
        Parser/TypedefTable.cc \
+       Parser/lex.ll \
+       Parser/parser.yy \
+       Parser/parserutility.cc
+       Parser/TypedefTable.h
 MOSTLYCLEANFILES += Parser/lex.cc Parser/parser.cc Parser/parser.hh Parser/parser.output

src/Parser/parser.yy

-              r3c64c668
+              r58fe85a
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Feb 21 14:47:29 2020
 // Update Count     : 4468
+// Last Modified On : Sat Oct 24 08:21:14 2020
+// Update Count     : 4624
 //
 …
                         return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
                 } else {
                         SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
                 } // if
         } else {
                 SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed." ); return nullptr;
         } // if
 } // forCtrl
 …
 %token OTYPE FTYPE DTYPE TTYPE TRAIT                                    // CFA
 %token SIZEOF OFFSETOF
+// %token SUSPEND RESUME                                                                        // CFA
+// %token RESUME                                                                                        // CFA
+%token SUSPEND                                                                                  // CFA
 %token ATTRIBUTE EXTENSION                                                              // GCC
 %token IF ELSE SWITCH CASE DEFAULT DO WHILE FOR BREAK CONTINUE GOTO RETURN
 …
 %type<en> conditional_expression                constant_expression                     assignment_expression           assignment_expression_opt
 %type<en> comma_expression                              comma_expression_opt
 %type<en> argument_expression_list              argument_expression                     default_initialize_opt
+%type<en> argument_expression_list_opt  argument_expression                     default_initialize_opt
 %type<ifctl> if_control_expression
 %type<fctl> for_control_expression              for_control_expression_list
 …
 %type<decl> assertion assertion_list assertion_list_opt
 %type<en>   bit_subrange_size_opt bit_subrange_size
+%type<en> bit_subrange_size_opt bit_subrange_size
 %type<decl> basic_declaration_specifier basic_type_name basic_type_specifier direct_type indirect_type
 …
                 // equivalent to the old x[i,j].
                 { $$ = new ExpressionNode( build_binary_val( OperKinds::Index, $1, $3 ) ); }
         | postfix_expression '{' argument_expression_list '}' // CFA, constructor call
+        | postfix_expression '{' argument_expression_list_opt '}' // CFA, constructor call
+                {
                         Token fn;
 …
                         $$ = new ExpressionNode( new ConstructorExpr( build_func( new ExpressionNode( build_varref( fn ) ), (ExpressionNode *)( $1 )->set_last( $3 ) ) ) );
+                }
         | postfix_expression '(' argument_expression_list ')'
+        | postfix_expression '(' argument_expression_list_opt ')'
                 { $$ = new ExpressionNode( build_func( $1, $3 ) ); }
         | postfix_expression '`' identifier                                     // CFA, postfix call
 …
         | '(' type_no_function ')' '@' '{' initializer_list_opt comma_opt '}' // CFA, explicit C compound-literal
                 { $$ = new ExpressionNode( build_compoundLiteral( $2, (new InitializerNode( $6, true ))->set_maybeConstructed( false ) ) ); }
         | '^' primary_expression '{' argument_expression_list '}' // CFA, destructor call
+        | '^' primary_expression '{' argument_expression_list_opt '}' // CFA, destructor call
+                {
                         Token fn;
 …
+        ;
 argument_expression_list:
+argument_expression_list_opt:
         // empty
                 { $$ = nullptr; }
         | argument_expression
         | argument_expression_list ',' argument_expression
+        | argument_expression_list_opt ',' argument_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        ;
 …
         | '(' aggregate_control '&' ')' cast_expression         // CFA
                 { $$ = new ExpressionNode( build_keyword_cast( $2, $5 ) ); }
-                // VIRTUAL cannot be opt because of look ahead issues
         | '(' VIRTUAL ')' cast_expression                                       // CFA
                 { $$ = new ExpressionNode( new VirtualCastExpr( maybeMoveBuild< Expression >( $4 ), maybeMoveBuildType( nullptr ) ) ); }
 …
         conditional_expression
         | unary_expression assignment_operator assignment_expression
+                { $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) ); }
+                {
+//                      if ( $2 == OperKinds::AtAssn ) {
+//                              SemanticError( yylloc, "C @= assignment is currently unimplemented." ); $$ = nullptr;
+//                      } else {
+                                $$ = new ExpressionNode( build_binary_val( $2, $1, $3 ) );
+//                      } // if
+                }
         | unary_expression '=' '{' initializer_list_opt comma_opt '}'
                 { SemanticError( yylloc, "Initializer assignment is currently unimplemented." ); $$ = nullptr; }
 …
 tuple_expression_list:
+        assignment_expression_opt
+        | tuple_expression_list ',' assignment_expression_opt
+        assignment_expression
+        | '@'                                                                                           // CFA
+                { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
+        | tuple_expression_list ',' assignment_expression
                 { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+        | tuple_expression_list ',' '@'
+                { SemanticError( yylloc, "Eliding tuple element with '@' is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
         IF '(' if_control_expression ')' statement                      %prec THEN
                 // explicitly deal with the shift/reduce conflict on if/else
                 { $$ = new StatementNode( build_if( $3, $5, nullptr ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), nullptr ) ); }
         | IF '(' if_control_expression ')' statement ELSE statement
                 { $$ = new StatementNode( build_if( $3, $5, $7 ) ); }
+                { $$ = new StatementNode( build_if( $3, maybe_build_compound( $5 ), maybe_build_compound( $7 ) ) ); }
+        ;
 …
 case_clause:                                                                                    // CFA
         case_label_list statement                                       { $$ = $1->append_last_case( new StatementNode( build_compound( $2 ) ) ); }
+        case_label_list statement                                       { $$ = $1->append_last_case( maybe_build_compound( $2 ) ); }
+        ;
 …
 iteration_statement:
         WHILE '(' push if_control_expression ')' statement pop
                 { $$ = new StatementNode( build_while( $4, $6 ) ); }
+                { $$ = new StatementNode( build_while( $4, maybe_build_compound( $6 ) ) ); }
         | WHILE '(' ')' statement                                                       // CFA => while ( 1 )
                 { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), $4 ) ); }
+                { $$ = new StatementNode( build_while( new IfCtrl( nullptr, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ), maybe_build_compound( $4 ) ) ); }
         | DO statement WHILE '(' comma_expression ')' ';'
                 { $$ = new StatementNode( build_do_while( $5, $2 ) ); }
+                { $$ = new StatementNode( build_do_while( $5, maybe_build_compound( $2 ) ) ); }
         | DO statement WHILE '(' ')' ';'                                        // CFA => do while( 1 )
                 { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), $2 ) ); }
+                { $$ = new StatementNode( build_do_while( new ExpressionNode( build_constantInteger( *new string( "1" ) ) ), maybe_build_compound( $2 ) ) ); }
         | FOR '(' push for_control_expression_list ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
+                { $$ = new StatementNode( build_for( $4, maybe_build_compound( $6 ) ) ); }
         | FOR '(' ')' statement                                                         // CFA => for ( ;; )
                 { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), maybe_build_compound( $4 ) ) ); }
+        ;
 …
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | '=' comma_expression                                                                  // CFA
+        | '=' comma_expression                                                          // CFA
                 { $$ = forCtrl( $2, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LEThan, $2->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
 …
         | comma_expression inclexcl comma_expression '~' comma_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
+        | comma_expression ';'                                                          // CFA
+                { $$ = forCtrl( new ExpressionNode( build_constantInteger( *new string( "0u" ) ) ), $1, nullptr, OperKinds::LThan, nullptr, nullptr ); }
         | comma_expression ';' comma_expression                         // CFA
                 { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | comma_expression ';' '=' comma_expression                             // CFA
+        | comma_expression ';' '=' comma_expression                     // CFA
                 { $$ = forCtrl( $4, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
                                                 OperKinds::LEThan, $4->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
 …
         | RETURN '{' initializer_list_opt comma_opt '}' ';'
                 { SemanticError( yylloc, "Initializer return is currently unimplemented." ); $$ = nullptr; }
+        // | SUSPEND ';'
+        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        // | SUSPEND compound_statement ';'
+        //      { SemanticError( yylloc, "Suspend expression is currently unimplemented." ); $$ = nullptr; }
+        | SUSPEND ';'
+                { $$ = new StatementNode( build_suspend( nullptr ) ); }
+        | SUSPEND compound_statement
+                { $$ = new StatementNode( build_suspend( $2 ) ); }
+        | SUSPEND COROUTINE ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Coroutine ) ); }
+        | SUSPEND COROUTINE compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Coroutine ) ); }
+        | SUSPEND GENERATOR ';'
+                { $$ = new StatementNode( build_suspend( nullptr, SuspendStmt::Generator ) ); }
+        | SUSPEND GENERATOR compound_statement
+                { $$ = new StatementNode( build_suspend( $3, SuspendStmt::Generator ) ); }
         | THROW assignment_expression_opt ';'                           // handles rethrow
                 { $$ = new StatementNode( build_throw( $2 ) ); }
 …
 // If MUTEX becomes a general qualifier, there are shift/reduce conflicts, so change syntax to "with mutex".
 mutex_statement:
         MUTEX '(' argument_expression_list ')' statement
+        MUTEX '(' argument_expression_list_opt ')' statement
                 { SemanticError( yylloc, "Mutex statement is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
         WAITFOR '(' cast_expression ')'
                 { $$ = $3; }
 //      | WAITFOR '(' cast_expression ',' argument_expression_list ')'
+//      | WAITFOR '(' cast_expression ',' argument_expression_list_opt ')'
 //              { $$ = (ExpressionNode *)$3->set_last( $5 ); }
         | WAITFOR '(' cast_expression_list ':' argument_expression_list ')'
+        | WAITFOR '(' cast_expression_list ':' argument_expression_list_opt ')'
                 { $$ = (ExpressionNode *)($3->set_last( $5 )); }
+        ;
 …
         cast_expression
         | cast_expression_list ',' cast_expression
+                { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                // { $$ = (ExpressionNode *)($1->set_last( $3 )); }
+                { SemanticError( yylloc, "List of mutex member is currently unimplemented." ); $$ = nullptr; }
+        ;
 …
 waitfor_clause:
         when_clause_opt waitfor statement                                       %prec THEN
                 { $$ = build_waitfor( $2, $3, $1 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt waitfor statement WOR waitfor_clause
                 { $$ = build_waitfor( $2, $3, $1, $5 ); }
+                { $$ = build_waitfor( $2, maybe_build_compound( $3 ), $1, $5 ); }
         | when_clause_opt timeout statement                                     %prec THEN
                 { $$ = build_waitfor_timeout( $2, $3, $1 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1 ); }
         | when_clause_opt ELSE statement
                 { $$ = build_waitfor_timeout( nullptr, $3, $1 ); }
+                { $$ = build_waitfor_timeout( nullptr, maybe_build_compound( $3 ), $1 ); }
                 // "else" must be conditional after timeout or timeout is never triggered (i.e., it is meaningless)
         | when_clause_opt timeout statement WOR ELSE statement
                 { SemanticError( yylloc, "else clause must be conditional after timeout or timeout never triggered." ); $$ = nullptr; }
         | when_clause_opt timeout statement WOR when_clause ELSE statement
                 { $$ = build_waitfor_timeout( $2, $3, $1, $7, $5 ); }
+                { $$ = build_waitfor_timeout( $2, maybe_build_compound( $3 ), $1, maybe_build_compound( $7 ), $5 ); }
+        ;
 …
 typedef_expression:
                 // GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
+                // deprecated GCC, naming expression type: typedef name = exp; gives a name to the type of an expression
         TYPEDEF identifier '=' assignment_expression
+                {
+                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
+                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
         | typedef_expression pop ',' push identifier '=' assignment_expression
+                {
+                        // $$ = DeclarationNode::newName( 0 );                  // unimplemented
+                        SemanticError( yylloc, "Typedef expression is currently unimplemented." ); $$ = nullptr;
+                }
+        ;
+//c_declaration:
+//      declaring_list pop ';'
+//      | typedef_declaration pop ';'
+//      | typedef_expression pop ';'                                            // GCC, naming expression type
+//      | sue_declaration_specifier pop ';'
+//      ;
+//
+//declaring_list:
+//              // A semantic check is required to ensure asm_name only appears on declarations with implicit or explicit static
+//              // storage-class
+//       declarator asm_name_opt initializer_opt
+//              {
+//                      typedefTable.addToEnclosingScope( IDENTIFIER );
+//                      $$ = ( $2->addType( $1 ))->addAsmName( $3 )->addInitializer( $4 );
+//              }
+//      | declaring_list ',' attribute_list_opt declarator asm_name_opt initializer_opt
+//              {
+//                      typedefTable.addToEnclosingScope( IDENTIFIER );
+//                      $$ = $1->appendList( $1->cloneBaseType( $4->addAsmName( $5 )->addInitializer( $6 ) ) );
+//              }
+//      ;
+                        SemanticError( yylloc, "Typedef expression is deprecated, use typeof(...) instead." ); $$ = nullptr;
+                }
+        ;
 c_declaration:
 …
                 { $$ = distAttr( $1, $2 ); }
         | typedef_declaration
         | typedef_expression                                                            // GCC, naming expression type
+        | typedef_expression                                                            // deprecated GCC, naming expression type
         | sue_declaration_specifier
+        ;
 …
                 { yyy = true; $$ = AggregateDecl::Union; }
         | EXCEPTION                                                                                     // CFA
+                { yyy = true; $$ = AggregateDecl::Exception; }
+                // { yyy = true; $$ = AggregateDecl::Exception; }
+                { SemanticError( yylloc, "exception aggregate is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+        ;
 aggregate_control:                                                                              // CFA
+        GENERATOR
+                { yyy = true; $$ = AggregateDecl::Coroutine; }
+        MONITOR
+                { yyy = true; $$ = AggregateDecl::Monitor; }
+        | MUTEX STRUCT
+                { yyy = true; $$ = AggregateDecl::Monitor; }
+        | GENERATOR
+                { yyy = true; $$ = AggregateDecl::Generator; }
+        | MUTEX GENERATOR
+                { SemanticError( yylloc, "monitor generator is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | COROUTINE
                 { yyy = true; $$ = AggregateDecl::Coroutine; }
         | MONITOR
                 { yyy = true; $$ = AggregateDecl::Monitor; }
+        | MUTEX COROUTINE
+                { SemanticError( yylloc, "monitor coroutine is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
         | THREAD
                 { yyy = true; $$ = AggregateDecl::Thread; }
+        | MUTEX THREAD
+                { SemanticError( yylloc, "monitor thread is currently unimplemented." ); $$ = AggregateDecl::NoAggregate; }
+        ;
 …
 // Overloading: function, data, and operator identifiers may be overloaded.
 //
 // Type declarations: "type" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
+// Type declarations: "otype" is used to generate new types for declaring objects. Similarly, "dtype" is used for object
 //     and incomplete types, and "ftype" is used for function types. Type declarations with initializers provide
 //     definitions of new types. Type declarations with storage class "extern" provide opaque types.
 …
         type_class identifier_or_type_name
                 { typedefTable.addToScope( *$2, TYPEDEFname, "9" ); }
           type_initializer_opt assertion_list_opt
+        type_initializer_opt assertion_list_opt
                 { $$ = DeclarationNode::newTypeParam( $1, $2 )->addTypeInitializer( $4 )->addAssertions( $5 ); }
         | type_specifier identifier_parameter_declarator
 …
         assertion
         | assertion_list assertion
                 { $$ = $1 ? $1->appendList( $2 ) : $2; }
+                { $$ = $1->appendList( $2 ); }
+        ;
 …
         | attr_name
                 { $$ = DeclarationNode::newAttribute( $1 ); }
         | attr_name '(' argument_expression_list ')'
+        | attr_name '(' argument_expression_list_opt ')'
                 { $$ = DeclarationNode::newAttribute( $1, $3 ); }
+        ;

src/ResolvExpr/AdjustExprType.cc

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

src/ResolvExpr/AlternativeFinder.cc

-              r3c64c668
+              r58fe85a
         void printAlts( const AltList &list, std::ostream &os, unsigned int indentAmt ) {
+                Indenter indent = { indentAmt };
+                for ( AltList::const_iterator i = list.begin(); i != list.end(); ++i ) {
+                        i->print( os, indent );
+                        os << std::endl;
+                std::vector<std::string> sorted;
+                sorted.reserve(list.size());
+                for(const auto & c : list) {
+                        std::stringstream ss;
+                        c.print( ss, indentAmt );
+                        sorted.push_back(ss.str());
+                }
+                std::sort(sorted.begin(), sorted.end());
+                for ( const auto & s : sorted ) {
+                        os << s << std::endl;
+                }
+        }
 …
                         SemanticError( expr, "No reasonable alternatives for expression " );
+                }
                 if ( mode.satisfyAssns || mode.prune ) {
+                if ( mode.prune ) {
                         // trim candidates just to those where the assertions resolve
                         // - necessary pre-requisite to pruning
 …
                         unify( castExpr->result, alt.expr->result, alt.env, needAssertions,
                                 haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),
+                                indexer, alt.env );
+                        Cost thisCost =
+                                castExpr->isGenerated
+                                ? conversionCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(),   indexer, alt.env )
+                                : castCost( alt.expr->result, castExpr->result, alt.expr->get_lvalue(), indexer, alt.env );
                         PRINT(
                                 std::cerr << "working on cast with result: " << castExpr->result << std::endl;
 …
                                 // unification run for side-effects
+                                unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                bool canUnify = unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                (void) canUnify;
                                 // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?
                                 Cost thisCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                Cost thisCost = computeConversionCost( alt.expr->result, toType, alt.expr->get_lvalue(),
                                         indexer, newEnv );
+                                PRINT(
+                                        Cost legacyCost = castCost( alt.expr->result, toType, alt.expr->get_lvalue(),
+                                                indexer, newEnv );
+                                        std::cerr << "Considering initialization:";
+                                        std::cerr << std::endl << "  FROM: "; alt.expr->result->print(std::cerr);
+                                        std::cerr << std::endl << "  TO: ";   toType          ->print(std::cerr);
+                                        std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                        std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                        std::cerr << std::endl << "  New cost " << thisCost;
+                                        std::cerr << std::endl;
+                                )
                                 if ( thisCost != Cost::infinity ) {
                                         // count one safe conversion for each value that is thrown away

src/ResolvExpr/Candidate.cpp

-              r3c64c668
+              r58fe85a
 void print( std::ostream & os, const CandidateList & cands, Indenter indent ) {
+        for ( const CandidateRef & cand : cands ) {
+                print( os, *cand, indent );
+                os << std::endl;
+        std::vector<std::string> sorted;
+        sorted.reserve(cands.size());
+        for(const auto & c : cands) {
+                std::stringstream ss;
+                print( ss, *c, indent );
+                sorted.push_back(ss.str());
+        }
+        std::sort(sorted.begin(), sorted.end());
+        for ( const auto & s : sorted ) {
+                os << s << std::endl;
+        }
+}

src/ResolvExpr/Candidate.hpp

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

src/ResolvExpr/CandidateFinder.cpp

-              r3c64c668
+              r58fe85a
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Wed Jun 5 14:30:00 2019
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1 14:55:00 2019
+// Update Count     : 2
 //
 …
 #include "SymTab/Validate.h"      // for validateType
 #include "Tuples/Tuples.h"        // for handleTupleAssignment
+#include "InitTweak/InitTweak.h"  // for getPointerBase
+#include "Common/Stats/Counter.h"
 #define PRINT( text ) if ( resolvep ) { text }
 …
                 return new ast::CastExpr{ expr, expr->result->stripReferences() };
+        }
         return expr;
+}
 …
 UniqueId globalResnSlot = 0;
 Cost computeConversionCost(
         const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab,
         const ast::TypeEnvironment & env
+Cost computeConversionCost(
+        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         PRINT(
 …
                 std::cerr << std::endl;
+        )
         Cost convCost = conversionCost( argType, paramType, symtab, env );
+        Cost convCost = conversionCost( argType, paramType, argIsLvalue, symtab, env );
         PRINT(
                 std::cerr << std::endl << "cost is " << convCost << std::endl;
 …
         /// Computes conversion cost for a given expression to a given type
         const ast::Expr * computeExpressionConversionCost(
                 const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
+        const ast::Expr * computeExpressionConversionCost(
+                const ast::Expr * arg, const ast::Type * paramType, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env, Cost & outCost
         ) {
+                Cost convCost = computeConversionCost( arg->result, paramType, symtab, env );
+                Cost convCost = computeConversionCost(
+                                arg->result, paramType, arg->get_lvalue(), symtab, env );
                 outCost += convCost;
                 // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
                 // conversion. Ignore poly cost for now, since this requires resolution of the cast to
+                // If there is a non-zero conversion cost, ignoring poly cost, then the expression requires
+                // conversion. Ignore poly cost for now, since this requires resolution of the cast to
                 // infer parameters and this does not currently work for the reason stated below
                 Cost tmpCost = convCost;
 …
                         return new ast::CastExpr{ arg, newType };
                         // xxx - *should* be able to resolve this cast, but at the moment pointers are not
                         // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
+                        // xxx - *should* be able to resolve this cast, but at the moment pointers are not
+                        // castable to zero_t, but are implicitly convertible. This is clearly inconsistent,
                         // once this is fixed it should be possible to resolve the cast.
                         // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
                         // but it shouldn't be because this makes the conversion from DT* to DT* since
+                        // xxx - this isn't working, it appears because type1 (parameter) is seen as widenable,
+                        // but it shouldn't be because this makes the conversion from DT* to DT* since
                         // commontype(zero_t, DT*) is DT*, rather than nothing
                         // CandidateFinder finder{ symtab, env };
                         // finder.find( arg, ResolvMode::withAdjustment() );
                         // assertf( finder.candidates.size() > 0,
+                        // assertf( finder.candidates.size() > 0,
                         //      "Somehow castable expression failed to find alternatives." );
                         // assertf( finder.candidates.size() == 1,
+                        // assertf( finder.candidates.size() == 1,
                         //      "Somehow got multiple alternatives for known cast expression." );
                         // return finder.candidates.front()->expr;
 …
         /// Computes conversion cost for a given candidate
         Cost computeApplicationConversionCost(
                 CandidateRef cand, const ast::SymbolTable & symtab
+        Cost computeApplicationConversionCost(
+                CandidateRef cand, const ast::SymbolTable & symtab
         ) {
                 auto appExpr = cand->expr.strict_as< ast::ApplicationExpr >();
 …
                                 if ( function->isVarArgs ) {
                                         convCost.incUnsafe();
                                         PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
+                                        PRINT( std::cerr << "end of params with varargs function: inc unsafe: "
                                                 << convCost << std::endl; ; )
                                         // convert reference-typed expressions into value-typed expressions
                                         cand->expr = ast::mutate_field_index(
                                                 appExpr, &ast::ApplicationExpr::args, i,
+                                        cand->expr = ast::mutate_field_index(
+                                                appExpr, &ast::ApplicationExpr::args, i,
                                                 referenceToRvalueConversion( args[i], convCost ) );
                                         continue;
 …
                                 // Default arguments should be free - don't include conversion cost.
                                 // Unwrap them here because they are not relevant to the rest of the system
                                 cand->expr = ast::mutate_field_index(
+                                cand->expr = ast::mutate_field_index(
                                         appExpr, &ast::ApplicationExpr::args, i, def->expr );
                                 ++param;
 …
                         // mark conversion cost and also specialization cost of param type
                         const ast::Type * paramType = (*param)->get_type();
                         cand->expr = ast::mutate_field_index(
                                 appExpr, &ast::ApplicationExpr::args, i,
                                 computeExpressionConversionCost(
                                         args[i], paramType, symtab, cand->env, convCost ) );
                         convCost.decSpec( specCost( paramType ) );
+                        // const ast::Type * paramType = (*param)->get_type();
+                        cand->expr = ast::mutate_field_index(
+                                appExpr, &ast::ApplicationExpr::args, i,
+                                computeExpressionConversionCost(
+                                        args[i], *param, symtab, cand->env, convCost ) );
+                        convCost.decSpec( specCost( *param ) );
                         ++param;  // can't be in for-loop update because of the continue
+                }
 …
                 if ( param != params.end() ) return Cost::infinity;
                 // specialization cost of return types can't be accounted for directly, it disables
+                // specialization cost of return types can't be accounted for directly, it disables
                 // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
                 //
 …
                 // mark type variable and specialization cost of forall clause
                 convCost.incVar( function->forall.size() );
+                for ( const ast::TypeDecl * td : function->forall ) {
+                        convCost.decSpec( td->assertions.size() );
+                }
+                convCost.decSpec( function->assertions.size() );
                 return convCost;
+        }
         void makeUnifiableVars(
                 const ast::ParameterizedType * type, ast::OpenVarSet & unifiableVars,
                 ast::AssertionSet & need
+        void makeUnifiableVars(
+                const ast::FunctionType * type, ast::OpenVarSet & unifiableVars,
+                ast::AssertionSet & need
         ) {
                 for ( const ast::TypeDecl * tyvar : type->forall ) {
                         unifiableVars[ tyvar->name ] = ast::TypeDecl::Data{ tyvar };
                         for ( const ast::DeclWithType * assn : tyvar->assertions ) {
                                 need[ assn ].isUsed = true;
+                        }
+                for ( auto & tyvar : type->forall ) {
+                        unifiableVars[ *tyvar ] = ast::TypeDecl::Data{ tyvar->base };
+                }
+                for ( auto & assn : type->assertions ) {
+                        need[ assn ].isUsed = true;
+                }
+        }
 …
                 ArgPack()
                 : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
+                : parent( 0 ), expr(), cost( Cost::zero ), env(), need(), have(), open(), nextArg( 0 ),
                   tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
                 ArgPack(
                         const ast::TypeEnvironment & env, const ast::AssertionSet & need,
+                ArgPack(
+                        const ast::TypeEnvironment & env, const ast::AssertionSet & need,
                         const ast::AssertionSet & have, const ast::OpenVarSet & open )
                 : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
+                : parent( 0 ), expr(), cost( Cost::zero ), env( env ), need( need ), have( have ),
                   open( open ), nextArg( 0 ), tupleStart( 0 ), nextExpl( 0 ), explAlt( 0 ) {}
                 ArgPack(
                         std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
                         ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
                         unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
+                        std::size_t parent, const ast::Expr * expr, ast::TypeEnvironment && env,
+                        ast::AssertionSet && need, ast::AssertionSet && have, ast::OpenVarSet && open,
+                        unsigned nextArg, unsigned tupleStart = 0, Cost cost = Cost::zero,
                         unsigned nextExpl = 0, unsigned explAlt = 0 )
                 : parent(parent), expr( expr ), cost( cost ), env( move( env ) ), need( move( need ) ),
                   have( move( have ) ), open( move( open ) ), nextArg( nextArg ), tupleStart( tupleStart ),
                   nextExpl( nextExpl ), explAlt( explAlt ) {}
                 ArgPack(
                         const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
+                        const ArgPack & o, ast::TypeEnvironment && env, ast::AssertionSet && need,
                         ast::AssertionSet && have, ast::OpenVarSet && open, unsigned nextArg, Cost added )
                 : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ),
                   need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ),
+                : parent( o.parent ), expr( o.expr ), cost( o.cost + added ), env( move( env ) ),
+                  need( move( need ) ), have( move( have ) ), open( move( open ) ), nextArg( nextArg ),
                   tupleStart( o.tupleStart ), nextExpl( 0 ), explAlt( 0 ) {}
                 /// true if this pack is in the middle of an exploded argument
                 bool hasExpl() const { return nextExpl > 0; }
 …
                         return args[ nextArg-1 ][ explAlt ];
+                }
                 /// Ends a tuple expression, consolidating the appropriate args
                 void endTuple( const std::vector< ArgPack > & packs ) {
 …
         /// Instantiates an argument to match a parameter, returns false if no matching results left
         bool instantiateArgument(
                 const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
                 std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
                 unsigned nTuples = 0
+        bool instantiateArgument(
+                const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
+                std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
+                unsigned nTuples = 0
         ) {
                 if ( auto tupleType = dynamic_cast< const ast::TupleType * >( paramType ) ) {
 …
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
                                 // ^^^ need to handle the case where a tuple has a default argument
                                 if ( ! instantiateArgument(
+                                if ( ! instantiateArgument(
                                         type, nullptr, args, results, genStart, symtab, nTuples ) ) return false;
                                 nTuples = 0;
 …
                 } else if ( const ast::TypeInstType * ttype = Tuples::isTtype( paramType ) ) {
                         // paramType is a ttype, consumes all remaining arguments
                         // completed tuples; will be spliced to end of results to finish
                         std::vector< ArgPack > finalResults{};
 …
                                 for ( std::size_t i = genStart; i < genEnd; ++i ) {
                                         unsigned nextArg = results[i].nextArg;
                                         // use next element of exploded tuple if present
                                         if ( results[i].hasExpl() ) {
 …
                                                 results.emplace_back(
                                                         i, expl.exprs[ results[i].nextExpl ], copy( results[i].env ),
                                                         copy( results[i].need ), copy( results[i].have ),
+                                                        copy( results[i].need ), copy( results[i].have ),
                                                         copy( results[i].open ), nextArg, nTuples, Cost::zero, nextExpl,
                                                         results[i].explAlt );
 …
                                                         // push empty tuple expression
                                                         newResult.parent = i;
+                                                        std::vector< ast::ptr< ast::Expr > > emptyList;
+                                                        newResult.expr =
+                                                                new ast::TupleExpr{ CodeLocation{}, move( emptyList ) };
+                                                        newResult.expr = new ast::TupleExpr{ CodeLocation{}, {} };
                                                         argType = newResult.expr->result;
                                                 } else {
 …
                                                 // check unification for ttype before adding to final
                                                 if (
                                                         unify(
+                                                if (
+                                                        unify(
                                                                 ttype, argType, newResult.env, newResult.need, newResult.have,
                                                                 newResult.open, symtab )
+                                                                newResult.open, symtab )
                                                 ) {
                                                         finalResults.emplace_back( move( newResult ) );
 …
                                                 if ( expl.exprs.empty() ) {
                                                         results.emplace_back(
                                                                 results[i], move( env ), copy( results[i].need ),
+                                                                results[i], move( env ), copy( results[i].need ),
                                                                 copy( results[i].have ), move( open ), nextArg + 1, expl.cost );
                                                         continue;
+                                                }
 …
                                                 // add new result
                                                 results.emplace_back(
                                                         i, expl.exprs.front(), move( env ), copy( results[i].need ),
                                                         copy( results[i].have ), move( open ), nextArg + 1, nTuples,
+                                                        i, expl.exprs.front(), move( env ), copy( results[i].need ),
+                                                        copy( results[i].have ), move( open ), nextArg + 1, nTuples,
                                                         expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                        }
 …
                                         results.emplace_back(
                                                 i, expr, move( env ), move( need ), move( have ), move( open ), nextArg,
+                                                i, expr, move( env ), move( need ), move( have ), move( open ), nextArg,
                                                 nTuples, Cost::zero, nextExpl, results[i].explAlt );
+                                }
 …
                                         if ( unify( paramType, cnst->result, env, need, have, open, symtab ) ) {
                                                 results.emplace_back(
                                                         i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ),
+                                                        i, new ast::DefaultArgExpr{ cnst->location, cnst }, move( env ),
                                                         move( need ), move( have ), move( open ), nextArg, nTuples );
+                                        }
 …
                                 if ( expl.exprs.empty() ) {
                                         results.emplace_back(
                                                 results[i], move( env ), move( need ), move( have ), move( open ),
+                                                results[i], move( env ), move( need ), move( have ), move( open ),
                                                 nextArg + 1, expl.cost );
                                         continue;
+                                }
 …
                                         // add new result
                                         results.emplace_back(
                                                 i, expr, move( env ), move( need ), move( have ), move( open ),
+                                                i, expr, move( env ), move( need ), move( have ), move( open ),
                                                 nextArg + 1, nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
+                                }
 …
                 genStart = genEnd;
                 return genEnd != results.size();
+                return genEnd != results.size();  // were any new results added?
+        }
         /// Generate a cast expression from `arg` to `toType`
         const ast::Expr * restructureCast(
+        const ast::Expr * restructureCast(
                 ast::ptr< ast::Expr > & arg, const ast::Type * toType, ast::GeneratedFlag isGenerated = ast::GeneratedCast
         ) {
                 if (
                         arg->result->size() > 1
                         && ! toType->isVoid()
                         && ! dynamic_cast< const ast::ReferenceType * >( toType )
+                if (
+                        arg->result->size() > 1
+                        && ! toType->isVoid()
+                        && ! dynamic_cast< const ast::ReferenceType * >( toType )
                 ) {
                         // Argument is a tuple and the target type is neither void nor a reference. Cast each
                         // member of the tuple to its corresponding target type, producing the tuple of those
                         // cast expressions. If there are more components of the tuple than components in the
                         // target type, then excess components do not come out in the result expression (but
+                        // Argument is a tuple and the target type is neither void nor a reference. Cast each
+                        // member of the tuple to its corresponding target type, producing the tuple of those
+                        // cast expressions. If there are more components of the tuple than components in the
+                        // target type, then excess components do not come out in the result expression (but
                         // UniqueExpr ensures that the side effects will still be produced)
                         if ( Tuples::maybeImpureIgnoreUnique( arg ) ) {
                                 // expressions which may contain side effects require a single unique instance of
+                                // expressions which may contain side effects require a single unique instance of
                                 // the expression
                                 arg = new ast::UniqueExpr{ arg->location, arg };
 …
                                 // cast each component
                                 ast::ptr< ast::Expr > idx = new ast::TupleIndexExpr{ arg->location, arg, i };
                                 components.emplace_back(
+                                components.emplace_back(
                                         restructureCast( idx, toType->getComponent( i ), isGenerated ) );
+                        }
 …
         /// Actually visits expressions to find their candidate interpretations
+        struct Finder final : public ast::WithShortCircuiting {
+        class Finder final : public ast::WithShortCircuiting {
+                const ast::SymbolTable & symtab;
+        public:
+                static size_t traceId;
                 CandidateFinder & selfFinder;
-                const ast::SymbolTable & symtab;
                 CandidateList & candidates;
                 const ast::TypeEnvironment & tenv;
                 ast::ptr< ast::Type > & targetType;
+                enum Errors {
+                        NotFound,
+                        NoMatch,
+                        ArgsToFew,
+                        ArgsToMany,
+                        RetsToFew,
+                        RetsToMany,
+                        NoReason
+                };
+                struct {
+                        Errors code = NotFound;
+                } reason;
                 Finder( CandidateFinder & f )
                 : selfFinder( f ), symtab( f.symtab ), candidates( f.candidates ), tenv( f.env ),
+                : symtab( f.localSyms ), selfFinder( f ), candidates( f.candidates ), tenv( f.env ),
                   targetType( f.targetType ) {}
                 void previsit( const ast::Node * ) { visit_children = false; }
 …
                 void addCandidate( Args &&... args ) {
                         candidates.emplace_back( new Candidate{ std::forward<Args>( args )... } );
+                        reason.code = NoReason;
+                }
 …
                 /// Completes a function candidate with arguments located
                 void validateFunctionCandidate(
                         const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
                         CandidateList & out
+                void validateFunctionCandidate(
+                        const CandidateRef & func, ArgPack & result, const std::vector< ArgPack > & results,
+                        CandidateList & out
                 ) {
                         ast::ApplicationExpr * appExpr =
+                        ast::ApplicationExpr * appExpr =
                                 new ast::ApplicationExpr{ func->expr->location, func->expr };
                         // sum cost and accumulate arguments
 …
                         appExpr->args = move( vargs );
                         // build and validate new candidate
                         auto newCand =
+                        auto newCand =
                                 std::make_shared<Candidate>( appExpr, result.env, result.open, result.need, cost );
                         PRINT(
 …
                 /// Builds a list of candidates for a function, storing them in out
                 void makeFunctionCandidates(
                         const CandidateRef & func, const ast::FunctionType * funcType,
+                        const CandidateRef & func, const ast::FunctionType * funcType,
                         const ExplodedArgs_new & args, CandidateList & out
                 ) {
 …
                         ast::TypeEnvironment funcEnv{ func->env };
                         makeUnifiableVars( funcType, funcOpen, funcNeed );
                         // add all type variables as open variables now so that those not used in the parameter
                         // list are still considered open
+                        // add all type variables as open variables now so that those not used in the
+                        // parameter list are still considered open
                         funcEnv.add( funcType->forall );
                         if ( targetType && ! targetType->isVoid() && ! funcType->returns.empty() ) {
                                 // attempt to narrow based on expected target type
                                 const ast::Type * returnType = funcType->returns.front()->get_type();
                                 if ( ! unify(
                                         returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
+                                const ast::Type * returnType = funcType->returns.front();
+                                if ( ! unify(
+                                        returnType, targetType, funcEnv, funcNeed, funcHave, funcOpen, symtab )
                                 ) {
                                         // unification failed, do not pursue this candidate
 …
                         std::size_t genStart = 0;
+                        for ( const ast::DeclWithType * param : funcType->params ) {
+                                auto obj = strict_dynamic_cast< const ast::ObjectDecl * >( param );
+                                // Try adding the arguments corresponding to the current parameter to the existing
+                        // xxx - how to handle default arg after change to ftype representation?
+                        if (const ast::VariableExpr * varExpr = func->expr.as<ast::VariableExpr>()) {
+                                if (const ast::FunctionDecl * funcDecl = varExpr->var.as<ast::FunctionDecl>()) {
+                                        // function may have default args only if directly calling by name
+                                        // must use types on candidate however, due to RenameVars substitution
+                                        auto nParams = funcType->params.size();
+                                        for (size_t i=0; i<nParams; ++i) {
+                                                auto obj = funcDecl->params[i].strict_as<ast::ObjectDecl>();
+                                                if (!instantiateArgument(
+                                                        funcType->params[i], obj->init, args, results, genStart, symtab)) return;
+                                        }
+                                        goto endMatch;
+                                }
+                        }
+                        for ( const auto & param : funcType->params ) {
+                                // Try adding the arguments corresponding to the current parameter to the existing
                                 // matches
+                                if ( ! instantiateArgument(
+                                        obj->type, obj->init, args, results, genStart, symtab ) ) return;
+                        }
+                                // no default args for indirect calls
+                                if ( ! instantiateArgument(
+                                        param, nullptr, args, results, genStart, symtab ) ) return;
+                        }
+                        endMatch:
                         if ( funcType->isVarArgs ) {
                                 // append any unused arguments to vararg pack
 …
                                                         if ( expl.exprs.empty() ) {
                                                                 results.emplace_back(
                                                                         results[i], move( env ), copy( results[i].need ),
                                                                         copy( results[i].have ), move( open ), nextArg + 1,
+                                                                        results[i], move( env ), copy( results[i].need ),
+                                                                        copy( results[i].have ), move( open ), nextArg + 1,
                                                                         expl.cost );
 …
                                                         results.emplace_back(
                                                                 i, expl.exprs.front(), move( env ), copy( results[i].need ),
                                                                 copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost,
+                                                                copy( results[i].have ), move( open ), nextArg + 1, 0, expl.cost,
                                                                 expl.exprs.size() == 1 ? 0 : 1, j );
+                                                }
 …
                 /// Adds implicit struct-conversions to the alternative list
                 void addAnonConversions( const CandidateRef & cand ) {
                         // adds anonymous member interpretations whenever an aggregate value type is seen.
                         // it's okay for the aggregate expression to have reference type -- cast it to the
+                        // adds anonymous member interpretations whenever an aggregate value type is seen.
+                        // it's okay for the aggregate expression to have reference type -- cast it to the
                         // base type to treat the aggregate as the referenced value
                         ast::ptr< ast::Expr > aggrExpr( cand->expr );
                         ast::ptr< ast::Type > & aggrType = aggrExpr.get_and_mutate()->result;
                         cand->env.apply( aggrType );
                         if ( aggrType.as< ast::ReferenceType >() ) {
                                 aggrExpr = new ast::CastExpr{ aggrExpr, aggrType->stripReferences() };
 …
                 /// Adds aggregate member interpretations
                 void addAggMembers(
                         const ast::ReferenceToType * aggrInst, const ast::Expr * expr,
                         const Candidate & cand, const Cost & addedCost, const std::string & name
+                void addAggMembers(
+                        const ast::BaseInstType * aggrInst, const ast::Expr * expr,
+                        const Candidate & cand, const Cost & addedCost, const std::string & name
                 ) {
                         for ( const ast::Decl * decl : aggrInst->lookup( name ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( decl );
                                 CandidateRef newCand = std::make_shared<Candidate>(
+                                CandidateRef newCand = std::make_shared<Candidate>(
                                         cand, new ast::MemberExpr{ expr->location, dwt, expr }, addedCost );
                                 // add anonymous member interpretations whenever an aggregate value type is seen
+                                // add anonymous member interpretations whenever an aggregate value type is seen
                                 // as a member expression
                                 addAnonConversions( newCand );
 …
                 /// Adds tuple member interpretations
                 void addTupleMembers(
                         const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
                         const Cost & addedCost, const ast::Expr * member
+                void addTupleMembers(
+                        const ast::TupleType * tupleType, const ast::Expr * expr, const Candidate & cand,
+                        const Cost & addedCost, const ast::Expr * member
                 ) {
                         if ( auto constantExpr = dynamic_cast< const ast::ConstantExpr * >( member ) ) {
                                 // get the value of the constant expression as an int, must be between 0 and the
+                                // get the value of the constant expression as an int, must be between 0 and the
                                 // length of the tuple to have meaning
                                 long long val = constantExpr->intValue();
                                 if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
                                         addCandidate(
                                                 cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
+                                                cand, new ast::TupleIndexExpr{ expr->location, expr, (unsigned)val },
                                                 addedCost );
+                                }
 …
                 void postvisit( const ast::UntypedExpr * untypedExpr ) {
+                        CandidateFinder funcFinder{ symtab, tenv };
+                        funcFinder.find( untypedExpr->func, ResolvMode::withAdjustment() );
+                        // short-circuit if no candidates
+                        if ( funcFinder.candidates.empty() ) return;
+                        std::vector< CandidateFinder > argCandidates =
+                        std::vector< CandidateFinder > argCandidates =
                                 selfFinder.findSubExprs( untypedExpr->args );
                         // take care of possible tuple assignments
                         // if not tuple assignment, handled as normal function call
                         Tuples::handleTupleAssignment( selfFinder, untypedExpr, argCandidates );
+                        CandidateFinder funcFinder{ symtab, tenv };
+                        if (auto nameExpr = untypedExpr->func.as<ast::NameExpr>()) {
+                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
+                                        assertf(!argCandidates.empty(), "special function call without argument");
+                                        for (auto & firstArgCand: argCandidates[0]) {
+                                                ast::ptr<ast::Type> argType = firstArgCand->expr->result;
+                                                firstArgCand->env.apply(argType);
+                                                // strip references
+                                                // xxx - is this correct?
+                                                while (argType.as<ast::ReferenceType>()) argType = argType.as<ast::ReferenceType>()->base;
+                                                // convert 1-tuple to plain type
+                                                if (auto tuple = argType.as<ast::TupleType>()) {
+                                                        if (tuple->size() == 1) {
+                                                                argType = tuple->types[0];
+                                                        }
+                                                }
+                                                // if argType is an unbound type parameter, all special functions need to be searched.
+                                                if (isUnboundType(argType)) {
+                                                        funcFinder.otypeKeys.clear();
+                                                        break;
+                                                }
+                                                if (argType.as<ast::PointerType>()) funcFinder.otypeKeys.insert(Mangle::Encoding::pointer);
+                                                else funcFinder.otypeKeys.insert(Mangle::mangle(argType, Mangle::NoGenericParams | Mangle::Type));
+                                        }
+                                }
+                        }
+                        // if candidates are already produced, do not fail
+                        // xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
+                        // this means there exists ctor/assign functions with a tuple as first parameter.
+                        ResolvMode mode = {
+                                true, // adjust
+                                !untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
+                                selfFinder.candidates.empty() // failfast if other options are not found
+                        };
+                        funcFinder.find( untypedExpr->func, mode );
+                        // short-circuit if no candidates
+                        // if ( funcFinder.candidates.empty() ) return;
+                        reason.code = NoMatch;
                         // find function operators
 …
                                                 if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                         CandidateRef newFunc{ new Candidate{ *func } };
                                                         newFunc->expr =
+                                                        newFunc->expr =
                                                                 referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                         makeFunctionCandidates( newFunc, function, argExpansions, found );
+                                                }
                                         } else if (
                                                 auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
+                                        } else if (
+                                                auto inst = dynamic_cast< const ast::TypeInstType * >( funcResult )
                                         ) {
                                                 if ( const ast::EqvClass * clz = func->env.lookup( inst->name ) ) {
+                                                if ( const ast::EqvClass * clz = func->env.lookup( *inst ) ) {
                                                         if ( auto function = clz->bound.as< ast::FunctionType >() ) {
                                                                 CandidateRef newFunc{ new Candidate{ *func } };
                                                                 newFunc->expr =
+                                                                newFunc->expr =
                                                                         referenceToRvalueConversion( newFunc->expr, newFunc->cost );
                                                                 makeFunctionCandidates( newFunc, function, argExpansions, found );
 …
                                 std::vector< ExplodedArg > funcE;
                                 funcE.reserve( funcFinder.candidates.size() );
                                 for ( const CandidateRef & func : funcFinder ) {
+                                for ( const CandidateRef & func : funcFinder ) {
                                         funcE.emplace_back( *func, symtab );
+                                }
 …
                                                         if ( auto function = pointer->base.as< ast::FunctionType >() ) {
                                                                 CandidateRef newOp{ new Candidate{ *op} };
                                                                 newOp->expr =
+                                                                newOp->expr =
                                                                         referenceToRvalueConversion( newOp->expr, newOp->cost );
                                                                 makeFunctionCandidates( newOp, function, argExpansions, found );
 …
+                        }
                         // Implement SFINAE; resolution errors are only errors if there aren't any non-error
+                        // Implement SFINAE; resolution errors are only errors if there aren't any non-error
                         // candidates
                         if ( found.empty() && ! errors.isEmpty() ) { throw errors; }
 …
                                         auto pointer = appExpr->func->result.strict_as< ast::PointerType >();
                                         auto function = pointer->base.strict_as< ast::FunctionType >();
                                         std::cerr << "Case +++++++++++++ " << appExpr->func << std::endl;
                                         std::cerr << "parameters are:" << std::endl;
 …
                         promoteCvtCost( winners );
                         // function may return a struct/union value, in which case we need to add candidates
                         // for implicit conversions to each of the anonymous members, which must happen after
+                        // function may return a struct/union value, in which case we need to add candidates
+                        // for implicit conversions to each of the anonymous members, which must happen after
                         // `findMinCost`, since anon conversions are never the cheapest
                         for ( const CandidateRef & c : winners ) {
 …
                         if ( candidates.empty() && targetType && ! targetType->isVoid() ) {
                                 // If resolution is unsuccessful with a target type, try again without, since it
+                                // If resolution is unsuccessful with a target type, try again without, since it
                                 // will sometimes succeed when it wouldn't with a target type binding.
                                 // For example:
 …
                 /// true if expression is an lvalue
                 static bool isLvalue( const ast::Expr * x ) {
                         return x->result && ( x->result->is_lvalue() || x->result.as< ast::ReferenceType >() );
+                        return x->result && ( x->get_lvalue() || x->result.as< ast::ReferenceType >() );
+                }
 …
                         CandidateFinder finder{ symtab, tenv };
                         finder.find( addressExpr->arg );
+                        if( finder.candidates.empty() ) return;
+                        reason.code = NoMatch;
                         for ( CandidateRef & r : finder.candidates ) {
                                 if ( ! isLvalue( r->expr ) ) continue;
 …
                         assert( toType );
                         toType = resolveTypeof( toType, symtab );
                         toType = SymTab::validateType( castExpr->location, toType, symtab );
+                        // toType = SymTab::validateType( castExpr->location, toType, symtab );
                         toType = adjustExprType( toType, tenv, symtab );
                         CandidateFinder finder{ symtab, tenv, toType };
                         finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+                        if( !finder.candidates.empty() ) reason.code = NoMatch;
                         CandidateList matches;
 …
                                 cand->env.extractOpenVars( open );
                                 // It is possible that a cast can throw away some values in a multiply-valued
                                 // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
                                 // subexpression results that are cast directly. The candidate is invalid if it
+                                // It is possible that a cast can throw away some values in a multiply-valued
+                                // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of the
+                                // subexpression results that are cast directly. The candidate is invalid if it
                                 // has fewer results than there are types to cast to.
                                 int discardedValues = cand->expr->result->size() - toType->size();
 …
                                 // unification run for side-effects
                                 unify( toType, cand->expr->result, cand->env, need, have, open, symtab );
+                                Cost thisCost = castCost( cand->expr->result, toType, symtab, cand->env );
+                                Cost thisCost =
+                                        (castExpr->isGenerated == ast::GeneratedFlag::GeneratedCast)
+                            ? conversionCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env )
+                            : castCost( cand->expr->result, toType, cand->expr->get_lvalue(), symtab, cand->env );
                                 PRINT(
                                         std::cerr << "working on cast with result: " << toType << std::endl;
 …
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
                                         CandidateRef newCand = std::make_shared<Candidate>(
                                                 restructureCast( cand->expr, toType, castExpr->isGenerated ),
                                                 copy( cand->env ), move( open ), move( need ), cand->cost,
+                                        CandidateRef newCand = std::make_shared<Candidate>(
+                                                restructureCast( cand->expr, toType, castExpr->isGenerated ),
+                                                copy( cand->env ), move( open ), move( need ), cand->cost,
                                                 cand->cost + thisCost );
                                         inferParameters( newCand, matches );
 …
                         finder.find( castExpr->arg, ResolvMode::withoutPrune() );
                         for ( CandidateRef & r : finder.candidates ) {
                                 addCandidate(
                                         *r,
+                                addCandidate(
+                                        *r,
                                         new ast::VirtualCastExpr{ castExpr->location, r->expr, castExpr->result } );
+                        }
+                }
+                void postvisit( const ast::KeywordCastExpr * castExpr ) {
+                        const auto & loc = castExpr->location;
+                        assertf( castExpr->result, "Cast target should have been set in Validate." );
+                        auto ref = castExpr->result.strict_as<ast::ReferenceType>();
+                        auto inst = ref->base.strict_as<ast::StructInstType>();
+                        auto target = inst->base.get();
+                        CandidateFinder finder{ symtab, tenv };
+                        auto pick_alternatives = [target, this](CandidateList & found, bool expect_ref) {
+                                for(auto & cand : found) {
+                                        const ast::Type * expr = cand->expr->result.get();
+                                        if(expect_ref) {
+                                                auto res = dynamic_cast<const ast::ReferenceType*>(expr);
+                                                if(!res) { continue; }
+                                                expr = res->base.get();
+                                        }
+                                        if(auto insttype = dynamic_cast<const ast::TypeInstType*>(expr)) {
+                                                auto td = cand->env.lookup(*insttype);
+                                                if(!td) { continue; }
+                                                expr = td->bound.get();
+                                        }
+                                        if(auto base = dynamic_cast<const ast::StructInstType*>(expr)) {
+                                                if(base->base == target) {
+                                                        candidates.push_back( std::move(cand) );
+                                                        reason.code = NoReason;
+                                                }
+                                        }
+                                }
+                        };
+                        try {
+                                // Attempt 1 : turn (thread&)X into ($thread&)X.__thrd
+                                // Clone is purely for memory management
+                                std::unique_ptr<const ast::Expr> tech1 { new ast::UntypedMemberExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.field), castExpr->arg) };
+                                // don't prune here, since it's guaranteed all alternatives will have the same type
+                                finder.find( tech1.get(), ResolvMode::withoutPrune() );
+                                pick_alternatives(finder.candidates, false);
+                                return;
+                        } catch(SemanticErrorException & ) {}
+                        // Fallback : turn (thread&)X into ($thread&)get_thread(X)
+                        std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
+                        // don't prune here, since it's guaranteed all alternatives will have the same type
+                        finder.find( fallback.get(), ResolvMode::withoutPrune() );
+                        pick_alternatives(finder.candidates, true);
+                        // Whatever happens here, we have no more fallbacks
+                }
 …
                         aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
                         for ( CandidateRef & agg : aggFinder.candidates ) {
                                 // it's okay for the aggregate expression to have reference type -- cast it to the
+                                // it's okay for the aggregate expression to have reference type -- cast it to the
                                 // base type to treat the aggregate as the referenced value
                                 Cost addedCost = Cost::zero;
 …
                                 // find member of the given type
                                 if ( auto structInst = agg->expr->result.as< ast::StructInstType >() ) {
                                         addAggMembers(
+                                        addAggMembers(
                                                 structInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto unionInst = agg->expr->result.as< ast::UnionInstType >() ) {
                                         addAggMembers(
+                                        addAggMembers(
                                                 unionInst, agg->expr, *agg, addedCost, getMemberName( memberExpr ) );
                                 } else if ( auto tupleType = agg->expr->result.as< ast::TupleType >() ) {
 …
                 void postvisit( const ast::NameExpr * nameExpr ) {
+                        std::vector< ast::SymbolTable::IdData > declList = symtab.lookupId( nameExpr->name );
+                        std::vector< ast::SymbolTable::IdData > declList;
+                        if (!selfFinder.otypeKeys.empty()) {
+                                auto kind = ast::SymbolTable::getSpecialFunctionKind(nameExpr->name);
+                                assertf(kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS, "special lookup with non-special target: %s", nameExpr->name.c_str());
+                                for (auto & otypeKey: selfFinder.otypeKeys) {
+                                        auto result = symtab.specialLookupId(kind, otypeKey);
+                                        declList.insert(declList.end(), std::make_move_iterator(result.begin()), std::make_move_iterator(result.end()));
+                                }
+                        }
+                        else {
+                                declList = symtab.lookupId( nameExpr->name );
+                        }
                         PRINT( std::cerr << "nameExpr is " << nameExpr->name << std::endl; )
+                        if( declList.empty() ) return;
+                        reason.code = NoMatch;
                         for ( auto & data : declList ) {
                                 Cost cost = Cost::zero;
 …
                                 CandidateRef newCand = std::make_shared<Candidate>(
                                         newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
+                                        newExpr, copy( tenv ), ast::OpenVarSet{}, ast::AssertionSet{}, Cost::zero,
                                         cost );
                                 PRINT(
 …
                                         std::cerr << std::endl;
+                                )
                                 newCand->expr = ast::mutate_field(
                                         newCand->expr.get(), &ast::Expr::result,
+                                newCand->expr = ast::mutate_field(
+                                        newCand->expr.get(), &ast::Expr::result,
                                         renameTyVars( newCand->expr->result ) );
                                 // add anonymous member interpretations whenever an aggregate value type is seen
+                                // add anonymous member interpretations whenever an aggregate value type is seen
                                 // as a name expression
                                 addAnonConversions( newCand );
 …
                         // not sufficient to just pass `variableExpr` here, type might have changed since
                         // creation
                         addCandidate(
+                        addCandidate(
                                 new ast::VariableExpr{ variableExpr->location, variableExpr->var }, tenv );
+                }
 …
                 void postvisit( const ast::SizeofExpr * sizeofExpr ) {
                         if ( sizeofExpr->type ) {
                                 addCandidate(
                                         new ast::SizeofExpr{
                                                 sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) },
+                                addCandidate(
+                                        new ast::SizeofExpr{
+                                                sizeofExpr->location, resolveTypeof( sizeofExpr->type, symtab ) },
                                         tenv );
                         } else {
 …
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
                                         SemanticError(
+                                        SemanticError(
                                                 sizeofExpr->expr.get(), "Ambiguous expression in sizeof operand: " );
+                                }
 …
                 void postvisit( const ast::AlignofExpr * alignofExpr ) {
                         if ( alignofExpr->type ) {
                                 addCandidate(
                                         new ast::AlignofExpr{
                                                 alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) },
+                                addCandidate(
+                                        new ast::AlignofExpr{
+                                                alignofExpr->location, resolveTypeof( alignofExpr->type, symtab ) },
                                         tenv );
                         } else {
 …
                                 CandidateList winners = findMinCost( finder.candidates );
                                 if ( winners.size() != 1 ) {
                                         SemanticError(
+                                        SemanticError(
                                                 alignofExpr->expr.get(), "Ambiguous expression in alignof operand: " );
+                                }
 …
                                 choice->expr = referenceToRvalueConversion( choice->expr, choice->cost );
                                 choice->cost = Cost::zero;
                                 addCandidate(
+                                addCandidate(
                                         *choice, new ast::AlignofExpr{ alignofExpr->location, choice->expr } );
+                        }
 …
                 void postvisit( const ast::UntypedOffsetofExpr * offsetofExpr ) {
                         const ast::ReferenceToType * aggInst;
+                        const ast::BaseInstType * aggInst;
                         if (( aggInst = offsetofExpr->type.as< ast::StructInstType >() )) ;
                         else if (( aggInst = offsetofExpr->type.as< ast::UnionInstType >() )) ;
 …
                         for ( const ast::Decl * member : aggInst->lookup( offsetofExpr->member ) ) {
                                 auto dwt = strict_dynamic_cast< const ast::DeclWithType * >( member );
                                 addCandidate(
+                                addCandidate(
                                         new ast::OffsetofExpr{ offsetofExpr->location, aggInst, dwt }, tenv );
+                        }
 …
                         finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
                         if ( finder2.candidates.empty() ) return;
+                        reason.code = NoMatch;
                         for ( const CandidateRef & r1 : finder1.candidates ) {
 …
                                         addCandidate(
                                                 new ast::LogicalExpr{
+                                                new ast::LogicalExpr{
                                                         logicalExpr->location, r1->expr, r2->expr, logicalExpr->isAnd },
                                                 move( env ), move( open ), move( need ), r1->cost + r2->cost );
 …
                         finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
                         if ( finder3.candidates.empty() ) return;
+                        reason.code = NoMatch;
                         for ( const CandidateRef & r1 : finder1.candidates ) {
 …
                                                 ast::AssertionSet have;
                                                 // unify true and false results, then infer parameters to produce new
+                                                // unify true and false results, then infer parameters to produce new
                                                 // candidates
                                                 ast::ptr< ast::Type > common;
                                                 if (
                                                         unify(
                                                                 r2->expr->result, r3->expr->result, env, need, have, open, symtab,
                                                                 common )
+                                                if (
+                                                        unify(
+                                                                r2->expr->result, r3->expr->result, env, need, have, open, symtab,
+                                                                common )
                                                 ) {
                                                         // generate typed expression
                                                         ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
+                                                        ast::ConditionalExpr * newExpr = new ast::ConditionalExpr{
                                                                 conditionalExpr->location, r1->expr, r2->expr, r3->expr };
                                                         newExpr->result = common ? common : r2->expr->result;
                                                         // convert both options to result type
                                                         Cost cost = r1->cost + r2->cost + r3->cost;
                                                         newExpr->arg2 = computeExpressionConversionCost(
+                                                        newExpr->arg2 = computeExpressionConversionCost(
                                                                 newExpr->arg2, newExpr->result, symtab, env, cost );
                                                         newExpr->arg3 = computeExpressionConversionCost(
 …
                         ast::TypeEnvironment env{ tenv };
                         ast::ptr< ast::Expr > arg1 = resolveInVoidContext( commaExpr->arg1, symtab, env );
                         CandidateFinder finder2{ symtab, env };
                         finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
 …
                         finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
                         if ( finder2.candidates.empty() ) return;
+                        reason.code = NoMatch;
                         for ( const CandidateRef & r1 : finder1.candidates ) {
 …
                                         ast::ptr< ast::Type > common;
                                         if (
                                                 unify(
                                                         r1->expr->result, r2->expr->result, env, need, have, open, symtab,
                                                         common )
+                                        if (
+                                                unify(
+                                                        r1->expr->result, r2->expr->result, env, need, have, open, symtab,
+                                                        common )
                                         ) {
                                                 // generate new expression
                                                 ast::RangeExpr * newExpr =
+                                                ast::RangeExpr * newExpr =
                                                         new ast::RangeExpr{ rangeExpr->location, r1->expr, r2->expr };
                                                 newExpr->result = common ? common : r1->expr->result;
                                                 // add candidate
                                                 CandidateRef newCand = std::make_shared<Candidate>(
                                                         newExpr, move( env ), move( open ), move( need ),
+                                                        newExpr, move( env ), move( open ), move( need ),
                                                         r1->cost + r2->cost );
                                                 inferParameters( newCand, candidates );
 …
                 void postvisit( const ast::UntypedTupleExpr * tupleExpr ) {
                         std::vector< CandidateFinder > subCandidates =
+                        std::vector< CandidateFinder > subCandidates =
                                 selfFinder.findSubExprs( tupleExpr->exprs );
                         std::vector< CandidateList > possibilities;
 …
                                 addCandidate(
                                         new ast::TupleExpr{ tupleExpr->location, move( exprs ) },
+                                        new ast::TupleExpr{ tupleExpr->location, move( exprs ) },
                                         move( env ), move( open ), move( need ), sumCost( subs ) );
+                        }
 …
                                 // calculate target type
                                 const ast::Type * toType = resolveTypeof( initAlt.type, symtab );
                                 toType = SymTab::validateType( initExpr->location, toType, symtab );
+                                // toType = SymTab::validateType( initExpr->location, toType, symtab );
                                 toType = adjustExprType( toType, tenv, symtab );
                                 // The call to find must occur inside this loop, otherwise polymorphic return
                                 // types are not bound to the initialization type, since return type variables are
                                 // only open for the duration of resolving the UntypedExpr.
+                                // The call to find must occur inside this loop, otherwise polymorphic return
+                                // types are not bound to the initialization type, since return type variables are
+                                // only open for the duration of resolving the UntypedExpr.
                                 CandidateFinder finder{ symtab, tenv, toType };
                                 finder.find( initExpr->expr, ResolvMode::withAdjustment() );
                                 for ( CandidateRef & cand : finder.candidates ) {
+                                        if(reason.code == NotFound) reason.code = NoMatch;
                                         ast::TypeEnvironment env{ cand->env };
                                         ast::AssertionSet need( cand->need.begin(), cand->need.end() ), have;
 …
+                                        )
                                         // It is possible that a cast can throw away some values in a multiply-valued
                                         // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
                                         // the subexpression results that are cast directly. The candidate is invalid
+                                        // It is possible that a cast can throw away some values in a multiply-valued
+                                        // expression, e.g. cast-to-void, one value to zero. Figure out the prefix of
+                                        // the subexpression results that are cast directly. The candidate is invalid
                                         // if it has fewer results than there are types to cast to.
                                         int discardedValues = cand->expr->result->size() - toType->size();
 …
                                         // unification run for side-effects
+                                        unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        Cost thisCost = castCost( cand->expr->result, toType, symtab, env );
+                                        bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
+                                        (void) canUnify;
+                                        Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                symtab, env );
+                                        PRINT(
+                                                Cost legacyCost = castCost( cand->expr->result, toType, cand->expr->get_lvalue(),
+                                                        symtab, env );
+                                                std::cerr << "Considering initialization:";
+                                                std::cerr << std::endl << "  FROM: " << cand->expr->result << std::endl;
+                                                std::cerr << std::endl << "  TO: "   << toType             << std::endl;
+                                                std::cerr << std::endl << "  Unification " << (canUnify ? "succeeded" : "failed");
+                                                std::cerr << std::endl << "  Legacy cost " << legacyCost;
+                                                std::cerr << std::endl << "  New cost " << thisCost;
+                                                std::cerr << std::endl;
+                                        )
                                         if ( thisCost != Cost::infinity ) {
                                                 // count one safe conversion for each value that is thrown away
                                                 thisCost.incSafe( discardedValues );
                                                 CandidateRef newCand = std::make_shared<Candidate>(
                                                         new ast::InitExpr{
                                                                 initExpr->location, restructureCast( cand->expr, toType ),
                                                                 initAlt.designation },
                                                         copy( cand->env ), move( open ), move( need ), cand->cost, thisCost );
+                                                CandidateRef newCand = std::make_shared<Candidate>(
+                                                        new ast::InitExpr{
+                                                                initExpr->location, restructureCast( cand->expr, toType ),
+                                                                initAlt.designation },
+                                                        move(env), move( open ), move( need ), cand->cost, thisCost );
                                                 inferParameters( newCand, matches );
+                                        }
+                                }
+                        }
 …
         };
+        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
+        // size_t Finder::traceId = Stats::Heap::new_stacktrace_id("Finder");
+        /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
         /// return type. Skips ambiguous candidates.
+        CandidateList pruneCandidates( CandidateList & candidates ) {
+                struct PruneStruct {
+                        CandidateRef candidate;
+                        bool ambiguous;
+                        PruneStruct() = default;
+                        PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
+                };
+                // find lowest-cost candidate for each type
+                std::unordered_map< std::string, PruneStruct > selected;
+                for ( CandidateRef & candidate : candidates ) {
+                        std::string mangleName;
+} // anonymous namespace
+bool CandidateFinder::pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors ) {
+        struct PruneStruct {
+                CandidateRef candidate;
+                bool ambiguous;
+                PruneStruct() = default;
+                PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
+        };
+        // find lowest-cost candidate for each type
+        std::unordered_map< std::string, PruneStruct > selected;
+        // attempt to skip satisfyAssertions on more expensive alternatives if better options have been found
+        std::sort(candidates.begin(), candidates.end(), [](const CandidateRef & x, const CandidateRef & y){return x->cost < y->cost;});
+        for ( CandidateRef & candidate : candidates ) {
+                std::string mangleName;
+                {
+                        ast::ptr< ast::Type > newType = candidate->expr->result;
+                        assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
+                        candidate->env.apply( newType );
+                        mangleName = Mangle::mangle( newType );
+                }
+                auto found = selected.find( mangleName );
+                if (found != selected.end() && found->second.candidate->cost < candidate->cost) {
+                        PRINT(
+                                std::cerr << "cost " << candidate->cost << " loses to "
+                                        << found->second.candidate->cost << std::endl;
+                        )
+                        continue;
+                }
+                // xxx - when do satisfyAssertions produce more than 1 result?
+                // this should only happen when initial result type contains
+                // unbound type parameters, then it should never be pruned by
+                // the previous step, since renameTyVars guarantees the mangled name
+                // is unique.
+                CandidateList satisfied;
+                bool needRecomputeKey = false;
+                if (candidate->need.empty()) {
+                        satisfied.emplace_back(candidate);
+                }
+                else {
+                        satisfyAssertions(candidate, localSyms, satisfied, errors);
+                        needRecomputeKey = true;
+                }
+                for (auto & newCand : satisfied) {
+                        // recomputes type key, if satisfyAssertions changed it
+                        if (needRecomputeKey)
+                        {
+                                ast::ptr< ast::Type > newType = candidate->expr->result;
+                                candidate->env.apply( newType );
+                                ast::ptr< ast::Type > newType = newCand->expr->result;
+                                assertf(newCand->expr->result, "Result of expression %p for candidate is null", newCand->expr.get());
+                                newCand->env.apply( newType );
                                 mangleName = Mangle::mangle( newType );
+                        }
                         auto found = selected.find( mangleName );
                         if ( found != selected.end() ) {
                                 if ( candidate->cost < found->second.candidate->cost ) {
+                                if ( newCand->cost < found->second.candidate->cost ) {
                                         PRINT(
                                                 std::cerr << "cost " << candidate->cost << " beats "
+                                                std::cerr << "cost " << newCand->cost << " beats "
                                                         << found->second.candidate->cost << std::endl;
+                                        )
                                         found->second = PruneStruct{ candidate };
                                 } else if ( candidate->cost == found->second.candidate->cost ) {
                                         // if one of the candidates contains a deleted identifier, can pick the other,
                                         // since deleted expressions should not be ambiguous if there is another option
+                                        found->second = PruneStruct{ newCand };
+                                } else if ( newCand->cost == found->second.candidate->cost ) {
+                                        // if one of the candidates contains a deleted identifier, can pick the other,
+                                        // since deleted expressions should not be ambiguous if there is another option
                                         // that is at least as good
                                         if ( findDeletedExpr( candidate->expr ) ) {
+                                        if ( findDeletedExpr( newCand->expr ) ) {
                                                 // do nothing
                                                 PRINT( std::cerr << "candidate is deleted" << std::endl; )
                                         } else if ( findDeletedExpr( found->second.candidate->expr ) ) {
                                                 PRINT( std::cerr << "current is deleted" << std::endl; )
                                                 found->second = PruneStruct{ candidate };
+                                                found->second = PruneStruct{ newCand };
                                         } else {
                                                 PRINT( std::cerr << "marking ambiguous" << std::endl; )
                                                 found->second.ambiguous = true;
+                                        }
+                                } else {
+                                } else {
+                                        // xxx - can satisfyAssertions increase the cost?
                                         PRINT(
                                                 std::cerr << "cost " << candidate->cost << " loses to "
+                                                std::cerr << "cost " << newCand->cost << " loses to "
                                                         << found->second.candidate->cost << std::endl;
+                                        )
+                                        )
+                                }
                         } else {
+                                selected.emplace_hint( found, mangleName, candidate );
+                        }
+                }
+                // report unambiguous min-cost candidates
+                CandidateList out;
+                for ( auto & target : selected ) {
+                        if ( target.second.ambiguous ) continue;
+                        CandidateRef cand = target.second.candidate;
+                        ast::ptr< ast::Type > newResult = cand->expr->result;
+                        cand->env.applyFree( newResult );
+                        cand->expr = ast::mutate_field(
+                                cand->expr.get(), &ast::Expr::result, move( newResult ) );
+                        out.emplace_back( cand );
+                }
+                return out;
+                                selected.emplace_hint( found, mangleName, newCand );
+                        }
+                }
+        }
+} // anonymous namespace
+        // report unambiguous min-cost candidates
+        // CandidateList out;
+        for ( auto & target : selected ) {
+                if ( target.second.ambiguous ) continue;
+                CandidateRef cand = target.second.candidate;
+                ast::ptr< ast::Type > newResult = cand->expr->result;
+                cand->env.applyFree( newResult );
+                cand->expr = ast::mutate_field(
+                        cand->expr.get(), &ast::Expr::result, move( newResult ) );
+                out.emplace_back( cand );
+        }
+        // if everything is lost in satisfyAssertions, report the error
+        return !selected.empty();
+}
 void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
 …
         if ( mode.failFast && candidates.empty() ) {
+                SemanticError( expr, "No reasonable alternatives for expression " );
+                switch(finder.core.reason.code) {
+                case Finder::NotFound:
+                        { SemanticError( expr, "No alternatives for expression " ); break; }
+                case Finder::NoMatch:
+                        { SemanticError( expr, "Invalid application of existing declaration(s) in expression " ); break; }
+                case Finder::ArgsToFew:
+                case Finder::ArgsToMany:
+                case Finder::RetsToFew:
+                case Finder::RetsToMany:
+                case Finder::NoReason:
+                default:
+                        { SemanticError( expr->location, "No reasonable alternatives for expression : reasons unkown" ); }
+                }
+        }
+        /*
         if ( mode.satisfyAssns || mode.prune ) {
                 // trim candidates to just those where the assertions are satisfiable
 …
                 std::vector< std::string > errors;
                 for ( CandidateRef & candidate : candidates ) {
                         satisfyAssertions( candidate, symtab, satisfied, errors );
+                        satisfyAssertions( candidate, localSyms, satisfied, errors );
+                }
 …
                 candidates = move( satisfied );
+        }
+        */
         if ( mode.prune ) {
 …
+                )
+                CandidateList pruned = pruneCandidates( candidates );
+                CandidateList pruned;
+                std::vector<std::string> errors;
+                bool found = pruneCandidates( candidates, pruned, errors );
                 if ( mode.failFast && pruned.empty() ) {
                         std::ostringstream stream;
+                        CandidateList winners = findMinCost( candidates );
+                        stream << "Cannot choose between " << winners.size() << " alternatives for "
+                                "expression\n";
+                        ast::print( stream, expr );
+                        stream << " Alternatives are:\n";
+                        print( stream, winners, 1 );
+                        SemanticError( expr->location, stream.str() );
+                        if (found) {
+                                CandidateList winners = findMinCost( candidates );
+                                stream << "Cannot choose between " << winners.size() << " alternatives for "
+                                        "expression\n";
+                                ast::print( stream, expr );
+                                stream << " Alternatives are:\n";
+                                print( stream, winners, 1 );
+                                SemanticError( expr->location, stream.str() );
+                        }
+                        else {
+                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
+                                for ( const auto& err : errors ) {
+                                        stream << err;
+                                }
+                                SemanticError( expr->location, stream.str() );
+                        }
+                }
 …
+                )
                 PRINT(
                         std::cerr << "there are " << candidates.size() << " alternatives after elimination"
+                        std::cerr << "there are " << candidates.size() << " alternatives after elimination"
                                 << std::endl;
+                )
+        }
         // adjust types after pruning so that types substituted by pruneAlternatives are correctly
+        // adjust types after pruning so that types substituted by pruneAlternatives are correctly
         // adjusted
         if ( mode.adjust ) {
                 for ( CandidateRef & r : candidates ) {
                         r->expr = ast::mutate_field(
                                 r->expr.get(), &ast::Expr::result,
                                 adjustExprType( r->expr->result, r->env, symtab ) );
+                        r->expr = ast::mutate_field(
+                                r->expr.get(), &ast::Expr::result,
+                                adjustExprType( r->expr->result, r->env, localSyms ) );
+                }
+        }
 …
+}
 std::vector< CandidateFinder > CandidateFinder::findSubExprs(
         const std::vector< ast::ptr< ast::Expr > > & xs
+std::vector< CandidateFinder > CandidateFinder::findSubExprs(
+        const std::vector< ast::ptr< ast::Expr > > & xs
 ) {
         std::vector< CandidateFinder > out;
         for ( const auto & x : xs ) {
                 out.emplace_back( symtab, env );
+                out.emplace_back( localSyms, env );
                 out.back().find( x, ResolvMode::withAdjustment() );
                 PRINT(
                         std::cerr << "findSubExprs" << std::endl;

src/ResolvExpr/CandidateFinder.hpp

-              r3c64c668
+              r58fe85a
 // Author           : Aaron B. Moss
 // Created On       : Wed Jun 5 14:30:00 2019
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Wed Jun 5 14:30:00 2019
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1  9:51:00 2019
+// Update Count     : 2
 //
 …
 struct CandidateFinder {
         CandidateList candidates;          ///< List of candidate resolutions
         const ast::SymbolTable & symtab;   ///< Symbol table to lookup candidates
+        const ast::SymbolTable & localSyms;   ///< Symbol table to lookup candidates
         const ast::TypeEnvironment & env;  ///< Substitutions performed in this resolution
         ast::ptr< ast::Type > targetType;  ///< Target type for resolution
+        std::set< std::string > otypeKeys;  /// different type may map to same key
         CandidateFinder(
                 const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+        CandidateFinder(
+                const ast::SymbolTable & syms, const ast::TypeEnvironment & env,
                 const ast::Type * tt = nullptr )
         : candidates(), symtab( symtab ), env( env ), targetType( tt ) {}
+        : candidates(), localSyms( syms ), env( env ), targetType( tt ) {}
         /// Fill candidates with feasible resolutions for `expr`
         void find( const ast::Expr * expr, ResolvMode mode = {} );
+        bool pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors );
         /// Runs new candidate finder on each element in xs, returning the list of finders
 …
         iterator begin() { return candidates.begin(); }
         const_iterator begin() const { return candidates.begin(); }
         iterator end() { return candidates.end(); }
         const_iterator end() const { return candidates.end(); }
 …
 /// Computes conversion cost between two types
 Cost computeConversionCost(
         const ast::Type * argType, const ast::Type * paramType, const ast::SymbolTable & symtab,
         const ast::TypeEnvironment & env );
+Cost computeConversionCost(
+        const ast::Type * argType, const ast::Type * paramType, bool argIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
 } // namespace ResolvExpr

src/ResolvExpr/CastCost.cc

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

src/ResolvExpr/CommonType.cc

-              r3c64c668
+              r58fe85a
                 const ast::OpenVarSet & open;
         public:
+                static size_t traceId;
                 ast::ptr< ast::Type > result;
 …
                         const ast::Type * base = oPtr->base;
                         if ( auto var = dynamic_cast< const ast::TypeInstType * >( base ) ) {
                                 auto entry = open.find( var->name );
+                                auto entry = open.find( *var );
                                 if ( entry != open.end() ) {
                                         ast::AssertionSet need, have;
 …
         };
+        // size_t CommonType_new::traceId = Stats::Heap::new_stacktrace_id("CommonType_new");
         namespace {
                 ast::ptr< ast::Type > handleReference(
 …
                         ast::ptr< ast::Type > result;
                         const ast::ReferenceType * ref1 = type1.as< ast::ReferenceType >();
                         const ast::ReferenceType * ref2 = type1.as< ast::ReferenceType >();
+                        const ast::ReferenceType * ref2 = type2.as< ast::ReferenceType >();
                         if ( depth1 > depth2 ) {
 …
                 ast::Pass<CommonType_new> visitor{ type2, widen, symtab, env, open };
                 type1->accept( visitor );
                 ast::ptr< ast::Type > result = visitor.pass.result;
+                ast::ptr< ast::Type > result = visitor.core.result;
                 // handling for opaque type declarations (?)

src/ResolvExpr/ConversionCost.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Sun May 17 07:06:19 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Mon Aug 12 10:21:00 2019
 // Update Count     : 27
+// Last Modified On : Wed Jul 29 16:11:00 2020
+// Update Count     : 28
 //
 …
         void ConversionCost::postvisit( const FunctionType * ) {}
-        void ConversionCost::postvisit( const StructInstType * inst ) {
-                if ( const StructInstType * destAsInst = dynamic_cast< const StructInstType * >( dest ) ) {
-                        if ( inst->name == destAsInst->name ) {
-                                cost = Cost::zero;
-                        } // if
-                } // if
+        }
-        void ConversionCost::postvisit( const UnionInstType * inst ) {
-                if ( const UnionInstType * destAsInst = dynamic_cast< const UnionInstType * >( dest ) ) {
-                        if ( inst->name == destAsInst->name ) {
-                                cost = Cost::zero;
-                        } // if
-                } // if
+        }
         void ConversionCost::postvisit( const EnumInstType * ) {
                 static Type::Qualifiers q;
 …
+        }
+static int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
                 const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
         return ptrsAssignable( t1, t2, env );
+}
+// TODO: This is used for overload resolution. It might be able to be dropped once the old system
+// is removed.
+static Cost localConversionCost(
         const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
         const ast::TypeEnvironment & env
 ) { return conversionCost( src, dst, symtab, env ); }
+namespace {
+        # warning For overload resolution between the two versions.
+        int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
+                        const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
+                return ptrsAssignable( t1, t2, env );
+        }
+        Cost localConversionCost(
+                const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+                const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
+        ) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
+}
 Cost conversionCost(
         const ast::Type * src, const ast::Type * dst, const ast::SymbolTable & symtab,
         const ast::TypeEnvironment & env
+        const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
+        const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
         if ( const ast::TypeInstType * inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( inst->name ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( *inst ) ) {
                         if ( eqv->bound ) {
                                 return conversionCost(src, eqv->bound, symtab, env );
+                                return conversionCost(src, eqv->bound, srcIsLvalue, symtab, env );
                         } else {
                                 return Cost::infinity;
 …
                         assertf( type, "Unexpected typedef." );
                         if ( type->base ) {
                                 return conversionCost( src, type->base, symtab, env ) + Cost::safe;
+                                return conversionCost( src, type->base, srcIsLvalue, symtab, env ) + Cost::safe;
+                        }
+                }
 …
         } else if ( const ast::ReferenceType * refType =
                          dynamic_cast< const ast::ReferenceType * >( dst ) ) {
                 return convertToReferenceCost( src, refType, symtab, env, localPtrsAssignable );
+                return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
         } else {
+                ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                src->accept( converter );
+                return converter.pass.cost;
+        }
+}
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst,
+                return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
+        }
+}
+static Cost convertToReferenceCost( const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
                 int diff, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
                 NumCostCalculation func ) {
+                PtrsCalculation func ) {
         if ( 0 < diff ) {
                 Cost cost = convertToReferenceCost(
                         strict_dynamic_cast< const ast::ReferenceType * >( src )->base,
                         dst, (diff - 1), symtab, env, func );
+                        strict_dynamic_cast< const ast::ReferenceType * >( src )->base, dst,
+                        srcIsLvalue, (diff - 1), symtab, env, func );
                 cost.incReference();
                 return cost;
 …
                 Cost cost = convertToReferenceCost(
                         src, strict_dynamic_cast< const ast::ReferenceType * >( dst )->base,
                         (diff + 1), symtab, env, func );
+                        srcIsLvalue, (diff + 1), symtab, env, func );
                 cost.incReference();
                 return cost;
 …
+                        }
                 } else {
+                        ast::Pass<ConversionCost_new> converter( dst, symtab, env, localConversionCost );
+                        src->accept( converter );
+                        return converter.pass.cost;
+                        return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
+                }
         } else {
 …
                 assert( dstAsRef );
                 if ( typesCompatibleIgnoreQualifiers( src, dstAsRef->base, symtab, env ) ) {
                         if ( src->is_lvalue() ) {
+                        if ( srcIsLvalue ) {
                                 if ( src->qualifiers == dstAsRef->base->qualifiers ) {
                                         return Cost::reference;
 …
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dst,
             const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
                 NumCostCalculation func ) {
+                bool srcIsLvalue, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env,
+                PtrsCalculation func ) {
         int sdepth = src->referenceDepth(), ddepth = dst->referenceDepth();
         return convertToReferenceCost( src, dst, sdepth - ddepth, symtab, env, func );
+        return convertToReferenceCost( src, dst, srcIsLvalue, sdepth - ddepth, symtab, env, func );
+}
 …
         assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
         cost = costCalc( refType->base, dst, symtab, env );
+        cost = costCalc( refType->base, dst, srcIsLvalue, symtab, env );
         if ( refType->base->qualifiers == dst->qualifiers ) {
                 cost.incReference();
 …
+}
-void ConversionCost_new::postvisit( const ast::StructInstType * structInstType ) {
-        if ( const ast::StructInstType * dstAsInst =
-                        dynamic_cast< const ast::StructInstType * >( dst ) ) {
-                if ( structInstType->name == dstAsInst->name ) {
-                        cost = Cost::zero;
+                }
+        }
+}
-void ConversionCost_new::postvisit( const ast::UnionInstType * unionInstType ) {
-        if ( const ast::UnionInstType * dstAsInst =
-                        dynamic_cast< const ast::UnionInstType * >( dst ) ) {
-                if ( unionInstType->name == dstAsInst->name ) {
-                        cost = Cost::zero;
+                }
+        }
+}
 void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
         (void)enumInstType;
         static const ast::BasicType integer( ast::BasicType::SignedInt );
         cost = costCalc( &integer, dst, symtab, env );
+        static ast::ptr<ast::BasicType> integer = { new ast::BasicType( ast::BasicType::SignedInt ) };
+        cost = costCalc( integer, dst, srcIsLvalue, symtab, env );
         if ( cost < Cost::unsafe ) {
                 cost.incSafe();
 …
 void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
         if ( const ast::EqvClass * eqv = env.lookup( typeInstType->name ) ) {
                 cost = costCalc( eqv->bound, dst, symtab, env );
+        if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
+                cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
         } else if ( const ast::TypeInstType * dstAsInst =
                         dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( typeInstType->name == dstAsInst->name ) {
+                if ( *typeInstType == *dstAsInst ) {
                         cost = Cost::zero;
+                }
 …
                 assertf( type, "Unexpected typedef.");
                 if ( type->base ) {
                         cost = costCalc( type->base, dst, symtab, env ) + Cost::safe;
+                        cost = costCalc( type->base, dst, srcIsLvalue, symtab, env ) + Cost::safe;
+                }
+        }
 …
                 auto dstEnd = dstAsTuple->types.end();
                 while ( srcIt != srcEnd && dstIt != dstEnd ) {
                         Cost newCost = costCalc( * srcIt++, * dstIt++, symtab, env );
+                        Cost newCost = costCalc( * srcIt++, * dstIt++, srcIsLvalue, symtab, env );
                         if ( newCost == Cost::infinity ) {
                                 return;
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
+        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
+                cost = Cost::zero;
+                // +1 for zero_t ->, +1 for disambiguation
+                cost.incSafe( maxIntCost + 2 );
+        }
+}
 …
                         cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
+                }
+        } else if ( dynamic_cast< const ast::PointerType * >( dst ) ) {
+                cost = Cost::zero;
+                cost.incSafe( maxIntCost + 2 );
+        }
+}
+        }
+}
+// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
 } // namespace ResolvExpr

src/ResolvExpr/ConversionCost.h

-              r3c64c668
+              r58fe85a
 // Created On       : Sun May 17 09:37:28 2015
 // Last Modified By : Andrew Beach
 // Last Modified On : Thu Aug  8 16:13:00 2019
 // Update Count     : 6
+// Last Modified On : Wed Jul 29 16:12:00 2020
+// Update Count     : 7
 //
 …
                 void postvisit( const ReferenceType * refType );
                 void postvisit( const FunctionType * functionType );
-                void postvisit( const StructInstType * aggregateUseType );
-                void postvisit( const UnionInstType * aggregateUseType );
                 void postvisit( const EnumInstType * aggregateUseType );
                 void postvisit( const TraitInstType * aggregateUseType );
 …
 // Some function pointer types, differ in return type.
 using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *,
+using CostCalculation = std::function<Cost(const ast::Type *, const ast::Type *, bool,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
 using NumCostCalculation = std::function<int(const ast::Type *, const ast::Type *,
+using PtrsCalculation = std::function<int(const ast::Type *, const ast::Type *,
         const ast::SymbolTable &, const ast::TypeEnvironment &)>;
 …
 protected:
         const ast::Type * dst;
+        bool srcIsLvalue;
         const ast::SymbolTable & symtab;
         const ast::TypeEnvironment & env;
         CostCalculation costCalc;
 public:
+        static size_t traceId;
         Cost cost;
+        Cost result() { return cost; }
         ConversionCost_new( const ast::Type * dst, const ast::SymbolTable & symtab,
+        ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
                         const ast::TypeEnvironment & env, CostCalculation costCalc ) :
+                dst( dst ), symtab( symtab ), env( env ), costCalc( costCalc ), cost( Cost::infinity )
+                dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ),
+                costCalc( costCalc ), cost( Cost::infinity )
         {}
 …
         void postvisit( const ast::ReferenceType * refType );
         void postvisit( const ast::FunctionType * functionType );
-        void postvisit( const ast::StructInstType * structInstType );
-        void postvisit( const ast::UnionInstType * unionInstType );
         void postvisit( const ast::EnumInstType * enumInstType );
         void postvisit( const ast::TraitInstType * traitInstType );
 …
 Cost convertToReferenceCost( const ast::Type * src, const ast::ReferenceType * dest,
+        const ast::SymbolTable & indexer, const ast::TypeEnvironment & env, NumCostCalculation func );
+        bool srcIsLvalue, const ast::SymbolTable & indexer, const ast::TypeEnvironment & env,
+        PtrsCalculation func );
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

-              r3c64c668
+              r58fe85a
 #include <string>                      // for string, operator<<, allocator
+#include "AST/Copy.hpp"                // for shallowCopy
 #include "AST/Expr.hpp"                // for InitAlternative
 #include "AST/GenericSubstitution.hpp" // for genericSubstitution
 #include "AST/Init.hpp"                // for Designation
 #include "AST/Node.hpp"                // for readonly
+#include "AST/Print.hpp"                // for readonly
 #include "AST/Type.hpp"
 #include "Common/Indenter.h"           // for Indenter, operator<<
 …
         class SimpleIterator final : public MemberIterator {
                 CodeLocation location;
                 readonly< Type > type = nullptr;
+                const Type * type = nullptr;
         public:
                 SimpleIterator( const CodeLocation & loc, const Type * t ) : location( loc ), type( t ) {}
                 void setPosition(
                         std::deque< ptr< Expr > >::const_iterator begin,
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) override {
 …
         class ArrayIterator final : public MemberIterator {
                 CodeLocation location;
                 readonly< ArrayType > array = nullptr;
                 readonly< Type > base = nullptr;
+                const ArrayType * array = nullptr;
+                const Type * base = nullptr;
                 size_t index = 0;
                 size_t size = 0;
 …
                         auto res = eval(expr);
                         if ( ! res.second ) {
                                 SemanticError( location,
+                                SemanticError( location,
                                         toString("Array designator must be a constant expression: ", expr ) );
+                        }
 …
         public:
                 ArrayIterator( const CodeLocation & loc, const ArrayType * at )
+                ArrayIterator( const CodeLocation & loc, const ArrayType * at )
                 : location( loc ), array( at ), base( at->base ) {
                         PRINT( std::cerr << "Creating array iterator: " << at << std::endl; )
 …
                 void setPosition( const Expr * expr ) {
                         // need to permit integer-constant-expressions, including: integer constants,
                         // enumeration constants, character constants, sizeof expressions, alignof expressions,
+                        // need to permit integer-constant-expressions, including: integer constants,
+                        // enumeration constants, character constants, sizeof expressions, alignof expressions,
                         // cast expressions
                         if ( auto constExpr = dynamic_cast< const ConstantExpr * >( expr ) ) {
 …
                                         index = constExpr->intValue();
                                 } catch ( SemanticErrorException & ) {
                                         SemanticError( expr,
+                                        SemanticError( expr,
                                                 "Constant expression of non-integral type in array designator: " );
+                                }
                         } else if ( auto castExpr = dynamic_cast< const CastExpr * >( expr ) ) {
                                 setPosition( castExpr->arg );
                         } else if (
                                 dynamic_cast< const SizeofExpr * >( expr )
                                 || dynamic_cast< const AlignofExpr * >( expr )
+                        } else if (
+                                dynamic_cast< const SizeofExpr * >( expr )
+                                || dynamic_cast< const AlignofExpr * >( expr )
                         ) {
                                 index = 0;
                         } else {
                                 assertf( false,
+                                assertf( false,
                                         "bad designator given to ArrayIterator: %s", toString( expr ).c_str() );
+                        }
+                }
                 void setPosition(
                         std::deque< ptr< Expr > >::const_iterator begin,
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) override {
 …
+                }
                 AggregateIterator(
                         const CodeLocation & loc, const std::string k, const std::string & n, const Type * i,
+                AggregateIterator(
+                        const CodeLocation & loc, const std::string k, const std::string & n, const Type * i,
                         const MemberList & ms )
                 : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ),
+                : location( loc ), kind( k ), name( n ), inst( i ), members( ms ), curMember( ms.begin() ),
                   sub( genericSubstitution( i ) ) {
                         PRINT( std::cerr << "Creating " << kind << "(" << name << ")"; )
 …
         public:
                 void setPosition(
                         std::deque< ptr< Expr > >::const_iterator begin,
+                void setPosition(
+                        std::deque< ptr< Expr > >::const_iterator begin,
                         std::deque< ptr< Expr > >::const_iterator end
                 ) final {
 …
                                         return;
+                                }
                                 assertf( false,
+                                assertf( false,
                                         "could not find member in %s: %s", kind.c_str(), toString( varExpr ).c_str() );
                         } else {
                                 assertf( false,
+                                assertf( false,
                                         "bad designator given to %s: %s", kind.c_str(), toString( *begin ).c_str() );
+                        }
 …
                                                 new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
                                         // need to substitute for generic types so that casts are to concrete types
+                                        alt.type = shallowCopy(alt.type.get());
                                         PRINT( std::cerr << "  type is: " << alt.type; )
                                         sub.apply( alt.type ); // also apply to designation??
 …
                                 for ( InitAlternative & alt : ret ) {
                                         PRINT( std::cerr << "iterating and adding designators" << std::endl; )
                                         alt.designation.get_and_mutate()->designators.emplace_front(
+                                        alt.designation.get_and_mutate()->designators.emplace_front(
                                                 new VariableExpr{ location, curMember->strict_as< ObjectDecl >() } );
+                                }
 …
         class TupleIterator final : public AggregateIterator {
         public:
                 TupleIterator( const CodeLocation & loc, const TupleType * inst )
                 : AggregateIterator(
                         loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
+                TupleIterator( const CodeLocation & loc, const TupleType * inst )
+                : AggregateIterator(
+                        loc, "TupleIterator", toString("Tuple", inst->size()), inst, inst->members
                 ) {}
 …
         MemberIterator * createMemberIterator( const CodeLocation & loc, const Type * type ) {
                 if ( auto aggr = dynamic_cast< const ReferenceToType * >( type ) ) {
+                if ( auto aggr = dynamic_cast< const BaseInstType * >( type ) ) {
                         if ( auto sit = dynamic_cast< const StructInstType * >( aggr ) ) {
                                 return new StructIterator{ loc, sit };
 …
                                 return new UnionIterator{ loc, uit };
                         } else {
                                 assertf(
                                         dynamic_cast< const EnumInstType * >( aggr )
                                                 || dynamic_cast< const TypeInstType * >( aggr ),
                                         "Encountered unhandled ReferenceToType in createMemberIterator: %s",
+                                assertf(
+                                        dynamic_cast< const EnumInstType * >( type )
+                                                || dynamic_cast< const TypeInstType * >( type ),
+                                        "Encountered unhandled BaseInstType in createMemberIterator: %s",
                                                 toString( type ).c_str() );
                                 return new SimpleIterator{ loc, type };
 …
                 using DesignatorChain = std::deque< ptr< Expr > >;
                 PRINT( std::cerr << "___findNext" << std::endl; )
                 // find all the d's
                 std::vector< DesignatorChain > desigAlts{ {} }, newDesigAlts;
 …
                                         DesignatorChain & d = *dit;
                                         PRINT( std::cerr << "____actual: " << t << std::endl; )
                                         if ( auto refType = dynamic_cast< const ReferenceToType * >( t ) ) {
+                                        if ( auto refType = dynamic_cast< const BaseInstType * >( t ) ) {
                                                 // concatenate identical field names
                                                 for ( const Decl * mem : refType->lookup( nexpr->name ) ) {
 …
                 // set new designators
                 assertf( ! objStack.empty(), "empty object stack when setting designation" );
                 Designation * actualDesignation =
+                Designation * actualDesignation =
                         new Designation{ designation->location, DesignatorChain{d} };
                 objStack.back()->setPosition( d ); // destroys d

src/ResolvExpr/FindOpenVars.cc

-              r3c64c668
+              r58fe85a
                                 // mark open/closed variables
                                 if ( nextIsOpen ) {
                                         for ( const ast::TypeDecl * decl : type->forall ) {
                                                 open[ decl->name ] = ast::TypeDecl::Data{ decl };
                                                 for ( const ast::DeclWithType * assert : decl->assertions ) {
                                                         need[ assert ].isUsed = false;
+                                                }
+                                        for ( auto & decl : type->forall ) {
+                                                open[ *decl ] = ast::TypeDecl::Data{ decl->base };
+                                        }
+                                        for ( auto & assert : type->assertions ) {
+                                                need[ assert ].isUsed = false;
+                                        }
                                 } else {
                                         for ( const ast::TypeDecl * decl : type->forall ) {
                                                 closed[ decl->name ] = ast::TypeDecl::Data{ decl };
                                                 for ( const ast::DeclWithType * assert : decl->assertions ) {
                                                         have[ assert ].isUsed = false;
+                                                }
+                                        for ( auto & decl : type->forall ) {
+                                                closed[ *decl ] = ast::TypeDecl::Data{ decl->base };
+                                        }
+                                        for ( auto & assert : type->assertions ) {
+                                                have[ assert ].isUsed = false;
+                                        }
+                                }

src/ResolvExpr/PolyCost.cc

-              r3c64c668
+              r58fe85a
 // TODO: When the old PolyCost is torn out get rid of the _new suffix.
+struct PolyCost_new {
+class PolyCost_new {
+        const ast::SymbolTable &symtab;
+public:
         int result;
-        const ast::SymbolTable &symtab;
         const ast::TypeEnvironment &env_;
         PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) :
                 result( 0 ), symtab( symtab ), env_( env ) {}
+        PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env )
+        : symtab( symtab ), result( 0 ), env_( env ) {}
         void previsit( const ast::TypeInstType * type ) {
                 if ( const ast::EqvClass * eqv = env_.lookup( type->name ) ) /* && */ if ( eqv->bound ) {
+                if ( const ast::EqvClass * eqv = env_.lookup( *type ) ) /* && */ if ( eqv->bound ) {
                         if ( const ast::TypeInstType * otherType = eqv->bound.as< ast::TypeInstType >() ) {
                                 if ( symtab.lookupType( otherType->name ) ) {
 …
         ast::Pass<PolyCost_new> costing( symtab, env );
         type->accept( costing );
         return costing.pass.result;
+        return costing.core.result;
+}

src/ResolvExpr/PtrsAssignable.cc

-              r3c64c668
+              r58fe85a
+        }
         void postvisit( const ast::TypeInstType * inst ) {
                 if ( const ast::EqvClass * eqv = typeEnv.lookup( inst->name ) ) {
+                if ( const ast::EqvClass * eqv = typeEnv.lookup( *inst ) ) {
                         if ( eqv->bound ) {
                                 // T * = S * for any S depends on the type bound to T
 …
                 const ast::TypeEnvironment & env ) {
         if ( const ast::TypeInstType * dstAsInst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
                 if ( const ast::EqvClass * eqv = env.lookup( dstAsInst->name ) ) {
+                if ( const ast::EqvClass * eqv = env.lookup( *dstAsInst ) ) {
                         return ptrsAssignable( src, eqv->bound, env );
+                }
 …
                 ast::Pass<PtrsAssignable_new> visitor( dst, env );
                 src->accept( visitor );
                 return visitor.pass.result;
+                return visitor.core.result;
+        }

src/ResolvExpr/PtrsCastable.cc

r3c64c668	r58fe85a
180	180	}
181	181	}
182		} else if ( const ast::EqvClass * eqvClass = env.lookup( ~~inst->name~~ ) ) {
	182	} else if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
183	183	if ( eqvClass->data.kind == ast::TypeDecl::Ftype ) {
184	184	return -1;
…	…
283	283	) {
284	284	if ( auto inst = dynamic_cast< const ast::TypeInstType * >( dst ) ) {
285		if ( const ast::EqvClass * eqvClass = env.lookup( ~~inst->name~~ ) ) {
	285	if ( const ast::EqvClass * eqvClass = env.lookup( *inst ) ) {
286	286	return ptrsAssignable( src, eqvClass->bound, env );
287	287	}
…	…
293	293	ast::Pass< PtrsCastable_new > ptrs{ dst, env, symtab };
294	294	src->accept( ptrs );
295		return ptrs.~~pass~~.result;
	295	return ptrs.core.result;
296	296	}
297	297	}

src/ResolvExpr/RenameVars.cc

-              r3c64c668
+              r58fe85a
 #include "SynTree/Visitor.h"       // for acceptAll, maybeAccept
+#include "AST/Copy.hpp"
 namespace ResolvExpr {
 …
                 int level = 0;
                 int resetCount = 0;
+                int next_expr_id = 1;
+                int next_usage_id = 1;
                 ScopedMap< std::string, std::string > nameMap;
+                ScopedMap< std::string, ast::TypeInstType::TypeEnvKey > idMap;
         public:
                 void reset() {
 …
+                }
-                using mapConstIterator = ScopedMap< std::string, std::string >::const_iterator;
                 void rename( TypeInstType * type ) {
                         mapConstIterator it = nameMap.find( type->name );
+                        auto it = nameMap.find( type->name );
                         if ( it != nameMap.end() ) {
                                 type->name = it->second;
+                        }
+                }
+                void nextUsage() {
+                        ++next_usage_id;
+                }
 …
                                         // ditto for assertion names, the next level in
                                         level++;
+                                        // acceptAll( td->assertions, *this );
+                                } // for
+                        } // if
+                                }
+                        }
+                }
 …
                 const ast::TypeInstType * rename( const ast::TypeInstType * type ) {
+                        mapConstIterator it = nameMap.find( type->name );
+                        if ( it != nameMap.end() ) {
+                                ast::TypeInstType * mutType = ast::mutate( type );
+                                mutType->name = it->second;
+                    type = mutType;
+                        }
+                        // rename
+                        auto it = idMap.find( type->name );
+                        if ( it != idMap.end() ) {
+                                // unconditionally mutate because map will *always* have different name
+                                ast::TypeInstType * mut = ast::shallowCopy( type );
+                                // reconcile base node since some copies might have been made
+                                mut->base = it->second.base;
+                                mut->formal_usage = it->second.formal_usage;
+                                mut->expr_id = it->second.expr_id;
+                    type = mut;
+                        }
                         return type;
+                }
+                template<typename NodeT>
+                const NodeT * openLevel( const NodeT * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.beginScope();
+                                // Load new names from this forall clause and perform renaming.
+                                NodeT * mutType = ast::mutate( type );
+                                for ( ast::ptr< ast::TypeDecl > & td : mutType->forall ) {
+                                        std::ostringstream output;
+                                        output << "_" << resetCount << "_" << level << "_" << td->name;
+                                        std::string newname( output.str() );
+                                        nameMap[ td->name ] = newname;
+                                        ++level;
+                                        ast::TypeDecl * decl = ast::mutate( td.get() );
+                                        decl->name = newname;
+                                        td = decl;
+                                }
+                        }
+                        return type;
+                }
+                template<typename NodeT>
+                const NodeT * closeLevel( const NodeT * type ) {
+                        if ( !type->forall.empty() ) {
+                                nameMap.endScope();
+                        }
+                        return type;
+                const ast::FunctionType * openLevel( const ast::FunctionType * type, RenameMode mode ) {
+                        if ( type->forall.empty() ) return type;
+                        idMap.beginScope();
+                        // Load new names from this forall clause and perform renaming.
+                        auto mutType = ast::shallowCopy( type );
+                        // assert( type == mutType && "mutated type must be unique from ForallSubstitutor" );
+                        for ( auto & td : mutType->forall ) {
+                                auto mut = ast::shallowCopy( td.get() );
+                                // assert( td == mutDecl && "mutated decl must be unique from ForallSubstitutor" );
+                                if (mode == GEN_EXPR_ID) {
+                                        mut->expr_id = next_expr_id;
+                                        mut->formal_usage = -1;
+                                        ++next_expr_id;
+                                }
+                                else if (mode == GEN_USAGE) {
+                                        assertf(mut->expr_id, "unfilled expression id in generating candidate type");
+                                        mut->formal_usage = next_usage_id;
+                                }
+                                else {
+                                        assert(false);
+                                }
+                                idMap[ td->name ] = ast::TypeInstType::TypeEnvKey(*mut);
+                                td = mut;
+                        }
+                        return mutType;
+                }
+                void closeLevel( const ast::FunctionType * type ) {
+                        if ( type->forall.empty() ) return;
+                        idMap.endScope();
+                }
         };
 …
         RenamingData renaming;
         struct RenameVars {
+        struct RenameVars_old {
                 void previsit( TypeInstType * instType ) {
                         renaming.openLevel( (Type*)instType );
 …
                         renaming.closeLevel( type );
+                }
+        };
+        struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
+                RenameMode mode;
                 const ast::FunctionType * previsit( const ast::FunctionType * type ) {
+                        return renaming.openLevel( type );
+                }
+                        return renaming.openLevel( type, mode );
+                }
+                /*
                 const ast::StructInstType * previsit( const ast::StructInstType * type ) {
                         return renaming.openLevel( type );
 …
                         return renaming.openLevel( type );
+                }
+                */
                 const ast::TypeInstType * previsit( const ast::TypeInstType * type ) {
+                        return renaming.rename( renaming.openLevel( type ) );
+                }
+                const ast::ParameterizedType * postvisit( const ast::ParameterizedType * type ) {
+                        return renaming.closeLevel( type );
+                        if (mode == GEN_USAGE && !type->formal_usage) return type; // do not rename an actual type
+                        return renaming.rename( type );
+                }
+                void postvisit( const ast::FunctionType * type ) {
+                        renaming.closeLevel( type );
+                }
         };
 …
 void renameTyVars( Type * t ) {
         PassVisitor<RenameVars> renamer;
+        PassVisitor<RenameVars_old> renamer;
         t->accept( renamer );
+}
+const ast::Type * renameTyVars( const ast::Type * t ) {
+        ast::Pass<RenameVars> renamer;
+const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
+        // ast::Type *tc = ast::deepCopy(t);
+        ast::Pass<RenameVars_new> renamer;
+        renamer.core.mode = mode;
+        if (mode == GEN_USAGE && reset) {
+                renaming.nextUsage();
+        }
         return t->accept( renamer );
+}
 …
 void resetTyVarRenaming() {
         renaming.reset();
+        renaming.nextUsage();
+}

src/ResolvExpr/RenameVars.h

-              r3c64c668
+              r58fe85a
         /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
         void renameTyVars( Type * );
+        const ast::Type * renameTyVars( const ast::Type * );
+        enum RenameMode {
+                GEN_USAGE, // for type in VariableExpr
+                GEN_EXPR_ID // for type in decl
+        };
+        const ast::Type * renameTyVars( const ast::Type *, RenameMode mode = GEN_USAGE, bool reset = true );
         /// resets internal state of renamer to avoid overflow
         void resetTyVarRenaming();
 } // namespace ResolvExpr

src/ResolvExpr/ResolvMode.h

-              r3c64c668
+              r58fe85a
                 const bool prune;            ///< Prune alternatives to min-cost per return type? [true]
                 const bool failFast;         ///< Fail on no resulting alternatives? [true]
-                const bool satisfyAssns;     ///< Satisfy assertions? [false]
+        private:
+                constexpr ResolvMode(bool a, bool p, bool ff, bool sa)
+                : adjust(a), prune(p), failFast(ff), satisfyAssns(sa) {}
+                constexpr ResolvMode(bool a, bool p, bool ff)
+                : adjust(a), prune(p), failFast(ff) {}
-        public:
                 /// Default settings
                 constexpr ResolvMode() : adjust(false), prune(true), failFast(true), satisfyAssns(false) {}
+                constexpr ResolvMode() : adjust(false), prune(true), failFast(true) {}
                 /// With adjust flag set; turns array and function types into equivalent pointers
                 static constexpr ResolvMode withAdjustment() { return { true, true, true, false }; }
+                static constexpr ResolvMode withAdjustment() { return { true, true, true }; }
                 /// With adjust flag set but prune unset; pruning ensures there is at least one alternative
                 /// per result type
                 static constexpr ResolvMode withoutPrune() { return { true, false, true, false }; }
+                static constexpr ResolvMode withoutPrune() { return { true, false, true }; }
                 /// With adjust and prune flags set but failFast unset; failFast ensures there is at least
                 /// one resulting alternative
                 static constexpr ResolvMode withoutFailFast() { return { true, true, false, false }; }
+                static constexpr ResolvMode withoutFailFast() { return { true, true, false }; }
                 /// The same mode, but with satisfyAssns turned on; for top-level calls
                 ResolvMode atTopLevel() const { return { adjust, prune, failFast, true }; }
+                ResolvMode atTopLevel() const { return { adjust, true, failFast }; }
         };
 } // namespace ResolvExpr

src/ResolvExpr/ResolveAssertions.cc

-              r3c64c668
+              r58fe85a
                         const DeclarationWithType * candidate = cdata.id;
+                        // build independent unification context for candidate
+                        // ignore deleted candidates.
+                        // NOTE: this behavior is different from main resolver.
+                        // further investigations might be needed to determine
+                        // if we should implement the same rule here
+                        // (i.e. error if unique best match is deleted)
+                        if (candidate->isDeleted) continue;
+                        // build independent unification context. for candidate
                         AssertionSet have, newNeed;
                         TypeEnvironment newEnv{ resn.alt.env };
 …
         /// Limit to depth of recursion of assertion satisfaction
         static const int recursionLimit = 4;
+        static const int recursionLimit = 7;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;

src/ResolvExpr/ResolveTypeof.cc

-              r3c64c668
+              r58fe85a
 #include "ResolveTypeof.h"
+#include "RenameVars.h"
 #include <cassert>               // for assert
 …
 #include "SynTree/Mutator.h"     // for Mutator
 #include "SynTree/Type.h"        // for TypeofType, Type
+#include "SymTab/Mangler.h"
+#include "InitTweak/InitTweak.h" // for isConstExpr
 namespace SymTab {
 …
                         // replace basetypeof(<enum>) by int
                         if ( dynamic_cast<EnumInstType*>(newType) ) {
                                 Type* newerType =
                                         new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
+                                Type* newerType =
+                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt,
                                         newType->attributes };
                                 delete newType;
                                 newType = newerType;
+                        }
                         newType->get_qualifiers().val
+                        newType->get_qualifiers().val
                                 = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
                 } else {
                         newType->get_qualifiers().val |= oldQuals;
+                }
                 return newType;
+        }
 …
                 ResolveTypeof_new( const ast::SymbolTable & syms ) : localSymtab( syms ) {}
                 void premutate( const ast::TypeofType * ) { visit_children = false; }
                 const ast::Type * postmutate( const ast::TypeofType * typeofType ) {
+                void previsit( const ast::TypeofType * ) { visit_children = false; }
+                const ast::Type * postvisit( const ast::TypeofType * typeofType ) {
                         // pass on null expression
                         if ( ! typeofType->expr ) return typeofType;
 …
                                 // typeof wrapping expression
                                 ast::TypeEnvironment dummy;
                                 ast::ptr< ast::Expr > newExpr =
+                                ast::ptr< ast::Expr > newExpr =
                                         resolveInVoidContext( typeofType->expr, localSymtab, dummy );
                                 assert( newExpr->result && ! newExpr->result->isVoid() );
 …
                                 // replace basetypeof(<enum>) by int
                                 if ( newType.as< ast::EnumInstType >() ) {
                                         newType = new ast::BasicType{
+                                        newType = new ast::BasicType{
                                                 ast::BasicType::SignedInt, newType->qualifiers, copy(newType->attributes) };
+                                }
                                 reset_qualifiers(
                                         newType,
+                                reset_qualifiers(
+                                        newType,
                                         ( newType->qualifiers & ~ast::CV::EquivQualifiers ) | typeofType->qualifiers );
                         } else {
 …
+                        }
                         return newType;
+                        return newType.release();
+                }
         };
 …
         ast::Pass< ResolveTypeof_new > mutator{ symtab };
         return type->accept( mutator );
+}
+struct FixArrayDimension {
+        // should not require a mutable symbol table - prevent pass template instantiation
+        const ast::SymbolTable & _symtab;
+        FixArrayDimension(const ast::SymbolTable & symtab): _symtab(symtab) {}
+        const ast::ArrayType * previsit (const ast::ArrayType * arrayType) {
+                if (!arrayType->dimension) return arrayType;
+                auto mutType = mutate(arrayType);
+                ast::ptr<ast::Type> sizetype = ast::sizeType ? ast::sizeType : new ast::BasicType(ast::BasicType::LongUnsignedInt);
+                mutType->dimension = findSingleExpression(arrayType->dimension, sizetype, _symtab);
+                if (InitTweak::isConstExpr(mutType->dimension)) {
+                        mutType->isVarLen = ast::LengthFlag::FixedLen;
+                }
+                else {
+                        mutType->isVarLen = ast::LengthFlag::VariableLen;
+                }
+                return mutType;
+        }
+};
+const ast::Type * fixArrayType( const ast::Type * type, const ast::SymbolTable & symtab) {
+        ast::Pass<FixArrayDimension> visitor {symtab};
+        return type->accept(visitor);
+}
+const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ast::SymbolTable & symtab ) {
+        if (!decl->isTypeFixed) {
+                auto mutDecl = mutate(decl);
+                auto resolvedType = resolveTypeof(decl->type, symtab);
+                resolvedType = fixArrayType(resolvedType, symtab);
+                mutDecl->type = resolvedType;
+                // check variable length if object is an array.
+                // xxx - should this be part of fixObjectType?
+                /*
+                if (auto arrayType = dynamic_cast<const ast::ArrayType *>(resolvedType)) {
+                        auto dimExpr = findSingleExpression(arrayType->dimension, ast::sizeType, symtab);
+                        if (auto varexpr = arrayType->dimension.as<ast::VariableExpr>()) {// hoisted previously
+                                if (InitTweak::isConstExpr(varexpr->var.strict_as<ast::ObjectDecl>()->init)) {
+                                        auto mutType = mutate(arrayType);
+                                        mutType->isVarLen = ast::LengthFlag::VariableLen;
+                                        mutDecl->type = mutType;
+                                }
+                        }
+                }
+                */
+                if (!mutDecl->name.empty())
+                        mutDecl->mangleName = Mangle::mangle(mutDecl); // do not mangle unnamed variables
+                mutDecl->type = renameTyVars(mutDecl->type, RenameMode::GEN_EXPR_ID);
+                mutDecl->isTypeFixed = true;
+                return mutDecl;
+        }
+        return decl;
+}

src/ResolvExpr/ResolveTypeof.h

-              r3c64c668
+              r58fe85a
         class Type;
         class SymbolTable;
+        class ObjectDecl;
+}
 …
         Type *resolveTypeof( Type*, const SymTab::Indexer &indexer );
         const ast::Type * resolveTypeof( const ast::Type *, const ast::SymbolTable & );
+        const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ast::SymbolTable & symtab );
 } // namespace ResolvExpr

src/ResolvExpr/Resolver.cc

-              r3c64c668
+              r58fe85a
 // Author           : Aaron B. Moss
 // Created On       : Sun May 17 12:17:01 2015
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Wed May 29 11:00:00 2019
 // Update Count     : 241
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Mar 27 11:58:00 2020
+// Update Count     : 242
 //
 …
 #include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "Resolver.h"
+#include "ResolveTypeof.h"
 #include "ResolvMode.h"                  // for ResolvMode
 #include "typeops.h"                     // for extractResultType
 #include "Unify.h"                       // for unify
+#include "CompilationState.h"
 #include "AST/Chain.hpp"
 #include "AST/Decl.hpp"
 …
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
+#include "Common/Stats/ResolveTime.h"    // for ResolveTime::start(), ResolveTime::stop()
 #include "Common/utility.h"              // for ValueGuard, group_iterate
 #include "InitTweak/GenInit.h"
 …
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
+#include "SymTab/Mangler.h"              // for Mangler
 #include "SynTree/Declaration.h"         // for ObjectDecl, TypeDecl, Declar...
 #include "SynTree/Expression.h"          // for Expression, CastExpr, InitExpr
 …
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
                         const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exception_decl );
                         Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
 …
         namespace {
                 /// Finds deleted expressions in an expression tree
                 struct DeleteFinder_new final : public ast::WithShortCircuiting {
                         const ast::DeletedExpr * delExpr = nullptr;
+                struct DeleteFinder_new final : public ast::WithShortCircuiting, public ast::WithVisitorRef<DeleteFinder_new> {
+                        const ast::DeletedExpr * result = nullptr;
                         void previsit( const ast::DeletedExpr * expr ) {
+                                if ( delExpr ) { visit_children = false; }
+                                else { delExpr = expr; }
+                        }
+                        void previsit( const ast::Expr * ) {
+                                if ( delExpr ) { visit_children = false; }
+                                if ( result ) { visit_children = false; }
+                                else { result = expr; }
+                        }
+                        void previsit( const ast::Expr * expr ) {
+                                if ( result ) { visit_children = false; }
+                                if (expr->inferred.hasParams()) {
+                                        for (auto & imp : expr->inferred.inferParams() ) {
+                                                imp.second.expr->accept(*visitor);
+                                        }
+                                }
+                        }
                 };
         } // anonymous namespace
         /// Check if this expression is or includes a deleted expression
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
+                ast::Pass<DeleteFinder_new> finder;
+                expr->accept( finder );
+                return finder.pass.delExpr;
+                return ast::Pass<DeleteFinder_new>::read( expr );
+        }
 …
                 /// Strips extraneous casts out of an expression
                 struct StripCasts_new final {
                         const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
+                        const ast::Expr * postvisit( const ast::CastExpr * castExpr ) {
                                 if (
                                         castExpr->isGenerated
+                                        castExpr->isGenerated == ast::GeneratedCast
                                         && typesCompatible( castExpr->arg->result, castExpr->result )
                                 ) {
 …
+                }
+                /// Establish post-resolver invariants for expressions
+        } // anonymous namespace
+/// Establish post-resolver invariants for expressions
                 void finishExpr(
                         ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
 …
                         StripCasts_new::strip( expr );
+                }
-        } // anonymous namespace
         ast::ptr< ast::Expr > resolveInVoidContext(
 …
                 // set up and resolve expression cast to void
                 ast::CastExpr * untyped = new ast::CastExpr{ expr };
+                ast::ptr< ast::CastExpr > untyped = new ast::CastExpr{ expr };
                 CandidateRef choice = findUnfinishedKindExpression(
                         untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
 …
+        }
+        namespace {
+                /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
+        /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
                 /// context.
                 ast::ptr< ast::Expr > findVoidExpression(
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
-                        resetTyVarRenaming();
                         ast::TypeEnvironment env;
                         ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
 …
                         return newExpr;
+                }
+        namespace {
                 /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
 …
                         CandidateRef choice =
                                 findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
                         finishExpr( choice->expr, choice->env, untyped->env );
+                        ResolvExpr::finishExpr( choice->expr, choice->env, untyped->env );
                         return std::move( choice->expr );
+                }
 …
                         const ast::Expr * untyped, const ast::SymbolTable & symtab
                 ) {
+                        return findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::start( untyped );
+                        auto res = findKindExpression( untyped, symtab );
+                        Stats::ResolveTime::stop();
+                        return res;
+                }
         } // anonymous namespace
                 ast::ptr< ast::Expr > findSingleExpression(
                         const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
                 ) {
                         assert( untyped && type );
                         ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
                         ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, symtab );
                         removeExtraneousCast( newExpr, symtab );
                         return newExpr;
+                }
+        ast::ptr< ast::Expr > findSingleExpression(
+                const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
+        ) {
+                assert( untyped && type );
+                ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
+                ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, symtab );
+                removeExtraneousCast( newExpr, symtab );
+                return newExpr;
+        }
         namespace {
+                bool structOrUnion( const Candidate & i ) {
+                        const ast::Type * t = i.expr->result->stripReferences();
+                        return dynamic_cast< const ast::StructInstType * >( t ) || dynamic_cast< const ast::UnionInstType * >( t );
+                }
                 /// Predicate for "Candidate has integral type"
                 bool hasIntegralType( const Candidate & i ) {
 …
                 template<typename Iter>
                 inline bool nextMutex( Iter & it, const Iter & end ) {
                         while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
+                        while ( it != end && ! (*it)->is_mutex() ) { ++it; }
                         return it != end;
+                }
 …
                 ast::ptr< ast::Type > functionReturn = nullptr;
                 ast::CurrentObject currentObject;
+                // for work previously in GenInit
+                static InitTweak::ManagedTypes_new managedTypes;
                 bool inEnumDecl = false;
         public:
+                static size_t traceId;
                 Resolver_new() = default;
                 Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
                 void previsit( const ast::FunctionDecl * );
+                const ast::FunctionDecl * previsit( const ast::FunctionDecl * );
                 const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
+                void previsit( const ast::ObjectDecl * );
+                const ast::ObjectDecl * previsit( const ast::ObjectDecl * );
+                void previsit( const ast::AggregateDecl * );
+                void previsit( const ast::StructDecl * );
                 void previsit( const ast::EnumDecl * );
                 const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
 …
                 const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
                 const ast::CatchStmt *       previsit( const ast::CatchStmt * );
+                const ast::CatchStmt *       postvisit( const ast::CatchStmt * );
                 const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
+                const ast::WithStmt *        previsit( const ast::WithStmt * );
                 const ast::SingleInit *      previsit( const ast::SingleInit * );
                 const ast::ListInit *        previsit( const ast::ListInit * );
                 const ast::ConstructorInit * previsit( const ast::ConstructorInit * );
+                void resolveWithExprs(std::vector<ast::ptr<ast::Expr>> & exprs, std::list<ast::ptr<ast::Stmt>> & stmtsToAdd);
+                void beginScope() { managedTypes.beginScope(); }
+                void endScope() { managedTypes.endScope(); }
+                bool on_error(ast::ptr<ast::Decl> & decl);
         };
+        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
+                ast::Pass< Resolver_new > resolver;
+                accept_all( translationUnit, resolver );
+        // size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
+        InitTweak::ManagedTypes_new Resolver_new::managedTypes;
+        void resolve( ast::TranslationUnit& translationUnit ) {
+                ast::Pass< Resolver_new >::run( translationUnit );
+        }
 …
+        }
         ast::ptr< ast::Expr > resolveStmtExpr(
+        const ast::Expr * resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
         ) {
                 assert( stmtExpr );
                 ast::Pass< Resolver_new > resolver{ symtab };
+                ast::ptr< ast::Expr > ret = stmtExpr;
+                ret = ret->accept( resolver );
+                strict_dynamic_cast< ast::StmtExpr * >( ret.get_and_mutate() )->computeResult();
+                auto ret = mutate(stmtExpr->accept(resolver));
+                strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
                 return ret;
+        }
+        void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
+        namespace {
+                const ast::Attribute * handleAttribute(const CodeLocation & loc, const ast::Attribute * attr, const ast::SymbolTable & symtab) {
+                        std::string name = attr->normalizedName();
+                        if (name == "constructor" || name == "destructor") {
+                                if (attr->params.size() == 1) {
+                                        auto arg = attr->params.front();
+                                        auto resolved = ResolvExpr::findSingleExpression( arg, new ast::BasicType( ast::BasicType::LongLongSignedInt ), symtab );
+                                        auto result = eval(arg);
+                                        auto mutAttr = mutate(attr);
+                                        mutAttr->params.front() = resolved;
+                                        if (! result.second) {
+                                                SemanticWarning(loc, Warning::GccAttributes,
+                                                        toCString( name, " priorities must be integers from 0 to 65535 inclusive: ", arg ) );
+                                        }
+                                        else {
+                                                auto priority = result.first;
+                                                if (priority < 101) {
+                                                        SemanticWarning(loc, Warning::GccAttributes,
+                                                                toCString( name, " priorities from 0 to 100 are reserved for the implementation" ) );
+                                                } else if (priority < 201 && ! buildingLibrary()) {
+                                                        SemanticWarning(loc, Warning::GccAttributes,
+                                                                toCString( name, " priorities from 101 to 200 are reserved for the implementation" ) );
+                                                }
+                                        }
+                                        return mutAttr;
+                                } else if (attr->params.size() > 1) {
+                                        SemanticWarning(loc, Warning::GccAttributes, toCString( "too many arguments to ", name, " attribute" ) );
+                                } else {
+                                        SemanticWarning(loc, Warning::GccAttributes, toCString( "too few arguments to ", name, " attribute" ) );
+                                }
+                        }
+                        return attr;
+                }
+        }
+        const ast::FunctionDecl * Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
                 GuardValue( functionReturn );
+                assert (functionDecl->unique());
+                if (!functionDecl->has_body() && !functionDecl->withExprs.empty()) {
+                        SemanticError(functionDecl->location, functionDecl, "Function without body has with declarations");
+                }
+                if (!functionDecl->isTypeFixed) {
+                        auto mutDecl = mutate(functionDecl);
+                        auto mutType = mutDecl->type.get_and_mutate();
+                        for (auto & attr: mutDecl->attributes) {
+                                attr = handleAttribute(mutDecl->location, attr, symtab);
+                        }
+                        // handle assertions
+                        symtab.enterScope();
+                        mutType->forall.clear();
+                        mutType->assertions.clear();
+                        for (auto & typeParam : mutDecl->type_params) {
+                                symtab.addType(typeParam);
+                                mutType->forall.emplace_back(new ast::TypeInstType(typeParam->name, typeParam));
+                        }
+                        for (auto & asst : mutDecl->assertions) {
+                                asst = fixObjectType(asst.strict_as<ast::ObjectDecl>(), symtab);
+                                symtab.addId(asst);
+                                mutType->assertions.emplace_back(new ast::VariableExpr(functionDecl->location, asst));
+                        }
+                        // temporarily adds params to symbol table.
+                        // actual scoping rules for params and withexprs differ - see Pass::visit(FunctionDecl)
+                        std::vector<ast::ptr<ast::Type>> paramTypes;
+                        std::vector<ast::ptr<ast::Type>> returnTypes;
+                        for (auto & param : mutDecl->params) {
+                                param = fixObjectType(param.strict_as<ast::ObjectDecl>(), symtab);
+                                symtab.addId(param);
+                                paramTypes.emplace_back(param->get_type());
+                        }
+                        for (auto & ret : mutDecl->returns) {
+                                ret = fixObjectType(ret.strict_as<ast::ObjectDecl>(), symtab);
+                                returnTypes.emplace_back(ret->get_type());
+                        }
+                        // since function type in decl is just a view of param types, need to update that as well
+                        mutType->params = std::move(paramTypes);
+                        mutType->returns = std::move(returnTypes);
+                        auto renamedType = strict_dynamic_cast<const ast::FunctionType *>(renameTyVars(mutType, RenameMode::GEN_EXPR_ID));
+                        std::list<ast::ptr<ast::Stmt>> newStmts;
+                        resolveWithExprs (mutDecl->withExprs, newStmts);
+                        if (mutDecl->stmts) {
+                                auto mutStmt = mutDecl->stmts.get_and_mutate();
+                                mutStmt->kids.splice(mutStmt->kids.begin(), std::move(newStmts));
+                                mutDecl->stmts = mutStmt;
+                        }
+                        symtab.leaveScope();
+                        mutDecl->type = renamedType;
+                        mutDecl->mangleName = Mangle::mangle(mutDecl);
+                        mutDecl->isTypeFixed = true;
+                        functionDecl = mutDecl;
+                }
+                managedTypes.handleDWT(functionDecl);
                 functionReturn = extractResultType( functionDecl->type );
+                return functionDecl;
+        }
 …
                 // default value expressions have an environment which shouldn't be there and trips up
                 // later passes.
                 ast::ptr< ast::FunctionDecl > ret = functionDecl;
                 for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
+                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
                         if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
+                assert( functionDecl->unique() );
+                ast::FunctionType * mutType = mutate( functionDecl->type.get() );
+                for ( unsigned i = 0 ; i < mutType->params.size() ; ++i ) {
+                        if ( const ast::ObjectDecl * obj = mutType->params[i].as< ast::ObjectDecl >() ) {
                                 if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
                                         if ( init->value->env == nullptr ) continue;
                                         // clone initializer minus the initializer environment
+                                        ast::chain_mutate( ret )
+                                                ( &ast::FunctionDecl::type )
+                                                        ( &ast::FunctionType::params )[i]
+                                                                ( &ast::ObjectDecl::init )
+                                                                        ( &ast::SingleInit::value )->env = nullptr;
+                                        assert( functionDecl != ret.get() || functionDecl->unique() );
+                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
+                                        auto mutParam = mutate( mutType->params[i].strict_as< ast::ObjectDecl >() );
+                                        auto mutInit = mutate( mutParam->init.strict_as< ast::SingleInit >() );
+                                        auto mutValue = mutate( mutInit->value.get() );
+                                        mutValue->env = nullptr;
+                                        mutInit->value = mutValue;
+                                        mutParam->init = mutInit;
+                                        mutType->params[i] = mutParam;
+                                        assert( ! mutType->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env);
+                                }
+                        }
+                }
+                return ret.get();
+        }
+        void Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
+                mutate_field(functionDecl, &ast::FunctionDecl::type, mutType);
+                return functionDecl;
+        }
+        const ast::ObjectDecl * Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
                 // To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()],
                 // class-variable `initContext` is changed multiple times because the LHS is analyzed
 …
                 // selecting the RHS.
                 GuardValue( currentObject );
+                currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
                 if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
                         // enumerator initializers should not use the enum type to initialize, since the
                         // enum type is still incomplete at this point. Use `int` instead.
+                        objectDecl = fixObjectType(objectDecl, symtab);
                         currentObject = ast::CurrentObject{
                                 objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
+                }
+                else {
+                        if (!objectDecl->isTypeFixed) {
+                                auto newDecl = fixObjectType(objectDecl, symtab);
+                                auto mutDecl = mutate(newDecl);
+                                // generate CtorInit wrapper when necessary.
+                                // in certain cases, fixObjectType is called before reaching
+                                // this object in visitor pass, thus disabling CtorInit codegen.
+                                // this happens on aggregate members and function parameters.
+                                if ( InitTweak::tryConstruct( mutDecl ) && ( managedTypes.isManaged( mutDecl ) || ((! isInFunction() || mutDecl->storage.is_static ) && ! InitTweak::isConstExpr( mutDecl->init ) ) ) ) {
+                                        // constructed objects cannot be designated
+                                        if ( InitTweak::isDesignated( mutDecl->init ) ) SemanticError( mutDecl, "Cannot include designations in the initializer for a managed Object. If this is really what you want, then initialize with @=.\n" );
+                                        // constructed objects should not have initializers nested too deeply
+                                        if ( ! InitTweak::checkInitDepth( mutDecl ) ) SemanticError( mutDecl, "Managed object's initializer is too deep " );
+                                        mutDecl->init = InitTweak::genCtorInit( mutDecl->location, mutDecl );
+                                }
+                                objectDecl = mutDecl;
+                        }
+                        currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
+                }
+                return objectDecl;
+        }
+        void Resolver_new::previsit( const ast::AggregateDecl * _aggDecl ) {
+                auto aggDecl = mutate(_aggDecl);
+                assertf(aggDecl == _aggDecl, "type declarations must be unique");
+                for (auto & member: aggDecl->members) {
+                        // nested type decls are hoisted already. no need to do anything
+                        if (auto obj = member.as<ast::ObjectDecl>()) {
+                                member = fixObjectType(obj, symtab);
+                        }
+                }
+        }
+        void Resolver_new::previsit( const ast::StructDecl * structDecl ) {
+                previsit(static_cast<const ast::AggregateDecl *>(structDecl));
+                managedTypes.handleStruct(structDecl);
+        }
 …
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
+                inEnumDecl = false;
+        }
+                inEnumDecl = true;
+                // don't need to fix types for enum fields
+        }
         const ast::StaticAssertDecl * Resolver_new::previsit(
 …
         const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
                 if ( type->dimension ) {
+                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
+                        ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
+                        ast::ptr< ast::Type > sizeType = ast::sizeType;
                         ast::mutate_field(
                                 type, &PtrType::dimension,
 …
                 if ( throwStmt->expr ) {
                         const ast::StructDecl * exceptionDecl =
                                 symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                                symtab.lookupStruct( "__cfaehm_base_exception_t" );
                         assert( exceptionDecl );
                         ast::ptr< ast::Type > exceptType =
 …
         const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
+                // TODO: This will need a fix for the decl/cond scoping problem.
+                // Until we are very sure this invarent (ifs that move between passes have thenPart)
+                // holds, check it. This allows a check for when to decode the mangling.
+                if ( auto ifStmt = catchStmt->body.as<ast::IfStmt>() ) {
+                        assert( ifStmt->thenPart );
+                }
+                // Encode the catchStmt so the condition can see the declaration.
                 if ( catchStmt->cond ) {
+                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
+                        catchStmt = ast::mutate_field(
+                                catchStmt, &ast::CatchStmt::cond,
+                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
+                        ast::CatchStmt * stmt = mutate( catchStmt );
+                        stmt->body = new ast::IfStmt( stmt->location, stmt->cond, nullptr, stmt->body );
+                        stmt->cond = nullptr;
+                        return stmt;
+                }
+                return catchStmt;
+        }
+        const ast::CatchStmt * Resolver_new::postvisit( const ast::CatchStmt * catchStmt ) {
+                // Decode the catchStmt so everything is stored properly.
+                const ast::IfStmt * ifStmt = catchStmt->body.as<ast::IfStmt>();
+                if ( nullptr != ifStmt && nullptr == ifStmt->thenPart ) {
+                        assert( ifStmt->cond );
+                        assert( ifStmt->elsePart );
+                        ast::CatchStmt * stmt = ast::mutate( catchStmt );
+                        stmt->cond = ifStmt->cond;
+                        stmt->body = ifStmt->elsePart;
+                        // ifStmt should be implicately deleted here.
+                        return stmt;
+                }
                 return catchStmt;
 …
                                                                 // Check if the argument matches the parameter type in the current
                                                                 // scope
                                                                 ast::ptr< ast::Type > paramType = (*param)->get_type();
+                                                                // ast::ptr< ast::Type > paramType = (*param)->get_type();
                                                                 if (
                                                                         ! unify(
                                                                                 arg->expr->result, paramType, resultEnv, need, have, open,
+                                                                                arg->expr->result, *param, resultEnv, need, have, open,
                                                                                 symtab )
                                                                 ) {
 …
                                                                         ss << "candidate function not viable: no known conversion "
                                                                                 "from '";
                                                                         ast::print( ss, (*param)->get_type() );
+                                                                        ast::print( ss, *param );
                                                                         ss << "' to '";
                                                                         ast::print( ss, arg->expr->result );
 …
+        }
+        const ast::WithStmt * Resolver_new::previsit( const ast::WithStmt * withStmt ) {
+                auto mutStmt = mutate(withStmt);
+                resolveWithExprs(mutStmt->exprs, stmtsToAddBefore);
+                return mutStmt;
+        }
+        void Resolver_new::resolveWithExprs(std::vector<ast::ptr<ast::Expr>> & exprs, std::list<ast::ptr<ast::Stmt>> & stmtsToAdd) {
+                for (auto & expr : exprs) {
+                        // only struct- and union-typed expressions are viable candidates
+                        expr = findKindExpression( expr, symtab, structOrUnion, "with expression" );
+                        // if with expression might be impure, create a temporary so that it is evaluated once
+                        if ( Tuples::maybeImpure( expr ) ) {
+                                static UniqueName tmpNamer( "_with_tmp_" );
+                                const CodeLocation loc = expr->location;
+                                auto tmp = new ast::ObjectDecl(loc, tmpNamer.newName(), expr->result, new ast::SingleInit(loc, expr ) );
+                                expr = new ast::VariableExpr( loc, tmp );
+                                stmtsToAdd.push_back( new ast::DeclStmt(loc, tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( loc, tmp );
+                                }
+                                // since tmp is freshly created, this should modify tmp in-place
+                                tmp->accept( *visitor );
+                        }
+                }
+        }
 …
+        }
+        // suppress error on autogen functions and mark invalid autogen as deleted.
+        bool Resolver_new::on_error(ast::ptr<ast::Decl> & decl) {
+                if (auto functionDecl = decl.as<ast::FunctionDecl>()) {
+                        // xxx - can intrinsic gen ever fail?
+                        if (functionDecl->linkage == ast::Linkage::AutoGen) {
+                                auto mutDecl = mutate(functionDecl);
+                                mutDecl->isDeleted = true;
+                                mutDecl->stmts = nullptr;
+                                decl = mutDecl;
+                                return false;
+                        }
+                }
+                return true;
+        }
 } // namespace ResolvExpr

src/ResolvExpr/Resolver.h

-              r3c64c668
+              r58fe85a
         class StmtExpr;
         class SymbolTable;
+        struct TranslationUnit;
         class Type;
         class TypeEnvironment;
 …
         /// Checks types and binds syntactic constructs to typed representations
         void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit );
+        void resolve( ast::TranslationUnit& translationUnit );
         /// Searches expr and returns the first DeletedExpr found, otherwise nullptr
         const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr );
 …
         ast::ptr< ast::Expr > resolveInVoidContext(
                 const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env );
         /// Resolve `untyped` to the single expression whose candidate is the best match for the
+        /// Resolve `untyped` to the single expression whose candidate is the best match for the
         /// given type.
         ast::ptr< ast::Expr > findSingleExpression(
                 const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab );
+        ast::ptr< ast::Expr > findVoidExpression(
+                const ast::Expr * untyped, const ast::SymbolTable & symtab);
         /// Resolves a constructor init expression
         ast::ptr< ast::Init > resolveCtorInit(
+        ast::ptr< ast::Init > resolveCtorInit(
                 const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab );
         /// Resolves a statement expression
         ast::ptr< ast::Expr > resolveStmtExpr(
+        /// Resolves a statement expression
+        const ast::Expr * resolveStmtExpr(
                 const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab );
 } // namespace ResolvExpr

src/ResolvExpr/SatisfyAssertions.cpp

-              r3c64c668
+              r58fe85a
 // Author           : Aaron B. Moss
 // Created On       : Mon Jun 10 17:45:00 2019
 // Last Modified By : Aaron B. Moss
 // Last Modified On : Mon Jun 10 17:45:00 2019
 // Update Count     : 1
+// Last Modified By : Andrew Beach
+// Last Modified On : Tue Oct  1 13:56:00 2019
+// Update Count     : 2
 //
 …
                 ast::UniqueId resnSlot;          ///< Slot for any recursive assertion IDs
                 AssnCandidate(
                         const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e,
+                AssnCandidate(
+                        const ast::SymbolTable::IdData c, const ast::Type * at, ast::TypeEnvironment && e,
                         ast::AssertionSet && h, ast::AssertionSet && n, ast::OpenVarSet && o, ast::UniqueId rs )
                 : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
+                : cdata( c ), adjType( at ), env( std::move( e ) ), have( std::move( h ) ),
                   need( std::move( n ) ), open( std::move( o ) ), resnSlot( rs ) {}
         };
 …
         /// Reference to a single deferred item
         struct DeferRef {
                 const ast::DeclWithType * decl;
+                const ast::VariableExpr * expr;
                 const ast::AssertionSetValue & info;
                 const AssnCandidate & match;
         };
         /// Wrapper for the deferred items from a single assertion satisfaction.
+        /// Wrapper for the deferred items from a single assertion satisfaction.
         /// Acts like an indexed list of DeferRef
         struct DeferItem {
                 const ast::DeclWithType * decl;
+                const ast::VariableExpr * expr;
                 const ast::AssertionSetValue & info;
                 AssnCandidateList matches;
                 DeferItem(
                         const ast::DeclWithType * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
                 : decl( d ), info( i ), matches( std::move( ms ) ) {}
+                DeferItem(
+                        const ast::VariableExpr * d, const ast::AssertionSetValue & i, AssnCandidateList && ms )
+                : expr( d ), info( i ), matches( std::move( ms ) ) {}
                 bool empty() const { return matches.empty(); }
 …
                 AssnCandidateList::size_type size() const { return matches.size(); }
                 DeferRef operator[] ( unsigned i ) const { return { decl, info, matches[i] }; }
+                DeferRef operator[] ( unsigned i ) const { return { expr, info, matches[i] }; }
         };
 …
                 /// Initial satisfaction state for a candidate
                 SatState( CandidateRef & c, const ast::SymbolTable & syms )
                 : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero },
+                : cand( c ), need(), newNeed(), deferred(), inferred(), costs{ Cost::zero },
                   symtab( syms ) { need.swap( c->need ); }
                 /// Update satisfaction state for next step after previous state
                 SatState( SatState && o, IterateFlag )
                 : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(),
                   deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ),
+                : cand( std::move( o.cand ) ), need( o.newNeed.begin(), o.newNeed.end() ), newNeed(),
+                  deferred(), inferred( std::move( o.inferred ) ), costs( std::move( o.costs ) ),
                   symtab( o.symtab ) { costs.emplace_back( Cost::zero ); }
                 /// Field-wise next step constructor
                 SatState(
                         CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs,
+                        CandidateRef && c, ast::AssertionSet && nn, InferCache && i, CostVec && cs,
                         ast::SymbolTable && syms )
                 : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(),
+                : cand( std::move( c ) ), need( nn.begin(), nn.end() ), newNeed(), deferred(),
                   inferred( std::move( i ) ), costs( std::move( cs ) ), symtab( std::move( syms ) )
                   { costs.emplace_back( Cost::zero ); }
 …
         void addToSymbolTable( const ast::AssertionSet & have, ast::SymbolTable & symtab ) {
                 for ( auto & i : have ) {
                         if ( i.second.isUsed ) { symtab.addId( i.first ); }
+                        if ( i.second.isUsed ) { symtab.addId( i.first->var ); }
+                }
+        }
         /// Binds a single assertion, updating satisfaction state
         void bindAssertion(
                 const ast::DeclWithType * decl, const ast::AssertionSetValue & info, CandidateRef & cand,
+        void bindAssertion(
+                const ast::VariableExpr * expr, const ast::AssertionSetValue & info, CandidateRef & cand,
                 AssnCandidate & match, InferCache & inferred
         ) {
                 const ast::DeclWithType * candidate = match.cdata.id;
                 assertf( candidate->uniqueId,
+                assertf( candidate->uniqueId,
                         "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
                 ast::Expr * varExpr = match.cdata.combine( cand->expr->location, cand->cvtCost );
                 varExpr->result = match.adjType;
 …
                 // place newly-inferred assertion in proper location in cache
                 inferred[ info.resnSlot ][ decl->uniqueId ] = ast::ParamEntry{
                         candidate->uniqueId, candidate, match.adjType, decl->get_type(), varExpr };
+                inferred[ info.resnSlot ][ expr->var->uniqueId ] = ast::ParamEntry{
+                        candidate->uniqueId, candidate, match.adjType, expr->result, varExpr };
+        }
 …
                 // find candidates that unify with the desired type
                 AssnCandidateList matches;
+                for ( const ast::SymbolTable::IdData & cdata : sat.symtab.lookupId( assn.first->name ) ) {
+                std::vector<ast::SymbolTable::IdData> candidates;
+                auto kind = ast::SymbolTable::getSpecialFunctionKind(assn.first->var->name);
+                if (kind != ast::SymbolTable::SpecialFunctionKind::NUMBER_OF_KINDS) {
+                        // prefilter special decls by argument type, if already known
+                        ast::ptr<ast::Type> thisArgType = assn.first->result.strict_as<ast::PointerType>()->base
+                                .strict_as<ast::FunctionType>()->params[0]
+                                .strict_as<ast::ReferenceType>()->base;
+                        sat.cand->env.apply(thisArgType);
+                        std::string otypeKey = "";
+                        if (thisArgType.as<ast::PointerType>()) otypeKey = Mangle::Encoding::pointer;
+                        else if (!isUnboundType(thisArgType)) otypeKey = Mangle::mangle(thisArgType, Mangle::Type | Mangle::NoGenericParams);
+                        candidates = sat.symtab.specialLookupId(kind, otypeKey);
+                }
+                else {
+                        candidates = sat.symtab.lookupId(assn.first->var->name);
+                }
+                for ( const ast::SymbolTable::IdData & cdata : candidates ) {
                         const ast::DeclWithType * candidate = cdata.id;
+                        // ignore deleted candidates.
+                        // NOTE: this behavior is different from main resolver.
+                        // further investigations might be needed to determine
+                        // if we should implement the same rule here
+                        // (i.e. error if unique best match is deleted)
+                        if (candidate->isDeleted && candidate->linkage == ast::Linkage::AutoGen) continue;
                         // build independent unification context for candidate
 …
                         ast::TypeEnvironment newEnv{ sat.cand->env };
                         ast::OpenVarSet newOpen{ sat.cand->open };
                         ast::ptr< ast::Type > toType = assn.first->get_type();
                         ast::ptr< ast::Type > adjType =
                                 renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ) );
+                        ast::ptr< ast::Type > toType = assn.first->result;
+                        ast::ptr< ast::Type > adjType =
+                                renameTyVars( adjustExprType( candidate->get_type(), newEnv, sat.symtab ), GEN_USAGE, false );
                         // only keep candidates which unify
 …
+                                }
                                 matches.emplace_back(
                                         cdata, adjType, std::move( newEnv ), std::move( newNeed ), std::move( have ),
+                                matches.emplace_back(
+                                        cdata, adjType, std::move( newEnv ), std::move( have ), std::move( newNeed ),
                                         std::move( newOpen ), crntResnSlot );
+                        }
 …
                 InferMatcher( InferCache & inferred ) : inferred( inferred ) {}
                 const ast::Expr * postmutate( const ast::Expr * expr ) {
+                const ast::Expr * postvisit( const ast::Expr * expr ) {
                         // Skip if no slots to find
+                        if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr;
+                        if ( !expr->inferred.hasSlots() ) return expr;
+                        // if ( expr->inferred.mode != ast::Expr::InferUnion::Slots ) return expr;
+                        std::vector<UniqueId> missingSlots;
                         // find inferred parameters for resolution slots
                         ast::InferredParams newInferred;
+                        ast::InferredParams * newInferred = new ast::InferredParams();
                         for ( UniqueId slot : expr->inferred.resnSlots() ) {
                                 // fail if no matching assertions found
                                 auto it = inferred.find( slot );
                                 if ( it == inferred.end() ) {
+                                        assert(!"missing assertion");
+                                        // std::cerr << "missing assertion " << slot << std::endl;
+                                        missingSlots.push_back(slot);
+                                        continue;
+                                }
 …
                                 for ( auto & entry : it->second ) {
                                         // recurse on inferParams of resolved expressions
                                         entry.second.expr = postmutate( entry.second.expr );
                                         auto res = newInferred.emplace( entry );
+                                        entry.second.expr = postvisit( entry.second.expr );
+                                        auto res = newInferred->emplace( entry );
                                         assert( res.second && "all assertions newly placed" );
+                                }
 …
                         ast::Expr * ret = mutate( expr );
+                        ret->inferred.set_inferParams( std::move( newInferred ) );
+                        ret->inferred.set_inferParams( newInferred );
+                        if (!missingSlots.empty()) ret->inferred.resnSlots() = missingSlots;
                         return ret;
+                }
         };
         /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning
+        /// Replace ResnSlots with InferParams and add alternative to output list, if it meets pruning
         /// threshold.
         void finalizeAssertions(
                 CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs,
                 CandidateList & out
+        void finalizeAssertions(
+                CandidateRef & cand, InferCache & inferred, PruneMap & thresholds, CostVec && costs,
+                CandidateList & out
         ) {
                 // prune if cheaper alternative for same key has already been generated
 …
+        }
         /// Combo iterator that combines candidates into an output list, merging their environments.
         /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h`
+        /// Combo iterator that combines candidates into an output list, merging their environments.
+        /// Rejects an appended candidate if environments cannot be merged. See `Common/FilterCombos.h`
         /// for description of "combo iterator".
         class CandidateEnvMerger {
 …
                         Cost cost;
                         OutType(
                                 const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
+                        OutType(
+                                const ast::TypeEnvironment & e, const ast::OpenVarSet & o,
                                 const std::vector< DeferRef > & as, const ast::SymbolTable & symtab )
                         : env( e ), open( o ), assns( as ), cost( Cost::zero ) {
 …
                                 for ( const DeferRef & assn : assns ) {
                                         // compute conversion cost from satisfying decl to assertion
                                         cost += computeConversionCost(
                                                 assn.match.adjType, assn.decl->get_type(), symtab, env );
+                                        cost += computeConversionCost(
+                                                assn.match.adjType, assn.expr->result, false, symtab, env );
                                         // mark vars+specialization on function-type assertions
                                         const ast::FunctionType * func =
+                                        const ast::FunctionType * func =
                                                 GenPoly::getFunctionType( assn.match.cdata.id->get_type() );
                                         if ( ! func ) continue;
                                         for ( const ast::DeclWithType * param : func->params ) {
                                                 cost.decSpec( specCost( param->get_type() ) );
+                                        for ( const auto & param : func->params ) {
+                                                cost.decSpec( specCost( param ) );
+                                        }
                                         cost.incVar( func->forall.size() );
+                                        for ( const ast::TypeDecl * td : func->forall ) {
+                                                cost.decSpec( td->assertions.size() );
+                                        }
+                                        cost.decSpec( func->assertions.size() );
+                                }
+                        }
 …
                 };
                 CandidateEnvMerger(
                         const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
+                CandidateEnvMerger(
+                        const ast::TypeEnvironment & env, const ast::OpenVarSet & open,
                         const ast::SymbolTable & syms )
                 : crnt(), envs{ env }, opens{ open }, symtab( syms ) {}
 …
         /// Limit to depth of recursion of assertion satisfaction
         static const int recursionLimit = 4;
+        static const int recursionLimit = 8;
         /// Maximum number of simultaneously-deferred assertions to attempt concurrent satisfaction of
         static const int deferLimit = 10;
 } // anonymous namespace
 void satisfyAssertions(
         CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
         std::vector<std::string> & errors
 ) {
 …
                         if ( it != thresholds.end() && it->second < sat.costs ) goto nextSat;
+                        // make initial pass at matching assertions
+                        for ( auto & assn : sat.need ) {
+                                // fail early if any assertion is not satisfiable
+                                if ( ! satisfyAssertion( assn, sat ) ) {
+                        // should a limit be imposed? worst case here is O(n^2) but very unlikely to happen.
+                        for (unsigned resetCount = 0; ; ++resetCount) {
+                                ast::AssertionList next;
+                                resetTyVarRenaming();
+                                // make initial pass at matching assertions
+                                for ( auto & assn : sat.need ) {
+                                        // fail early if any assertion is not satisfiable
+                                        if ( ! satisfyAssertion( assn, sat ) ) {
+                                                next.emplace_back(assn);
+                                                // goto nextSat;
+                                        }
+                                }
+                                // success
+                                if (next.empty()) break;
+                                // fail if nothing resolves
+                                else if (next.size() == sat.need.size()) {
                                         Indenter tabs{ 3 };
                                         std::ostringstream ss;
 …
                                         print( ss, *sat.cand, ++tabs );
                                         ss << (tabs-1) << "Could not satisfy assertion:\n";
                                         ast::print( ss, assn.first, tabs );
+                                        ast::print( ss, next[0].first, tabs );
                                         errors.emplace_back( ss.str() );
                                         goto nextSat;
+                                }
+                                sat.need = std::move(next);
+                        }
 …
                                 // either add successful match or push back next state
                                 if ( sat.newNeed.empty() ) {
                                         finalizeAssertions(
+                                        finalizeAssertions(
                                                 sat.cand, sat.inferred, thresholds, std::move( sat.costs ), out );
                                 } else {
 …
                                 ss << (tabs-1) << "Too many non-unique satisfying assignments for assertions:\n";
                                 for ( const auto & d : sat.deferred ) {
                                         ast::print( ss, d.decl, tabs );
+                                        ast::print( ss, d.expr, tabs );
+                                }
 …
                                 std::vector< CandidateEnvMerger::OutType > compatible = filterCombos(
                                         sat.deferred, CandidateEnvMerger{ sat.cand->env, sat.cand->open, sat.symtab } );
                                 // fail early if no mutually-compatible assertion satisfaction
                                 if ( compatible.empty() ) {
 …
                                         ss << (tabs-1) << "No mutually-compatible satisfaction for assertions:\n";
                                         for ( const auto& d : sat.deferred ) {
                                                 ast::print( ss, d.decl, tabs );
+                                                ast::print( ss, d.expr, tabs );
+                                        }
 …
                                         // set up next satisfaction state
                                         CandidateRef nextCand = std::make_shared<Candidate>(
                                                 sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
+                                                sat.cand->expr, std::move( compat.env ), std::move( compat.open ),
                                                 ast::AssertionSet{} /* need moved into satisfaction state */,
                                                 sat.cand->cost, sat.cand->cvtCost );
 …
                                         ast::AssertionSet nextNewNeed{ sat.newNeed };
                                         InferCache nextInferred{ sat.inferred };
                                         CostVec nextCosts{ sat.costs };
                                         nextCosts.back() += compat.cost;
                                         ast::SymbolTable nextSymtab{ sat.symtab };
 …
                                                 nextNewNeed.insert( match.need.begin(), match.need.end() );
                                                 bindAssertion( r.decl, r.info, nextCand, match, nextInferred );
+                                                bindAssertion( r.expr, r.info, nextCand, match, nextInferred );
+                                        }
                                         // either add successful match or push back next state
                                         if ( nextNewNeed.empty() ) {
                                                 finalizeAssertions(
+                                                finalizeAssertions(
                                                         nextCand, nextInferred, thresholds, std::move( nextCosts ), out );
                                         } else {
                                                 nextSats.emplace_back(
                                                         std::move( nextCand ), std::move( nextNewNeed ),
                                                         std::move( nextInferred ), std::move( nextCosts ),
+                                                nextSats.emplace_back(
+                                                        std::move( nextCand ), std::move( nextNewNeed ),
+                                                        std::move( nextInferred ), std::move( nextCosts ),
                                                         std::move( nextSymtab ) );
+                                        }
 …
                 nextSats.clear();
+        }
         // exceeded recursion limit if reaches here
         if ( out.empty() ) {

src/ResolvExpr/SatisfyAssertions.hpp

-              r3c64c668
+              r58fe85a
 namespace ResolvExpr {
+/// Recursively satisfies all assertions provided in a candidate; returns true if succeeds
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
+/// Recursively satisfies all assertions provided in a candidate
+/// returns true if it has been run (candidate has any assertions)
+void satisfyAssertions(
+        CandidateRef & cand, const ast::SymbolTable & symtab, CandidateList & out,
         std::vector<std::string> & errors );

src/ResolvExpr/SpecCost.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Tue Oct 02 15:50:00 2018
 // Last Modified By : Andrew Beach
+// Last Modified On : Wed Jun 19 10:43:00 2019
+// Update Count     : 2
+//
+// Last Modified On : Wed Jul  3 11:07:00 2019
+// Update Count     : 3
+//
+#include <cassert>
 #include <limits>
 #include <list>
 …
                         typename std::add_pointer<ast::Type const *(typename T::value_type const &)>::type;
+                #warning Should use a standard maybe_accept
+                void maybe_accept( ast::Type const * type ) {
+                        if ( type ) {
+                                auto node = type->accept( *visitor );
+                                assert( node == nullptr || node == type );
+                        }
+                }
                 // Update the minimum to the new lowest non-none value.
                 template<typename T>
 …
                         for ( const auto & node : list ) {
                                 count = -1;
                                 mapper( node )->accept( *visitor );
+                                maybe_accept( mapper( node ) );
                                 if ( count != -1 && count < minimum ) minimum = count;
+                        }
 …
                 void previsit( const ast::FunctionType * fty ) {
                         int minCount = std::numeric_limits<int>::max();
                         updateMinimumPresent( minCount, fty->params, decl_type );
                         updateMinimumPresent( minCount, fty->returns, decl_type );
+                        updateMinimumPresent( minCount, fty->params, type_deref );
+                        updateMinimumPresent( minCount, fty->returns, type_deref );
                         // Add another level to minCount if set.
                         count = toNoneOrInc( minCount );
 …
+        }
         ast::Pass<SpecCounter> counter;
         type->accept( *counter.pass.visitor );
         return counter.pass.get_count();
+        type->accept( counter );
+        return counter.core.get_count();
+}

src/ResolvExpr/TypeEnvironment.cc

-              r3c64c668
+              r58fe85a
 #include <utility>                     // for pair, move
+#include "CompilationState.h"          // for deterministic_output
 #include "Common/utility.h"            // for maybeClone
 #include "SynTree/Type.h"              // for Type, FunctionType, Type::Fora...
 …
         void EqvClass::print( std::ostream &os, Indenter indent ) const {
+                os << "( ";
+                std::copy( vars.begin(), vars.end(), std::ostream_iterator< std::string >( os, " " ) );
+                os << "(";
+                bool first = true;
+                for(const auto & var : vars) {
+                        if(first) first = false;
+                        else os << " ";
+                        if( deterministic_output && isUnboundType(var) ) os << "[unbound]";
+                        else os << var;
+                }
                 os << ")";
                 if ( type ) {
 …
                 // check safely bindable
                 if ( r.type && occursIn( r.type, s.vars.begin(), s.vars.end(), *this ) ) return false;
                 // merge classes in
                 r.vars.insert( s.vars.begin(), s.vars.end() );

src/ResolvExpr/TypeEnvironment.h

r3c64c668	r58fe85a
149	149	iterator end() const { return env.end(); }
150	150
	151	auto size() const { return env.size(); }
	152
151	153	private:
152	154	ClassList env;

src/ResolvExpr/Unify.cc

-              r3c64c668
+              r58fe85a
 #include <vector>
+#include "AST/Copy.hpp"
 #include "AST/Decl.hpp"
 #include "AST/Node.hpp"
 #include "AST/Pass.hpp"
+#include "AST/Print.hpp"
 #include "AST/Type.hpp"
 #include "AST/TypeEnvironment.hpp"
 …
                 findOpenVars( newSecond, open, closed, need, have, FirstOpen );
+                return unifyExact(
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                return unifyExact(newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+        }
 …
                 newFirst->get_qualifiers() = Type::Qualifiers();
                 newSecond->get_qualifiers() = Type::Qualifiers();
+///   std::cerr << "first is ";
+///   first->print( std::cerr );
+///   std::cerr << std::endl << "second is ";
+///   second->print( std::cerr );
+///   std::cerr << std::endl << "newFirst is ";
+///   newFirst->print( std::cerr );
+///   std::cerr << std::endl << "newSecond is ";
+///   newSecond->print( std::cerr );
+///   std::cerr << std::endl;
                 bool result = unifyExact( newFirst, newSecond, newEnv, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
                 delete newFirst;
 …
                 ast::AssertionSet need, have;
+                ast::ptr<ast::Type> newFirst{ first }, newSecond{ second };
+                env.apply( newFirst );
+                env.apply( newSecond );
+                reset_qualifiers( newFirst );
+                reset_qualifiers( newSecond );
+                ast::Type * newFirst  = shallowCopy( first  );
+                ast::Type * newSecond = shallowCopy( second );
+                newFirst ->qualifiers = {};
+                newSecond->qualifiers = {};
+                ast::ptr< ast::Type > t1_(newFirst );
+                ast::ptr< ast::Type > t2_(newSecond);
+                ast::ptr< ast::Type > subFirst = env.apply(newFirst).node;
+                ast::ptr< ast::Type > subSecond = env.apply(newSecond).node;
                 return unifyExact(
+                        newFirst, newSecond, newEnv, need, have, open, noWiden(), symtab );
+                        subFirst,
+                        subSecond,
+                        newEnv, need, have, open, noWiden(), symtab );
+        }
 …
         void markAssertionSet( AssertionSet &assertions, DeclarationWithType *assert ) {
-///   std::cerr << "assertion set is" << std::endl;
-///   printAssertionSet( assertions, std::cerr, 8 );
-///   std::cerr << "looking for ";
-///   assert->print( std::cerr );
-///   std::cerr << std::endl;
                 AssertionSet::iterator i = assertions.find( assert );
                 if ( i != assertions.end() ) {
-///     std::cerr << "found it!" << std::endl;
                         i->second.isUsed = true;
                 } // if
 …
         template< typename Iterator1, typename Iterator2 >
         bool unifyDeclList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
+        bool unifyTypeList( Iterator1 list1Begin, Iterator1 list1End, Iterator2 list2Begin, Iterator2 list2End, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, const SymTab::Indexer &indexer ) {
                 auto get_type = [](DeclarationWithType * dwt){ return dwt->get_type(); };
                 for ( ; list1Begin != list1End && list2Begin != list2End; ++list1Begin, ++list2Begin ) {
 …
                                         || flatOther->isTtype()
                         ) {
                                 if ( unifyDeclList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
                                         if ( unifyDeclList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                if ( unifyTypeList( flatFunc->parameters.begin(), flatFunc->parameters.end(), flatOther->parameters.begin(), flatOther->parameters.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
+                                        if ( unifyTypeList( flatFunc->returnVals.begin(), flatFunc->returnVals.end(), flatOther->returnVals.begin(), flatOther->returnVals.end(), env, needAssertions, haveAssertions, openVars, indexer ) ) {
                                                 // the original types must be used in mark assertions, since pointer comparisons are used
 …
                 const ast::SymbolTable & symtab;
         public:
+                static size_t traceId;
                 bool result;
 …
                 /// If this isn't done when satifying ttype assertions, then argument lists can have
                 /// different size and structure when they should be compatible.
                 struct TtypeExpander_new : public ast::WithShortCircuiting {
+                struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor {
                         ast::TypeEnvironment & tenv;
 …
                         const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
                                 if ( const ast::EqvClass * clz = tenv.lookup( typeInst->name ) ) {
+                                if ( const ast::EqvClass * clz = tenv.lookup( *typeInst ) ) {
                                         // expand ttype parameter into its actual type
                                         if ( clz->data.kind == ast::TypeDecl::Ttype && clz->bound ) {
 …
                 /// returns flattened version of `src`
                 static std::vector< ast::ptr< ast::DeclWithType > > flattenList(
                         const std::vector< ast::ptr< ast::DeclWithType > > & src, ast::TypeEnvironment & env
+                static std::vector< ast::ptr< ast::Type > > flattenList(
+                        const std::vector< ast::ptr< ast::Type > > & src, ast::TypeEnvironment & env
                 ) {
                         std::vector< ast::ptr< ast::DeclWithType > > dst;
+                        std::vector< ast::ptr< ast::Type > > dst;
                         dst.reserve( src.size() );
                         for ( const ast::DeclWithType * d : src ) {
+                        for ( const auto & d : src ) {
                                 ast::Pass<TtypeExpander_new> expander{ env };
+                                d = d->accept( expander );
+                                auto types = flatten( d->get_type() );
+                                // TtypeExpander pass is impure (may mutate nodes in place)
+                                // need to make nodes shared to prevent accidental mutation
+                                ast::ptr<ast::Type> dc = d->accept(expander);
+                                auto types = flatten( dc );
                                 for ( ast::ptr< ast::Type > & t : types ) {
                                         // outermost const, volatile, _Atomic qualifiers in parameters should not play
 …
                                         // requirements than a non-mutex function
                                         remove_qualifiers( t, ast::CV::Const | ast::CV::Volatile | ast::CV::Atomic );
                                         dst.emplace_back( new ast::ObjectDecl{ d->location, "", t } );
+                                        dst.emplace_back( t );
+                                }
+                        }
 …
                 /// Creates a tuple type based on a list of DeclWithType
                 template< typename Iter >
                 static ast::ptr< ast::Type > tupleFromDecls( Iter crnt, Iter end ) {
+                static const ast::Type * tupleFromTypes( Iter crnt, Iter end ) {
                         std::vector< ast::ptr< ast::Type > > types;
                         while ( crnt != end ) {
                                 // it is guaranteed that a ttype variable will be bound to a flat tuple, so ensure
                                 // that this results in a flat tuple
                                 flatten( (*crnt)->get_type(), types );
+                                flatten( *crnt, types );
                                 ++crnt;
+                        }
                         return { new ast::TupleType{ std::move(types) } };
+                        return new ast::TupleType{ std::move(types) };
+                }
                 template< typename Iter >
                 static bool unifyDeclList(
+                static bool unifyTypeList(
                         Iter crnt1, Iter end1, Iter crnt2, Iter end2, ast::TypeEnvironment & env,
                         ast::AssertionSet & need, ast::AssertionSet & have, const ast::OpenVarSet & open,
 …
                 ) {
                         while ( crnt1 != end1 && crnt2 != end2 ) {
                                 const ast::Type * t1 = (*crnt1)->get_type();
                                 const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t1 = *crnt1;
+                                const ast::Type * t2 = *crnt2;
                                 bool isTuple1 = Tuples::isTtype( t1 );
                                 bool isTuple2 = Tuples::isTtype( t2 );
 …
                                         // combine remainder of list2, then unify
                                         return unifyExact(
                                                 t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                                t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                                 noWiden(), symtab );
                                 } else if ( ! isTuple1 && isTuple2 ) {
                                         // combine remainder of list1, then unify
                                         return unifyExact(
                                                 tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                                tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                                 noWiden(), symtab );
+                                }
 …
                         if ( crnt1 != end1 ) {
                                 // try unifying empty tuple with ttype
                                 const ast::Type * t1 = (*crnt1)->get_type();
+                                const ast::Type * t1 = *crnt1;
                                 if ( ! Tuples::isTtype( t1 ) ) return false;
                                 return unifyExact(
                                         t1, tupleFromDecls( crnt2, end2 ), env, need, have, open,
+                                        t1, tupleFromTypes( crnt2, end2 ), env, need, have, open,
                                         noWiden(), symtab );
                         } else if ( crnt2 != end2 ) {
                                 // try unifying empty tuple with ttype
                                 const ast::Type * t2 = (*crnt2)->get_type();
+                                const ast::Type * t2 = *crnt2;
                                 if ( ! Tuples::isTtype( t2 ) ) return false;
                                 return unifyExact(
                                         tupleFromDecls( crnt1, end1 ), t2, env, need, have, open,
+                                        tupleFromTypes( crnt1, end1 ), t2, env, need, have, open,
                                         noWiden(), symtab );
+                        }
 …
+                }
                 static bool unifyDeclList(
                         const std::vector< ast::ptr< ast::DeclWithType > > & list1,
                         const std::vector< ast::ptr< ast::DeclWithType > > & list2,
+                static bool unifyTypeList(
+                        const std::vector< ast::ptr< ast::Type > > & list1,
+                        const std::vector< ast::ptr< ast::Type > > & list2,
                         ast::TypeEnvironment & env, ast::AssertionSet & need, ast::AssertionSet & have,
                         const ast::OpenVarSet & open, const ast::SymbolTable & symtab
                 ) {
                         return unifyDeclList(
+                        return unifyTypeList(
                                 list1.begin(), list1.end(), list2.begin(), list2.end(), env, need, have, open,
                                 symtab );
+                }
                 static void markAssertionSet( ast::AssertionSet & assns, const ast::DeclWithType * assn ) {
+                static void markAssertionSet( ast::AssertionSet & assns, const ast::VariableExpr * assn ) {
                         auto i = assns.find( assn );
                         if ( i != assns.end() ) {
 …
                 static void markAssertions(
                         ast::AssertionSet & assn1, ast::AssertionSet & assn2,
                         const ast::ParameterizedType * type
+                        const ast::FunctionType * type
                 ) {
+                        for ( const auto & tyvar : type->forall ) {
+                                for ( const ast::DeclWithType * assert : tyvar->assertions ) {
+                                        markAssertionSet( assn1, assert );
+                                        markAssertionSet( assn2, assert );
+                                }
+                        for ( auto & assert : type->assertions ) {
+                                markAssertionSet( assn1, assert );
+                                markAssertionSet( assn2, assert );
+                        }
+                }
 …
                         ) return;
                         if ( ! unifyDeclList( params, params2, tenv, need, have, open, symtab ) ) return;
                         if ( ! unifyDeclList(
+                        if ( ! unifyTypeList( params, params2, tenv, need, have, open, symtab ) ) return;
+                        if ( ! unifyTypeList(
                                 func->returns, func2->returns, tenv, need, have, open, symtab ) ) return;
 …
         private:
+                template< typename RefType >
+                const RefType * handleRefType( const RefType * inst, const ast::Type * other ) {
+                // Returns: other, cast as XInstType
+                // Assigns this->result: whether types are compatible (up to generic parameters)
+                template< typename XInstType >
+                const XInstType * handleRefType( const XInstType * inst, const ast::Type * other ) {
                         // check that the other type is compatible and named the same
                         auto otherInst = dynamic_cast< const RefType * >( other );
                         result = otherInst && inst->name == otherInst->name;
+                        auto otherInst = dynamic_cast< const XInstType * >( other );
+                        this->result = otherInst && inst->name == otherInst->name;
                         return otherInst;
+                }
 …
+                }
                 template< typename RefType >
                 void handleGenericRefType( const RefType * inst, const ast::Type * other ) {
+                template< typename XInstType >
+                void handleGenericRefType( const XInstType * inst, const ast::Type * other ) {
                         // check that other type is compatible and named the same
                         const RefType * inst2 = handleRefType( inst, other );
                         if ( ! inst2 ) return;
+                        const XInstType * otherInst = handleRefType( inst, other );
+                        if ( ! this->result ) return;
                         // check that parameters of types unify, if any
                         const std::vector< ast::ptr< ast::Expr > > & params = inst->params;
                         const std::vector< ast::ptr< ast::Expr > > & params2 = inst2->params;
+                        const std::vector< ast::ptr< ast::Expr > > & params2 = otherInst->params;
                         auto it = params.begin();
 …
                 void postvisit( const ast::TypeInstType * typeInst ) {
                         assert( open.find( typeInst->name ) == open.end() );
+                        assert( open.find( *typeInst ) == open.end() );
                         handleRefType( typeInst, type2 );
+                }
 …
         private:
                 /// Creates a tuple type based on a list of Type
                 static ast::ptr< ast::Type > tupleFromTypes(
+                static const ast::Type * tupleFromTypes(
                         const std::vector< ast::ptr< ast::Type > > & tys
                 ) {
 …
                         ast::Pass<TtypeExpander_new> expander{ tenv };
                         const ast::Type * flat = tuple->accept( expander );
                         const ast::Type * flat2 = tuple2->accept( expander );
 …
         };
+        // size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new");
         bool unify(
                         const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
 …
                 auto var2 = dynamic_cast< const ast::TypeInstType * >( type2 );
                 ast::OpenVarSet::const_iterator
                         entry1 = var1 ? open.find( var1->name ) : open.end(),
                         entry2 = var2 ? open.find( var2->name ) : open.end();
+                        entry1 = var1 ? open.find( *var1 ) : open.end(),
+                        entry2 = var2 ? open.find( *var2 ) : open.end();
                 bool isopen1 = entry1 != open.end();
                 bool isopen2 = entry2 != open.end();
 …
                         ast::Pass<Unify_new> comparator{ type2, env, need, have, open, widen, symtab };
                         type1->accept( comparator );
                         return comparator.pass.result;
+                        return comparator.core.result;
+                }
+        }
 …
                 // force t1 and t2 to be cloned if their qualifiers must be stripped, so that type1 and
                 // type2 are left unchanged; calling convention forces type{1,2}->strong_ref >= 1
+                ast::ptr<ast::Type> t1{ type1 }, t2{ type2 };
+                reset_qualifiers( t1 );
+                reset_qualifiers( t2 );
+                ast::Type * t1 = shallowCopy(type1.get());
+                ast::Type * t2 = shallowCopy(type2.get());
+                t1->qualifiers = {};
+                t2->qualifiers = {};
+                ast::ptr< ast::Type > t1_(t1);
+                ast::ptr< ast::Type > t2_(t2);
                 if ( unifyExact( t1, t2, env, need, have, open, widen, symtab ) ) {
-                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
                         // if exact unification on unqualified types, try to merge qualifiers
                         if ( q1 == q2 || ( ( q1 > q2 || widen.first ) && ( q2 > q1 || widen.second ) ) ) {
                                 common = type1;
                                 reset_qualifiers( common, q1 | q2 );
+                                t1->qualifiers = q1 | q2;
+                                common = t1;
                                 return true;
                         } else {
 …
                 } else if (( common = commonType( t1, t2, widen, symtab, env, open ) )) {
-                        t1 = nullptr; t2 = nullptr; // release t1, t2 to avoid spurious clones
                         // no exact unification, but common type
+                        reset_qualifiers( common, q1 | q2 );
+                        auto c = shallowCopy(common.get());
+                        c->qualifiers = q1 | q2;
+                        common = c;
                         return true;
                 } else {
 …
         ast::ptr<ast::Type> extractResultType( const ast::FunctionType * func ) {
                 if ( func->returns.empty() ) return new ast::VoidType{};
                 if ( func->returns.size() == 1 ) return func->returns[0]->get_type();
+                if ( func->returns.size() == 1 ) return func->returns[0];
                 std::vector<ast::ptr<ast::Type>> tys;
                 for ( const ast::DeclWithType * decl : func->returns ) {
                         tys.emplace_back( decl->get_type() );
+                for ( const auto & decl : func->returns ) {
+                        tys.emplace_back( decl );
+                }
                 return new ast::TupleType{ std::move(tys) };

src/ResolvExpr/module.mk

-              r3c64c668
+              r58fe85a
       ResolvExpr/Alternative.cc \
       ResolvExpr/AlternativeFinder.cc \
+      ResolvExpr/AlternativeFinder.h \
+      ResolvExpr/Alternative.h \
       ResolvExpr/Candidate.cpp \
       ResolvExpr/CandidateFinder.cpp \
+      ResolvExpr/CandidateFinder.hpp \
+      ResolvExpr/Candidate.hpp \
       ResolvExpr/CastCost.cc \
       ResolvExpr/CommonType.cc \
       ResolvExpr/ConversionCost.cc \
+      ResolvExpr/ConversionCost.h \
+      ResolvExpr/Cost.h \
       ResolvExpr/CurrentObject.cc \
+      ResolvExpr/CurrentObject.h \
       ResolvExpr/ExplodedActual.cc \
+      ResolvExpr/ExplodedActual.h \
       ResolvExpr/ExplodedArg.cpp \
+      ResolvExpr/ExplodedArg.hpp \
       ResolvExpr/FindOpenVars.cc \
+      ResolvExpr/FindOpenVars.h \
       ResolvExpr/Occurs.cc \
       ResolvExpr/PolyCost.cc \
 …
       ResolvExpr/PtrsCastable.cc \
       ResolvExpr/RenameVars.cc \
+      ResolvExpr/RenameVars.h \
       ResolvExpr/ResolveAssertions.cc \
+      ResolvExpr/ResolveAssertions.h \
       ResolvExpr/Resolver.cc \
+      ResolvExpr/Resolver.h \
       ResolvExpr/ResolveTypeof.cc \
+      ResolvExpr/ResolveTypeof.h \
+      ResolvExpr/ResolvMode.h \
       ResolvExpr/SatisfyAssertions.cpp \
+      ResolvExpr/SatisfyAssertions.hpp \
       ResolvExpr/SpecCost.cc \
       ResolvExpr/TypeEnvironment.cc \
+      ResolvExpr/Unify.cc
+      ResolvExpr/TypeEnvironment.h \
+      ResolvExpr/typeops.h \
+      ResolvExpr/Unify.cc \
+      ResolvExpr/Unify.h \
+      ResolvExpr/WidenMode.h
+SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc
+SRC += $(SRC_RESOLVEXPR) ResolvExpr/AlternativePrinter.cc ResolvExpr/AlternativePrinter.h
 SRCDEMANGLE += $(SRC_RESOLVEXPR)

src/ResolvExpr/typeops.h

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

src/SymTab/Autogen.cc

-              r3c64c668
+              r58fe85a
 #include "SynTree/Type.h"          // for FunctionType, Type, TypeInstType
 #include "SynTree/Visitor.h"       // for maybeAccept, Visitor, acceptAll
+#include "CompilationState.h"
 class Attribute;
 …
+        }
+        // shallow copy the pointer list for return
+        std::vector<ast::ptr<ast::TypeDecl>> getGenericParams (const ast::Type * t) {
+                if (auto structInst = dynamic_cast<const ast::StructInstType*>(t)) {
+                        return structInst->base->params;
+                }
+                if (auto unionInst = dynamic_cast<const ast::UnionInstType*>(t)) {
+                        return unionInst->base->params;
+                }
+                return {};
+        }
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
 …
                 ftype->parameters.push_back( dstParam );
                 return ftype;
+        }
+        ///
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic) {
+                std::vector<ast::ptr<ast::TypeDecl>> typeParams;
+                if (maybePolymorphic) typeParams = getGenericParams(paramType);
+                auto dstParam = new ast::ObjectDecl(loc, "_dst", new ast::ReferenceType(paramType), nullptr, {}, ast::Linkage::Cforall);
+                return new ast::FunctionDecl(loc, fname, std::move(typeParams), {dstParam}, {}, new ast::CompoundStmt(loc));
+        }
 …
         void FuncGenerator::resolve( FunctionDecl * dcl ) {
                 try {
+                        ResolvExpr::resolveDecl( dcl, indexer );
+                        if (!useNewAST) // attempt to delay resolver call
+                                ResolvExpr::resolveDecl( dcl, indexer );
                         if ( functionNesting == 0 ) {
                                 // forward declare if top-level struct, so that
 …
                 } catch ( SemanticErrorException & ) {
                         // okay if decl does not resolve - that means the function should not be generated
+                        delete dcl;
+                        // delete dcl;
+                        delete dcl->statements;
+                        dcl->statements = nullptr;
+                        dcl->isDeleted = true;
+                        definitions.push_back( dcl );
+                        indexer.addId( dcl );
+                }
+        }

src/SymTab/Autogen.h

-              r3c64c668
+              r58fe85a
 #include "AST/Decl.hpp"
+#include "AST/Eval.hpp"
 #include "AST/Expr.hpp"
 #include "AST/Init.hpp"
 …
         /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
         FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
+        ast::FunctionDecl * genDefaultFunc(const CodeLocation loc, const std::string fname, const ast::Type * paramType, bool maybePolymorphic = true);
         /// generate the type of a copy constructor for paramType.
 …
                 fExpr->args.emplace_back( dstParam );
                 const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
+                ast::ptr<ast::Stmt> listInit = srcParam.buildListInit( fExpr );
                 // fetch next set of arguments
 …
+                }
+                ast::ptr< ast::Expr > begin, end, cmp, update;
+                ast::ptr< ast::Expr > begin, end;
+                std::string cmp, update;
                 if ( forward ) {
 …
                         begin = ast::ConstantExpr::from_int( loc, 0 );
                         end = array->dimension;
                         cmp = new ast::NameExpr{ loc, "?<?" };
                         update = new ast::NameExpr{ loc, "++?" };
+                        cmp = "?<?";
+                        update = "++?";
                 } else {
                         // generate: for ( int i = N-1; i >= 0; --i )
+                        begin = new ast::UntypedExpr{
+                                loc, new ast::NameExpr{ loc, "?-?" },
+                                { array->dimension, ast::ConstantExpr::from_int( loc, 1 ) } };
+                        begin = ast::call(
+                                loc, "?-?", array->dimension, ast::ConstantExpr::from_int( loc, 1 ) );
                         end = ast::ConstantExpr::from_int( loc, 0 );
                         cmp = new ast::NameExpr{ loc, "?>=?" };
                         update = new ast::NameExpr{ loc, "--?" };
+                        cmp = "?>=?";
+                        update = "--?";
+                }
 …
                         loc, indexName.newName(), new ast::BasicType{ ast::BasicType::SignedInt },
                         new ast::SingleInit{ loc, begin } };
+                ast::ptr< ast::Expr > cond = new ast::UntypedExpr{
+                        loc, cmp, { new ast::VariableExpr{ loc, index }, end } };
+                ast::ptr< ast::Expr > inc = new ast::UntypedExpr{
+                        loc, update, { new ast::VariableExpr{ loc, index } } };
+                ast::ptr< ast::Expr > dstIndex = new ast::UntypedExpr{
+                        loc, new ast::NameExpr{ loc, "?[?]" },
+                        { dstParam, new ast::VariableExpr{ loc, index } } };
+                ast::ptr< ast::Expr > indexVar = new ast::VariableExpr{ loc, index };
+                ast::ptr< ast::Expr > cond = ast::call( loc, cmp, indexVar, end );
+                ast::ptr< ast::Expr > inc = ast::call( loc, update, indexVar );
+                ast::ptr< ast::Expr > dstIndex = ast::call( loc, "?[?]", dstParam, indexVar );
                 // srcParam must keep track of the array indices to build the source parameter and/or
                 // array list initializer
                 srcParam.addArrayIndex( new ast::VariableExpr{ loc, index }, array->dimension );
+                srcParam.addArrayIndex( indexVar, array->dimension );
                 // for stmt's body, eventually containing call
 …
                 if ( isUnnamedBitfield( obj ) ) return {};
                 ast::ptr< ast::Type > addCast = nullptr;
+                ast::ptr< ast::Type > addCast;
                 if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
                         assert( dstParam->result );

src/SymTab/FixFunction.cc

-              r3c64c668
+              r58fe85a
                 bool isVoid = false;
                 void premutate( const ast::FunctionDecl * ) { visit_children = false; }
+                void previsit( const ast::FunctionDecl * ) { visit_children = false; }
                 const ast::DeclWithType * postmutate( const ast::FunctionDecl * func ) {
+                const ast::DeclWithType * postvisit( const ast::FunctionDecl * func ) {
                         return new ast::ObjectDecl{
                                 func->location, func->name, new ast::PointerType{ func->type }, nullptr,
 …
+                }
                 void premutate( const ast::ArrayType * ) { visit_children = false; }
+                void previsit( const ast::ArrayType * ) { visit_children = false; }
                 const ast::Type * postmutate( const ast::ArrayType * array ) {
+                const ast::Type * postvisit( const ast::ArrayType * array ) {
                         return new ast::PointerType{
                                 array->base, array->dimension, array->isVarLen, array->isStatic,
 …
+                }
                 void premutate( const ast::VoidType * ) { isVoid = true; }
+                void previsit( const ast::VoidType * ) { isVoid = true; }
                 void premutate( const ast::BasicType * ) { visit_children = false; }
                 void premutate( const ast::PointerType * ) { visit_children = false; }
                 void premutate( const ast::StructInstType * ) { visit_children = false; }
                 void premutate( const ast::UnionInstType * ) { visit_children = false; }
                 void premutate( const ast::EnumInstType * ) { visit_children = false; }
                 void premutate( const ast::TraitInstType * ) { visit_children = false; }
                 void premutate( const ast::TypeInstType * ) { visit_children = false; }
                 void premutate( const ast::TupleType * ) { visit_children = false; }
                 void premutate( const ast::VarArgsType * ) { visit_children = false; }
                 void premutate( const ast::ZeroType * ) { visit_children = false; }
                 void premutate( const ast::OneType * ) { visit_children = false; }
+                void previsit( const ast::BasicType * ) { visit_children = false; }
+                void previsit( const ast::PointerType * ) { visit_children = false; }
+                void previsit( const ast::StructInstType * ) { visit_children = false; }
+                void previsit( const ast::UnionInstType * ) { visit_children = false; }
+                void previsit( const ast::EnumInstType * ) { visit_children = false; }
+                void previsit( const ast::TraitInstType * ) { visit_children = false; }
+                void previsit( const ast::TypeInstType * ) { visit_children = false; }
+                void previsit( const ast::TupleType * ) { visit_children = false; }
+                void previsit( const ast::VarArgsType * ) { visit_children = false; }
+                void previsit( const ast::ZeroType * ) { visit_children = false; }
+                void previsit( const ast::OneType * ) { visit_children = false; }
         };
 } // anonymous namespace
 …
         ast::Pass< FixFunction_new > fixer;
         dwt = dwt->accept( fixer );
         isVoid |= fixer.pass.isVoid;
+        isVoid |= fixer.core.isVoid;
         return dwt;
+}

src/SymTab/Mangler.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb 15 13:55:12 2020
 // Update Count     : 33
+// Last Modified On : Wed Nov 18 12:01:38 2020
+// Update Count     : 64
 //
 #include "Mangler.h"
 …
                                 void postvisit( const QualifiedType * qualType );
                                 std::string get_mangleName() { return mangleName.str(); }
+                                std::string get_mangleName() { return mangleName; }
                           private:
                                 std::ostringstream mangleName;  ///< Mangled name being constructed
+                                std::string mangleName;         ///< Mangled name being constructed
                                 typedef std::map< std::string, std::pair< int, int > > VarMapType;
                                 VarMapType varNums;             ///< Map of type variables to indices
 …
                                         isTopLevel = false;
                                 } // if
                                 mangleName << Encoding::manglePrefix;
+                                mangleName += Encoding::manglePrefix;
                                 const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( declaration->get_name() );
                                 if ( opInfo ) {
                                         mangleName << opInfo->outputName.size() << opInfo->outputName;
+                                        mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
                                 } else {
                                         mangleName << declaration->name.size() << declaration->name;
+                                        mangleName += std::to_string( declaration->name.size() ) + declaration->name;
                                 } // if
                                 maybeAccept( declaration->get_type(), *visitor );
 …
                                         // so they need a different name mangling
                                         if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
                                                 mangleName << Encoding::autogen;
+                                                mangleName += Encoding::autogen;
                                         } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
                                                 mangleName << Encoding::intrinsic;
+                                                mangleName += Encoding::intrinsic;
                                         } else {
                                                 // if we add another kind of overridable function, this has to change
 …
                         void Mangler_old::postvisit( const VoidType * voidType ) {
                                 printQualifiers( voidType );
                                 mangleName << Encoding::void_t;
+                                mangleName += Encoding::void_t;
+                        }
 …
                                 printQualifiers( basicType );
                                 assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
                                 mangleName << Encoding::basicTypes[ basicType->kind ];
+                                mangleName += Encoding::basicTypes[ basicType->kind ];
+                        }
 …
                                 printQualifiers( pointerType );
                                 // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
                                 if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << Encoding::pointer;
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName += Encoding::pointer;
                                 maybeAccept( pointerType->base, *visitor );
+                        }
 …
                                 // TODO: encode dimension
                                 printQualifiers( arrayType );
                                 mangleName << Encoding::array << "0";
+                                mangleName += Encoding::array + "0";
                                 maybeAccept( arrayType->base, *visitor );
+                        }
 …
                         void Mangler_old::postvisit( const FunctionType * functionType ) {
                                 printQualifiers( functionType );
                                 mangleName << Encoding::function;
+                                mangleName += Encoding::function;
                                 // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
                                 // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
 …
                                 inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->returnVals );
                                 if (returnTypes.empty()) mangleName << Encoding::void_t;
+                                if (returnTypes.empty()) mangleName += Encoding::void_t;
                                 else acceptAll( returnTypes, *visitor );
                                 mangleName << "_";
+                                mangleName += "_";
                                 std::list< Type* > paramTypes = getTypes( functionType->parameters );
                                 acceptAll( paramTypes, *visitor );
                                 mangleName << "_";
+                                mangleName += "_";
+                        }
 …
                                 printQualifiers( refType );
                                 mangleName << prefix << refType->name.length() << refType->name;
+                                mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
                                 if ( mangleGenericParams ) {
                                         const std::list< Expression* > & params = refType->parameters;
                                         if ( ! params.empty() ) {
                                                 mangleName << "_";
+                                                mangleName += "_";
                                                 for ( const Expression * param : params ) {
                                                         const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
 …
                                                         maybeAccept( paramType->type, *visitor );
+                                                }
                                                 mangleName << "_";
+                                                mangleName += "_";
+                                        }
+                                }
 …
                                         // are first found and prefixing with the appropriate encoding for the type class.
                                         assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
                                         mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
+                                        mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
                                 } // if
+                        }
 …
                         void Mangler_old::postvisit( const TraitInstType * inst ) {
                                 printQualifiers( inst );
                                 mangleName << inst->name.size() << inst->name;
+                                mangleName += std::to_string( inst->name.size() ) + inst->name;
+                        }
                         void Mangler_old::postvisit( const TupleType * tupleType ) {
                                 printQualifiers( tupleType );
                                 mangleName << Encoding::tuple << tupleType->types.size();
+                                mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
                                 acceptAll( tupleType->types, *visitor );
+                        }
 …
                                 printQualifiers( varArgsType );
                                 static const std::string vargs = "__builtin_va_list";
                                 mangleName << Encoding::type << vargs.size() << vargs;
+                                mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
+                        }
                         void Mangler_old::postvisit( const ZeroType * ) {
                                 mangleName << Encoding::zero;
+                                mangleName += Encoding::zero;
+                        }
                         void Mangler_old::postvisit( const OneType * ) {
                                 mangleName << Encoding::one;
+                                mangleName += Encoding::one;
+                        }
 …
                                         // N marks the start of a qualified type
                                         inQualifiedType = true;
                                         mangleName << Encoding::qualifiedTypeStart;
+                                        mangleName += Encoding::qualifiedTypeStart;
+                                }
                                 maybeAccept( qualType->parent, *visitor );
 …
                                         // E marks the end of a qualified type
                                         inQualifiedType = false;
                                         mangleName << Encoding::qualifiedTypeEnd;
+                                        mangleName += Encoding::qualifiedTypeEnd;
+                                }
+                        }
 …
                                 assertf(false, "Mangler_old should not visit typedecl: %s", toCString(decl));
                                 assertf( decl->kind < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
                                 mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
+                                mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
+                        }
 …
                                         std::list< std::string > assertionNames;
                                         int dcount = 0, fcount = 0, vcount = 0, acount = 0;
                                         mangleName << Encoding::forall;
+                                        mangleName += Encoding::forall;
                                         for ( const TypeDecl * i : type->forall ) {
                                                 switch ( i->kind ) {
 …
                                                 } // for
                                         } // for
+                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
+                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName << "_";
+                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                        for(const auto & a : assertionNames) mangleName += a;
+//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName += "_";
                                 } // if
                                 if ( ! inFunctionType ) {
                                         // these qualifiers do not distinguish the outermost type of a function parameter
                                         if ( type->get_const() ) {
                                                 mangleName << Encoding::qualifiers.at(Type::Const);
+                                                mangleName += Encoding::qualifiers.at(Type::Const);
                                         } // if
                                         if ( type->get_volatile() ) {
                                                 mangleName << Encoding::qualifiers.at(Type::Volatile);
+                                                mangleName += Encoding::qualifiers.at(Type::Volatile);
                                         } // if
                                         // Removed due to restrict not affecting function compatibility in GCC
                                         // if ( type->get_isRestrict() ) {
                                         //      mangleName << "E";
+                                        //      mangleName += "E";
                                         // } // if
                                         if ( type->get_atomic() ) {
                                                 mangleName << Encoding::qualifiers.at(Type::Atomic);
+                                                mangleName += Encoding::qualifiers.at(Type::Atomic);
                                         } // if
+                                }
                                 if ( type->get_mutex() ) {
                                         mangleName << Encoding::qualifiers.at(Type::Mutex);
+                                        mangleName += Encoding::qualifiers.at(Type::Mutex);
                                 } // if
                                 if ( inFunctionType ) {
 …
+                                }
+                        }
                 }       // namespace
+                } // namespace
         } // namespace Mangler
 } // namespace SymTab
 …
                         void postvisit( const ast::QualifiedType * qualType );
                         std::string get_mangleName() { return mangleName.str(); }
+                        std::string get_mangleName() { return mangleName; }
                   private:
                         std::ostringstream mangleName;  ///< Mangled name being constructed
+                        std::string mangleName;         ///< Mangled name being constructed
                         typedef std::map< std::string, std::pair< int, int > > VarMapType;
                         VarMapType varNums;             ///< Map of type variables to indices
 …
                   private:
                         void mangleDecl( const ast::DeclWithType *declaration );
                         void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
+                        void mangleRef( const ast::BaseInstType *refType, std::string prefix );
                         void printQualifiers( const ast::Type *type );
 …
                 ast::Pass<Mangler_new> mangler( mode );
                 maybeAccept( decl, mangler );
                 return mangler.pass.get_mangleName();
+                return mangler.core.get_mangleName();
+        }
 …
                                 isTopLevel = false;
                         } // if
                         mangleName << Encoding::manglePrefix;
+                        mangleName += Encoding::manglePrefix;
                         const CodeGen::OperatorInfo * opInfo = CodeGen::operatorLookup( decl->name );
                         if ( opInfo ) {
                                 mangleName << opInfo->outputName.size() << opInfo->outputName;
+                                mangleName += std::to_string( opInfo->outputName.size() ) + opInfo->outputName;
                         } else {
                                 mangleName << decl->name.size() << decl->name;
+                                mangleName += std::to_string( decl->name.size() ) + decl->name;
                         } // if
                         maybeAccept( decl->get_type(), *visitor );
 …
                                 // so they need a different name mangling
                                 if ( decl->linkage == ast::Linkage::AutoGen ) {
                                         mangleName << Encoding::autogen;
+                                        mangleName += Encoding::autogen;
                                 } else if ( decl->linkage == ast::Linkage::Intrinsic ) {
                                         mangleName << Encoding::intrinsic;
+                                        mangleName += Encoding::intrinsic;
                                 } else {
                                         // if we add another kind of overridable function, this has to change
 …
                 void Mangler_new::postvisit( const ast::VoidType * voidType ) {
                         printQualifiers( voidType );
                         mangleName << Encoding::void_t;
+                        mangleName += Encoding::void_t;
+                }
 …
                         printQualifiers( basicType );
                         assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
                         mangleName << Encoding::basicTypes[ basicType->kind ];
+                        mangleName += Encoding::basicTypes[ basicType->kind ];
+                }
 …
                         printQualifiers( pointerType );
                         // mangle void (*f)() and void f() to the same name to prevent overloading on functions and function pointers
                         if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName << Encoding::pointer;
+                        if ( ! pointerType->base.as<ast::FunctionType>() ) mangleName += Encoding::pointer;
                         maybe_accept( pointerType->base.get(), *visitor );
+                }
 …
                         // TODO: encode dimension
                         printQualifiers( arrayType );
                         mangleName << Encoding::array << "0";
+                        mangleName += Encoding::array + "0";
                         maybeAccept( arrayType->base.get(), *visitor );
+                }
 …
                 void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
                         printQualifiers( functionType );
                         mangleName << Encoding::function;
+                        mangleName += Encoding::function;
                         // turn on inFunctionType so that printQualifiers does not print most qualifiers for function parameters,
                         // since qualifiers on outermost parameter type do not differentiate function types, e.g.,
 …
                         GuardValue( inFunctionType );
                         inFunctionType = true;
+                        std::vector< ast::ptr< ast::Type > > returnTypes = getTypes( functionType->returns );
+                        if (returnTypes.empty()) mangleName << Encoding::void_t;
+                        else accept_each( returnTypes, *visitor );
+                        mangleName << "_";
+                        std::vector< ast::ptr< ast::Type > > paramTypes = getTypes( functionType->params );
+                        accept_each( paramTypes, *visitor );
+                        mangleName << "_";
+                }
+                void Mangler_new::mangleRef( const ast::ReferenceToType * refType, std::string prefix ) {
+                        if (functionType->returns.empty()) mangleName += Encoding::void_t;
+                        else accept_each( functionType->returns, *visitor );
+                        mangleName += "_";
+                        accept_each( functionType->params, *visitor );
+                        mangleName += "_";
+                }
+                void Mangler_new::mangleRef( const ast::BaseInstType * refType, std::string prefix ) {
                         printQualifiers( refType );
                         mangleName << prefix << refType->name.length() << refType->name;
+                        mangleName += prefix + std::to_string( refType->name.length() ) + refType->name;
                         if ( mangleGenericParams ) {
                                 if ( ! refType->params.empty() ) {
                                         mangleName << "_";
+                                        mangleName += "_";
                                         for ( const ast::Expr * param : refType->params ) {
                                                 auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
 …
                                                 maybeAccept( paramType->type.get(), *visitor );
+                                        }
                                         mangleName << "_";
+                                        mangleName += "_";
+                                }
+                        }
 …
                                 // are first found and prefixing with the appropriate encoding for the type class.
                                 assertf( varNum->second.second < TypeDecl::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", varNum->second.second );
                                 mangleName << Encoding::typeVariables[varNum->second.second] << varNum->second.first;
+                                mangleName += Encoding::typeVariables[varNum->second.second] + std::to_string( varNum->second.first );
                         } // if
+                }
 …
                 void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
                         printQualifiers( inst );
                         mangleName << inst->name.size() << inst->name;
+                        mangleName += std::to_string( inst->name.size() ) + inst->name;
+                }
                 void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
                         printQualifiers( tupleType );
                         mangleName << Encoding::tuple << tupleType->types.size();
+                        mangleName += Encoding::tuple + std::to_string( tupleType->types.size() );
                         accept_each( tupleType->types, *visitor );
+                }
 …
                         printQualifiers( varArgsType );
                         static const std::string vargs = "__builtin_va_list";
                         mangleName << Encoding::type << vargs.size() << vargs;
+                        mangleName += Encoding::type + std::to_string( vargs.size() ) + vargs;
+                }
                 void Mangler_new::postvisit( const ast::ZeroType * ) {
                         mangleName << Encoding::zero;
+                        mangleName += Encoding::zero;
+                }
                 void Mangler_new::postvisit( const ast::OneType * ) {
                         mangleName << Encoding::one;
+                        mangleName += Encoding::one;
+                }
 …
                                 // N marks the start of a qualified type
                                 inQualifiedType = true;
                                 mangleName << Encoding::qualifiedTypeStart;
+                                mangleName += Encoding::qualifiedTypeStart;
+                        }
                         maybeAccept( qualType->parent.get(), *visitor );
 …
                                 // E marks the end of a qualified type
                                 inQualifiedType = false;
                                 mangleName << Encoding::qualifiedTypeEnd;
+                                mangleName += Encoding::qualifiedTypeEnd;
+                        }
+                }
 …
                         assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
                         assertf( decl->kind < ast::TypeDecl::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
                         mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
+                        mangleName += Encoding::typeVariables[ decl->kind ] + std::to_string( decl->name.length() ) + decl->name;
+                }
 …
                         // skip if not including qualifiers
                         if ( typeMode ) return;
                         if ( auto ptype = dynamic_cast< const ast::ParameterizedType * >(type) ) {
+                        if ( auto ptype = dynamic_cast< const ast::FunctionType * >(type) ) {
                                 if ( ! ptype->forall.empty() ) {
                                         std::list< std::string > assertionNames;
                                         int dcount = 0, fcount = 0, vcount = 0, acount = 0;
                                         mangleName << Encoding::forall;
                                         for ( const ast::TypeDecl * decl : ptype->forall ) {
+                                        mangleName += Encoding::forall;
+                                        for ( auto & decl : ptype->forall ) {
                                                 switch ( decl->kind ) {
                                                 case ast::TypeDecl::Kind::Dtype:
 …
                                                 } // switch
                                                 varNums[ decl->name ] = std::make_pair( nextVarNum, (int)decl->kind );
-                                                for ( const ast::DeclWithType * assert : decl->assertions ) {
-                                                        ast::Pass<Mangler_new> sub_mangler(
-                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
-                                                        assert->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
-                                                        acount++;
-                                                } // for
                                         } // for
+                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
+                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName << "_";
+                                        for ( auto & assert : ptype->assertions ) {
+                                                ast::Pass<Mangler_new> sub_mangler(
+                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
+                                                assert->var->accept( sub_mangler );
+                                                assertionNames.push_back( sub_mangler.core.get_mangleName() );
+                                                acount++;
+                                        } // for
+                                        mangleName += std::to_string( dcount ) + "_" + std::to_string( fcount ) + "_" + std::to_string( vcount ) + "_" + std::to_string( acount ) + "_";
+                                        for(const auto & a : assertionNames) mangleName += a;
+//                                      std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                                        mangleName += "_";
                                 } // if
                         } // if
 …
                                 // these qualifiers do not distinguish the outermost type of a function parameter
                                 if ( type->is_const() ) {
                                         mangleName << Encoding::qualifiers.at(Type::Const);
+                                        mangleName += Encoding::qualifiers.at(Type::Const);
                                 } // if
                                 if ( type->is_volatile() ) {
                                         mangleName << Encoding::qualifiers.at(Type::Volatile);
+                                        mangleName += Encoding::qualifiers.at(Type::Volatile);
                                 } // if
                                 // Removed due to restrict not affecting function compatibility in GCC
                                 // if ( type->get_isRestrict() ) {
                                 //      mangleName << "E";
+                                //      mangleName += "E";
                                 // } // if
                                 if ( type->is_atomic() ) {
                                         mangleName << Encoding::qualifiers.at(Type::Atomic);
+                                        mangleName += Encoding::qualifiers.at(Type::Atomic);
                                 } // if
+                        }
                         if ( type->is_mutex() ) {
                                 mangleName << Encoding::qualifiers.at(Type::Mutex);
+                                mangleName += Encoding::qualifiers.at(Type::Mutex);
                         } // if
                         if ( inFunctionType ) {

src/SymTab/Validate.cc

-              r3c64c668
+              r58fe85a
 #include "Common/UniqueName.h"         // for UniqueName
 #include "Common/utility.h"            // for operator+, cloneAll, deleteAll
+#include "CompilationState.h"          // skip some passes in new-ast build
 #include "Concurrency/Keywords.h"      // for applyKeywords
 #include "FixFunction.h"               // for FixFunction
 …
         };
         struct ArrayLength : public WithIndexer {
+        struct InitializerLength {
                 /// for array types without an explicit length, compute the length and store it so that it
                 /// is known to the rest of the phases. For example,
 …
                 void previsit( ObjectDecl * objDecl );
+        };
+        struct ArrayLength : public WithIndexer {
+                static void computeLength( std::list< Declaration * > & translationUnit );
                 void previsit( ArrayType * arrayType );
         };
 …
                                 mutateAll( translationUnit, compoundliteral );
                         });
+                        Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                        });
+                        if (!useNewAST) {
+                                Stats::Time::TimeBlock("Resolve With Expressions", [&]() {
+                                        ResolvExpr::resolveWithExprs( translationUnit ); // must happen before FixObjectType because user-code is resolved and may contain with variables
+                                });
+                        }
+                }
+                {
                         Stats::Heap::newPass("validate-F");
                         Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeCall("Fix Object Type",
+                                FixObjectType::fix, translationUnit);
+                        Stats::Time::TimeCall("Array Length",
+                                ArrayLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Fix Object Type",
+                                        FixObjectType::fix, translationUnit);
+                        }
+                        Stats::Time::TimeCall("Initializer Length",
+                                InitializerLength::computeLength, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Array Length",
+                                        ArrayLength::computeLength, translationUnit);
+                        }
                         Stats::Time::TimeCall("Find Special Declarations",
                                 Validate::findSpecialDecls, translationUnit);
                         Stats::Time::TimeCall("Fix Label Address",
                                 mutateAll<LabelAddressFixer>, translationUnit, labelAddrFixer);
+                        Stats::Time::TimeCall("Handle Attributes",
+                                Validate::handleAttributes, translationUnit);
+                        if (!useNewAST) {
+                                Stats::Time::TimeCall("Handle Attributes",
+                                        Validate::handleAttributes, translationUnit);
+                        }
+                }
+        }
 …
+        }
+        static bool isNonParameterAttribute( Attribute * attr ) {
+                static const std::vector<std::string> bad_names = {
+                        "aligned", "__aligned__",
+                };
+                for ( auto name : bad_names ) {
+                        if ( name == attr->name ) {
+                                return true;
+                        }
+                }
+                return false;
+        }
         Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
 …
                         ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
+                        // attributes are not carried over from typedef to function parameters/return values
+                        if ( ! inFunctionType ) {
+                                ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
+                        } else {
+                                deleteAll( ret->attributes );
+                                ret->attributes.clear();
+                        }
+                        // GCC ignores certain attributes if they arrive by typedef, this mimics that.
+                        if ( inFunctionType ) {
+                                ret->attributes.remove_if( isNonParameterAttribute );
+                        }
+                        ret->attributes.splice( ret->attributes.end(), typeInst->attributes );
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
 …
+        }
+        void InitializerLength::computeLength( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<InitializerLength> len;
+                acceptAll( translationUnit, len );
+        }
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ArrayLength> len;
 …
+        }
         void ArrayLength::previsit( ObjectDecl * objDecl ) {
+        void InitializerLength::previsit( ObjectDecl * objDecl ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
                         if ( at->dimension ) return;
 …
         /// Replaces enum types by int, and function/array types in function parameter and return
         /// lists by appropriate pointers
+        /*
         struct EnumAndPointerDecay_new {
                 const ast::EnumDecl * previsit( const ast::EnumDecl * enumDecl ) {
 …
+                }
         };
+        */
         /// expand assertions from a trait instance, performing appropriate type variable substitutions
 …
+        }
+        /*
         /// Associates forward declarations of aggregates with their definitions
         class LinkReferenceToTypes_new final
 …
+                }
                 void checkGenericParameters( const ast::ReferenceToType * inst ) {
+                void checkGenericParameters( const ast::BaseInstType * inst ) {
                         for ( const ast::Expr * param : inst->params ) {
                                 if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
 …
                 static const node_t * forallFixer(
                         const CodeLocation & loc, const node_t * node,
                         ast::ParameterizedType::ForallList parent_t::* forallField
+                        ast::FunctionType::ForallList parent_t::* forallField
                 ) {
                         for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
 …
+                }
         };
+        */
 } // anonymous namespace
+/*
 const ast::Type * validateType(
                 const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
         ast::Pass< EnumAndPointerDecay_new > epc;
+        // ast::Pass< EnumAndPointerDecay_new > epc;
         ast::Pass< LinkReferenceToTypes_new > lrt{ loc, symtab };
         ast::Pass< ForallPointerDecay_new > fpd{ loc };
         return type->accept( epc )->accept( lrt )->accept( fpd );
+        return type->accept( lrt )->accept( fpd );
+}
+*/
 } // namespace SymTab

src/SymTab/module.mk

-              r3c64c668
+              r58fe85a
 SRC_SYMTAB = \
       SymTab/Autogen.cc \
+      SymTab/Autogen.h \
       SymTab/FixFunction.cc \
+      SymTab/FixFunction.h \
       SymTab/Indexer.cc \
+      SymTab/Indexer.h \
       SymTab/Mangler.cc \
       SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+      SymTab/Mangler.h \
+      SymTab/Validate.cc \
+      SymTab/Validate.h
 SRC += $(SRC_SYMTAB)

src/SynTree/AggregateDecl.cc

-              r3c64c668
+              r58fe85a
 #include "Common/utility.h"      // for printAll, cloneAll, deleteAll
 #include "Declaration.h"         // for AggregateDecl, TypeDecl, Declaration
+#include "Expression.h"
 #include "Initializer.h"
 #include "LinkageSpec.h"         // for Spec, linkageName, Cforall
 …
 const char * StructDecl::typeString() const { return aggrString( kind ); }
+StructInstType * StructDecl::makeInst( std::list< Expression * > const & new_parameters ) {
+        std::list< Expression * > copy_parameters;
+        cloneAll( new_parameters, copy_parameters );
+        return makeInst( move( copy( copy_parameters ) ) );
+}
+StructInstType * StructDecl::makeInst( std::list< Expression * > && new_parameters ) {
+        assert( parameters.size() == new_parameters.size() );
+        StructInstType * type = new StructInstType( noQualifiers, this );
+        type->parameters = std::move( new_parameters );
+        return type;
+}
 const char * UnionDecl::typeString() const { return aggrString( Union ); }

src/SynTree/ApplicationExpr.cc

-              r3c64c668
+              r58fe85a
 ParamEntry::ParamEntry( const ParamEntry &other ) :
                 decl( other.decl ), declptr( maybeClone( other.declptr ) ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) {
+                decl( other.decl ), declptr( other.declptr ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ) {
+}
 ParamEntry::~ParamEntry() {
         delete declptr;
+        // delete declptr;
         delete actualType;
         delete formalType;

src/SynTree/Declaration.h

-              r3c64c668
+              r58fe85a
   public:
         Type * base;
-        std::list< TypeDecl * > parameters;
         std::list< DeclarationWithType * > assertions;
 …
         Type * get_base() const { return base; }
         void set_base( Type * newValue ) { base = newValue; }
-        std::list< TypeDecl* > & get_parameters() { return parameters; }
         std::list< DeclarationWithType * >& get_assertions() { return assertions; }
 …
         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   ; }
+        // Make a type instance of this declaration.
+        StructInstType * makeInst( std::list< Expression * > const & parameters );
+        StructInstType * makeInst( std::list< Expression * > && parameters );
         virtual StructDecl * clone() const override { return new StructDecl( *this ); }

src/SynTree/Expression.cc

-              r3c64c668
+              r58fe85a
 #include "Type.h"                    // for Type, BasicType, Type::Qualifiers
 #include "TypeSubstitution.h"        // for TypeSubstitution
+#include "CompilationState.h"        // for deterministic_output
 #include "GenPoly/Lvalue.h"
 …
         printInferParams( inferParams, os, indent+1, 0 );
+        if ( result ) {
+                os << std::endl << indent << "with resolved type:" << std::endl;
+                os << (indent+1);
+                result->print( os, indent+1 );
+        }
         if ( env ) {
                 os << std::endl << indent << "... with environment:" << std::endl;
 …
+}
+KeywordCastExpr::KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target ) : Expression(), arg(arg), target( target ) {
+}
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {
+}
+KeywordCastExpr::KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target ) : Expression(), arg(arg), target( target ) {}
+KeywordCastExpr::KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target, const KeywordCastExpr::Concrete & concrete_target ) : Expression(), arg(arg), target( target ), concrete_target(concrete_target) {}
+KeywordCastExpr::KeywordCastExpr( const KeywordCastExpr & other ) : Expression( other ), arg( maybeClone( other.arg ) ), target( other.target ) {}
 KeywordCastExpr::~KeywordCastExpr() {

src/SynTree/Expression.h

-              r3c64c668
+              r58fe85a
 };
+/// VariableExpr represents an expression that simply refers to the value of a named variable.
+/// Does not take ownership of var.
+class VariableExpr : public Expression {
+  public:
+        DeclarationWithType * var;
+        VariableExpr();
+        VariableExpr( DeclarationWithType * var );
+        VariableExpr( const VariableExpr & other );
+        virtual ~VariableExpr();
+        bool get_lvalue() const final;
+        DeclarationWithType * get_var() const { return var; }
+        void set_var( DeclarationWithType * newValue ) { var = newValue; }
+        static VariableExpr * functionPointer( FunctionDecl * decl );
+        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
 // The following classes are used to represent expression types that cannot be converted into
 // function-call format.
 …
   public:
         Expression * arg;
+        bool isGenerated = true; // cast generated implicitly by code generation or explicit in program
+        // Inidicates cast is introduced by the CFA type system.
+        // true for casts that the resolver introduces to force a return type
+        // false for casts from user code
+        // false for casts from desugaring advanced CFA features into simpler CFA
+        // example
+        //   int * p;     // declaration
+        //   (float *) p; // use, with subject cast
+        // subject cast isGenerated means we are considering an interpretation with a type mismatch
+        // subject cast not isGenerated means someone in charge wants it that way
+        bool isGenerated = true;
         CastExpr( Expression * arg, bool isGenerated = true );
 …
         KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target );
+        KeywordCastExpr( Expression * arg, AggregateDecl::Aggregate target, const Concrete & concrete_target );
         KeywordCastExpr( const KeywordCastExpr & other );
         virtual ~KeywordCastExpr();
 …
         virtual MemberExpr * clone() const override { return new MemberExpr( * this ); }
-        virtual void accept( Visitor & v ) override { v.visit( this ); }
-        virtual void accept( Visitor & v ) const override { v.visit( this ); }
-        virtual Expression * acceptMutator( Mutator & m ) override { return m.mutate( this ); }
-        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
-};
-/// VariableExpr represents an expression that simply refers to the value of a named variable.
-/// Does not take ownership of var.
-class VariableExpr : public Expression {
-  public:
-        DeclarationWithType * var;
-        VariableExpr();
-        VariableExpr( DeclarationWithType * var );
-        VariableExpr( const VariableExpr & other );
-        virtual ~VariableExpr();
-        bool get_lvalue() const final;
-        DeclarationWithType * get_var() const { return var; }
-        void set_var( DeclarationWithType * newValue ) { var = newValue; }
-        static VariableExpr * functionPointer( FunctionDecl * decl );
-        virtual VariableExpr * clone() const override { return new VariableExpr( * this ); }
         virtual void accept( Visitor & v ) override { v.visit( this ); }
         virtual void accept( Visitor & v ) const override { v.visit( this ); }

src/SynTree/LinkageSpec.cc

-              r3c64c668
+              r58fe85a
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:22:09 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:02:29 2019
 // Update Count     : 28
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar  2 16:13:00 2020
+// Update Count     : 29
 //
 …
 #include "LinkageSpec.h"
+#include "Common/CodeLocation.h"
 #include "Common/SemanticError.h"

src/SynTree/LinkageSpec.h

-              r3c64c668
+              r58fe85a
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Mon Dec 16 15:03:43 2019
 // Update Count     : 20
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Mar  2 16:13:00 2020
+// Update Count     : 21
 //
 …
 #include <string>
+#include "Common/CodeLocation.h"
+struct CodeLocation;
 namespace LinkageSpec {

src/SynTree/Mutator.h

r3c64c668	r58fe85a
51	51	virtual Statement * mutate( CatchStmt * catchStmt ) = 0;
52	52	virtual Statement * mutate( FinallyStmt * catchStmt ) = 0;
	53	virtual Statement * mutate( SuspendStmt * suspendStmt ) = 0;
53	54	virtual Statement * mutate( WaitForStmt * waitforStmt ) = 0;
54	55	virtual Declaration * mutate( WithStmt * withStmt ) = 0;

src/SynTree/NamedTypeDecl.cc

-              r3c64c668
+              r58fe85a
 #include "LinkageSpec.h"         // for Spec, Cforall, linkageName
 #include "Type.h"                // for Type, Type::StorageClasses
+#include "CompilationState.h"
 NamedTypeDecl::NamedTypeDecl( const std::string &name, Type::StorageClasses scs, Type *base )
 …
 NamedTypeDecl::NamedTypeDecl( const NamedTypeDecl &other )
         : Parent( other ), base( maybeClone( other.base ) ) {
-        cloneAll( other.parameters, parameters );
         cloneAll( other.assertions, assertions );
+}
 …
 NamedTypeDecl::~NamedTypeDecl() {
         delete base;
-        deleteAll( parameters );
         deleteAll( assertions );
+}
 …
         using namespace std;
+        if ( name != "" ) os << name << ": ";
+        if ( ! name.empty() ) {
+                if( deterministic_output && isUnboundType(name) ) os << "[unbound]:";
+                else os << name << ": ";
+        }
         if ( linkage != LinkageSpec::Cforall ) {
 …
                 os << " for ";
                 base->print( os, indent+1 );
-        } // if
-        if ( ! parameters.empty() ) {
-                os << endl << indent << "... with parameters" << endl;
-                printAll( parameters, os, indent+1 );
         } // if
         if ( ! assertions.empty() ) {
 …
                 base->print( os, indent+1 );
         } // if
-        if ( ! parameters.empty() ) {
-                os << endl << indent << "... with parameters" << endl;
-                printAll( parameters, os, indent+1 );
-        } // if
+}

src/SynTree/ReferenceToType.cc

-              r3c64c668
+              r58fe85a
 #include "Type.h"             // for TypeInstType, StructInstType, UnionInstType
 #include "TypeSubstitution.h" // for TypeSubstitution
+#include "CompilationState.h"
 class Attribute;
 …
         Type::print( os, indent );
+        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type)";
+        os << "instance of " << typeString() << " ";
+        const auto & name_ = get_name();
+        if( deterministic_output && isUnboundType(name) ) os << "[unbound]";
+        else os << name;
+        os << " (" << ( isFtype ? "" : "not" ) << " function type)";
         if ( ! parameters.empty() ) {
                 os << endl << indent << "... with parameters" << endl;

src/SynTree/Statement.cc

-              r3c64c668
+              r58fe85a
+}
+SuspendStmt::SuspendStmt( const SuspendStmt & other )
+        : Statement( other )
+        , then( maybeClone(other.then) )
+{}
+SuspendStmt::~SuspendStmt() {
+        delete then;
+}
+void SuspendStmt::print( std::ostream & os, Indenter indent ) const {
+        os << "Suspend Statement";
+        switch (type) {
+                case None     : os << " with implicit target"; break;
+                case Generator: os << " for generator"       ; break;
+                case Coroutine: os << " for coroutine"       ; break;
+        }
+        os << endl;
+        indent += 1;
+        if(then) {
+                os << indent << " with post statement :" << endl;
+                then->print( os, indent + 1);
+        }
+}
 WaitForStmt::WaitForStmt() : Statement() {
         timeout.time      = nullptr;

src/SynTree/Statement.h

-              r3c64c668
+              r58fe85a
 };
+class SuspendStmt : public Statement {
+  public:
+        CompoundStmt * then = nullptr;
+        enum Type { None, Coroutine, Generator } type = None;
+        SuspendStmt() = default;
+        SuspendStmt( const SuspendStmt & );
+        virtual ~SuspendStmt();
+        virtual SuspendStmt * clone() const override { return new SuspendStmt( *this ); }
+        virtual void accept( Visitor & v ) override { v.visit( this ); }
+        virtual void accept( Visitor & v ) const override { v.visit( this ); }
+        virtual Statement * acceptMutator( Mutator & m )  override { return m.mutate( this ); }
+        virtual void print( std::ostream & os, Indenter indent = {} ) const override;
+};
 class WaitForStmt : public Statement {
   public:
 …
 class ImplicitCtorDtorStmt : public Statement {
   public:
         // Non-owned pointer to the constructor/destructor statement
+        // the constructor/destructor call statement; owned here for a while, eventually transferred elsewhere
         Statement * callStmt;

src/SynTree/SynTree.h

r3c64c668	r58fe85a
54	54	class CatchStmt;
55	55	class FinallyStmt;
	56	class SuspendStmt;
56	57	class WaitForStmt;
57	58	class WithStmt;

src/SynTree/Type.cc

-              r3c64c668
+              r58fe85a
 const Type::Qualifiers noQualifiers;
+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 isUnboundType(typeInst->name);
+        }
+        return false;
+}
+bool isUnboundType(const std::string & tname) {
+        // 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
+        if (std::count(tname.begin(), tname.end(), '_') >= 3) {
+                return true;
+        }
+        return false;
+}
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/Type.h

-              r3c64c668
+              r58fe85a
 };
+bool isUnboundType(const Type * type);
+bool isUnboundType(const std::string & tname);
 // Local Variables: //
 // tab-width: 4 //

src/SynTree/TypeDecl.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Fri Dec 13 15:26:14 2019
 // Update Count     : 21
+// Last Modified On : Thu Oct  8 18:18:55 2020
+// Update Count     : 22
 //
 …
 #include "Type.h"            // for Type, Type::StorageClasses
+TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) : Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
+TypeDecl::TypeDecl( const std::string & name, Type::StorageClasses scs, Type * type, Kind kind, bool sized, Type * init ) :
+        Parent( name, scs, type ), kind( kind ), sized( kind == Ttype || sized ), init( init ) {
+}

src/SynTree/Visitor.h

r3c64c668	r58fe85a
78	78	virtual void visit( FinallyStmt * node ) { visit( const_cast<const FinallyStmt *>(node) ); }
79	79	virtual void visit( const FinallyStmt * finallyStmt ) = 0;
	80	virtual void visit( SuspendStmt * node ) { visit( const_cast<const SuspendStmt *>(node) ); }
	81	virtual void visit( const SuspendStmt * suspendStmt ) = 0;
80	82	virtual void visit( WaitForStmt * node ) { visit( const_cast<const WaitForStmt *>(node) ); }
81	83	virtual void visit( const WaitForStmt * waitforStmt ) = 0;

src/SynTree/module.mk

-              r3c64c668
+              r58fe85a
       SynTree/ApplicationExpr.cc \
       SynTree/ArrayType.cc \
+      SynTree/Attribute.cc \
+      SynTree/Attribute.h \
       SynTree/AttrType.cc \
       SynTree/Attribute.cc \
+      SynTree/BaseSyntaxNode.h \
       SynTree/BasicType.cc \
       SynTree/CommaExpr.cc \
       SynTree/CompoundStmt.cc \
       SynTree/Constant.cc \
+      SynTree/Constant.h \
+      SynTree/Declaration.cc \
+      SynTree/Declaration.h \
+      SynTree/DeclarationWithType.cc \
       SynTree/DeclReplacer.cc \
+      SynTree/DeclReplacer.h \
       SynTree/DeclStmt.cc \
-      SynTree/Declaration.cc \
-      SynTree/DeclarationWithType.cc \
       SynTree/Expression.cc \
+      SynTree/Expression.h \
       SynTree/FunctionDecl.cc \
       SynTree/FunctionType.cc \
       SynTree/Initializer.cc \
+      SynTree/Initializer.h \
+      SynTree/Label.h \
       SynTree/LinkageSpec.cc \
+      SynTree/LinkageSpec.h \
+      SynTree/Mutator.h \
       SynTree/NamedTypeDecl.cc \
       SynTree/ObjectDecl.cc \
 …
       SynTree/ReferenceType.cc \
       SynTree/Statement.cc \
+      SynTree/Statement.h \
+      SynTree/SynTree.h \
       SynTree/TupleExpr.cc \
       SynTree/TupleType.cc \
 …
       SynTree/TypeDecl.cc \
       SynTree/TypeExpr.cc \
+      SynTree/Type.h \
+      SynTree/TypeofType.cc \
       SynTree/TypeSubstitution.cc \
       SynTree/TypeofType.cc \
+      SynTree/TypeSubstitution.h \
       SynTree/VarArgsType.cc \
+      SynTree/Visitor.h \
       SynTree/VoidType.cc \
       SynTree/ZeroOneType.cc

src/Tuples/Explode.cc

-              r3c64c668
+              r58fe85a
                         for ( const ast::Expr * expr : tupleExpr->exprs ) {
                                 exprs.emplace_back( applyCast( expr, false ) );
-                                //exprs.emplace_back( ast::ptr< ast::Expr >( applyCast( expr, false ) ) );
+                        }
                         if ( first ) {
 …
+        }
         const ast::Expr * postmutate( const ast::UniqueExpr * node ) {
+        const ast::Expr * postvisit( const ast::UniqueExpr * node ) {
                 // move cast into unique expr so that the unique expr has type T& rather than
                 // type T. In particular, this transformation helps with generating the
 …
                         castAdded = false;
                         const ast::Type * newType = getReferenceBase( newNode->result );
                         return new ast::CastExpr{ newNode->location, node, newType };
+                        return new ast::CastExpr{ newNode->location, newNode, newType };
+                }
                 return newNode;
+        }
         const ast::Expr * postmutate( const ast::TupleIndexExpr * tupleExpr ) {
+        const ast::Expr * postvisit( const ast::TupleIndexExpr * tupleExpr ) {
                 // tuple index expr needs to be rebuilt to ensure that the type of the
                 // field is consistent with the type of the tuple expr, since the field
 …
         ast::Pass<CastExploderCore> exploder;
         expr = expr->accept( exploder );
         if ( ! exploder.pass.foundUniqueExpr ) {
+        if ( ! exploder.core.foundUniqueExpr ) {
                 expr = new ast::CastExpr{ expr, new ast::ReferenceType{ expr->result } };
+        }

src/Tuples/Explode.h

r3c64c668	r58fe85a
210	210	}
211	211	// Cast a reference away to a value-type to allow further explosion.
212		if ( ~~dynamic_cast< const ast::ReferenceType *>( local->result.get()~~ ) ) {
	212	if ( local->result.as< ast::ReferenceType >() ) {
213	213	local = new ast::CastExpr{ local, tupleType };
214	214	}
…	…
220	220	// delete idx;
221	221	}
222		~~// delete local;~~
223	222	}
224	223	} else {

src/Tuples/TupleAssignment.cc

-              r3c64c668
+              r58fe85a
                                         // resolve ctor/dtor for the new object
                                         ast::ptr< ast::Init > ctorInit = ResolvExpr::resolveCtorInit(
                                                         InitTweak::genCtorInit( location, ret ), spotter.crntFinder.symtab );
+                                                        InitTweak::genCtorInit( location, ret ), spotter.crntFinder.localSyms );
                                         // remove environments from subexpressions of stmtExpr
                                         ast::Pass< EnvRemover > rm{ env };
 …
                                         // resolve the cast expression so that rhsCand return type is bound by the cast
                                         // type as needed, and transfer the resulting environment
                                         ResolvExpr::CandidateFinder finder{ spotter.crntFinder.symtab, env };
+                                        ResolvExpr::CandidateFinder finder{ spotter.crntFinder.localSyms, env };
                                         finder.find( rhsCand->expr, ResolvExpr::ResolvMode::withAdjustment() );
                                         assert( finder.candidates.size() == 1 );
 …
                                         // explode the LHS so that each field of a tuple-valued expr is assigned
                                         ResolvExpr::CandidateList lhs;
                                         explode( *lhsCand, crntFinder.symtab, back_inserter(lhs), true );
+                                        explode( *lhsCand, crntFinder.localSyms, back_inserter(lhs), true );
                                         for ( ResolvExpr::CandidateRef & cand : lhs ) {
                                                 // each LHS value must be a reference - some come in with a cast, if not
 …
                                                         if ( isTuple( rhsCand->expr ) ) {
                                                                 // multiple assignment
                                                                 explode( *rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                                explode( *rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                                 matcher.reset(
                                                                         new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
 …
                                                         // multiple assignment
                                                         ResolvExpr::CandidateList rhs;
                                                         explode( rhsCand, crntFinder.symtab, back_inserter(rhs), true );
+                                                        explode( rhsCand, crntFinder.localSyms, back_inserter(rhs), true );
                                                         matcher.reset(
                                                                 new MultipleAssignMatcher{ *this, expr->location, lhs, rhs } );
 …
+                                )
                                 ResolvExpr::CandidateFinder finder{ crntFinder.symtab, matcher->env };
+                                ResolvExpr::CandidateFinder finder{ crntFinder.localSyms, matcher->env };
                                 try {

src/Tuples/TupleExpansion.cc

r3c64c668	r58fe85a
323	323	std::vector<ast::ptr<ast::Type>> types;
324	324	ast::CV::Qualifiers quals{
325		ast::CV::Const \| ast::CV::Volatile \| ast::CV::Restrict \| ~~ast::CV::Lvalue \|~~
	325	ast::CV::Const \| ast::CV::Volatile \| ast::CV::Restrict \|
326	326	ast::CV::Atomic \| ast::CV::Mutex };
327	327

src/Tuples/Tuples.cc

-              r3c64c668
+              r58fe85a
         };
         struct ImpurityDetectorIgnoreUnique : public ImpurityDetector {
+                using ImpurityDetector::previsit;
                 void previsit( ast::UniqueExpr const * ) {
                         visit_children = false;
 …
                 ast::Pass<Detector> detector;
                 expr->accept( detector );
                 return detector.pass.maybeImpure;
+                return detector.core.maybeImpure;
+        }
 } // namespace

src/Tuples/module.mk

-              r3c64c668
+              r58fe85a
 ###############################################################################
+SRC += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc \
+        Tuples/Tuples.cc
+SRCDEMANGLE += Tuples/TupleAssignment.cc Tuples/TupleExpansion.cc Tuples/Explode.cc \
+        Tuples/Tuples.cc
+SRC_TUPLES = \
+        Tuples/Explode.cc \
+        Tuples/Explode.h \
+        Tuples/TupleAssignment.cc \
+        Tuples/TupleExpansion.cc \
+        Tuples/Tuples.cc \
+        Tuples/Tuples.h
+SRC += $(SRC_TUPLES)
+SRCDEMANGLE += $(SRC_TUPLES)

src/Validate/module.mk

r3c64c668	r58fe85a
15	15	###############################################################################
16	16
17		SRC += Validate/HandleAttributes.cc Validate/~~FindSpecialDecls.cc~~
18		SRCDEMANGLE += Validate/HandleAttributes.cc Validate/~~FindSpecialDecls.cc~~
	17	SRC += Validate/HandleAttributes.cc Validate/HandleAttributes.h Validate/FindSpecialDecls.cc Validate/FindSpecialDecls.h
	18	SRCDEMANGLE += Validate/HandleAttributes.cc Validate/HandleAttributes.h Validate/FindSpecialDecls.cc Validate/FindSpecialDecls.h

src/Virtual/ExpandCasts.cc

-              r3c64c668
+              r58fe85a
 // Created On       : Mon Jul 24 13:59:00 2017
 // Last Modified By : Andrew Beach
 // Last Modified On : Tus Aug  2 14:59:00 2017
 // Update Count     : 1
+// Last Modified On : Fri Jul 31 10:29:00 2020
+// Update Count     : 4
 //
 …
 #include <cassert>                 // for assert, assertf
 #include <iterator>                // for back_inserter, inserter
-#include <map>                     // for map, _Rb_tree_iterator, map<>::ite...
 #include <string>                  // for string, allocator, operator==, ope...
-#include <utility>                 // for pair
 #include "Common/PassVisitor.h"    // for PassVisitor
+#include "Common/ScopedMap.h"      // for ScopedMap
 #include "Common/SemanticError.h"  // for SemanticError
+#include "SymTab/Mangler.h"        // for mangleType
 #include "SynTree/Declaration.h"   // for ObjectDecl, StructDecl, FunctionDecl
 #include "SynTree/Expression.h"    // for VirtualCastExpr, CastExpr, Address...
 …
 namespace Virtual {
+        // Indented until the new ast code gets added.
+        /// Maps virtual table types the instance for that type.
+        class VirtualTableMap final {
+                ScopedMap<std::string, ObjectDecl *> vtable_instances;
+        public:
+                void enterScope() {
+                        vtable_instances.beginScope();
+                }
+                void leaveScope() {
+                        vtable_instances.endScope();
+                }
+                ObjectDecl * insert( ObjectDecl * vtableDecl ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableDecl->type );
+                        ObjectDecl *& value = vtable_instances[ mangledName ];
+                        if ( value ) {
+                                if ( vtableDecl->storageClasses.is_extern ) {
+                                        return nullptr;
+                                } else if ( ! value->storageClasses.is_extern ) {
+                                        return value;
+                                }
+                        }
+                        value = vtableDecl;
+                        return nullptr;
+                }
+                ObjectDecl * lookup( const Type * vtableType ) {
+                        std::string const & mangledName = SymTab::Mangler::mangleType( vtableType );
+                        const auto it = vtable_instances.find( mangledName );
+                        return ( vtable_instances.end() == it ) ? nullptr : it->second;
+                }
+        };
         /* Currently virtual depends on the rather brittle name matching between
 …
          */
+        namespace {
         std::string get_vtable_name( std::string const & name ) {
                 return name + "_vtable";
 …
         std::string get_vtable_inst_name_root( std::string const & name ) {
                 return get_vtable_name_root( name.substr(1, name.size() - 10 ) );
+        }
-        bool is_vtable_name( std::string const & name ) {
-                return (name.substr( name.size() - 7 ) == "_vtable" );
+        }
 …
+        }
+        } // namespace
         class VirtualCastCore {
-        std::map<std::string, ObjectDecl *> vtable_instances;
-        FunctionDecl *vcast_decl;
-        StructDecl *pvt_decl;
                 Type * pointer_to_pvt(int level_of_indirection) {
                         Type * type = new StructInstType(
 …
         public:
                 VirtualCastCore() :
                         vtable_instances(), vcast_decl( nullptr ), pvt_decl( nullptr )
+                        indexer(), vcast_decl( nullptr ), pvt_decl( nullptr )
                 {}
 …
                 Expression * postmutate( VirtualCastExpr * castExpr );
+                VirtualTableMap indexer;
+        private:
+                FunctionDecl *vcast_decl;
+                StructDecl *pvt_decl;
         };
 …
         void VirtualCastCore::premutate( ObjectDecl * objectDecl ) {
                 if ( is_vtable_inst_name( objectDecl->get_name() ) ) {
+                        vtable_instances[objectDecl->get_name()] = objectDecl;
+                }
+        }
+                        if ( ObjectDecl * existing = indexer.insert( objectDecl ) ) {
+                                std::string msg = "Repeated instance of virtual table, original found at: ";
+                                msg += existing->location.filename;
+                                msg += ":" + toString( existing->location.first_line );
+                                SemanticError( objectDecl->location, msg );
+                        }
+                }
+        }
+        namespace {
+        /// Better error locations for generated casts.
+        CodeLocation castLocation( const VirtualCastExpr * castExpr ) {
+                if ( castExpr->location.isSet() ) {
+                        return castExpr->location;
+                } else if ( castExpr->arg->location.isSet() ) {
+                        return castExpr->arg->location;
+                } else if ( castExpr->result->location.isSet() ) {
+                        return castExpr->result->location;
+                } else {
+                        return CodeLocation();
+                }
+        }
+        [[noreturn]] void castError( const VirtualCastExpr * castExpr, std::string const & message ) {
+                SemanticError( castLocation( castExpr ), message );
+        }
+        /// Get the virtual table type used in a virtual cast.
+        Type * getVirtualTableType( const VirtualCastExpr * castExpr ) {
+                const Type * objectType;
+                if ( auto target = dynamic_cast<const PointerType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else if ( auto target = dynamic_cast<const ReferenceType *>( castExpr->result ) ) {
+                        objectType = target->base;
+                } else {
+                        castError( castExpr, "Virtual cast type must be a pointer or reference type." );
+                }
+                assert( objectType );
+                const StructInstType * structType = dynamic_cast<const StructInstType *>( objectType );
+                if ( nullptr == structType ) {
+                        castError( castExpr, "Virtual cast type must refer to a structure type." );
+                }
+                const StructDecl * structDecl = structType->baseStruct;
+                assert( structDecl );
+                const ObjectDecl * fieldDecl = nullptr;
+                if ( 0 < structDecl->members.size() ) {
+                        const Declaration * memberDecl = structDecl->members.front();
+                        assert( memberDecl );
+                        fieldDecl = dynamic_cast<const ObjectDecl *>( memberDecl );
+                        if ( fieldDecl && fieldDecl->name != "virtual_table" ) {
+                                fieldDecl = nullptr;
+                        }
+                }
+                if ( nullptr == fieldDecl ) {
+                        castError( castExpr, "Virtual cast type must have a leading virtual_table field." );
+                }
+                const PointerType * fieldType = dynamic_cast<const PointerType *>( fieldDecl->type );
+                if ( nullptr == fieldType ) {
+                        castError( castExpr, "Virtual cast type virtual_table field is not a pointer." );
+                }
+                assert( fieldType->base );
+                auto virtualStructType = dynamic_cast<const StructInstType *>( fieldType->base );
+                assert( virtualStructType );
+                // Here is the type, but if it is polymorphic it will have lost information.
+                // (Always a clone so that it may always be deleted.)
+                StructInstType * virtualType = virtualStructType->clone();
+                if ( ! structType->parameters.empty() ) {
+                        deleteAll( virtualType->parameters );
+                        virtualType->parameters.clear();
+                        cloneAll( structType->parameters, virtualType->parameters );
+                }
+                return virtualType;
+        }
+        } // namespace
         Expression * VirtualCastCore::postmutate( VirtualCastExpr * castExpr ) {
                 assertf( castExpr->get_result(), "Virtual Cast target not found before expansion." );
+                assertf( castExpr->result, "Virtual Cast target not found before expansion." );
                 assert( vcast_decl );
                 assert( pvt_decl );
+                // May only cast to a pointer or reference type.
+                // A earlier validation should give a syntax error, this is
+                // just to make sure errors don't creep during translation.
+                // Move to helper with more detailed error messages.
+                PointerType * target_type =
+                        dynamic_cast<PointerType *>( castExpr->get_result() );
+                assert( target_type );
+                StructInstType * target_struct =
+                        dynamic_cast<StructInstType *>( target_type->get_base() );
+                assert( target_struct );
+                StructDecl * target_decl = target_struct->get_baseStruct();
+                std::map<std::string, ObjectDecl *>::iterator found =
+                        vtable_instances.find(
+                                get_vtable_inst_name( target_decl->get_name() ) );
+                if ( vtable_instances.end() == found ) {
+                        assertf( false, "virtual table instance not found." );
+                }
+                ObjectDecl * table = found->second;
+                const Type * vtable_type = getVirtualTableType( castExpr );
+                ObjectDecl * table = indexer.lookup( vtable_type );
+                if ( nullptr == table ) {
+                        SemanticError( castLocation( castExpr ),
+                                "Could not find virtual table instance." );
+                }
                 Expression * result = new CastExpr(
-                        //new ApplicationExpr(
-                                //new AddressExpr( new VariableExpr( vcast_decl ) ),
-                                //new CastExpr( new VariableExpr( vcast_decl ),
-                                //      new PointerType( noQualifiers,
-                                //              vcast_decl->get_type()->clone()
-                                //              )
-                                //      ),
                         new ApplicationExpr( VariableExpr::functionPointer( vcast_decl ), {
                                         new CastExpr(
 …
                 castExpr->set_result( nullptr );
                 delete castExpr;
+                delete vtable_type;
                 return result;
+        }

src/Virtual/module.mk

-              r3c64c668
+              r58fe85a
 ###############################################################################
+SRC += Virtual/ExpandCasts.cc
+SRC += Virtual/ExpandCasts.cc Virtual/ExpandCasts.h \
+        Virtual/Tables.cc Virtual/Tables.h
+SRCDEMANGLE += Virtual/Tables.cc

src/config.h.in

-              r3c64c668
+              r58fe85a
 /* Location of cfa install. */
 #undef CFA_PREFIX
+/* Sets whether or not to use the new-ast, this is adefault value and can be
+   overrided by --old-ast and --new-ast */
+#undef CFA_USE_NEW_AST
 /* Major.Minor */

src/main.cc

-              r3c64c668
+              r58fe85a
 // Author           : Peter Buhr and Rob Schluntz
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Sat Feb  8 08:33:50 2020
 // Update Count     : 633
+// Last Modified By : Andrew Beach
+// Last Modified On : Mon Dec  7 15:29:00 2020
+// Update Count     : 639
 //
 …
 using namespace std;
+#include "AST/Convert.hpp"
 #include "CompilationState.h"
 #include "../config.h"                      // for CFA_LIBDIR
 …
 #include "CodeTools/ResolvProtoDump.h"      // for dumpAsResolvProto
 #include "CodeTools/TrackLoc.h"             // for fillLocations
+#include "Common/CodeLocationTools.hpp"     // for forceFillCodeLocations
 #include "Common/CompilerError.h"           // for CompilerError
 #include "Common/Stats.h"
 …
                 } // if
+                PASS( "Translate Throws", ControlStruct::translateThrows( translationUnit ) );
                 PASS( "Fix Labels", ControlStruct::fixLabels( translationUnit ) );
                 PASS( "Fix Names", CodeGen::fixNames( translationUnit ) );
 …
                 } // if
+                PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                if ( exprp ) {
+                        dump( translationUnit );
+                        return EXIT_SUCCESS;
+                } // if
+                if( useNewAST ) {
+                        if (Stats::Counters::enabled) {
+                                ast::pass_visitor_stats.avg = Stats::Counters::build<Stats::Counters::AverageCounter<double>>("Average Depth - New");
+                                ast::pass_visitor_stats.max = Stats::Counters::build<Stats::Counters::MaxCounter<double>>("Max depth - New");
+                        }
+                        auto transUnit = convert( move( translationUnit ) );
+                        PASS( "Resolve", ResolvExpr::resolve( transUnit ) );
+                        if ( exprp ) {
+                                translationUnit = convert( move( transUnit ) );
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        } // if
+                        forceFillCodeLocations( transUnit );
+                        PASS( "Fix Init", InitTweak::fix(transUnit, buildingLibrary()));
+                        translationUnit = convert( move( transUnit ) );
+                } else {
+                        PASS( "Resolve", ResolvExpr::resolve( translationUnit ) );
+                        if ( exprp ) {
+                                dump( translationUnit );
+                                return EXIT_SUCCESS;
+                        }
+                        PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
+                }
                 // fix ObjectDecl - replaces ConstructorInit nodes
-                PASS( "Fix Init", InitTweak::fix( translationUnit, buildingLibrary() ) );
                 if ( ctorinitp ) {
                         dump ( translationUnit );
 …
                 PASS( "Expand Unique Expr", Tuples::expandUniqueExpr( translationUnit ) ); // xxx - is this the right place for this? want to expand ASAP so tha, sequent passes don't need to worry about double-visiting a unique expr - needs to go after InitTweak::fix so that copy constructed return declarations are reused
                 PASS( "Translate EHM" , ControlStruct::translateEHM( translationUnit ) );
+                PASS( "Translate Tries" , ControlStruct::translateTries( translationUnit ) );
                 PASS( "Gen Waitfor" , Concurrency::generateWaitFor( translationUnit ) );
 …
 static const char optstring[] = ":c:ghlLmNnpP:S:twW:D:";
+static const char optstring[] = ":c:ghlLmNnpdOAP:S:twW:D:";
 enum { PreludeDir = 128 };
 …
         { "no-prelude", no_argument, nullptr, 'n' },
         { "prototypes", no_argument, nullptr, 'p' },
+        { "deterministic-out", no_argument, nullptr, 'd' },
+        { "old-ast", no_argument, nullptr, 'O'},
+        { "new-ast", no_argument, nullptr, 'A'},
         { "print", required_argument, nullptr, 'P' },
         { "prelude-dir", required_argument, nullptr, PreludeDir },
 …
 static const char * description[] = {
         "diagnostic color: never, always, or auto.",          // -c
         "wait for gdb to attach",                             // -g
         "print help message",                                 // -h
         "generate libcfa.c",                                  // -l
         "generate line marks",                                // -L
         "do not replace main",                                // -m
         "do not generate line marks",                         // -N
         "do not read prelude",                                // -n
+        "diagnostic color: never, always, or auto.",            // -c
+        "wait for gdb to attach",                                                       // -g
+        "print help message",                                                           // -h
+        "generate libcfa.c",                                                            // -l
+        "generate line marks",                                                          // -L
+        "do not replace main",                                                          // -m
+        "do not generate line marks",                                           // -N
+        "do not read prelude",                                                          // -n
         "generate prototypes for prelude functions",            // -p
+        "print",                                              // -P
+        "only print deterministic output",                  // -d
+        "Use the old-ast",                                                                      // -O
+        "Use the new-ast",                                                                      // -A
+        "print",                                                                                        // -P
         "<directory> prelude directory for debug/nodebug",      // no flag
         "<option-list> enable profiling information:\n          counters,heap,time,all,none", // -S
         "building cfa standard lib",                          // -t
         "",                                                   // -w
         "",                                                   // -W
         "",                                                   // -D
+        "building cfa standard lib",                                            // -t
+        "",                                                                                                     // -w
+        "",                                                                                                     // -W
+        "",                                                                                                     // -D
 }; // description
 …
                         genproto = true;
                         break;
+                  case 'd':                                     // don't print non-deterministic output
+                        deterministic_output = true;
+                        break;
+                  case 'O':                                     // don't print non-deterministic output
+                        useNewAST = false;
+                        break;
+                  case 'A':                                     // don't print non-deterministic output
+                        useNewAST = true;
+                        break;
                   case 'P':                                                                             // print options
                         for ( int i = 0;; i += 1 ) {

Context Navigation

Legend:

Download in other formats: