Changeset b067d9b for src/SymTab

Timestamp:

Oct 29, 2019, 4:01:24 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

773db65, 9421f3d8

Parents:

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

Message:

Merge branch 'master' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src/SymTab

Files:

• Autogen.cc (modified) (8 diffs)
• Autogen.h (modified) (8 diffs)
• Demangle.cc (added)
• FixFunction.cc (modified) (4 diffs)
• FixFunction.h (modified) (1 diff)
• Indexer.cc (modified) (10 diffs)
• Indexer.h (modified) (3 diffs)
• Mangler.cc (modified) (16 diffs)
• Mangler.h (modified) (1 diff)
• ManglerCommon.cc (added)
• Validate.cc (modified) (48 diffs)
• Validate.h (modified) (2 diffs)
• demangler.cc (added)
• module.mk (modified) (1 diff)

src/SymTab/Autogen.cc

@@ -24 +24 @@
 #include <vector>                  // for vector
 
+#include "AST/Decl.hpp"
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/PassVisitor.h"    // for PassVisitor
@@ -41 +42 @@
 
 namespace SymTab {
-        Type * SizeType = 0;
-
         /// Data used to generate functions generically. Specifically, the name of the generated function and a function which generates the routine protoype
         struct FuncData {
-                typedef FunctionType * (*TypeGen)( Type * );
+                typedef FunctionType * (*TypeGen)( Type *, bool );
                 FuncData( const std::string & fname, const TypeGen & genType ) : fname( fname ), genType( genType ) {}
                 std::string fname;
@@ -211 +210 @@
         }
 
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj ) {
+                return obj && obj->name.empty() && obj->bitfieldWidth;
+        }
+
         /// inserts a forward declaration for functionDecl into declsToAdd
         void addForwardDecl( FunctionDecl * functionDecl, std::list< Declaration * > & declsToAdd ) {
@@ -231 +234 @@
 
         /// given type T, generate type of default ctor/dtor, i.e. function type void (*) (T *)
-        FunctionType * genDefaultType( Type * paramType ) {
-                const auto & typeParams = getGenericParams( paramType );
+        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic ) {
                 FunctionType *ftype = new FunctionType( Type::Qualifiers(), false );
-                cloneAll( typeParams, ftype->forall );
+                if ( maybePolymorphic ) {
+                        // only copy in
+                        const auto & typeParams = getGenericParams( paramType );
+                        cloneAll( typeParams, ftype->forall );
+                }
                 ObjectDecl *dstParam = new ObjectDecl( "_dst", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, new ReferenceType( Type::Qualifiers(), paramType->clone() ), nullptr );
                 ftype->parameters.push_back( dstParam );
@@ -241 +247 @@
 
         /// given type T, generate type of copy ctor, i.e. function type void (*) (T *, T)
-        FunctionType * genCopyType( Type * paramType ) {
-                FunctionType *ftype = genDefaultType( paramType );
+        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic ) {
+                FunctionType *ftype = genDefaultType( paramType, maybePolymorphic );
                 ObjectDecl *srcParam = new ObjectDecl( "_src", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->parameters.push_back( srcParam );
@@ -249 +255 @@
 
         /// given type T, generate type of assignment, i.e. function type T (*) (T *, T)
-        FunctionType * genAssignType( Type * paramType ) {
-                FunctionType *ftype = genCopyType( paramType );
+        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic ) {
+                FunctionType *ftype = genCopyType( paramType, maybePolymorphic );
                 ObjectDecl *returnVal = new ObjectDecl( "_ret", Type::StorageClasses(), LinkageSpec::Cforall, nullptr, paramType->clone(), nullptr );
                 ftype->returnVals.push_back( returnVal );
@@ -308 +314 @@
                 for ( const FuncData & d : data ) {
                         // generate a function (?{}, ?=?, ^?{}) based on the current FuncData.
-                        FunctionType * ftype = d.genType( type );
+                        FunctionType * ftype = d.genType( type, true );
 
                         // destructor for concurrent type must be mutex
@@ -387 +393 @@
 
         void StructFuncGenerator::makeMemberOp( ObjectDecl * dstParam, Expression * src, DeclarationWithType * field, FunctionDecl * func, bool forward ) {
-                InitTweak::InitExpander srcParam( src );
+                InitTweak::InitExpander_old srcParam( src );
 
                 // assign to destination

src/SymTab/Autogen.h

@@ -17 +17 @@
 
 #include <cassert>                // for assert
+#include <iterator>               // for back_inserter
 #include <string>                 // for string
 
+#include "AST/Decl.hpp"
+#include "AST/Expr.hpp"
+#include "AST/Init.hpp"
+#include "AST/Node.hpp"
+#include "AST/Stmt.hpp"
+#include "AST/Type.hpp"
 #include "CodeGen/OperatorTable.h"
 #include "Common/UniqueName.h"    // for UniqueName
+#include "Common/utility.h"       // for splice
 #include "InitTweak/InitTweak.h"  // for InitExpander
 #include "SynTree/Constant.h"     // for Constant
@@ -36 +44 @@
         /// returns true if obj's name is the empty string and it has a bitfield width
         bool isUnnamedBitfield( ObjectDecl * obj );
-
-        /// size_t type - set when size_t typedef is seen. Useful in a few places,
-        /// such as in determining array dimension type
-        extern Type * SizeType;
-
-        /// intrinsic dereference operator for unqualified types - set when *? function is seen in FindSpecialDeclarations.
-        /// Useful for creating dereference ApplicationExprs without a full resolver pass.
-        extern FunctionDecl * dereferenceOperator;
-
-        // generate the type of an assignment function for paramType
-        FunctionType * genAssignType( Type * paramType );
-
-        // generate the type of a default constructor or destructor for paramType
-        FunctionType * genDefaultType( Type * paramType );
-
-        // generate the type of a copy constructor for paramType
-        FunctionType * genCopyType( Type * paramType );
+        bool isUnnamedBitfield( const ast::ObjectDecl * obj );
+
+        /// generate the type of an assignment function for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genAssignType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a default constructor or destructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genDefaultType( Type * paramType, bool maybePolymorphic = true );
+
+        /// generate the type of a copy constructor for paramType.
+        /// maybePolymorphic is true if the resulting FunctionType is allowed to be polymorphic
+        FunctionType * genCopyType( Type * paramType, bool maybePolymorphic = true );
+
+        /// Enum for loop direction
+        enum LoopDirection { LoopBackward, LoopForward };
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
+
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward = LoopForward );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
+        Statement * genScalarCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -84 +97 @@
                         //   type->get_qualifiers() = Type::Qualifiers();
                         Type * castType = addCast->clone();
-                        castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
+                        castType->get_qualifiers() -= Type::Qualifiers( Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
                         dstParam = new CastExpr( dstParam, new ReferenceType( Type::Qualifiers(), castType ) );
@@ -111 +124 @@
         }
 
+        /// inserts into out a generated call expression to function fname with arguments dstParam and 
+        /// srcParam. Should only be called with non-array types.
+        /// optionally returns a statement which must be inserted prior to the containing loop, if 
+        /// there is one
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genScalarCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, std::string fname, OutIter && out, const ast::Type * type, 
+                const ast::Type * addCast = nullptr
+        ) {
+                bool isReferenceCtorDtor = false;
+                if ( dynamic_cast< const ast::ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
+                        // reference constructors are essentially application of the rebind operator.
+                        // apply & to both arguments, do not need a cast
+                        fname = "?=?";
+                        dstParam = new ast::AddressExpr{ dstParam };
+                        addCast = nullptr;
+                        isReferenceCtorDtor = true;
+                }
+
+                // want to be able to generate assignment, ctor, and dtor generically, so fname is one of
+                // "?=?", "?{}", or "^?{}"
+                ast::UntypedExpr * fExpr = new ast::UntypedExpr{ loc, new ast::NameExpr{ loc, fname } };
+
+                if ( addCast ) {
+                        // cast to T& with qualifiers removed, so that qualified objects can be constructed and 
+                        // destructed with the same functions as non-qualified objects. Unfortunately, lvalue 
+                        // is considered a qualifier - for AddressExpr to resolve, its argument must have an 
+                        // lvalue-qualified type, so remove all qualifiers except lvalue.
+                        // xxx -- old code actually removed lvalue too...
+                        ast::ptr< ast::Type > guard = addCast;  // prevent castType from mutating addCast
+                        ast::ptr< ast::Type > castType = addCast;
+                        ast::remove_qualifiers( 
+                                castType, 
+                                ast::CV::Const | ast::CV::Volatile | ast::CV::Restrict | ast::CV::Atomic );
+                        dstParam = new ast::CastExpr{ dstParam, new ast::ReferenceType{ castType } };
+                }
+                fExpr->args.emplace_back( dstParam );
+
+                const ast::Stmt * listInit = srcParam.buildListInit( fExpr );
+
+                // fetch next set of arguments
+                ++srcParam;
+
+                // return if adding reference fails -- will happen on default ctor and dtor
+                if ( isReferenceCtorDtor && ! srcParam.addReference() ) return listInit;
+
+                std::vector< ast::ptr< ast::Expr > > args = *srcParam;
+                splice( fExpr->args, args );
+
+                *out++ = new ast::ExprStmt{ loc, fExpr };
+
+                srcParam.clearArrayIndices();
+                
+                return listInit;
+        }
+
         /// Store in out a loop which calls fname on each element of the array with srcParam and dstParam as arguments.
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander_old & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
@@ -175 +245 @@
         }
 
+        /// Store in out a loop which calls fname on each element of the array with srcParam and 
+        /// dstParam as arguments. If forward is true, loop goes from 0 to N-1, else N-1 to 0
+        template< typename OutIter >
+        void genArrayCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::ArrayType * array, const ast::Type * addCast = nullptr, 
+                LoopDirection forward = LoopForward 
+        ) {
+                static UniqueName indexName( "_index" );
+
+                // for a flexible array member nothing is done -- user must define own assignment
+                if ( ! array->dimension ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        addCast = strict_dynamic_cast< const ast::ArrayType * >( addCast )->base;
+                }
+
+                ast::ptr< ast::Expr > begin, end, cmp, update;
+
+                if ( forward ) {
+                        // generate: for ( int i = 0; i < N; ++i )
+                        begin = ast::ConstantExpr::from_int( loc, 0 );
+                        end = array->dimension;
+                        cmp = new ast::NameExpr{ loc, "?<?" };
+                        update = new ast::NameExpr{ loc, "++?" };
+                } 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 ) } };
+                        end = ast::ConstantExpr::from_int( loc, 0 );
+                        cmp = new ast::NameExpr{ loc, "?>=?" };
+                        update = new ast::NameExpr{ loc, "--?" };
+                }
+
+                ast::ptr< ast::DeclWithType > index = new ast::ObjectDecl{ 
+                        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 } } };
+                
+                // 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 );
+
+                // for stmt's body, eventually containing call
+                ast::CompoundStmt * body = new ast::CompoundStmt{ loc };
+                ast::ptr< ast::Stmt > listInit = genCall( 
+                        srcParam, dstIndex, loc, fname, std::back_inserter( body->kids ), array->base, addCast, 
+                        forward );
+                
+                // block containing the stmt and index variable
+                ast::CompoundStmt * block = new ast::CompoundStmt{ loc };
+                block->push_back( new ast::DeclStmt{ loc, index } );
+                if ( listInit ) { block->push_back( listInit ); }
+                block->push_back( new ast::ForStmt{ loc, {}, cond, inc, body } );
+
+                *out++ = block;
+        }
+
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -185 +325 @@
         }
 
+        template< typename OutIter >
+        ast::ptr< ast::Stmt > genCall(
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, OutIter && out, 
+                const ast::Type * type, const ast::Type * addCast, LoopDirection forward
+        ) {
+                if ( auto at = dynamic_cast< const ast::ArrayType * >( type ) ) {
+                        genArrayCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >(out), at, addCast, 
+                                forward );
+                        return {};
+                } else {
+                        return genScalarCall( 
+                                srcParam, dstParam, loc, fname, std::forward< OutIter >( out ), type, addCast );
+                }
+        }
+
         /// inserts into out a generated call expression to function fname with arguments dstParam
         /// and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls. decl is the
@@ -190 +347 @@
         /// ImplicitCtorDtorStmt node.
         template< typename OutputIterator >
-        void genImplicitCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
+        void genImplicitCall( InitTweak::InitExpander_old & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, DeclarationWithType * decl, bool forward = true ) {
                 ObjectDecl *obj = dynamic_cast<ObjectDecl *>( decl );
                 assert( obj );
@@ -218 +375 @@
                 }
         }
+
+        static inline ast::ptr< ast::Stmt > genImplicitCall( 
+                InitTweak::InitExpander_new & srcParam, const ast::Expr * dstParam, 
+                const CodeLocation & loc, const std::string & fname, const ast::ObjectDecl * obj, 
+                LoopDirection forward = LoopForward 
+        ) {
+                // unnamed bit fields are not copied as they cannot be accessed
+                if ( isUnnamedBitfield( obj ) ) return {};
+
+                ast::ptr< ast::Type > addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( ! obj || ( obj && ! obj->bitfieldWidth ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
+
+                std::vector< ast::ptr< ast::Stmt > > stmts;
+                genCall( 
+                        srcParam, dstParam, loc, fname, back_inserter( stmts ), obj->type, addCast, forward );
+
+                if ( stmts.empty() ) {
+                        return {};
+                } else if ( stmts.size() == 1 ) {
+                        const ast::Stmt * callStmt = stmts.front();
+                        if ( addCast ) {
+                                // implicitly generated ctor/dtor calls should be wrapped so that later passes are 
+                                // aware they were generated.
+                                callStmt = new ast::ImplicitCtorDtorStmt{ callStmt->location, callStmt };
+                        }
+                        return callStmt;
+                } else {
+                        assert( false );
+                        return {};
+                }
+        }
 } // namespace SymTab
 

src/SymTab/FixFunction.cc

@@ -18 +18 @@
 #include <list>                   // for list
 
-#include "Common/utility.h"       // for maybeClone
+#include "AST/Decl.hpp"
+#include "AST/Pass.hpp"
+#include "AST/Type.hpp"
+#include "Common/utility.h"       // for maybeClone, copy
 #include "SynTree/Declaration.h"  // for FunctionDecl, ObjectDecl, Declarati...
 #include "SynTree/Expression.h"   // for Expression
@@ -24 +27 @@
 
 namespace SymTab {
-        FixFunction::FixFunction() : isVoid( false ) {}
+        class FixFunction_old : public WithShortCircuiting {
+                typedef Mutator Parent;
+          public:
+                FixFunction_old() : isVoid( false ) {}
 
+                void premutate(FunctionDecl *functionDecl);
+                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
 
-        DeclarationWithType * FixFunction::postmutate(FunctionDecl *functionDecl) {
+                Type * postmutate(ArrayType * arrayType);
+
+                void premutate(ArrayType * arrayType);
+                void premutate(VoidType * voidType);
+                void premutate(BasicType * basicType);
+                void premutate(PointerType * pointerType);
+                void premutate(StructInstType * aggregateUseType);
+                void premutate(UnionInstType * aggregateUseType);
+                void premutate(EnumInstType * aggregateUseType);
+                void premutate(TraitInstType * aggregateUseType);
+                void premutate(TypeInstType * aggregateUseType);
+                void premutate(TupleType * tupleType);
+                void premutate(VarArgsType * varArgsType);
+                void premutate(ZeroType * zeroType);
+                void premutate(OneType * oneType);
+
+                bool isVoid;
+        };
+
+        DeclarationWithType * FixFunction_old::postmutate(FunctionDecl *functionDecl) {
                 // can't delete function type because it may contain assertions, so transfer ownership to new object
                 ObjectDecl *pointer = new ObjectDecl( functionDecl->name, functionDecl->get_storageClasses(), functionDecl->linkage, nullptr, new PointerType( Type::Qualifiers(), functionDecl->type ), nullptr, functionDecl->attributes );
+                pointer->location = functionDecl->location;
                 functionDecl->attributes.clear();
                 functionDecl->type = nullptr;
@@ -40 +68 @@
         // does not cause an error
 
-        Type * FixFunction::postmutate(ArrayType *arrayType) {
+        Type * FixFunction_old::postmutate(ArrayType *arrayType) {
                 // need to recursively mutate the base type in order for multi-dimensional arrays to work.
                 PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->isVarLen, arrayType->isStatic );
+                pointerType->location = arrayType->location;
                 arrayType->base = nullptr;
                 arrayType->dimension = nullptr;
@@ -49 +78 @@
         }
 
-        void FixFunction::premutate(VoidType *) {
+        void FixFunction_old::premutate(VoidType *) {
                 isVoid = true;
         }
 
-        void FixFunction::premutate(FunctionDecl *) { visit_children = false; }
-        void FixFunction::premutate(ArrayType *) { visit_children = false; }
-        void FixFunction::premutate(BasicType *) { visit_children = false; }
-        void FixFunction::premutate(PointerType *) { visit_children = false; }
-        void FixFunction::premutate(StructInstType *) { visit_children = false; }
-        void FixFunction::premutate(UnionInstType *) { visit_children = false; }
-        void FixFunction::premutate(EnumInstType *) { visit_children = false; }
-        void FixFunction::premutate(TraitInstType *) { visit_children = false; }
-        void FixFunction::premutate(TypeInstType *) { visit_children = false; }
-        void FixFunction::premutate(TupleType *) { visit_children = false; }
-        void FixFunction::premutate(VarArgsType *) { visit_children = false; }
-        void FixFunction::premutate(ZeroType *) { visit_children = false; }
-        void FixFunction::premutate(OneType *) { visit_children = false; }
+        void FixFunction_old::premutate(FunctionDecl *) { visit_children = false; }
+        void FixFunction_old::premutate(ArrayType *) { visit_children = false; }
+        void FixFunction_old::premutate(BasicType *) { visit_children = false; }
+        void FixFunction_old::premutate(PointerType *) { visit_children = false; }
+        void FixFunction_old::premutate(StructInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(UnionInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(EnumInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TraitInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TypeInstType *) { visit_children = false; }
+        void FixFunction_old::premutate(TupleType *) { visit_children = false; }
+        void FixFunction_old::premutate(VarArgsType *) { visit_children = false; }
+        void FixFunction_old::premutate(ZeroType *) { visit_children = false; }
+        void FixFunction_old::premutate(OneType *) { visit_children = false; }
 
         bool fixFunction( DeclarationWithType *& dwt ) {
-                PassVisitor<FixFunction> fixer;
+                PassVisitor<FixFunction_old> fixer;
                 dwt = dwt->acceptMutator( fixer );
                 return fixer.pass.isVoid;
         }
+
+namespace {
+        struct FixFunction_new final : public ast::WithShortCircuiting {
+                bool isVoid = false;
+
+                void premutate( const ast::FunctionDecl * ) { visit_children = false; }
+
+                const ast::DeclWithType * postmutate( const ast::FunctionDecl * func ) {
+                        return new ast::ObjectDecl{ 
+                                func->location, func->name, new ast::PointerType{ func->type }, nullptr, 
+                                func->storage, func->linkage, nullptr, copy( func->attributes ) };
+                }
+
+                void premutate( const ast::ArrayType * ) { visit_children = false; }
+
+                const ast::Type * postmutate( const ast::ArrayType * array ) {
+                        return new ast::PointerType{ 
+                                array->base, array->dimension, array->isVarLen, array->isStatic, 
+                                array->qualifiers };
+                }
+
+                void premutate( 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; }
+        };
+} // anonymous namespace
+
+const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid ) {
+        ast::Pass< FixFunction_new > fixer;
+        dwt = dwt->accept( fixer );
+        isVoid |= fixer.pass.isVoid;
+        return dwt;
+}
+
 } // namespace SymTab
 

src/SymTab/FixFunction.h

@@ -19 +19 @@
 #include "SynTree/SynTree.h"    // for Types
 
+namespace ast {
+        class DeclWithType;
+}
+
 namespace SymTab {
-        /// Replaces function and array types by equivalent pointer types.
-        class FixFunction : public WithShortCircuiting {
-                typedef Mutator Parent;
-          public:
-                FixFunction();
+        /// Replaces function and array types by equivalent pointer types. Returns true if type is 
+        /// void
+        bool fixFunction( DeclarationWithType *& );
 
-                void premutate(FunctionDecl *functionDecl);
-                DeclarationWithType* postmutate(FunctionDecl *functionDecl);
-
-                Type * postmutate(ArrayType * arrayType);
-
-                void premutate(ArrayType * arrayType);
-                void premutate(VoidType * voidType);
-                void premutate(BasicType * basicType);
-                void premutate(PointerType * pointerType);
-                void premutate(StructInstType * aggregateUseType);
-                void premutate(UnionInstType * aggregateUseType);
-                void premutate(EnumInstType * aggregateUseType);
-                void premutate(TraitInstType * aggregateUseType);
-                void premutate(TypeInstType * aggregateUseType);
-                void premutate(TupleType * tupleType);
-                void premutate(VarArgsType * varArgsType);
-                void premutate(ZeroType * zeroType);
-                void premutate(OneType * oneType);
-
-                bool isVoid;
-        };
-
-        bool fixFunction( DeclarationWithType *& );
+        /// Returns declaration with function and array types replaced by equivalent pointer types.
+        /// Sets isVoid to true if type is void
+        const ast::DeclWithType * fixFunction( const ast::DeclWithType * dwt, bool & isVoid );
 } // namespace SymTab
 

src/SymTab/Indexer.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:37:33 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 16:08:40 2017
-// Update Count     : 20
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 21
 //
 
@@ -17 +17 @@
 
 #include <cassert>                 // for assert, strict_dynamic_cast
-#include <iostream>                // for operator<<, basic_ostream, ostream
 #include <string>                  // for string, operator<<, operator!=
+#include <memory>                  // for shared_ptr, make_shared
 #include <unordered_map>           // for operator!=, unordered_map<>::const...
 #include <unordered_set>           // for unordered_set
 #include <utility>                 // for pair, make_pair, move
+#include <vector>                  // for vector
 
 #include "CodeGen/OperatorTable.h" // for isCtorDtor, isCtorDtorAssign
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/utility.h"        // for cloneAll
-#include "GenPoly/GenPoly.h"
+#include "Common/Stats/Counter.h"  // for counters
+#include "GenPoly/GenPoly.h"       // for getFunctionType
 #include "InitTweak/InitTweak.h"   // for isConstructor, isCopyFunction, isC...
 #include "Mangler.h"               // for Mangler
@@ -38 +40 @@
 #include "SynTree/Type.h"          // for Type, StructInstType, UnionInstType
 
-#define debugPrint(x) if ( doDebug ) { std::cerr << x; }
-
 namespace SymTab {
-        std::ostream & operator<<( std::ostream & out, const Indexer::IdData & data ) {
-                return out << "(" << data.id << "," << data.baseExpr << ")";
-        }
-
-        typedef std::unordered_map< std::string, Indexer::IdData > MangleTable;
-        typedef std::unordered_map< std::string, MangleTable > IdTable;
-        typedef std::unordered_map< std::string, NamedTypeDecl* > TypeTable;
-        typedef std::unordered_map< std::string, StructDecl* > StructTable;
-        typedef std::unordered_map< std::string, EnumDecl* > EnumTable;
-        typedef std::unordered_map< std::string, UnionDecl* > UnionTable;
-        typedef std::unordered_map< std::string, TraitDecl* > TraitTable;
-
-        void dump( const IdTable &table, std::ostream &os ) {
-                for ( IdTable::const_iterator id = table.begin(); id != table.end(); ++id ) {
-                        for ( MangleTable::const_iterator mangle = id->second.begin(); mangle != id->second.end(); ++mangle ) {
-                                os << mangle->second << std::endl;
-                        }
-                }
-        }
-
-        template< typename Decl >
-        void dump( const std::unordered_map< std::string, Decl* > &table, std::ostream &os ) {
-                for ( typename std::unordered_map< std::string, Decl* >::const_iterator it = table.begin(); it != table.end(); ++it ) {
-                        os << it->second << std::endl;
-                } // for
-        }
-
-        struct Indexer::Impl {
-                Impl( unsigned long _scope ) : refCount(1), scope( _scope ), size( 0 ), base(),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                Impl( unsigned long _scope, Indexer &&_base ) : refCount(1), scope( _scope ), size( 0 ), base( _base ),
-                                idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable() {}
-                unsigned long refCount;   ///< Number of references to these tables
-                unsigned long scope;      ///< Scope these tables are associated with
-                unsigned long size;       ///< Number of elements stored in this table
-                const Indexer base;       ///< Base indexer this extends
-
-                IdTable idTable;          ///< Identifier namespace
-                TypeTable typeTable;      ///< Type namespace
-                StructTable structTable;  ///< Struct namespace
-                EnumTable enumTable;      ///< Enum namespace
-                UnionTable unionTable;    ///< Union namespace
-                TraitTable traitTable;    ///< Trait namespace
-        };
-
-        Indexer::Impl *Indexer::newRef( Indexer::Impl *toClone ) {
-                if ( ! toClone ) return 0;
-
-                // shorten the search chain by skipping empty links
-                Indexer::Impl *ret = toClone->size == 0 ? toClone->base.tables : toClone;
-                if ( ret ) { ++ret->refCount; }
-
-                return ret;
-        }
-
-        void Indexer::deleteRef( Indexer::Impl *toFree ) {
-                if ( ! toFree ) return;
-
-                if ( --toFree->refCount == 0 ) delete toFree;
-        }
-
-        void Indexer::removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const {
-                // only need to perform this step for constructors, destructors, and assignment functions
-                if ( ! CodeGen::isCtorDtorAssign( id ) ) return;
-
-                // helpful data structure to organize properties for a type
-                struct ValueType {
-                        struct DeclBall { // properties for this particular decl
-                                IdData decl;
-                                bool isUserDefinedFunc;
-                                bool isCopyFunc;
+
+        // Statistics block
+        namespace {
+                static inline auto stats() {
+                        using namespace Stats::Counters;
+                        static auto group   = build<CounterGroup>("Indexers");
+                        static struct {
+                                SimpleCounter * count;
+                                AverageCounter<double> * size;
+                                SimpleCounter * new_scopes;
+                                SimpleCounter * lazy_scopes;
+                                AverageCounter<double> * avg_scope_depth;
+                                MaxCounter<size_t> * max_scope_depth;
+                                SimpleCounter * add_calls;
+                                SimpleCounter * lookup_calls;
+                                SimpleCounter * map_lookups;
+                                SimpleCounter * map_mutations;
+                        } ret = {
+                                .count   = build<SimpleCounter>("Count", group),
+                                .size    = build<AverageCounter<double>>("Average Size", group),
+                                .new_scopes = build<SimpleCounter>("Scopes", group),
+                                .lazy_scopes = build<SimpleCounter>("Lazy Scopes", group),
+                                .avg_scope_depth = build<AverageCounter<double>>("Average Scope", group),
+                                .max_scope_depth = build<MaxCounter<size_t>>("Max Scope", group),
+                                .add_calls = build<SimpleCounter>("Add Calls", group),
+                                .lookup_calls = build<SimpleCounter>("Lookup Calls", group),
+                                .map_lookups = build<SimpleCounter>("Map Lookups", group),
+                                .map_mutations = build<SimpleCounter>("Map Mutations", group)
                         };
-                        // properties for this type
-                        bool existsUserDefinedCopyFunc = false;    // user-defined copy ctor found
-                        BaseSyntaxNode * deleteStmt = nullptr;     // non-null if a user-defined function is found
-                        std::list< DeclBall > decls;
-
-                        // another FunctionDecl for the current type was found - determine
-                        // if it has special properties and update data structure accordingly
-                        ValueType & operator+=( IdData data ) {
-                                DeclarationWithType * function = data.id;
-                                bool isUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
-                                bool isCopyFunc = InitTweak::isCopyFunction( function, function->name );
-                                decls.push_back( DeclBall{ data, isUserDefinedFunc, isCopyFunc } );
-                                existsUserDefinedCopyFunc = existsUserDefinedCopyFunc || (isUserDefinedFunc && isCopyFunc);
-                                if ( isUserDefinedFunc && ! data.deleteStmt ) {
-                                        // any user-defined function can act as an implicit delete statement for generated constructors.
-                                        // a delete stmt should not act as an implicit delete statement.
-                                        deleteStmt = data.id;
-                                }
-                                return *this;
-                        }
-                }; // ValueType
-
-                std::list< IdData > copy;
-                copy.splice( copy.end(), out );
-
-                // organize discovered declarations by type
-                std::unordered_map< std::string, ValueType > funcMap;
-                for ( auto decl : copy ) {
-                        if ( FunctionDecl * function = dynamic_cast< FunctionDecl * >( decl.id ) ) {
-                                std::list< DeclarationWithType * > & params = function->type->parameters;
-                                assert( ! params.empty() );
-                                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
-                                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
-                                assert( base );
-                                funcMap[ Mangler::mangle( base ) ] += decl;
-                        } else {
-                                out.push_back( decl );
-                        }
-                }
-
-                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which determine
-                // the set of ctor/dtor/assign that can be used  by the requester. In particular, if the user defines
-                // a default ctor, then the generated default ctor is unavailable, likewise for copy ctor
-                // and dtor. If the user defines any ctor/dtor, then no generated field ctors are available.
-                // If the user defines any ctor then the generated default ctor is unavailable (intrinsic default
-                // ctor must be overridden exactly). If the user defines anything that looks like a copy constructor,
-                // then the generated copy constructor is unavailable, and likewise for the assignment operator.
-                for ( std::pair< const std::string, ValueType > & pair : funcMap ) {
-                        ValueType & val = pair.second;
-                        for ( ValueType::DeclBall ball : val.decls ) {
-                                bool isNotUserDefinedFunc = ! ball.isUserDefinedFunc && ball.decl.id->linkage != LinkageSpec::Intrinsic;
-                                bool isCopyFunc = ball.isCopyFunc;
-                                bool existsUserDefinedCopyFunc = val.existsUserDefinedCopyFunc;
-                                // only implicitly delete non-user defined functions that are  not intrinsic, and are
-                                // not copy functions (assignment or copy constructor), unless a user-defined copy function exists.
-                                // deleteStmt will be non-null only if a user-defined function is found.
-                                if (isNotUserDefinedFunc && (! isCopyFunc || existsUserDefinedCopyFunc)) {
-                                        ball.decl.deleteStmt = val.deleteStmt;
-                                }
-                                out.push_back( ball.decl );
-                        }
-                }
-        }
-
-        void Indexer::makeWritable() {
-                if ( ! tables ) {
-                        // create indexer if not yet set
-                        tables = new Indexer::Impl( scope );
-                } else if ( tables->refCount > 1 || tables->scope != scope ) {
-                        // make this indexer the base of a fresh indexer at the current scope
-                        tables = new Indexer::Impl( scope, std::move( *this ) );
-                }
-        }
-
-        Indexer::Indexer() : tables( 0 ), scope( 0 ) {}
-
-        Indexer::Indexer( const Indexer &that ) : doDebug( that.doDebug ), tables( newRef( that.tables ) ), scope( that.scope ) {}
-
-        Indexer::Indexer( Indexer &&that ) : doDebug( that.doDebug ), tables( that.tables ), scope( that.scope ) {
-                that.tables = 0;
-        }
+                        return ret;
+                }
+        }
+
+        Indexer::Indexer()
+        : idTable(), typeTable(), structTable(), enumTable(), unionTable(), traitTable(),
+          prevScope(), scope( 0 ), repScope( 0 ) { ++* stats().count; }
 
         Indexer::~Indexer() {
-                deleteRef( tables );
-        }
-
-        Indexer& Indexer::operator= ( const Indexer &that ) {
-                deleteRef( tables );
-
-                tables = newRef( that.tables );
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                return *this;
-        }
-
-        Indexer& Indexer::operator= ( Indexer &&that ) {
-                deleteRef( tables );
-
-                tables = that.tables;
-                scope = that.scope;
-                doDebug = that.doDebug;
-
-                that.tables = 0;
-
-                return *this;
-        }
-
-        void Indexer::lookupId( const std::string &id, std::list< IdData > &out ) const {
-                std::unordered_set< std::string > foundMangleNames;
-
-                Indexer::Impl *searchTables = tables;
-                while ( searchTables ) {
-
-                        IdTable::const_iterator decls = searchTables->idTable.find( id );
-                        if ( decls != searchTables->idTable.end() ) {
-                                const MangleTable &mangleTable = decls->second;
-                                for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                        // mark the mangled name as found, skipping this insertion if a declaration for that name has already been found
-                                        if ( foundMangleNames.insert( decl->first ).second == false ) continue;
-
-                                        out.push_back( decl->second );
-                                }
-                        }
-
-                        // get declarations from base indexers
-                        searchTables = searchTables->base.tables;
-                }
-
-                // some special functions, e.g. constructors and destructors
-                // remove autogenerated functions when they are defined so that
-                // they can never be matched
-                removeSpecialOverrides( id, out );
-        }
-
-        NamedTypeDecl *Indexer::lookupType( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupType( id );
-        }
-
-        StructDecl *Indexer::lookupStruct( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStruct( id );
-        }
-
-        EnumDecl *Indexer::lookupEnum( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnum( id );
-        }
-
-        UnionDecl *Indexer::lookupUnion( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnion( id );
-        }
-
-        TraitDecl *Indexer::lookupTrait( const std::string &id ) const {
-                if ( ! tables ) return 0;
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTrait( id );
-        }
-
-        const Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return nullptr;
-                if ( tables->scope < scope ) return nullptr;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        MangleTable::const_iterator decl = mangleTable.find( mangleName );
-                        if ( decl != mangleTable.end() ) return &decl->second;
-                }
-
-                return tables->base.lookupIdAtScope( id, mangleName, scope );
-        }
-
-        Indexer::IdData * Indexer::lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) {
-                return const_cast<IdData *>(const_cast<const Indexer *>(this)->lookupIdAtScope( id, mangleName, scope ));
-        }
-
-        bool Indexer::hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return false;
-                if ( tables->scope < scope ) return false;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping those with a compatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first != mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasIncompatibleCDecl( id, mangleName, scope );
-        }
-
-        bool Indexer::hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const {
-                if ( ! tables ) return false;
-                if ( tables->scope < scope ) return false;
-
-                IdTable::const_iterator decls = tables->idTable.find( id );
-                if ( decls != tables->idTable.end() ) {
-                        const MangleTable &mangleTable = decls->second;
-                        for ( MangleTable::const_iterator decl = mangleTable.begin(); decl != mangleTable.end(); ++decl ) {
-                                // check for C decls with the same name, skipping
-                                // those with an incompatible type (by mangleName)
-                                if ( ! LinkageSpec::isMangled( decl->second.id->get_linkage() ) && decl->first == mangleName ) return true;
-                        }
-                }
-
-                return tables->base.hasCompatibleCDecl( id, mangleName, scope );
-        }
-
-        NamedTypeDecl *Indexer::lookupTypeAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                TypeTable::const_iterator ret = tables->typeTable.find( id );
-                return ret != tables->typeTable.end() ? ret->second : tables->base.lookupTypeAtScope( id, scope );
-        }
-
-        StructDecl *Indexer::lookupStructAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                StructTable::const_iterator ret = tables->structTable.find( id );
-                return ret != tables->structTable.end() ? ret->second : tables->base.lookupStructAtScope( id, scope );
-        }
-
-        EnumDecl *Indexer::lookupEnumAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                EnumTable::const_iterator ret = tables->enumTable.find( id );
-                return ret != tables->enumTable.end() ? ret->second : tables->base.lookupEnumAtScope( id, scope );
-        }
-
-        UnionDecl *Indexer::lookupUnionAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                UnionTable::const_iterator ret = tables->unionTable.find( id );
-                return ret != tables->unionTable.end() ? ret->second : tables->base.lookupUnionAtScope( id, scope );
-        }
-
-        TraitDecl *Indexer::lookupTraitAtScope( const std::string &id, unsigned long scope ) const {
-                if ( ! tables ) return 0;
-                if ( tables->scope < scope ) return 0;
-
-                TraitTable::const_iterator ret = tables->traitTable.find( id );
-                return ret != tables->traitTable.end() ? ret->second : tables->base.lookupTraitAtScope( id, scope );
-        }
-
-        bool isFunction( DeclarationWithType * decl ) {
+                stats().size->push( idTable ? idTable->size() : 0 );
+        }
+
+        void Indexer::lazyInitScope() {
+                if ( repScope < scope ) {
+                        ++* stats().lazy_scopes;
+                        // create rollback
+                        prevScope = std::make_shared<Indexer>( * this );
+                        // update repScope
+                        repScope = scope;
+                }
+        }
+
+        void Indexer::enterScope() {
+                ++scope;
+
+                ++* stats().new_scopes;
+                stats().avg_scope_depth->push( scope );
+                stats().max_scope_depth->push( scope );
+        }
+
+        void Indexer::leaveScope() {
+                if ( repScope == scope ) {
+                        Ptr prev = prevScope;           // make sure prevScope stays live
+                        * this = std::move(* prevScope);  // replace with previous scope
+                }
+
+                --scope;
+        }
+
+        void Indexer::lookupId( const std::string & id, std::list< IdData > &out ) const {
+                ++* stats().lookup_calls;
+                if ( ! idTable ) return;
+
+                ++* stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return;
+
+                for ( auto decl : *(decls->second) ) {
+                        out.push_back( decl.second );
+                }
+        }
+
+        const NamedTypeDecl * Indexer::lookupType( const std::string & id ) const {
+                ++* stats().lookup_calls;
+                if ( ! typeTable ) return nullptr;
+                ++* stats().map_lookups;
+                auto it = typeTable->find( id );
+                return it == typeTable->end() ? nullptr : it->second.decl;
+        }
+
+        const StructDecl * Indexer::lookupStruct( const std::string & id ) const {
+                ++* stats().lookup_calls;
+                if ( ! structTable ) return nullptr;
+                ++* stats().map_lookups;
+                auto it = structTable->find( id );
+                return it == structTable->end() ? nullptr : it->second.decl;
+        }
+
+        const EnumDecl * Indexer::lookupEnum( const std::string & id ) const {
+                ++* stats().lookup_calls;
+                if ( ! enumTable ) return nullptr;
+                ++* stats().map_lookups;
+                auto it = enumTable->find( id );
+                return it == enumTable->end() ? nullptr : it->second.decl;
+        }
+
+        const UnionDecl * Indexer::lookupUnion( const std::string & id ) const {
+                ++* stats().lookup_calls;
+                if ( ! unionTable ) return nullptr;
+                ++* stats().map_lookups;
+                auto it = unionTable->find( id );
+                return it == unionTable->end() ? nullptr : it->second.decl;
+        }
+
+        const TraitDecl * Indexer::lookupTrait( const std::string & id ) const {
+                ++* stats().lookup_calls;
+                if ( ! traitTable ) return nullptr;
+                ++* stats().map_lookups;
+                auto it = traitTable->find( id );
+                return it == traitTable->end() ? nullptr : it->second.decl;
+        }
+
+        const Indexer * Indexer::atScope( unsigned long target ) const {
+                // by lazy construction, final indexer in list has repScope 0, cannot be > target
+                // otherwise, will find first scope representing the target
+                const Indexer * indexer = this;
+                while ( indexer->repScope > target ) {
+                        indexer = indexer->prevScope.get();
+                }
+                return indexer;
+        }
+
+        const NamedTypeDecl * Indexer::globalLookupType( const std::string & id ) const {
+                return atScope( 0 )->lookupType( id );
+        }
+
+        const StructDecl * Indexer::globalLookupStruct( const std::string & id ) const {
+                return atScope( 0 )->lookupStruct( id );
+        }
+
+        const UnionDecl * Indexer::globalLookupUnion( const std::string & id ) const {
+                return atScope( 0 )->lookupUnion( id );
+        }
+
+        const EnumDecl * Indexer::globalLookupEnum( const std::string & id ) const {
+                return atScope( 0 )->lookupEnum( id );
+        }
+
+        bool isFunction( const DeclarationWithType * decl ) {
                 return GenPoly::getFunctionType( decl->get_type() );
         }
 
-        bool isObject( DeclarationWithType * decl ) {
+        bool isObject( const DeclarationWithType * decl ) {
                 return ! isFunction( decl );
         }
 
-        bool isDefinition( DeclarationWithType * decl ) {
-                if ( FunctionDecl * func = dynamic_cast< FunctionDecl * >( decl ) ) {
+        bool isDefinition( const DeclarationWithType * decl ) {
+                if ( const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl ) ) {
                         // a function is a definition if it has a body
                         return func->statements;
@@ -393 +207 @@
         }
 
-        bool addedIdConflicts( Indexer::IdData & existing, DeclarationWithType *added, BaseSyntaxNode * deleteStmt, Indexer::ConflictFunction handleConflicts ) {
-                // if we're giving the same name mangling to things of different types then there is something wrong
+
+        bool Indexer::addedIdConflicts(
+                        const Indexer::IdData & existing, const DeclarationWithType * added,
+                        Indexer::OnConflict handleConflicts, const Declaration * deleteStmt ) {
+                // if we're giving the same name mangling to things of different types then there is
+                // something wrong
                 assert( (isObject( added ) && isObject( existing.id ) )
                         || ( isFunction( added ) && isFunction( existing.id ) ) );
 
-                if ( LinkageSpec::isOverridable( existing.id->get_linkage() ) ) {
+                if ( LinkageSpec::isOverridable( existing.id->linkage ) ) {
                         // new definition shadows the autogenerated one, even at the same scope
                         return false;
-                } else if ( LinkageSpec::isMangled( added->get_linkage() ) || ResolvExpr::typesCompatible( added->get_type(), existing.id->get_type(), Indexer() ) ) {
+                } else if ( LinkageSpec::isMangled( added->linkage )
+                                || ResolvExpr::typesCompatible(
+                                        added->get_type(), existing.id->get_type(), Indexer() ) ) {
 
                         // it is a conflict if one declaration is deleted and the other is not
                         if ( deleteStmt && ! existing.deleteStmt ) {
-                                return handleConflicts( existing, "deletion of defined identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "deletion of defined identifier " );
+                                }
+                                return true;
                         } else if ( ! deleteStmt && existing.deleteStmt ) {
-                                return handleConflicts( existing, "definition of deleted identifier " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added, "definition of deleted identifier " );
+                                }
+                                return true;
                         }
 
                         if ( isDefinition( added ) && isDefinition( existing.id ) ) {
-                                if ( isFunction( added ) ) {
-                                        return handleConflicts( existing, "duplicate function definition for " );
+                                if ( handleConflicts.mode == OnConflict::Error ) {
+                                        SemanticError( added,
+                                                isFunction( added ) ?
+                                                        "duplicate function definition for " :
+                                                        "duplicate object definition for " );
+                                }
+                                return true;
+                        } // if
+                } else {
+                        if ( handleConflicts.mode == OnConflict::Error ) {
+                                SemanticError( added, "duplicate definition for " );
+                        }
+                        return true;
+                } // if
+
+                return true;
+        }
+
+        bool Indexer::hasCompatibleCDecl( const std::string & id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+
+                ++* stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with compatible type (by mangleName)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first == mangleName ) {
+                                return true;
+                        }
+                }
+
+                return false;
+        }
+
+        bool Indexer::hasIncompatibleCDecl(const std::string & id, const std::string &mangleName ) const {
+                if ( ! idTable ) return false;
+
+                ++* stats().map_lookups;
+                auto decls = idTable->find( id );
+                if ( decls == idTable->end() ) return false;
+
+                for ( auto decl : *(decls->second) ) {
+                        // skip other scopes (hidden by this decl)
+                        if ( decl.second.scope != scope ) continue;
+                        // check for C decl with incompatible type (by manglename)
+                        if ( ! LinkageSpec::isMangled( decl.second.id->linkage ) && decl.first != mangleName ) {
+                                return true;
+                        }
+                }
+
+                return false;
+        }
+
+        /// gets the base type of the first parameter; decl must be a ctor/dtor/assignment function
+        std::string getOtypeKey( const FunctionDecl * function ) {
+                auto& params = function->type->parameters;
+                assert( ! params.empty() );
+                // use base type of pointer, so that qualifiers on the pointer type aren't considered.
+                Type * base = InitTweak::getPointerBase( params.front()->get_type() );
+                assert( base );
+                return Mangler::mangle( base );
+        }
+
+        /// gets the declaration for the function acting on a type specified by otype key,
+        /// nullptr if none such
+        const FunctionDecl * getFunctionForOtype( const DeclarationWithType * decl, const std::string& otypeKey ) {
+                const FunctionDecl * func = dynamic_cast< const FunctionDecl * >( decl );
+                if ( ! func || otypeKey != getOtypeKey( func ) ) return nullptr;
+                return func;
+        }
+
+        bool Indexer::removeSpecialOverrides(Indexer::IdData& data, Indexer::MangleTable::Ptr& mangleTable ) {
+                // if a type contains user defined ctor/dtor/assign, then special rules trigger, which
+                // determinethe set of ctor/dtor/assign that can be used  by the requester. In particular,
+                // if the user defines a default ctor, then the generated default ctor is unavailable,
+                // likewise for copy ctor and dtor. If the user defines any ctor/dtor, then no generated
+                // field ctors are available. If the user defines any ctor then the generated default ctor
+                // is unavailable (intrinsic default ctor must be overridden exactly). If the user defines
+                // anything that looks like a copy constructor, then the generated copy constructor is
+                // unavailable, and likewise for the assignment operator.
+
+                // only relevant on function declarations
+                const FunctionDecl * function = dynamic_cast< const FunctionDecl * >( data.id );
+                if ( ! function ) return true;
+                // only need to perform this check for constructors, destructors, and assignment functions
+                if ( ! CodeGen::isCtorDtorAssign( data.id->name ) ) return true;
+
+                // set up information for this type
+                bool dataIsUserDefinedFunc = ! LinkageSpec::isOverridable( function->linkage );
+                bool dataIsCopyFunc = InitTweak::isCopyFunction( function, function->name );
+                std::string dataOtypeKey = getOtypeKey( function );
+
+                if ( dataIsUserDefinedFunc && dataIsCopyFunc ) {
+                        // this is a user-defined copy function
+                        // if this is the first such, delete/remove non-user-defined overloads as needed
+                        std::vector< std::string > removed;
+                        std::vector< MangleTable::value_type > deleted;
+                        bool alreadyUserDefinedFunc = false;
+
+                        for ( const auto& entry : * mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                bool isCopyFunc = InitTweak::isCopyFunction( decl, decl->name );
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) {
+                                        // matching user-defined function
+                                        if ( isCopyFunc ) {
+                                                // mutation already performed, return early
+                                                return true;
+                                        } else {
+                                                // note that non-copy deletions already performed
+                                                alreadyUserDefinedFunc = true;
+                                        }
                                 } else {
-                                        return handleConflicts( existing, "duplicate object definition for " );
-                                } // if
-                        } // if
-                } else {
-                        return handleConflicts( existing, "duplicate definition for " );
-                } // if
-
+                                        // non-user-defined function; mark for deletion/removal as appropriate
+                                        if ( isCopyFunc ) {
+                                                removed.push_back( entry.first );
+                                        } else if ( ! alreadyUserDefinedFunc ) {
+                                                deleted.push_back( entry );
+                                        }
+                                }
+                        }
+
+                        // perform removals from mangle table, and deletions if necessary
+                        for ( const auto& key : removed ) {
+                                ++* stats().map_mutations;
+                                mangleTable = mangleTable->erase( key );
+                        }
+                        if ( ! alreadyUserDefinedFunc ) for ( const auto& entry : deleted ) {
+                                ++* stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( dataIsUserDefinedFunc ) {
+                        // this is a user-defined non-copy function
+                        // if this is the first user-defined function, delete non-user-defined overloads
+                        std::vector< MangleTable::value_type > deleted;
+
+                        for ( const auto& entry : * mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // exit early if already a matching user-defined function;
+                                // earlier function will have mutated table
+                                if ( ! LinkageSpec::isOverridable( decl->linkage ) ) return true;
+
+                                // skip mutating intrinsic functions
+                                if ( decl->linkage == LinkageSpec::Intrinsic ) continue;
+
+                                // user-defined non-copy functions do not override copy functions
+                                if ( InitTweak::isCopyFunction( decl, decl->name ) ) continue;
+
+                                // this function to be deleted after mangleTable iteration is complete
+                                deleted.push_back( entry );
+                        }
+
+                        // mark deletions to update mangle table
+                        // this needs to be a separate loop because of iterator invalidation
+                        for ( const auto& entry : deleted ) {
+                                ++* stats().map_mutations;
+                                mangleTable = mangleTable->set( entry.first, IdData{ entry.second, function } );
+                        }
+                } else if ( function->linkage != LinkageSpec::Intrinsic ) {
+                        // this is an overridable generated function
+                        // if there already exists a matching user-defined function, delete this appropriately
+                        for ( const auto& entry : * mangleTable ) {
+                                // skip decls that aren't functions or are for the wrong type
+                                const FunctionDecl * decl = getFunctionForOtype( entry.second.id, dataOtypeKey );
+                                if ( ! decl ) continue;
+
+                                // skip non-user-defined functions
+                                if ( LinkageSpec::isOverridable( decl->linkage ) ) continue;
+
+                                if ( dataIsCopyFunc ) {
+                                        // remove current function if exists a user-defined copy function
+                                        // since the signatures for copy functions don't need to match exactly, using
+                                        // a delete statement is the wrong approach
+                                        if ( InitTweak::isCopyFunction( decl, decl->name ) ) return false;
+                                } else {
+                                        // mark current function deleted by first user-defined function found
+                                        data.deleteStmt = decl;
+                                        return true;
+                                }
+                        }
+                }
+
+                // nothing (more) to fix, return true
                 return true;
         }
 
-        void Indexer::addId( DeclarationWithType *decl, ConflictFunction handleConflicts, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) {
-                if ( decl->name == "" ) return;
-                debugPrint( "Adding Id " << decl->name << std::endl );
-                makeWritable();
-
+        void Indexer::addId(const DeclarationWithType * decl, OnConflict handleConflicts, const Expression * baseExpr,
+                        const Declaration * deleteStmt ) {
+                ++* stats().add_calls;
                 const std::string &name = decl->name;
+                if ( name == "" ) return;
+
                 std::string mangleName;
                 if ( LinkageSpec::isOverridable( decl->linkage ) ) {
-                        // mangle the name without including the appropriate suffix, so overridable routines are placed into the
-                        // same "bucket" as their user defined versions.
+                        // mangle the name without including the appropriate suffix, so overridable routines
+                        // are placed into the same "bucket" as their user defined versions.
                         mangleName = Mangler::mangle( decl, false );
                 } else {
@@ -439 +446 @@
                 } // if
 
-                // this ensures that no two declarations with the same unmangled name at the same scope both have C linkage
-                if ( ! LinkageSpec::isMangled( decl->linkage ) ) {
-                        // NOTE this is broken in Richard's original code in such a way that it never triggers (it
-                        // doesn't check decls that have the same manglename, and all C-linkage decls are defined to
-                        // have their name as their manglename, hence the error can never trigger).
-                        // The code here is closer to correct, but name mangling would have to be completely
-                        // isomorphic to C type-compatibility, which it may not be.
-                        if ( hasIncompatibleCDecl( name, mangleName, scope ) ) {
+                // this ensures that no two declarations with the same unmangled name at the same scope
+                // both have C linkage
+                if ( LinkageSpec::isMangled( decl->linkage ) ) {
+                        // Check that a Cforall declaration doesn't override any C declaration
+                        if ( hasCompatibleCDecl( name, mangleName ) ) {
+                                SemanticError( decl, "Cforall declaration hides C function " );
+                        }
+                } else {
+                        // NOTE: only correct if name mangling is completely isomorphic to C
+                        // type-compatibility, which it may not be.
+                        if ( hasIncompatibleCDecl( name, mangleName ) ) {
                                 SemanticError( decl, "conflicting overload of C function " );
                         }
-                } else {
-                        // Check that a Cforall declaration doesn't override any C declaration
-                        if ( hasCompatibleCDecl( name, mangleName, scope ) ) {
-                                SemanticError( decl, "Cforall declaration hides C function " );
-                        }
-                }
-
-                // Skip repeat declarations of the same identifier
-                IdData * existing = lookupIdAtScope( name, mangleName, scope );
-                if ( existing && existing->id && addedIdConflicts( *existing, decl, deleteStmt, handleConflicts ) ) return;
-
-                // add to indexer
-                tables->idTable[ name ][ mangleName ] = IdData{ decl, baseExpr, deleteStmt };
-                ++tables->size;
-        }
-
-        void Indexer::addId( DeclarationWithType * decl, Expression * baseExpr ) {
+                }
+
+                // ensure tables exist and add identifier
+                MangleTable::Ptr mangleTable;
+                if ( ! idTable ) {
+                        idTable = IdTable::new_ptr();
+                        mangleTable = MangleTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto decls = idTable->find( name );
+                        if ( decls == idTable->end() ) {
+                                mangleTable = MangleTable::new_ptr();
+                        } else {
+                                mangleTable = decls->second;
+                                // skip in-scope repeat declarations of same identifier
+                                ++* stats().map_lookups;
+                                auto existing = mangleTable->find( mangleName );
+                                if ( existing != mangleTable->end()
+                                                && existing->second.scope == scope
+                                                && existing->second.id ) {
+                                        if ( addedIdConflicts( existing->second, decl, handleConflicts, deleteStmt ) ) {
+                                                if ( handleConflicts.mode == OnConflict::Delete ) {
+                                                        // set delete expression for conflicting identifier
+                                                        lazyInitScope();
+                                                        * stats().map_mutations += 2;
+                                                        idTable = idTable->set(
+                                                                name,
+                                                                mangleTable->set(
+                                                                        mangleName,
+                                                                        IdData{ existing->second, handleConflicts.deleteStmt } ) );
+                                                }
+                                                return;
+                                        }
+                                }
+                        }
+                }
+
+                // add/overwrite with new identifier
+                lazyInitScope();
+                IdData data{ decl, baseExpr, deleteStmt, scope };
+                // Ensure that auto-generated ctor/dtor/assignment are deleted if necessary
+                if ( ! removeSpecialOverrides( data, mangleTable ) ) return;
+                * stats().map_mutations += 2;
+                idTable = idTable->set( name, mangleTable->set( mangleName, std::move(data) ) );
+        }
+
+        void Indexer::addId( const DeclarationWithType * decl, const Expression * baseExpr ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, baseExpr, decl->isDeleted ? decl : nullptr );
-        }
-
-        void Indexer::addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt ) {
+                addId( decl, OnConflict::error(), baseExpr, decl->isDeleted ? decl : nullptr );
+        }
+
+        void Indexer::addDeletedId( const DeclarationWithType * decl, const Declaration * deleteStmt ) {
                 // default handling of conflicts is to raise an error
-                addId( decl, [decl](IdData &, const std::string & msg) { SemanticError( decl, msg ); return true; }, nullptr, deleteStmt );
-        }
-
-        bool addedTypeConflicts( NamedTypeDecl *existing, NamedTypeDecl *added ) {
-                if ( existing->get_base() == 0 ) {
+                addId( decl, OnConflict::error(), nullptr, deleteStmt );
+        }
+
+        bool addedTypeConflicts( const NamedTypeDecl * existing, const NamedTypeDecl * added ) {
+                if ( existing->base == nullptr ) {
                         return false;
-                } else if ( added->get_base() == 0 ) {
+                } else if ( added->base == nullptr ) {
                         return true;
                 } else {
-                        SemanticError( added, "redeclaration of " );
-                }
-        }
-
-        void Indexer::addType( NamedTypeDecl *decl ) {
-                debugPrint( "Adding type " << decl->name << std::endl );
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                TypeTable::iterator existing = tables->typeTable.find( id );
-                if ( existing == tables->typeTable.end() ) {
-                        NamedTypeDecl *parent = tables->base.lookupTypeAtScope( id, scope );
-                        if ( ! parent || ! addedTypeConflicts( parent, decl ) ) {
-                                tables->typeTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedTypeConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        bool addedDeclConflicts( AggregateDecl *existing, AggregateDecl *added ) {
+                        assert( existing->base && added->base );
+                        // typedef redeclarations are errors only if types are different
+                        if ( ! ResolvExpr::typesCompatible( existing->base, added->base, Indexer() ) ) {
+                                SemanticError( added->location, "redeclaration of " + added->name );
+                        }
+                }
+                // does not need to be added to the table if both existing and added have a base that are
+                // the same
+                return true;
+        }
+
+        void Indexer::addType( const NamedTypeDecl * decl ) {
+                ++* stats().add_calls;
+                const std::string & id = decl->name;
+
+                if ( ! typeTable ) {
+                        typeTable = TypeTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto existing = typeTable->find( id );
+                        if ( existing != typeTable->end()
+                                && existing->second.scope == scope
+                                && addedTypeConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++* stats().map_mutations;
+                typeTable = typeTable->set( id, Scoped<NamedTypeDecl>{ decl, scope } );
+        }
+
+        bool addedDeclConflicts( const AggregateDecl * existing, const AggregateDecl * added ) {
                 if ( ! existing->body ) {
                         return false;
@@ -513 +560 @@
         }
 
-        void Indexer::addStruct( const std::string &id ) {
-                debugPrint( "Adding fwd decl for struct " << id << std::endl );
+        void Indexer::addStruct( const std::string & id ) {
                 addStruct( new StructDecl( id ) );
         }
 
-        void Indexer::addStruct( StructDecl *decl ) {
-                debugPrint( "Adding struct " << decl->name << std::endl );
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                StructTable::iterator existing = tables->structTable.find( id );
-                if ( existing == tables->structTable.end() ) {
-                        StructDecl *parent = tables->base.lookupStructAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->structTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addEnum( EnumDecl *decl ) {
-                debugPrint( "Adding enum " << decl->name << std::endl );
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                EnumTable::iterator existing = tables->enumTable.find( id );
-                if ( existing == tables->enumTable.end() ) {
-                        EnumDecl *parent = tables->base.lookupEnumAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->enumTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addUnion( const std::string &id ) {
-                debugPrint( "Adding fwd decl for union " << id << std::endl );
+        void Indexer::addStruct( const StructDecl * decl ) {
+                ++* stats().add_calls;
+                const std::string & id = decl->name;
+
+                if ( ! structTable ) {
+                        structTable = StructTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto existing = structTable->find( id );
+                        if ( existing != structTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++* stats().map_mutations;
+                structTable = structTable->set( id, Scoped<StructDecl>{ decl, scope } );
+        }
+
+        void Indexer::addEnum( const EnumDecl * decl ) {
+                ++* stats().add_calls;
+                const std::string & id = decl->name;
+
+                if ( ! enumTable ) {
+                        enumTable = EnumTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto existing = enumTable->find( id );
+                        if ( existing != enumTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++* stats().map_mutations;
+                enumTable = enumTable->set( id, Scoped<EnumDecl>{ decl, scope } );
+        }
+
+        void Indexer::addUnion( const std::string & id ) {
                 addUnion( new UnionDecl( id ) );
         }
 
-        void Indexer::addUnion( UnionDecl *decl ) {
-                debugPrint( "Adding union " << decl->name << std::endl );
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                UnionTable::iterator existing = tables->unionTable.find( id );
-                if ( existing == tables->unionTable.end() ) {
-                        UnionDecl *parent = tables->base.lookupUnionAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->unionTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addTrait( TraitDecl *decl ) {
-                debugPrint( "Adding trait " << decl->name << std::endl );
-                makeWritable();
-
-                const std::string &id = decl->get_name();
-                TraitTable::iterator existing = tables->traitTable.find( id );
-                if ( existing == tables->traitTable.end() ) {
-                        TraitDecl *parent = tables->base.lookupTraitAtScope( id, scope );
-                        if ( ! parent || ! addedDeclConflicts( parent, decl ) ) {
-                                tables->traitTable.insert( existing, std::make_pair( id, decl ) );
-                                ++tables->size;
-                        }
-                } else {
-                        if ( ! addedDeclConflicts( existing->second, decl ) ) {
-                                existing->second = decl;
-                        }
-                }
-        }
-
-        void Indexer::addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction handleConflicts ) {
+        void Indexer::addUnion( const UnionDecl * decl ) {
+                ++* stats().add_calls;
+                const std::string & id = decl->name;
+
+                if ( ! unionTable ) {
+                        unionTable = UnionTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto existing = unionTable->find( id );
+                        if ( existing != unionTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++* stats().map_mutations;
+                unionTable = unionTable->set( id, Scoped<UnionDecl>{ decl, scope } );
+        }
+
+        void Indexer::addTrait( const TraitDecl * decl ) {
+                ++* stats().add_calls;
+                const std::string & id = decl->name;
+
+                if ( ! traitTable ) {
+                        traitTable = TraitTable::new_ptr();
+                } else {
+                        ++* stats().map_lookups;
+                        auto existing = traitTable->find( id );
+                        if ( existing != traitTable->end()
+                                && existing->second.scope == scope
+                                && addedDeclConflicts( existing->second.decl, decl ) ) return;
+                }
+
+                lazyInitScope();
+                ++* stats().map_mutations;
+                traitTable = traitTable->set( id, Scoped<TraitDecl>{ decl, scope } );
+        }
+
+        void Indexer::addMembers( const AggregateDecl * aggr, const Expression * expr, OnConflict handleConflicts ) {
                 for ( Declaration * decl : aggr->members ) {
                         if ( DeclarationWithType * dwt = dynamic_cast< DeclarationWithType * >( decl ) ) {
                                 addId( dwt, handleConflicts, expr );
                                 if ( dwt->name == "" ) {
-                                        Type * t = dwt->get_type()->stripReferences();
-                                        if ( dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t ) ) {
+                                        const Type * t = dwt->get_type()->stripReferences();
+                                        if ( dynamic_cast<const StructInstType *>( t ) || dynamic_cast<const UnionInstType *>( t ) ) {
                                                 Expression * base = expr->clone();
                                                 ResolvExpr::Cost cost = ResolvExpr::Cost::zero; // xxx - carry this cost into the indexer as a base cost?
@@ -616 +661 @@
         }
 
-        void Indexer::addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt ) {
-                for ( Expression * expr : withExprs ) {
+        void Indexer::addWith( const std::list< Expression * > & withExprs, const Declaration * withStmt ) {
+                for ( const Expression * expr : withExprs ) {
                         if ( expr->result ) {
                                 AggregateDecl * aggr = expr->result->stripReferences()->getAggr();
                                 assertf( aggr, "WithStmt expr has non-aggregate type: %s", toString( expr->result ).c_str() );
 
-                                addMembers( aggr, expr, [withStmt](IdData & existing, const std::string &) {
-                                        // on conflict, delete the identifier
-                                        existing.deleteStmt = withStmt;
-                                        return true;
-                                });
+                                addMembers( aggr, expr, OnConflict::deleteWith( withStmt ) );
                         }
                 }
@@ -644 +685 @@
         }
 
-        void Indexer::addFunctionType( FunctionType * ftype ) {
+        void Indexer::addFunctionType( const FunctionType * ftype ) {
                 addTypes( ftype->forall );
                 addIds( ftype->returnVals );
                 addIds( ftype->parameters );
-        }
-
-        void Indexer::enterScope() {
-                ++scope;
-
-                if ( doDebug ) {
-                        std::cerr << "--- Entering scope " << scope << std::endl;
-                }
-        }
-
-        void Indexer::leaveScope() {
-                using std::cerr;
-
-                assert( scope > 0 && "cannot leave initial scope" );
-                if ( doDebug ) {
-                        cerr << "--- Leaving scope " << scope << " containing" << std::endl;
-                }
-                --scope;
-
-                while ( tables && tables->scope > scope ) {
-                        if ( doDebug ) {
-                                dump( tables->idTable, cerr );
-                                dump( tables->typeTable, cerr );
-                                dump( tables->structTable, cerr );
-                                dump( tables->enumTable, cerr );
-                                dump( tables->unionTable, cerr );
-                                dump( tables->traitTable, cerr );
-                        }
-
-                        // swap tables for base table until we find one at an appropriate scope
-                        Indexer::Impl *base = newRef( tables->base.tables );
-                        deleteRef( tables );
-                        tables = base;
-                }
-        }
-
-        void Indexer::print( std::ostream &os, int indent ) const {
-                using std::cerr;
-
-                if ( tables ) {
-                        os << "--- scope " << tables->scope << " ---" << std::endl;
-
-                        os << "===idTable===" << std::endl;
-                        dump( tables->idTable, os );
-                        os << "===typeTable===" << std::endl;
-                        dump( tables->typeTable, os );
-                        os << "===structTable===" << std::endl;
-                        dump( tables->structTable, os );
-                        os << "===enumTable===" << std::endl;
-                        dump( tables->enumTable, os );
-                        os << "===unionTable===" << std::endl;
-                        dump( tables->unionTable, os );
-                        os << "===contextTable===" << std::endl;
-                        dump( tables->traitTable, os );
-
-                        tables->base.print( os, indent );
-                } else {
-                        os << "--- end ---" << std::endl;
-                }
-
         }
 
@@ -715 +696 @@
                         Expression * base = baseExpr->clone();
                         ResolvExpr::referenceToRvalueConversion( base, cost );
-                        ret = new MemberExpr( id, base );
+                        ret = new MemberExpr( const_cast<DeclarationWithType *>(id), base );
                         // xxx - this introduces hidden environments, for now remove them.
                         // std::swap( base->env, ret->env );
@@ -721 +702 @@
                         base->env = nullptr;
                 } else {
-                        ret = new VariableExpr( id );
-                }
-                if ( deleteStmt ) ret = new DeletedExpr( ret, deleteStmt );
+                        ret = new VariableExpr( const_cast<DeclarationWithType *>(id) );
+                }
+                if ( deleteStmt ) ret = new DeletedExpr( ret, const_cast<Declaration *>(deleteStmt) );
                 return ret;
         }

src/SymTab/Indexer.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:38:55 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Thu Aug 17 16:09:12 2017
-// Update Count     : 8
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Mar  8 13:55:00 2019
+// Update Count     : 9
 //
 
 #pragma once
 
-#include <iosfwd>             // for ostream
-#include <list>               // for list
-#include <string>             // for string
-#include <functional>         // for function
+#include <functional>              // for function
+#include <list>                    // for list
+#include <memory>                  // for shared_ptr, enable_shared_from_this
+#include <string>                  // for string
 
-#include "SynTree/Visitor.h"  // for Visitor
-#include "SynTree/SynTree.h"  // for AST nodes
+#include "Common/PersistentMap.h"  // for PersistentMap
+#include "SynTree/SynTree.h"       // for AST nodes
 
 namespace ResolvExpr {
-class Cost;
+        class Cost;
 }
 
 namespace SymTab {
-        class Indexer {
-          public:
+        class Indexer : public std::enable_shared_from_this<SymTab::Indexer> {
+        public:
                 explicit Indexer();
+                virtual ~Indexer();
 
-                Indexer( const Indexer &that );
-                Indexer( Indexer &&that );
-                virtual ~Indexer();
-                Indexer& operator= ( const Indexer &that );
-                Indexer& operator= ( Indexer &&that );
-
-                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to tell the indexer
-                // explicitly when scopes begin and end
+                // when using an indexer manually (e.g., within a mutator traversal), it is necessary to
+                // tell the indexer explicitly when scopes begin and end
                 void enterScope();
                 void leaveScope();
 
                 struct IdData {
-                        DeclarationWithType * id = nullptr;
-                        Expression * baseExpr = nullptr; // WithExpr
+                        const DeclarationWithType * id = nullptr;
+                        const Expression * baseExpr = nullptr; // WithExpr
 
                         /// non-null if this declaration is deleted
-                        BaseSyntaxNode * deleteStmt = nullptr;
+                        const Declaration * deleteStmt = nullptr;
+                        /// scope of identifier
+                        unsigned long scope = 0;
 
                         // NOTE: shouldn't need either of these constructors, but gcc-4 does not properly support initializer lists with default members.
                         IdData() = default;
-                        IdData( DeclarationWithType * id, Expression * baseExpr, BaseSyntaxNode * deleteStmt ) : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ) {}
+                        IdData(
+                                const DeclarationWithType * id, const Expression * baseExpr, const Declaration * deleteStmt,
+                                unsigned long scope )
+                                : id( id ), baseExpr( baseExpr ), deleteStmt( deleteStmt ), scope( scope ) {}
+                        IdData( const IdData& o, const Declaration * deleteStmt )
+                                : id( o.id ), baseExpr( o.baseExpr ), deleteStmt( deleteStmt ), scope( o.scope ) {}
 
                         Expression * combine( ResolvExpr::Cost & cost ) const;
@@ -59 +61 @@
 
                 /// Gets all declarations with the given ID
-                void lookupId( const std::string &id, std::list< IdData > &out ) const;
+                void lookupId( const std::string & id, std::list< IdData > &out ) const;
                 /// Gets the top-most type declaration with the given ID
-                NamedTypeDecl *lookupType( const std::string &id ) const;
+                const NamedTypeDecl * lookupType( const std::string & id ) const;
                 /// Gets the top-most struct declaration with the given ID
-                StructDecl *lookupStruct( const std::string &id ) const;
+                const StructDecl * lookupStruct( const std::string & id ) const;
                 /// Gets the top-most enum declaration with the given ID
-                EnumDecl *lookupEnum( const std::string &id ) const;
+                const EnumDecl * lookupEnum( const std::string & id ) const;
                 /// Gets the top-most union declaration with the given ID
-                UnionDecl *lookupUnion( const std::string &id ) const;
+                const UnionDecl * lookupUnion( const std::string & id ) const;
                 /// Gets the top-most trait declaration with the given ID
-                TraitDecl *lookupTrait( const std::string &id ) const;
+                const TraitDecl * lookupTrait( const std::string & id ) const;
 
-                void print( std::ostream &os, int indent = 0 ) const;
+                /// Gets the type declaration with the given ID at global scope
+                const NamedTypeDecl * globalLookupType( const std::string & id ) const;
+                /// Gets the struct declaration with the given ID at global scope
+                const StructDecl * globalLookupStruct( const std::string & id ) const;
+                /// Gets the union declaration with the given ID at global scope
+                const UnionDecl * globalLookupUnion( const std::string & id ) const;
+                /// Gets the enum declaration with the given ID at global scope
+                const EnumDecl * globalLookupEnum( const std::string & id ) const;
 
-                /// looks up a specific mangled ID at the given scope
-                IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope );
-                const IdData * lookupIdAtScope( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
-                bool hasIncompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
-                bool hasCompatibleCDecl( const std::string &id, const std::string &mangleName, unsigned long scope ) const;
-                // equivalents to lookup functions that only look at tables at scope `scope` (which should be >= tables->scope)
-                NamedTypeDecl *lookupTypeAtScope( const std::string &id, unsigned long scope ) const;
-                StructDecl *lookupStructAtScope( const std::string &id, unsigned long scope ) const;
-                EnumDecl *lookupEnumAtScope( const std::string &id, unsigned long scope ) const;
-                UnionDecl *lookupUnionAtScope( const std::string &id, unsigned long scope ) const;
-                TraitDecl *lookupTraitAtScope( const std::string &id, unsigned long scope ) const;
+                void addId( const DeclarationWithType * decl, const Expression * baseExpr = nullptr );
+                void addDeletedId( const DeclarationWithType * decl, const Declaration * deleteStmt );
 
-                typedef std::function<bool(IdData &, const std::string &)> ConflictFunction;
-
-                void addId( DeclarationWithType * decl, Expression * baseExpr = nullptr );
-                void addDeletedId( DeclarationWithType * decl, BaseSyntaxNode * deleteStmt );
-
-                void addType( NamedTypeDecl *decl );
-                void addStruct( const std::string &id );
-                void addStruct( StructDecl *decl );
-                void addEnum( EnumDecl *decl );
-                void addUnion( const std::string &id );
-                void addUnion( UnionDecl *decl );
-                void addTrait( TraitDecl *decl );
+                void addType( const NamedTypeDecl * decl );
+                void addStruct( const std::string & id );
+                void addStruct( const StructDecl * decl );
+                void addEnum( const EnumDecl * decl );
+                void addUnion( const std::string & id );
+                void addUnion( const UnionDecl * decl );
+                void addTrait( const TraitDecl * decl );
 
                 /// adds all of the IDs from WithStmt exprs
-                void addWith( std::list< Expression * > & withExprs, BaseSyntaxNode * withStmt );
-
-                /// adds all of the members of the Aggregate (addWith helper)
-                void addMembers( AggregateDecl * aggr, Expression * expr, ConflictFunction );
+                void addWith( const std::list< Expression * > & withExprs, const Declaration * withStmt );
 
                 /// convenience function for adding a list of Ids to the indexer
@@ -113 +103 @@
 
                 /// convenience function for adding all of the declarations in a function type to the indexer
-                void addFunctionType( FunctionType * ftype );
+                void addFunctionType( const FunctionType * ftype );
 
-                bool doDebug = false; ///< Display debugging trace?
           private:
-                struct Impl;
+                /// Wraps a Decl * with a scope
+                template<typename Decl>
+                struct Scoped {
+                        const Decl * decl;           ///< declaration
+                        unsigned long scope;  ///< scope of this declaration
 
-                Impl *tables;         ///< Copy-on-write instance of table data structure
-                unsigned long scope;  ///< Scope index of this pointer
+                        Scoped(const Decl * d, unsigned long s) : decl(d), scope(s) {}
+                };
 
-                /// Takes a new ref to a table (returns null if null)
-                static Impl *newRef( Impl *toClone );
-                /// Clears a ref to a table (does nothing if null)
-                static void deleteRef( Impl *toFree );
+                using Ptr = std::shared_ptr<const Indexer>;
 
-                // Removes matching autogenerated constructors and destructors
-                // so that they will not be selected
-                // void removeSpecialOverrides( FunctionDecl *decl );
-                void removeSpecialOverrides( const std::string &id, std::list< IdData > & out ) const;
+                using MangleTable = PersistentMap< std::string, IdData >;
+                using IdTable = PersistentMap< std::string, MangleTable::Ptr >;
+                using TypeTable = PersistentMap< std::string, Scoped<NamedTypeDecl> >;
+                using StructTable = PersistentMap< std::string, Scoped<StructDecl> >;
+                using EnumTable = PersistentMap< std::string, Scoped<EnumDecl> >;
+                using UnionTable = PersistentMap< std::string, Scoped<UnionDecl> >;
+                using TraitTable = PersistentMap< std::string, Scoped<TraitDecl> >;
 
-                /// Ensures that tables variable is writable (i.e. allocated, uniquely owned by this Indexer, and at the current scope)
-                void makeWritable();
+                IdTable::Ptr idTable;          ///< identifier namespace
+                TypeTable::Ptr typeTable;      ///< type namespace
+                StructTable::Ptr structTable;  ///< struct namespace
+                EnumTable::Ptr enumTable;      ///< enum namespace
+                UnionTable::Ptr unionTable;    ///< union namespace
+                TraitTable::Ptr traitTable;    ///< trait namespace
+
+                Ptr prevScope;                 ///< reference to indexer for parent scope
+                unsigned long scope;           ///< Scope index of this indexer
+                unsigned long repScope;        ///< Scope index of currently represented scope
+
+                /// Ensures that a proper backtracking scope exists before a mutation
+                void lazyInitScope();
+
+                /// Gets the indexer at the given scope
+                const Indexer * atScope( unsigned long scope ) const;
+
+                /// Removes matching autogenerated constructors and destructors so that they will not be
+                /// selected. If returns false, passed decl should not be added.
+                bool removeSpecialOverrides( IdData & decl, MangleTable::Ptr & mangleTable );
+
+                /// Options for handling identifier conflicts
+                struct OnConflict {
+                        enum {
+                                Error,  ///< Throw a semantic error
+                                Delete  ///< Delete the earlier version with the delete statement
+                        } mode;
+                        const Declaration * deleteStmt;  ///< Statement that deletes this expression
+
+                private:
+                        OnConflict() : mode(Error), deleteStmt(nullptr) {}
+                        OnConflict( const Declaration * d ) : mode(Delete), deleteStmt(d) {}
+                public:
+                        OnConflict( const OnConflict& ) = default;
+
+                        static OnConflict error() { return {}; }
+                        static OnConflict deleteWith( const Declaration * d ) { return { d }; }
+                };
+
+                /// true if the existing identifier conflicts with the added identifier
+                bool addedIdConflicts(
+                        const IdData & existing, const DeclarationWithType * added, OnConflict handleConflicts,
+                        const Declaration * deleteStmt );
 
                 /// common code for addId, addDeletedId, etc.
-                void addId( DeclarationWithType * decl, ConflictFunction, Expression * baseExpr = nullptr, BaseSyntaxNode * deleteStmt = nullptr );
+                void addId(const DeclarationWithType * decl, OnConflict handleConflicts,
+                        const Expression * baseExpr = nullptr, const Declaration * deleteStmt = nullptr );
+
+                /// adds all of the members of the Aggregate (addWith helper)
+                void addMembers( const AggregateDecl * aggr, const Expression * expr, OnConflict handleConflicts );
+
+                /// returns true if there exists a declaration with C linkage and the given name with the same mangled name
+                bool hasCompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
+                /// returns true if there exists a declaration with C linkage and the given name with a different mangled name
+                bool hasIncompatibleCDecl( const std::string & id, const std::string & mangleName ) const;
         };
 } // namespace SymTab

src/SymTab/Mangler.cc

@@ -10 +10 @@
 // Created On       : Sun May 17 21:40:29 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Sep 25 15:49:26 2017
-// Update Count     : 23
+// Last Modified On : Tue Jul 30 13:46:10 2019
+// Update Count     : 26
 //
 #include "Mangler.h"
 
-#include <algorithm>                // for copy, transform
-#include <cassert>                  // for assert, assertf
-#include <functional>               // for const_mem_fun_t, mem_fun
-#include <iterator>                 // for ostream_iterator, back_insert_ite...
-#include <list>                     // for _List_iterator, list, _List_const...
-#include <string>                   // for string, char_traits, operator<<
-
-#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
+#include <algorithm>                     // for copy, transform
+#include <cassert>                       // for assert, assertf
+#include <functional>                    // for const_mem_fun_t, mem_fun
+#include <iterator>                      // for ostream_iterator, back_insert_ite...
+#include <list>                          // for _List_iterator, list, _List_const...
+#include <string>                        // for string, char_traits, operator<<
+
+#include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"   // for SemanticError
-#include "Common/utility.h"         // for toString
-#include "Parser/LinkageSpec.h"     // for Spec, isOverridable, AutoGen, Int...
-#include "SynTree/Declaration.h"    // for TypeDecl, DeclarationWithType
-#include "SynTree/Expression.h"     // for TypeExpr, Expression, operator<<
-#include "SynTree/Type.h"           // for Type, ReferenceToType, Type::Fora...
+#include "Common/SemanticError.h"        // for SemanticError
+#include "Common/utility.h"              // for toString
+#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
+#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
+
+#include "AST/Pass.hpp"
 
 namespace SymTab {
@@ -35 +38 @@
                 namespace {
                         /// Mangles names to a unique C identifier
-                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
-                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
-                                Mangler( const Mangler & ) = delete;
-
-                                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-
-                                void postvisit( ObjectDecl * declaration );
-                                void postvisit( FunctionDecl * declaration );
-                                void postvisit( TypeDecl * declaration );
-
-                                void postvisit( VoidType * voidType );
-                                void postvisit( BasicType * basicType );
-                                void postvisit( PointerType * pointerType );
-                                void postvisit( ArrayType * arrayType );
-                                void postvisit( ReferenceType * refType );
-                                void postvisit( FunctionType * functionType );
-                                void postvisit( StructInstType * aggregateUseType );
-                                void postvisit( UnionInstType * aggregateUseType );
-                                void postvisit( EnumInstType * aggregateUseType );
-                                void postvisit( TypeInstType * aggregateUseType );
-                                void postvisit( TraitInstType * inst );
-                                void postvisit( TupleType * tupleType );
-                                void postvisit( VarArgsType * varArgsType );
-                                void postvisit( ZeroType * zeroType );
-                                void postvisit( OneType * oneType );
+                        struct Mangler_old : public WithShortCircuiting, public WithVisitorRef<Mangler_old>, public WithGuards {
+                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                                Mangler_old( const Mangler_old & ) = delete;
+
+                                void previsit( const BaseSyntaxNode * ) { visit_children = false; }
+
+                                void postvisit( const ObjectDecl * declaration );
+                                void postvisit( const FunctionDecl * declaration );
+                                void postvisit( const TypeDecl * declaration );
+
+                                void postvisit( const VoidType * voidType );
+                                void postvisit( const BasicType * basicType );
+                                void postvisit( const PointerType * pointerType );
+                                void postvisit( const ArrayType * arrayType );
+                                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 TypeInstType * aggregateUseType );
+                                void postvisit( const TraitInstType * inst );
+                                void postvisit( const TupleType * tupleType );
+                                void postvisit( const VarArgsType * varArgsType );
+                                void postvisit( const ZeroType * zeroType );
+                                void postvisit( const OneType * oneType );
+                                void postvisit( const QualifiedType * qualType );
 
                                 std::string get_mangleName() { return mangleName.str(); }
@@ -72 +76 @@
                                 bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
                                 bool inFunctionType = false;    ///< Include type qualifiers if false.
-
-                                void mangleDecl( DeclarationWithType *declaration );
-                                void mangleRef( ReferenceToType *refType, std::string prefix );
-
-                                void printQualifiers( Type *type );
-                        }; // Mangler
+                                bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
+
+                          public:
+                                Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                        int nextVarNum, const VarMapType& varNums );
+
+                          private:
+                                void mangleDecl( const DeclarationWithType * declaration );
+                                void mangleRef( const ReferenceToType * refType, std::string prefix );
+
+                                void printQualifiers( const Type *type );
+                        }; // Mangler_old
                 } // namespace
 
-                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
-                        PassVisitor<Mangler> mangler( mangleOverridable, typeMode, mangleGenericParams );
+                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
+                        PassVisitor<Mangler_old> mangler( mangleOverridable, typeMode, mangleGenericParams );
                         maybeAccept( decl, mangler );
                         return mangler.pass.get_mangleName();
                 }
 
-                std::string mangleType( Type * ty ) {
-                        PassVisitor<Mangler> mangler( false, true, true );
+                std::string mangleType( const Type * ty ) {
+                        PassVisitor<Mangler_old> mangler( false, true, true );
                         maybeAccept( ty, mangler );
                         return mangler.pass.get_mangleName();
                 }
 
-                std::string mangleConcrete( Type * ty ) {
-                        PassVisitor<Mangler> mangler( false, false, false );
+                std::string mangleConcrete( const Type * ty ) {
+                        PassVisitor<Mangler_old> mangler( false, false, false );
                         maybeAccept( ty, mangler );
                         return mangler.pass.get_mangleName();
@@ -99 +109 @@
 
                 namespace {
-                        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
-
-                        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
+                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                                : nextVarNum( 0 ), isTopLevel( true ),
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
+                                mangleGenericParams( mangleGenericParams ) {}
+
+                        Mangler_old::Mangler_old( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                int nextVarNum, const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ),
+                                mangleGenericParams( mangleGenericParams ) {}
+
+                        void Mangler_old::mangleDecl( const DeclarationWithType * declaration ) {
                                 bool wasTopLevel = isTopLevel;
                                 if ( isTopLevel ) {
@@ -109 +127 @@
                                         isTopLevel = false;
                                 } // if
-                                mangleName << "__";
+                                mangleName << Encoding::manglePrefix;
                                 CodeGen::OperatorInfo opInfo;
                                 if ( operatorLookup( declaration->get_name(), opInfo ) ) {
-                                        mangleName << opInfo.outputName;
+                                        mangleName << opInfo.outputName.size() << opInfo.outputName;
                                 } else {
-                                        mangleName << declaration->get_name();
-                                } // if
-                                mangleName << "__";
+                                        mangleName << declaration->name.size() << declaration->name;
+                                } // if
                                 maybeAccept( declaration->get_type(), *visitor );
                                 if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
@@ -122 +139 @@
                                         // so they need a different name mangling
                                         if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
-                                                mangleName << "autogen__";
+                                                mangleName << Encoding::autogen;
                                         } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                mangleName << "intrinsic__";
+                                                mangleName << Encoding::intrinsic;
                                         } else {
                                                 // if we add another kind of overridable function, this has to change
@@ -133 +150 @@
                         }
 
-                        void Mangler::postvisit( ObjectDecl * declaration ) {
+                        void Mangler_old::postvisit( const ObjectDecl * declaration ) {
                                 mangleDecl( declaration );
                         }
 
-                        void Mangler::postvisit( FunctionDecl * declaration ) {
+                        void Mangler_old::postvisit( const FunctionDecl * declaration ) {
                                 mangleDecl( declaration );
                         }
 
-                        void Mangler::postvisit( VoidType * voidType ) {
+                        void Mangler_old::postvisit( const VoidType * voidType ) {
                                 printQualifiers( voidType );
-                                mangleName << "v";
-                        }
-
-                        void Mangler::postvisit( BasicType * basicType ) {
-                                static const char *btLetter[] = {
-                                        "b",    // Bool
-                                        "c",    // Char
-                                        "Sc",   // SignedChar
-                                        "Uc",   // UnsignedChar
-                                        "s",    // ShortSignedInt
-                                        "Us",   // ShortUnsignedInt
-                                        "i",    // SignedInt
-                                        "Ui",   // UnsignedInt
-                                        "l",    // LongSignedInt
-                                        "Ul",   // LongUnsignedInt
-                                        "q",    // LongLongSignedInt
-                                        "Uq",   // LongLongUnsignedInt
-                                        "f",    // Float
-                                        "d",    // Double
-                                        "r",    // LongDouble
-                                        "Xf",   // FloatComplex
-                                        "Xd",   // DoubleComplex
-                                        "Xr",   // LongDoubleComplex
-                                        "If",   // FloatImaginary
-                                        "Id",   // DoubleImaginary
-                                        "Ir",   // LongDoubleImaginary
-                                        "w",    // SignedInt128
-                                        "Uw",   // UnsignedInt128
-                                        "x",   // Float80
-                                        "y",   // Float128
-                                };
-                                static_assert(
-                                        sizeof(btLetter)/sizeof(btLetter[0]) == BasicType::NUMBER_OF_BASIC_TYPES,
-                                        "Each basic type kind should have a corresponding mangler letter"
-                                );
-
+                                mangleName << Encoding::void_t;
+                        }
+
+                        void Mangler_old::postvisit( const BasicType * basicType ) {
                                 printQualifiers( basicType );
-                                assert( basicType->get_kind() < sizeof(btLetter)/sizeof(btLetter[0]) );
-                                mangleName << btLetter[ basicType->get_kind() ];
-                        }
-
-                        void Mangler::postvisit( PointerType * pointerType ) {
+                                assertf( basicType->kind < BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
+                                mangleName << Encoding::basicTypes[ basicType->kind ];
+                        }
+
+                        void Mangler_old::postvisit( const PointerType * pointerType ) {
                                 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 << "P";
+                                if ( ! dynamic_cast<FunctionType *>( pointerType->base ) ) mangleName << Encoding::pointer;
                                 maybeAccept( pointerType->base, *visitor );
                         }
 
-                        void Mangler::postvisit( ArrayType * arrayType ) {
+                        void Mangler_old::postvisit( const ArrayType * arrayType ) {
                                 // TODO: encode dimension
                                 printQualifiers( arrayType );
-                                mangleName << "A0";
+                                mangleName << Encoding::array << "0";
                                 maybeAccept( arrayType->base, *visitor );
                         }
 
-                        void Mangler::postvisit( ReferenceType * refType ) {
+                        void Mangler_old::postvisit( const ReferenceType * refType ) {
                                 // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
                                 // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
@@ -217 +202 @@
                         }
 
-                        void Mangler::postvisit( FunctionType * functionType ) {
+                        void Mangler_old::postvisit( const FunctionType * functionType ) {
                                 printQualifiers( functionType );
-                                mangleName << "F";
+                                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.,
@@ -226 +211 @@
                                 inFunctionType = true;
                                 std::list< Type* > returnTypes = getTypes( functionType->returnVals );
-                                acceptAll( returnTypes, *visitor );
+                                if (returnTypes.empty()) mangleName << Encoding::void_t;
+                                else acceptAll( returnTypes, *visitor );
                                 mangleName << "_";
                                 std::list< Type* > paramTypes = getTypes( functionType->parameters );
@@ -233 +219 @@
                         }
 
-                        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
+                        void Mangler_old::mangleRef( const ReferenceToType * refType, std::string prefix ) {
                                 printQualifiers( refType );
 
-                                mangleName << ( refType->name.length() + prefix.length() ) << prefix << refType->name;
+                                mangleName << prefix << refType->name.length() << refType->name;
 
                                 if ( mangleGenericParams ) {
-                                        std::list< Expression* >& params = refType->parameters;
+                                        const std::list< Expression* > & params = refType->parameters;
                                         if ( ! params.empty() ) {
                                                 mangleName << "_";
-                                                for ( std::list< Expression* >::const_iterator param = params.begin(); param != params.end(); ++param ) {
-                                                        TypeExpr *paramType = dynamic_cast< TypeExpr* >( *param );
-                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(*param));
+                                                for ( const Expression * param : params ) {
+                                                        const TypeExpr * paramType = dynamic_cast< const TypeExpr * >( param );
+                                                        assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
                                                         maybeAccept( paramType->type, *visitor );
                                                 }
@@ -252 +238 @@
                         }
 
-                        void Mangler::postvisit( StructInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, "s" );
-                        }
-
-                        void Mangler::postvisit( UnionInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, "u" );
-                        }
-
-                        void Mangler::postvisit( EnumInstType * aggregateUseType ) {
-                                mangleRef( aggregateUseType, "e" );
-                        }
-
-                        void Mangler::postvisit( TypeInstType * typeInst ) {
+                        void Mangler_old::postvisit( const StructInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::struct_t );
+                        }
+
+                        void Mangler_old::postvisit( const UnionInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::union_t );
+                        }
+
+                        void Mangler_old::postvisit( const EnumInstType * aggregateUseType ) {
+                                mangleRef( aggregateUseType, Encoding::enum_t );
+                        }
+
+                        void Mangler_old::postvisit( const TypeInstType * typeInst ) {
                                 VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
                                 if ( varNum == varNums.end() ) {
-                                        mangleRef( typeInst, "t" );
+                                        mangleRef( typeInst, Encoding::type );
                                 } else {
                                         printQualifiers( typeInst );
-                                        std::ostringstream numStream;
-                                        numStream << varNum->second.first;
-                                        switch ( (TypeDecl::Kind )varNum->second.second ) {
-                                          case TypeDecl::Dtype:
-                                                mangleName << "d";
-                                                break;
-                                          case TypeDecl::Ftype:
-                                                mangleName << "f";
-                                                break;
-                                                case TypeDecl::Ttype:
-                                                mangleName << "tVARGS";
-                                                break;
-                                                default:
-                                                assert( false );
-                                        } // switch
-                                        mangleName << numStream.str();
-                                } // if
-                        }
-
-                        void Mangler::postvisit( TraitInstType * inst ) {
+                                        // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
+                                        //   forall(dtype T) void f(T);
+                                        //   forall(dtype S) void f(S);
+                                        // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
+                                        // 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;
+                                } // if
+                        }
+
+                        void Mangler_old::postvisit( const TraitInstType * inst ) {
                                 printQualifiers( inst );
-                                mangleName << "_Y" << inst->name << "_";
-                        }
-
-                        void Mangler::postvisit( TupleType * tupleType ) {
+                                mangleName << inst->name.size() << inst->name;
+                        }
+
+                        void Mangler_old::postvisit( const TupleType * tupleType ) {
                                 printQualifiers( tupleType );
-                                mangleName << "T";
+                                mangleName << Encoding::tuple << tupleType->types.size();
                                 acceptAll( tupleType->types, *visitor );
-                                mangleName << "_";
-                        }
-
-                        void Mangler::postvisit( VarArgsType * varArgsType ) {
+                        }
+
+                        void Mangler_old::postvisit( const VarArgsType * varArgsType ) {
                                 printQualifiers( varArgsType );
-                                mangleName << "VARGS";
-                        }
-
-                        void Mangler::postvisit( ZeroType * ) {
-                                mangleName << "Z";
-                        }
-
-                        void Mangler::postvisit( OneType * ) {
-                                mangleName << "O";
-                        }
-
-                        void Mangler::postvisit( TypeDecl * decl ) {
-                                static const char *typePrefix[] = { "BT", "BD", "BF" };
-                                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+                                static const std::string vargs = "__builtin_va_list";
+                                mangleName << Encoding::type << vargs.size() << vargs;
+                        }
+
+                        void Mangler_old::postvisit( const ZeroType * ) {
+                                mangleName << Encoding::zero;
+                        }
+
+                        void Mangler_old::postvisit( const OneType * ) {
+                                mangleName << Encoding::one;
+                        }
+
+                        void Mangler_old::postvisit( const QualifiedType * qualType ) {
+                                bool inqual = inQualifiedType;
+                                if (! inqual ) {
+                                        // N marks the start of a qualified type
+                                        inQualifiedType = true;
+                                        mangleName << Encoding::qualifiedTypeStart;
+                                }
+                                maybeAccept( qualType->parent, *visitor );
+                                maybeAccept( qualType->child, *visitor );
+                                if ( ! inqual ) {
+                                        // E marks the end of a qualified type
+                                        inQualifiedType = false;
+                                        mangleName << Encoding::qualifiedTypeEnd;
+                                }
+                        }
+
+                        void Mangler_old::postvisit( const TypeDecl * decl ) {
+                                // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
+                                // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
+                                // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
+                                // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
+                                // aside from the assert false.
+                                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;
                         }
 
@@ -325 +324 @@
                         }
 
-                        void Mangler::printQualifiers( Type * type ) {
+                        void Mangler_old::printQualifiers( const Type * type ) {
                                 // skip if not including qualifiers
                                 if ( typeMode ) return;
-                                if ( ! type->get_forall().empty() ) {
+                                if ( ! type->forall.empty() ) {
                                         std::list< std::string > assertionNames;
-                                        int tcount = 0, dcount = 0, fcount = 0, vcount = 0;
-                                        mangleName << "A";
-                                        for ( Type::ForallList::iterator i = type->forall.begin(); i != type->forall.end(); ++i ) {
-                                                switch ( (*i)->get_kind() ) {
+                                        int dcount = 0, fcount = 0, vcount = 0, acount = 0;
+                                        mangleName << Encoding::forall;
+                                        for ( const TypeDecl * i : type->forall ) {
+                                                switch ( i->kind ) {
                                                   case TypeDecl::Dtype:
                                                         dcount++;
@@ -346 +345 @@
                                                         assert( false );
                                                 } // switch
-                                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
-                                                for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
-                                                        PassVisitor<Mangler> sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
-                                                        sub_mangler.pass.nextVarNum = nextVarNum;
-                                                        sub_mangler.pass.isTopLevel = false;
-                                                        sub_mangler.pass.varNums = varNums;
-                                                        (*assert)->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.mangleName.str() );
+                                                varNums[ i->name ] = std::make_pair( nextVarNum, (int)i->kind );
+                                                for ( const DeclarationWithType * assert : i->assertions ) {
+                                                        PassVisitor<Mangler_old> sub_mangler(
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, varNums );
+                                                        assert->accept( sub_mangler );
+                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
+                                                        acount++;
                                                 } // for
                                         } // for
-                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
+                                        mangleName << dcount << "_" << fcount << "_" << vcount << "_" << acount << "_";
                                         std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
                                         mangleName << "_";
@@ -363 +361 @@
                                         // these qualifiers do not distinguish the outermost type of a function parameter
                                         if ( type->get_const() ) {
-                                                mangleName << "C";
+                                                mangleName << Encoding::qualifiers.at(Type::Const);
                                         } // if
                                         if ( type->get_volatile() ) {
-                                                mangleName << "V";
+                                                mangleName << Encoding::qualifiers.at(Type::Volatile);
                                         } // if
                                         // Removed due to restrict not affecting function compatibility in GCC
@@ -373 +371 @@
                                         // } // if
                                         if ( type->get_atomic() ) {
-                                                mangleName << "A";
+                                                mangleName << Encoding::qualifiers.at(Type::Atomic);
                                         } // if
                                 }
                                 if ( type->get_mutex() ) {
-                                        mangleName << "M";
-                                } // if
-                                if ( type->get_lvalue() ) {
-                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
-                                        mangleName << "L";
-                                }
-
+                                        mangleName << Encoding::qualifiers.at(Type::Mutex);
+                                } // if
                                 if ( inFunctionType ) {
                                         // turn off inFunctionType so that types can be differentiated for nested qualifiers
@@ -394 +387 @@
 } // namespace SymTab
 
+namespace Mangle {
+        namespace {
+                /// Mangles names to a unique C identifier
+                struct Mangler_new : public ast::WithShortCircuiting, public ast::WithVisitorRef<Mangler_new>, public ast::WithGuards {
+                        Mangler_new( Mangle::Mode mode );
+                        Mangler_new( const Mangler_new & ) = delete;
+
+                        void previsit( const ast::Node * ) { visit_children = false; }
+
+                        void postvisit( const ast::ObjectDecl * declaration );
+                        void postvisit( const ast::FunctionDecl * declaration );
+                        void postvisit( const ast::TypeDecl * declaration );
+
+                        void postvisit( const ast::VoidType * voidType );
+                        void postvisit( const ast::BasicType * basicType );
+                        void postvisit( const ast::PointerType * pointerType );
+                        void postvisit( const ast::ArrayType * arrayType );
+                        void postvisit( const ast::ReferenceType * refType );
+                        void postvisit( const ast::FunctionType * functionType );
+                        void postvisit( const ast::StructInstType * aggregateUseType );
+                        void postvisit( const ast::UnionInstType * aggregateUseType );
+                        void postvisit( const ast::EnumInstType * aggregateUseType );
+                        void postvisit( const ast::TypeInstType * aggregateUseType );
+                        void postvisit( const ast::TraitInstType * inst );
+                        void postvisit( const ast::TupleType * tupleType );
+                        void postvisit( const ast::VarArgsType * varArgsType );
+                        void postvisit( const ast::ZeroType * zeroType );
+                        void postvisit( const ast::OneType * oneType );
+                        void postvisit( const ast::QualifiedType * qualType );
+
+                        std::string get_mangleName() { return mangleName.str(); }
+                  private:
+                        std::ostringstream mangleName;  ///< Mangled name being constructed
+                        typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                        VarMapType varNums;             ///< Map of type variables to indices
+                        int nextVarNum;                 ///< Next type variable index
+                        bool isTopLevel;                ///< Is the Mangler at the top level
+                        bool mangleOverridable;         ///< Specially mangle overridable built-in methods
+                        bool typeMode;                  ///< Produce a unique mangled name for a type
+                        bool mangleGenericParams;       ///< Include generic parameters in name mangling if true
+                        bool inFunctionType = false;    ///< Include type qualifiers if false.
+                        bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
+
+                  private:
+                        Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                                int nextVarNum, const VarMapType& varNums );
+                        friend class ast::Pass<Mangler_new>;
+
+                  private:
+                        void mangleDecl( const ast::DeclWithType *declaration );
+                        void mangleRef( const ast::ReferenceToType *refType, std::string prefix );
+
+                        void printQualifiers( const ast::Type *type );
+                }; // Mangler_new
+        } // namespace
+
+
+        std::string mangle( const ast::Node * decl, Mangle::Mode mode ) {
+                ast::Pass<Mangler_new> mangler( mode );
+                maybeAccept( decl, mangler );
+                return mangler.pass.get_mangleName();
+        }
+
+        namespace {
+                Mangler_new::Mangler_new( Mangle::Mode mode )
+                        : nextVarNum( 0 ), isTopLevel( true ),
+                        mangleOverridable  ( ! mode.no_overrideable   ),
+                        typeMode           (   mode.type              ),
+                        mangleGenericParams( ! mode.no_generic_params ) {}
+
+                Mangler_new::Mangler_new( bool mangleOverridable, bool typeMode, bool mangleGenericParams,
+                        int nextVarNum, const VarMapType& varNums )
+                        : varNums( varNums ), nextVarNum( nextVarNum ), isTopLevel( false ),
+                        mangleOverridable( mangleOverridable ), typeMode( typeMode ),
+                        mangleGenericParams( mangleGenericParams ) {}
+
+                void Mangler_new::mangleDecl( const ast::DeclWithType * decl ) {
+                        bool wasTopLevel = isTopLevel;
+                        if ( isTopLevel ) {
+                                varNums.clear();
+                                nextVarNum = 0;
+                                isTopLevel = false;
+                        } // if
+                        mangleName << Encoding::manglePrefix;
+                        CodeGen::OperatorInfo opInfo;
+                        if ( operatorLookup( decl->name, opInfo ) ) {
+                                mangleName << opInfo.outputName.size() << opInfo.outputName;
+                        } else {
+                                mangleName << decl->name.size() << decl->name;
+                        } // if
+                        maybeAccept( decl->get_type(), *visitor );
+                        if ( mangleOverridable && decl->linkage.is_overrideable ) {
+                                // want to be able to override autogenerated and intrinsic routines,
+                                // so they need a different name mangling
+                                if ( decl->linkage == ast::Linkage::AutoGen ) {
+                                        mangleName << Encoding::autogen;
+                                } else if ( decl->linkage == ast::Linkage::Intrinsic ) {
+                                        mangleName << Encoding::intrinsic;
+                                } else {
+                                        // if we add another kind of overridable function, this has to change
+                                        assert( false && "unknown overrideable linkage" );
+                                } // if
+                        }
+                        isTopLevel = wasTopLevel;
+                }
+
+                void Mangler_new::postvisit( const ast::ObjectDecl * decl ) {
+                        mangleDecl( decl );
+                }
+
+                void Mangler_new::postvisit( const ast::FunctionDecl * decl ) {
+                        mangleDecl( decl );
+                }
+
+                void Mangler_new::postvisit( const ast::VoidType * voidType ) {
+                        printQualifiers( voidType );
+                        mangleName << Encoding::void_t;
+                }
+
+                void Mangler_new::postvisit( const ast::BasicType * basicType ) {
+                        printQualifiers( basicType );
+                        assertf( basicType->kind < ast::BasicType::NUMBER_OF_BASIC_TYPES, "Unhandled basic type: %d", basicType->kind );
+                        mangleName << Encoding::basicTypes[ basicType->kind ];
+                }
+
+                void Mangler_new::postvisit( const ast::PointerType * pointerType ) {
+                        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;
+                        maybe_accept( pointerType->base.get(), *visitor );
+                }
+
+                void Mangler_new::postvisit( const ast::ArrayType * arrayType ) {
+                        // TODO: encode dimension
+                        printQualifiers( arrayType );
+                        mangleName << Encoding::array << "0";
+                        maybeAccept( arrayType->base.get(), *visitor );
+                }
+
+                void Mangler_new::postvisit( const ast::ReferenceType * refType ) {
+                        // don't print prefix (e.g. 'R') for reference types so that references and non-references do not overload.
+                        // Further, do not print the qualifiers for a reference type (but do run printQualifers because of TypeDecls, etc.),
+                        // by pretending every reference type is a function parameter.
+                        GuardValue( inFunctionType );
+                        inFunctionType = true;
+                        printQualifiers( refType );
+                        maybeAccept( refType->base.get(), *visitor );
+                }
+
+                inline std::vector< ast::ptr< ast::Type > > getTypes( const std::vector< ast::ptr< ast::DeclWithType > > & decls ) {
+                        std::vector< ast::ptr< ast::Type > > ret;
+                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
+                                                        std::mem_fun( &ast::DeclWithType::get_type ) );
+                        return ret;
+                }
+
+                void Mangler_new::postvisit( const ast::FunctionType * functionType ) {
+                        printQualifiers( functionType );
+                        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.,
+                        // void (*)(const int) and void (*)(int) are the same type, but void (*)(const int *) and void (*)(int *) are different
+                        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 ) {
+                        printQualifiers( refType );
+
+                        mangleName << prefix << refType->name.length() << refType->name;
+
+                        if ( mangleGenericParams ) {
+                                if ( ! refType->params.empty() ) {
+                                        mangleName << "_";
+                                        for ( const ast::Expr * param : refType->params ) {
+                                                auto paramType = dynamic_cast< const ast::TypeExpr * >( param );
+                                                assertf(paramType, "Aggregate parameters should be type expressions: %s", toCString(param));
+                                                maybeAccept( paramType->type.get(), *visitor );
+                                        }
+                                        mangleName << "_";
+                                }
+                        }
+                }
+
+                void Mangler_new::postvisit( const ast::StructInstType * aggregateUseType ) {
+                        mangleRef( aggregateUseType, Encoding::struct_t );
+                }
+
+                void Mangler_new::postvisit( const ast::UnionInstType * aggregateUseType ) {
+                        mangleRef( aggregateUseType, Encoding::union_t );
+                }
+
+                void Mangler_new::postvisit( const ast::EnumInstType * aggregateUseType ) {
+                        mangleRef( aggregateUseType, Encoding::enum_t );
+                }
+
+                void Mangler_new::postvisit( const ast::TypeInstType * typeInst ) {
+                        VarMapType::iterator varNum = varNums.find( typeInst->name );
+                        if ( varNum == varNums.end() ) {
+                                mangleRef( typeInst, Encoding::type );
+                        } else {
+                                printQualifiers( typeInst );
+                                // Note: Can't use name here, since type variable names do not actually disambiguate a function, e.g.
+                                //   forall(dtype T) void f(T);
+                                //   forall(dtype S) void f(S);
+                                // are equivalent and should mangle the same way. This is accomplished by numbering the type variables when they
+                                // 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;
+                        } // if
+                }
+
+                void Mangler_new::postvisit( const ast::TraitInstType * inst ) {
+                        printQualifiers( inst );
+                        mangleName << inst->name.size() << inst->name;
+                }
+
+                void Mangler_new::postvisit( const ast::TupleType * tupleType ) {
+                        printQualifiers( tupleType );
+                        mangleName << Encoding::tuple << tupleType->types.size();
+                        accept_each( tupleType->types, *visitor );
+                }
+
+                void Mangler_new::postvisit( const ast::VarArgsType * varArgsType ) {
+                        printQualifiers( varArgsType );
+                        static const std::string vargs = "__builtin_va_list";
+                        mangleName << Encoding::type << vargs.size() << vargs;
+                }
+
+                void Mangler_new::postvisit( const ast::ZeroType * ) {
+                        mangleName << Encoding::zero;
+                }
+
+                void Mangler_new::postvisit( const ast::OneType * ) {
+                        mangleName << Encoding::one;
+                }
+
+                void Mangler_new::postvisit( const ast::QualifiedType * qualType ) {
+                        bool inqual = inQualifiedType;
+                        if (! inqual ) {
+                                // N marks the start of a qualified type
+                                inQualifiedType = true;
+                                mangleName << Encoding::qualifiedTypeStart;
+                        }
+                        maybeAccept( qualType->parent.get(), *visitor );
+                        maybeAccept( qualType->child.get(), *visitor );
+                        if ( ! inqual ) {
+                                // E marks the end of a qualified type
+                                inQualifiedType = false;
+                                mangleName << Encoding::qualifiedTypeEnd;
+                        }
+                }
+
+                void Mangler_new::postvisit( const ast::TypeDecl * decl ) {
+                        // TODO: is there any case where mangling a TypeDecl makes sense? If so, this code needs to be
+                        // fixed to ensure that two TypeDecls mangle to the same name when they are the same type and vice versa.
+                        // Note: The current scheme may already work correctly for this case, I have not thought about this deeply
+                        // and the case has not yet come up in practice. Alternatively, if not then this code can be removed
+                        // aside from the assert false.
+                        assertf(false, "Mangler_new should not visit typedecl: %s", toCString(decl));
+                        assertf( decl->kind < ast::TypeVar::Kind::NUMBER_OF_KINDS, "Unhandled type variable kind: %d", decl->kind );
+                        mangleName << Encoding::typeVariables[ decl->kind ] << ( decl->name.length() ) << decl->name;
+                }
+
+                __attribute__((unused)) void printVarMap( const std::map< std::string, std::pair< int, int > > &varMap, std::ostream &os ) {
+                        for ( std::map< std::string, std::pair< int, int > >::const_iterator i = varMap.begin(); i != varMap.end(); ++i ) {
+                                os << i->first << "(" << i->second.first << "/" << i->second.second << ")" << std::endl;
+                        } // for
+                }
+
+                void Mangler_new::printQualifiers( const ast::Type * type ) {
+                        // skip if not including qualifiers
+                        if ( typeMode ) return;
+                        if ( auto ptype = dynamic_cast< const ast::ParameterizedType * >(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 ) {
+                                                switch ( decl->kind ) {
+                                                case ast::TypeVar::Kind::Dtype:
+                                                        dcount++;
+                                                        break;
+                                                case ast::TypeVar::Kind::Ftype:
+                                                        fcount++;
+                                                        break;
+                                                case ast::TypeVar::Kind::Ttype:
+                                                        vcount++;
+                                                        break;
+                                                default:
+                                                        assert( false );
+                                                } // 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 << "_";
+                                } // if
+                        } // if
+                        if ( ! inFunctionType ) {
+                                // these qualifiers do not distinguish the outermost type of a function parameter
+                                if ( type->is_const() ) {
+                                        mangleName << Encoding::qualifiers.at(Type::Const);
+                                } // if
+                                if ( type->is_volatile() ) {
+                                        mangleName << Encoding::qualifiers.at(Type::Volatile);
+                                } // if
+                                // Removed due to restrict not affecting function compatibility in GCC
+                                // if ( type->get_isRestrict() ) {
+                                //      mangleName << "E";
+                                // } // if
+                                if ( type->is_atomic() ) {
+                                        mangleName << Encoding::qualifiers.at(Type::Atomic);
+                                } // if
+                        }
+                        if ( type->is_mutex() ) {
+                                mangleName << Encoding::qualifiers.at(Type::Mutex);
+                        } // if
+                        if ( inFunctionType ) {
+                                // turn off inFunctionType so that types can be differentiated for nested qualifiers
+                                GuardValue( inFunctionType );
+                                inFunctionType = false;
+                        }
+                }
+        }       // namespace
+} // namespace Mangle
+
 // Local Variables: //
 // tab-width: 4 //

src/SymTab/Mangler.h

@@ -21 +21 @@
 #include <utility>            // for pair
 
+#include "AST/Bitfield.hpp"
+#include "AST/Fwd.hpp"
 #include "SynTree/SynTree.h"  // for Types
 #include "SynTree/Visitor.h"  // for Visitor, maybeAccept
+
+// https://itanium-cxx-abi.github.io/cxx-abi/abi.html#mangling
+// The CFA name mangling scheme is based closely on the itanium C++ name mangling scheme, with the following key differences:
+// * Variable names are also mangled to include type information, not just functions
+// * CFA does not have template expansion, so the rules for function specialization do not apply.
+// * CFA instead has to handle type parameters and assertion parameters.
+// * Currently name compression is not implemented.
+
+namespace ResolvExpr {
+        class TypeEnvironment;
+}
 
 namespace SymTab {
         namespace Mangler {
                 /// Mangle syntax tree object; primary interface to clients
-                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+                std::string mangle( const BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
 
                 /// Mangle a type name; secondary interface
-                std::string mangleType( Type* ty );
+                std::string mangleType( const Type * ty );
                 /// Mangle ignoring generic type parameters
-                std::string mangleConcrete( Type* ty );
+                std::string mangleConcrete( const Type * ty );
+
+                namespace Encoding {
+                        extern const std::string manglePrefix;
+                        extern const std::string basicTypes[];
+                        extern const std::map<int, std::string> qualifiers;
+
+                        extern const std::string void_t;
+                        extern const std::string zero;
+                        extern const std::string one;
+
+                        extern const std::string function;
+                        extern const std::string tuple;
+                        extern const std::string pointer;
+                        extern const std::string array;
+                        extern const std::string qualifiedTypeStart;
+                        extern const std::string qualifiedTypeEnd;
+
+                        extern const std::string forall;
+                        extern const std::string typeVariables[];
+
+                        extern const std::string struct_t;
+                        extern const std::string union_t;
+                        extern const std::string enum_t;
+                        extern const std::string type;
+
+                        extern const std::string autogen;
+                        extern const std::string intrinsic;
+                };
         } // Mangler
 } // SymTab
+
+namespace Mangle {
+        /// Bitflags for mangle modes
+        enum {
+                NoOverrideable  = 1 << 0,
+                Type            = 1 << 1,
+                NoGenericParams = 1 << 2
+        };
+
+        /// Bitflag type for mangler modes
+        struct mangle_flags {
+                union {
+                        unsigned int val;
+                        struct {
+                                bool no_overrideable   : 1;
+                                bool type              : 1;
+                                bool no_generic_params : 1;
+                        };
+                };
+
+                constexpr mangle_flags( unsigned int val ) : val(val) {}
+        };
+
+        using Mode = bitfield<mangle_flags>;
+
+        static inline Mode typeMode() { return NoOverrideable | Type; }
+
+        /// Mangle declaration name
+        std::string mangle( const ast::Node * decl, Mode mode = {} );
+
+        namespace Encoding {
+                using namespace SymTab::Mangler::Encoding;
+        };
+}
+
+extern "C" {
+        char * cforall_demangle(const char *, int);
+}
 
 // Local Variables: //

src/SymTab/Validate.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 21:50:04 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Aug 28 13:47:23 2017
-// Update Count     : 359
+// Last Modified By : Andrew Beach
+// Last Modified On : Wed Aug  7 6:42:00 2019
+// Update Count     : 360
 //
 
@@ -44 +44 @@
 #include <list>                        // for list
 #include <string>                      // for string
+#include <unordered_map>               // for unordered_map
 #include <utility>                     // for pair
 
+#include "AST/Chain.hpp"
+#include "AST/Decl.hpp"
+#include "AST/Node.hpp"
+#include "AST/Pass.hpp"
+#include "AST/SymbolTable.hpp"
+#include "AST/Type.hpp"
+#include "AST/TypeSubstitution.hpp"
 #include "CodeGen/CodeGenerator.h"     // for genName
 #include "CodeGen/OperatorTable.h"     // for isCtorDtor, isCtorDtorAssign
 #include "ControlStruct/Mutate.h"      // for ForExprMutator
+#include "Common/CodeLocation.h"       // for CodeLocation
+#include "Common/Stats.h"              // for Stats::Heap
 #include "Common/PassVisitor.h"        // for PassVisitor, WithDeclsToAdd
 #include "Common/ScopedMap.h"          // for ScopedMap
@@ -61 +71 @@
 #include "Parser/LinkageSpec.h"        // for C
 #include "ResolvExpr/typeops.h"        // for typesCompatible
+#include "ResolvExpr/Resolver.h"       // for findSingleExpression
+#include "ResolvExpr/ResolveTypeof.h"  // for resolveTypeof
 #include "SymTab/Autogen.h"            // for SizeType
 #include "SynTree/Attribute.h"         // for noAttributes, Attribute
@@ -72 +84 @@
 #include "SynTree/TypeSubstitution.h"  // for TypeSubstitution
 #include "SynTree/Visitor.h"           // for Visitor
+#include "Validate/HandleAttributes.h" // for handleAttributes
+#include "Validate/FindSpecialDecls.h" // for FindSpecialDecls
 
 class CompoundStmt;
@@ -77 +91 @@
 class SwitchStmt;
 
-#define debugPrint( x ) if ( doDebug ) { std::cout << x; }
+#define debugPrint( x ) if ( doDebug ) x
 
 namespace SymTab {
+        /// hoists declarations that are difficult to hoist while parsing
+        struct HoistTypeDecls final : public WithDeclsToAdd {
+                void previsit( SizeofExpr * );
+                void previsit( AlignofExpr * );
+                void previsit( UntypedOffsetofExpr * );
+                void previsit( CompoundLiteralExpr * );
+                void handleType( Type * );
+        };
+
+        struct FixQualifiedTypes final : public WithIndexer {
+                Type * postmutate( QualifiedType * );
+        };
+
         struct HoistStruct final : public WithDeclsToAdd, public WithGuards {
                 /// Flattens nested struct types
                 static void hoistStruct( std::list< Declaration * > &translationUnit );
 
-                void previsit( EnumInstType * enumInstType );
-                void previsit( StructInstType * structInstType );
-                void previsit( UnionInstType * unionInstType );
                 void previsit( StructDecl * aggregateDecl );
                 void previsit( UnionDecl * aggregateDecl );
                 void previsit( StaticAssertDecl * assertDecl );
+                void previsit( StructInstType * type );
+                void previsit( UnionInstType * type );
+                void previsit( EnumInstType * type );
 
           private:
-                template< typename AggDecl > void handleAggregate( AggDecl *aggregateDecl );
+                template< typename AggDecl > void handleAggregate( AggDecl * aggregateDecl );
 
                 AggregateDecl * parentAggr = nullptr;
@@ -106 +133 @@
 
         /// Replaces enum types by int, and function or array types in function parameter and return lists by appropriate pointers.
-        struct EnumAndPointerDecay {
-                void previsit( EnumDecl *aggregateDecl );
-                void previsit( FunctionType *func );
+        struct EnumAndPointerDecay_old {
+                void previsit( EnumDecl * aggregateDecl );
+                void previsit( FunctionType * func );
         };
 
         /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
-                LinkReferenceToTypes( const Indexer *indexer );
-                void postvisit( TypeInstType *typeInst );
-
-                void postvisit( EnumInstType *enumInst );
-                void postvisit( StructInstType *structInst );
-                void postvisit( UnionInstType *unionInst );
-                void postvisit( TraitInstType *traitInst );
-
-                void postvisit( EnumDecl *enumDecl );
-                void postvisit( StructDecl *structDecl );
-                void postvisit( UnionDecl *unionDecl );
+        struct LinkReferenceToTypes_old final : public WithIndexer, public WithGuards, public WithVisitorRef<LinkReferenceToTypes_old>, public WithShortCircuiting {
+                LinkReferenceToTypes_old( const Indexer * indexer );
+                void postvisit( TypeInstType * typeInst );
+
+                void postvisit( EnumInstType * enumInst );
+                void postvisit( StructInstType * structInst );
+                void postvisit( UnionInstType * unionInst );
+                void postvisit( TraitInstType * traitInst );
+                void previsit( QualifiedType * qualType );
+                void postvisit( QualifiedType * qualType );
+
+                void postvisit( EnumDecl * enumDecl );
+                void postvisit( StructDecl * structDecl );
+                void postvisit( UnionDecl * unionDecl );
                 void postvisit( TraitDecl * traitDecl );
 
-                void previsit( StructDecl *structDecl );
-                void previsit( UnionDecl *unionDecl );
+                void previsit( StructDecl * structDecl );
+                void previsit( UnionDecl * unionDecl );
 
                 void renameGenericParams( std::list< TypeDecl * > & params );
 
           private:
-                const Indexer *local_indexer;
+                const Indexer * local_indexer;
 
                 typedef std::map< std::string, std::list< EnumInstType * > > ForwardEnumsType;
@@ -145 +174 @@
 
         /// Replaces array and function types in forall lists by appropriate pointer type and assigns each Object and Function declaration a unique ID.
-        struct ForallPointerDecay final {
+        struct ForallPointerDecay_old final {
                 void previsit( ObjectDecl * object );
                 void previsit( FunctionDecl * func );
@@ -165 +194 @@
         };
 
-        struct EliminateTypedef final : public WithVisitorRef<EliminateTypedef>, public WithGuards {
-                EliminateTypedef() : scopeLevel( 0 ) {}
+        struct ReplaceTypedef final : public WithVisitorRef<ReplaceTypedef>, public WithGuards, public WithShortCircuiting, public WithDeclsToAdd {
+                ReplaceTypedef() : scopeLevel( 0 ) {}
                 /// Replaces typedefs by forward declarations
-                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
-
+                static void replaceTypedef( std::list< Declaration * > &translationUnit );
+
+                void premutate( QualifiedType * );
+                Type * postmutate( QualifiedType * qualType );
                 Type * postmutate( TypeInstType * aggregateUseType );
                 Declaration * postmutate( TypedefDecl * typeDecl );
@@ -180 +211 @@
 
                 void premutate( CompoundStmt * compoundStmt );
-                CompoundStmt * postmutate( CompoundStmt * compoundStmt );
 
                 void premutate( StructDecl * structDecl );
-                Declaration * postmutate( StructDecl * structDecl );
                 void premutate( UnionDecl * unionDecl );
-                Declaration * postmutate( UnionDecl * unionDecl );
                 void premutate( EnumDecl * enumDecl );
-                Declaration * postmutate( EnumDecl * enumDecl );
-                Declaration * postmutate( TraitDecl * contextDecl );
+                void premutate( TraitDecl * );
 
                 void premutate( FunctionType * ftype );
@@ -194 +221 @@
           private:
                 template<typename AggDecl>
-                AggDecl *handleAggregate( AggDecl * aggDecl );
-
-                template<typename AggDecl>
                 void addImplicitTypedef( AggDecl * aggDecl );
+                template< typename AggDecl >
+                void handleAggregate( AggDecl * aggr );
 
                 typedef std::unique_ptr<TypedefDecl> TypedefDeclPtr;
                 typedef ScopedMap< std::string, std::pair< TypedefDeclPtr, int > > TypedefMap;
-                typedef std::map< std::string, TypeDecl * > TypeDeclMap;
+                typedef ScopedMap< std::string, TypeDecl * > TypeDeclMap;
                 TypedefMap typedefNames;
                 TypeDeclMap typedeclNames;
                 int scopeLevel;
                 bool inFunctionType = false;
+        };
+
+        struct EliminateTypedef {
+                /// removes TypedefDecls from the AST
+                static void eliminateTypedef( std::list< Declaration * > &translationUnit );
+
+                template<typename AggDecl>
+                void handleAggregate( AggDecl * aggregateDecl );
+
+                void previsit( StructDecl * aggregateDecl );
+                void previsit( UnionDecl * aggregateDecl );
+                void previsit( CompoundStmt * compoundStmt );
         };
 
@@ -214 +252 @@
                 static void verify( std::list< Declaration * > &translationUnit );
 
-                void previsit( FunctionDecl *funcDecl );
+                void previsit( FunctionDecl * funcDecl );
         };
 
@@ -223 +261 @@
         };
 
-        struct ArrayLength {
+        struct FixObjectType : public WithIndexer {
+                /// resolves typeof type in object, function, and type declarations
+                static void fix( std::list< Declaration * > & translationUnit );
+
+                void previsit( ObjectDecl * );
+                void previsit( FunctionDecl * );
+                void previsit( TypeDecl * );
+        };
+
+        struct ArrayLength : public WithIndexer {
                 /// 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,
@@ -234 +281 @@
 
                 void previsit( ObjectDecl * objDecl );
+                void previsit( ArrayType * arrayType );
         };
 
@@ -239 +287 @@
                 Type::StorageClasses storageClasses;
 
-                void premutate( ObjectDecl *objectDecl );
-                Expression * postmutate( CompoundLiteralExpr *compLitExpr );
+                void premutate( ObjectDecl * objectDecl );
+                Expression * postmutate( CompoundLiteralExpr * compLitExpr );
         };
 
@@ -250 +298 @@
         };
 
-        FunctionDecl * dereferenceOperator = nullptr;
-        struct FindSpecialDeclarations final {
-                void previsit( FunctionDecl * funcDecl );
-        };
-
         void validate( std::list< Declaration * > &translationUnit, __attribute__((unused)) bool doDebug ) {
-                PassVisitor<EnumAndPointerDecay> epc;
-                PassVisitor<LinkReferenceToTypes> lrt( nullptr );
-                PassVisitor<ForallPointerDecay> fpd;
+                PassVisitor<EnumAndPointerDecay_old> epc;
+                PassVisitor<LinkReferenceToTypes_old> lrt( nullptr );
+                PassVisitor<ForallPointerDecay_old> fpd;
                 PassVisitor<CompoundLiteral> compoundliteral;
                 PassVisitor<ValidateGenericParameters> genericParams;
-                PassVisitor<FindSpecialDeclarations> finder;
                 PassVisitor<LabelAddressFixer> labelAddrFixer;
-
-                EliminateTypedef::eliminateTypedef( translationUnit );
-                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
-                ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
-                acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes because it is an indexer and needs correct types for mangling
-                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
-                acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes
-                VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
-                ReturnChecker::checkFunctionReturns( translationUnit );
-                InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
-                Concurrency::applyKeywords( translationUnit );
-                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
-                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
-                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay
-                Concurrency::implementMutexFuncs( translationUnit );
-                Concurrency::implementThreadStarter( translationUnit );
-                mutateAll( translationUnit, compoundliteral );
-                ArrayLength::computeLength( translationUnit );
-                acceptAll( translationUnit, finder ); // xxx - remove this pass soon
-                mutateAll( translationUnit, labelAddrFixer );
-        }
-
-        void validateType( Type *type, const Indexer *indexer ) {
-                PassVisitor<EnumAndPointerDecay> epc;
-                PassVisitor<LinkReferenceToTypes> lrt( indexer );
-                PassVisitor<ForallPointerDecay> fpd;
+                PassVisitor<HoistTypeDecls> hoistDecls;
+                PassVisitor<FixQualifiedTypes> fixQual;
+
+                {
+                        Stats::Heap::newPass("validate-A");
+                        Stats::Time::BlockGuard guard("validate-A");
+                        acceptAll( translationUnit, hoistDecls );
+                        ReplaceTypedef::replaceTypedef( translationUnit );
+                        ReturnTypeFixer::fix( translationUnit ); // must happen before autogen
+                        acceptAll( translationUnit, epc ); // must happen before VerifyCtorDtorAssign, because void return objects should not exist; before LinkReferenceToTypes_old because it is an indexer and needs correct types for mangling
+                }
+                {
+                        Stats::Heap::newPass("validate-B");
+                        Stats::Time::BlockGuard guard("validate-B");
+                        Stats::Time::TimeBlock("Link Reference To Types", [&]() {
+                                acceptAll( translationUnit, lrt ); // must happen before autogen, because sized flag needs to propagate to generated functions
+                        });
+                        Stats::Time::TimeBlock("Fix Qualified Types", [&]() {
+                                mutateAll( translationUnit, fixQual ); // must happen after LinkReferenceToTypes_old, because aggregate members are accessed
+                        });
+                        Stats::Time::TimeBlock("Hoist Structs", [&]() {
+                                HoistStruct::hoistStruct( translationUnit ); // must happen after EliminateTypedef, so that aggregate typedefs occur in the correct order
+                        });
+                        Stats::Time::TimeBlock("Eliminate Typedefs", [&]() {
+                                EliminateTypedef::eliminateTypedef( translationUnit ); //
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-C");
+                        Stats::Time::BlockGuard guard("validate-C");
+                        acceptAll( translationUnit, genericParams );  // check as early as possible - can't happen before LinkReferenceToTypes_old
+                        VerifyCtorDtorAssign::verify( translationUnit );  // must happen before autogen, because autogen examines existing ctor/dtors
+                        ReturnChecker::checkFunctionReturns( translationUnit );
+                        InitTweak::fixReturnStatements( translationUnit ); // must happen before autogen
+                }
+                {
+                        Stats::Heap::newPass("validate-D");
+                        Stats::Time::BlockGuard guard("validate-D");
+                        Stats::Time::TimeBlock("Apply Concurrent Keywords", [&]() {
+                                Concurrency::applyKeywords( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Forall Pointer Decay", [&]() {
+                                acceptAll( translationUnit, fpd ); // must happen before autogenerateRoutines, after Concurrency::applyKeywords because uniqueIds must be set on declaration before resolution
+                        });
+                        Stats::Time::TimeBlock("Hoist Control Declarations", [&]() {
+                                ControlStruct::hoistControlDecls( translationUnit );  // hoist initialization out of for statements; must happen before autogenerateRoutines
+                        });
+                        Stats::Time::TimeBlock("Generate Autogen routines", [&]() {
+                                autogenerateRoutines( translationUnit ); // moved up, used to be below compoundLiteral - currently needs EnumAndPointerDecay_old
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-E");
+                        Stats::Time::BlockGuard guard("validate-E");
+                        Stats::Time::TimeBlock("Implement Mutex Func", [&]() {
+                                Concurrency::implementMutexFuncs( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Implement Thread Start", [&]() {
+                                Concurrency::implementThreadStarter( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Compound Literal", [&]() {
+                                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
+                        });
+                }
+                {
+                        Stats::Heap::newPass("validate-F");
+                        Stats::Time::BlockGuard guard("validate-F");
+                        Stats::Time::TimeBlock("Fix Object Type", [&]() {
+                                FixObjectType::fix( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Array Length", [&]() {
+                                ArrayLength::computeLength( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Find Special Declarations", [&]() {
+                                Validate::findSpecialDecls( translationUnit );
+                        });
+                        Stats::Time::TimeBlock("Fix Label Address", [&]() {
+                                mutateAll( translationUnit, labelAddrFixer );
+                        });
+                        Stats::Time::TimeBlock("Handle Attributes", [&]() {
+                                Validate::handleAttributes( translationUnit );
+                        });
+                }
+        }
+
+        void validateType( Type * type, const Indexer * indexer ) {
+                PassVisitor<EnumAndPointerDecay_old> epc;
+                PassVisitor<LinkReferenceToTypes_old> lrt( indexer );
+                PassVisitor<ForallPointerDecay_old> fpd;
                 type->accept( epc );
                 type->accept( lrt );
@@ -294 +402 @@
         }
 
+
+        void HoistTypeDecls::handleType( Type * type ) {
+                // some type declarations are buried in expressions and not easy to hoist during parsing; hoist them here
+                AggregateDecl * aggr = nullptr;
+                if ( StructInstType * inst = dynamic_cast< StructInstType * >( type ) ) {
+                        aggr = inst->baseStruct;
+                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( type ) ) {
+                        aggr = inst->baseUnion;
+                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( type ) ) {
+                        aggr = inst->baseEnum;
+                }
+                if ( aggr && aggr->body ) {
+                        declsToAddBefore.push_front( aggr );
+                }
+        }
+
+        void HoistTypeDecls::previsit( SizeofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+        void HoistTypeDecls::previsit( AlignofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+        void HoistTypeDecls::previsit( UntypedOffsetofExpr * expr ) {
+                handleType( expr->type );
+        }
+
+        void HoistTypeDecls::previsit( CompoundLiteralExpr * expr ) {
+                handleType( expr->result );
+        }
+
+
+        Type * FixQualifiedTypes::postmutate( QualifiedType * qualType ) {
+                Type * parent = qualType->parent;
+                Type * child = qualType->child;
+                if ( dynamic_cast< GlobalScopeType * >( qualType->parent ) ) {
+                        // .T => lookup T at global scope
+                        if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                auto td = indexer.globalLookupType( inst->name );
+                                if ( ! td ) {
+                                        SemanticError( qualType->location, toString("Use of undefined global type ", inst->name) );
+                                }
+                                auto base = td->base;
+                                assert( base );
+                                Type * ret = base->clone();
+                                ret->get_qualifiers() = qualType->get_qualifiers();
+                                return ret;
+                        } else {
+                                // .T => T is not a type name
+                                assertf( false, "unhandled global qualified child type: %s", toCString(child) );
+                        }
+                } else {
+                        // S.T => S must be an aggregate type, find the declaration for T in S.
+                        AggregateDecl * aggr = nullptr;
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( parent ) ) {
+                                aggr = inst->baseStruct;
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * > ( parent ) ) {
+                                aggr = inst->baseUnion;
+                        } else {
+                                SemanticError( qualType->location, toString("Qualified type requires an aggregate on the left, but has: ", parent) );
+                        }
+                        assert( aggr ); // TODO: need to handle forward declarations
+                        for ( Declaration * member : aggr->members ) {
+                                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                        // name on the right is a typedef
+                                        if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
+                                                if ( aggr->name == inst->name ) {
+                                                        assert( aggr->base );
+                                                        Type * ret = aggr->base->clone();
+                                                        ret->get_qualifiers() = qualType->get_qualifiers();
+                                                        TypeSubstitution sub = parent->genericSubstitution();
+                                                        sub.apply(ret);
+                                                        return ret;
+                                                }
+                                        }
+                                } else {
+                                        // S.T - S is not an aggregate => error
+                                        assertf( false, "unhandled qualified child type: %s", toCString(qualType) );
+                                }
+                        }
+                        // failed to find a satisfying definition of type
+                        SemanticError( qualType->location, toString("Undefined type in qualified type: ", qualType) );
+                }
+
+                // ... may want to link canonical SUE definition to each forward decl so that it becomes easier to lookup?
+        }
+
+
         void HoistStruct::hoistStruct( std::list< Declaration * > &translationUnit ) {
                 PassVisitor<HoistStruct> hoister;
@@ -299 +496 @@
         }
 
-        bool shouldHoist( Declaration *decl ) {
+        bool shouldHoist( Declaration * decl ) {
                 return dynamic_cast< StructDecl * >( decl ) || dynamic_cast< UnionDecl * >( decl ) || dynamic_cast< StaticAssertDecl * >( decl );
         }
 
+        namespace {
+                void qualifiedName( AggregateDecl * aggr, std::ostringstream & ss ) {
+                        if ( aggr->parent ) qualifiedName( aggr->parent, ss );
+                        ss << "__" << aggr->name;
+                }
+
+                // mangle nested type names using entire parent chain
+                std::string qualifiedName( AggregateDecl * aggr ) {
+                        std::ostringstream ss;
+                        qualifiedName( aggr, ss );
+                        return ss.str();
+                }
+        }
+
         template< typename AggDecl >
-        void HoistStruct::handleAggregate( AggDecl *aggregateDecl ) {
+        void HoistStruct::handleAggregate( AggDecl * aggregateDecl ) {
                 if ( parentAggr ) {
+                        aggregateDecl->parent = parentAggr;
+                        aggregateDecl->name = qualifiedName( aggregateDecl );
                         // Add elements in stack order corresponding to nesting structure.
                         declsToAddBefore.push_front( aggregateDecl );
@@ -316 +529 @@
         }
 
-        void HoistStruct::previsit( EnumInstType * inst ) {
-                if ( inst->baseEnum && inst->baseEnum->body ) {
-                        declsToAddBefore.push_front( inst->baseEnum );
-                }
-        }
-
-        void HoistStruct::previsit( StructInstType * inst ) {
-                if ( inst->baseStruct && inst->baseStruct->body ) {
-                        declsToAddBefore.push_front( inst->baseStruct );
-                }
-        }
-
-        void HoistStruct::previsit( UnionInstType * inst ) {
-                if ( inst->baseUnion && inst->baseUnion->body ) {
-                        declsToAddBefore.push_front( inst->baseUnion );
-                }
-        }
-
         void HoistStruct::previsit( StaticAssertDecl * assertDecl ) {
                 if ( parentAggr ) {
@@ -348 +543 @@
         }
 
-        void EnumAndPointerDecay::previsit( EnumDecl *enumDecl ) {
+        void HoistStruct::previsit( StructInstType * type ) {
+                // need to reset type name after expanding to qualified name
+                assert( type->baseStruct );
+                type->name = type->baseStruct->name;
+        }
+
+        void HoistStruct::previsit( UnionInstType * type ) {
+                assert( type->baseUnion );
+                type->name = type->baseUnion->name;
+        }
+
+        void HoistStruct::previsit( EnumInstType * type ) {
+                assert( type->baseEnum );
+                type->name = type->baseEnum->name;
+        }
+
+
+        bool isTypedef( Declaration * decl ) {
+                return dynamic_cast< TypedefDecl * >( decl );
+        }
+
+        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
+                PassVisitor<EliminateTypedef> eliminator;
+                acceptAll( translationUnit, eliminator );
+                filter( translationUnit, isTypedef, true );
+        }
+
+        template< typename AggDecl >
+        void EliminateTypedef::handleAggregate( AggDecl * aggregateDecl ) {
+                filter( aggregateDecl->members, isTypedef, true );
+        }
+
+        void EliminateTypedef::previsit( StructDecl * aggregateDecl ) {
+                handleAggregate( aggregateDecl );
+        }
+
+        void EliminateTypedef::previsit( UnionDecl * aggregateDecl ) {
+                handleAggregate( aggregateDecl );
+        }
+
+        void EliminateTypedef::previsit( CompoundStmt * compoundStmt ) {
+                // remove and delete decl stmts
+                filter( compoundStmt->kids, [](Statement * stmt) {
+                        if ( DeclStmt * declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
+                                if ( dynamic_cast< TypedefDecl * >( declStmt->decl ) ) {
+                                        return true;
+                                } // if
+                        } // if
+                        return false;
+                }, true);
+        }
+
+        void EnumAndPointerDecay_old::previsit( EnumDecl * enumDecl ) {
                 // Set the type of each member of the enumeration to be EnumConstant
-                for ( std::list< Declaration * >::iterator i = enumDecl->get_members().begin(); i != enumDecl->get_members().end(); ++i ) {
-                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( *i );
+                for ( std::list< Declaration * >::iterator i = enumDecl->members.begin(); i != enumDecl->members.end(); ++i ) {
+                        ObjectDecl * obj = dynamic_cast< ObjectDecl * >( * i );
                         assert( obj );
-                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->get_name() ) );
+                        obj->set_type( new EnumInstType( Type::Qualifiers( Type::Const ), enumDecl->name ) );
                 } // for
         }
@@ -380 +627 @@
         }
 
-        void EnumAndPointerDecay::previsit( FunctionType *func ) {
+        void EnumAndPointerDecay_old::previsit( FunctionType * func ) {
                 // Fix up parameters and return types
                 fixFunctionList( func->parameters, func->isVarArgs, func );
@@ -386 +633 @@
         }
 
-        LinkReferenceToTypes::LinkReferenceToTypes( const Indexer *other_indexer ) {
+        LinkReferenceToTypes_old::LinkReferenceToTypes_old( const Indexer * other_indexer ) {
                 if ( other_indexer ) {
                         local_indexer = other_indexer;
@@ -394 +641 @@
         }
 
-        void LinkReferenceToTypes::postvisit( EnumInstType *enumInst ) {
-                EnumDecl *st = local_indexer->lookupEnum( enumInst->get_name() );
+        void LinkReferenceToTypes_old::postvisit( EnumInstType * enumInst ) {
+                const EnumDecl * st = local_indexer->lookupEnum( enumInst->name );
                 // it's not a semantic error if the enum is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! enumInst->get_baseEnum() || enumInst->get_baseEnum()->get_members().empty() || ! st->get_members().empty() );
-                        enumInst->set_baseEnum( st );
-                } // if
-                if ( ! st || st->get_members().empty() ) {
+                        enumInst->baseEnum = const_cast<EnumDecl *>(st); // Just linking in the node
+                } // if
+                if ( ! st || ! st->body ) {
                         // use of forward declaration
-                        forwardEnums[ enumInst->get_name() ].push_back( enumInst );
+                        forwardEnums[ enumInst->name ].push_back( enumInst );
                 } // if
         }
@@ -415 +661 @@
         }
 
-        void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
-                StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
+        void LinkReferenceToTypes_old::postvisit( StructInstType * structInst ) {
+                const StructDecl * st = local_indexer->lookupStruct( structInst->name );
                 // it's not a semantic error if the struct is not found, just an implicit forward declaration
                 if ( st ) {
-                        //assert( ! structInst->get_baseStruct() || structInst->get_baseStruct()->get_members().empty() || ! st->get_members().empty() );
-                        structInst->set_baseStruct( st );
-                } // if
-                if ( ! st || st->get_members().empty() ) {
+                        structInst->baseStruct = const_cast<StructDecl *>(st); // Just linking in the node
+                } // if
+                if ( ! st || ! st->body ) {
                         // use of forward declaration
-                        forwardStructs[ structInst->get_name() ].push_back( structInst );
+                        forwardStructs[ structInst->name ].push_back( structInst );
                 } // if
                 checkGenericParameters( structInst );
         }
 
-        void LinkReferenceToTypes::postvisit( UnionInstType *unionInst ) {
-                UnionDecl *un = local_indexer->lookupUnion( unionInst->get_name() );
+        void LinkReferenceToTypes_old::postvisit( UnionInstType * unionInst ) {
+                const UnionDecl * un = local_indexer->lookupUnion( unionInst->name );
                 // it's not a semantic error if the union is not found, just an implicit forward declaration
                 if ( un ) {
-                        unionInst->set_baseUnion( un );
-                } // if
-                if ( ! un || un->get_members().empty() ) {
+                        unionInst->baseUnion = const_cast<UnionDecl *>(un); // Just linking in the node
+                } // if
+                if ( ! un || ! un->body ) {
                         // use of forward declaration
-                        forwardUnions[ unionInst->get_name() ].push_back( unionInst );
+                        forwardUnions[ unionInst->name ].push_back( unionInst );
                 } // if
                 checkGenericParameters( unionInst );
+        }
+
+        void LinkReferenceToTypes_old::previsit( QualifiedType * ) {
+                visit_children = false;
+        }
+
+        void LinkReferenceToTypes_old::postvisit( QualifiedType * qualType ) {
+                // linking only makes sense for the 'oldest ancestor' of the qualified type
+                qualType->parent->accept( * visitor );
         }
 
@@ -450 +704 @@
                         DeclarationWithType * dwt2 = dynamic_cast<DeclarationWithType *>( d2 );
                         if ( dwt1 && dwt2 ) {
-                                if ( dwt1->get_name() == dwt2->get_name() && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
+                                if ( dwt1->name == dwt2->name && ResolvExpr::typesCompatible( dwt1->get_type(), dwt2->get_type(), SymTab::Indexer() ) ) {
                                         // std::cerr << "=========== equal:" << std::endl;
                                         // std::cerr << "d1: " << d1 << std::endl;
@@ -475 +729 @@
         template< typename Iterator >
         void expandAssertions( TraitInstType * inst, Iterator out ) {
-                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toString( inst ).c_str() );
+                assertf( inst->baseTrait, "Trait instance not linked to base trait: %s", toCString( inst ) );
                 std::list< DeclarationWithType * > asserts;
                 for ( Declaration * decl : inst->baseTrait->members ) {
@@ -484 +738 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TraitDecl * traitDecl ) {
+        void LinkReferenceToTypes_old::postvisit( TraitDecl * traitDecl ) {
                 if ( traitDecl->name == "sized" ) {
                         // "sized" is a special trait - flick the sized status on for the type variable
@@ -506 +760 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TraitInstType * traitInst ) {
+        void LinkReferenceToTypes_old::postvisit( TraitInstType * traitInst ) {
                 // handle other traits
-                TraitDecl *traitDecl = local_indexer->lookupTrait( traitInst->name );
+                const TraitDecl * traitDecl = local_indexer->lookupTrait( traitInst->name );
                 if ( ! traitDecl ) {
                         SemanticError( traitInst->location, "use of undeclared trait " + traitInst->name );
                 } // if
-                if ( traitDecl->get_parameters().size() != traitInst->get_parameters().size() ) {
+                if ( traitDecl->parameters.size() != traitInst->parameters.size() ) {
                         SemanticError( traitInst, "incorrect number of trait parameters: " );
                 } // if
-                traitInst->baseTrait = traitDecl;
+                traitInst->baseTrait = const_cast<TraitDecl *>(traitDecl); // Just linking in the node
 
                 // need to carry over the 'sized' status of each decl in the instance
-                for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
+                for ( auto p : group_iterate( traitDecl->parameters, traitInst->parameters ) ) {
                         TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
                         if ( ! expr ) {
@@ -525 +779 @@
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
                                 TypeDecl * formalDecl = std::get<0>(p);
-                                TypeDecl * instDecl = inst->get_baseType();
+                                TypeDecl * instDecl = inst->baseType;
                                 if ( formalDecl->get_sized() ) instDecl->set_sized( true );
                         }
@@ -532 +786 @@
         }
 
-        void LinkReferenceToTypes::postvisit( EnumDecl *enumDecl ) {
+        void LinkReferenceToTypes_old::postvisit( EnumDecl * enumDecl ) {
                 // visit enum members first so that the types of self-referencing members are updated properly
-                if ( ! enumDecl->get_members().empty() ) {
-                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->get_name() );
+                if ( enumDecl->body ) {
+                        ForwardEnumsType::iterator fwds = forwardEnums.find( enumDecl->name );
                         if ( fwds != forwardEnums.end() ) {
                                 for ( std::list< EnumInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseEnum( enumDecl );
+                                        (* inst)->baseEnum = enumDecl;
                                 } // for
                                 forwardEnums.erase( fwds );
                         } // if
-                } // if
-        }
-
-        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
+
+                        for ( Declaration * member : enumDecl->members ) {
+                                ObjectDecl * field = strict_dynamic_cast<ObjectDecl *>( member );
+                                if ( field->init ) {
+                                        // need to resolve enumerator initializers early so that other passes that determine if an expression is constexpr have the appropriate information.
+                                        SingleInit * init = strict_dynamic_cast<SingleInit *>( field->init );
+                                        ResolvExpr::findSingleExpression( init->value, new BasicType( Type::Qualifiers(), BasicType::SignedInt ), indexer );
+                                }
+                        }
+                } // if
+        }
+
+        void LinkReferenceToTypes_old::renameGenericParams( std::list< TypeDecl * > & params ) {
                 // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
                 //   forall(otype T)
@@ -563 +826 @@
         }
 
-        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
+        void LinkReferenceToTypes_old::previsit( StructDecl * structDecl ) {
                 renameGenericParams( structDecl->parameters );
         }
 
-        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
+        void LinkReferenceToTypes_old::previsit( UnionDecl * unionDecl ) {
                 renameGenericParams( unionDecl->parameters );
         }
 
-        void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
+        void LinkReferenceToTypes_old::postvisit( StructDecl * structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
                 // xxx - need to ensure that type parameters match up between forward declarations and definition (most importantly, number of type parameters and their defaults)
-                if ( ! structDecl->get_members().empty() ) {
-                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->get_name() );
+                if ( structDecl->body ) {
+                        ForwardStructsType::iterator fwds = forwardStructs.find( structDecl->name );
                         if ( fwds != forwardStructs.end() ) {
                                 for ( std::list< StructInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseStruct( structDecl );
+                                        (* inst)->baseStruct = structDecl;
                                 } // for
                                 forwardStructs.erase( fwds );
@@ -585 +848 @@
         }
 
-        void LinkReferenceToTypes::postvisit( UnionDecl *unionDecl ) {
-                if ( ! unionDecl->get_members().empty() ) {
-                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->get_name() );
+        void LinkReferenceToTypes_old::postvisit( UnionDecl * unionDecl ) {
+                if ( unionDecl->body ) {
+                        ForwardUnionsType::iterator fwds = forwardUnions.find( unionDecl->name );
                         if ( fwds != forwardUnions.end() ) {
                                 for ( std::list< UnionInstType * >::iterator inst = fwds->second.begin(); inst != fwds->second.end(); ++inst ) {
-                                        (*inst )->set_baseUnion( unionDecl );
+                                        (* inst)->baseUnion = unionDecl;
                                 } // for
                                 forwardUnions.erase( fwds );
@@ -597 +860 @@
         }
 
-        void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+        void LinkReferenceToTypes_old::postvisit( TypeInstType * typeInst ) {
                 // ensure generic parameter instances are renamed like the base type
                 if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
-                if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
-                        if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {
-                                typeInst->set_isFtype( typeDecl->get_kind() == TypeDecl::Ftype );
+                if ( const NamedTypeDecl * namedTypeDecl = local_indexer->lookupType( typeInst->name ) ) {
+                        if ( const TypeDecl * typeDecl = dynamic_cast< const TypeDecl * >( namedTypeDecl ) ) {
+                                typeInst->set_isFtype( typeDecl->kind == TypeDecl::Ftype );
                         } // if
                 } // if
@@ -614 +877 @@
                         // expand trait instances into their members
                         for ( DeclarationWithType * assertion : asserts ) {
-                                if ( TraitInstType *traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
+                                if ( TraitInstType * traitInst = dynamic_cast< TraitInstType * >( assertion->get_type() ) ) {
                                         // expand trait instance into all of its members
                                         expandAssertions( traitInst, back_inserter( type->assertions ) );
@@ -634 +897 @@
         }
 
-        void ForallPointerDecay::previsit( ObjectDecl *object ) {
+        void ForallPointerDecay_old::previsit( ObjectDecl * object ) {
                 // ensure that operator names only apply to functions or function pointers
                 if ( CodeGen::isOperator( object->name ) && ! dynamic_cast< FunctionType * >( object->type->stripDeclarator() ) ) {
@@ -642 +905 @@
         }
 
-        void ForallPointerDecay::previsit( FunctionDecl *func ) {
+        void ForallPointerDecay_old::previsit( FunctionDecl * func ) {
                 func->fixUniqueId();
         }
 
-        void ForallPointerDecay::previsit( FunctionType * ftype ) {
+        void ForallPointerDecay_old::previsit( FunctionType * ftype ) {
                 forallFixer( ftype->forall, ftype );
         }
 
-        void ForallPointerDecay::previsit( StructDecl * aggrDecl ) {
+        void ForallPointerDecay_old::previsit( StructDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
         }
 
-        void ForallPointerDecay::previsit( UnionDecl * aggrDecl ) {
+        void ForallPointerDecay_old::previsit( UnionDecl * aggrDecl ) {
                 forallFixer( aggrDecl->parameters, aggrDecl );
         }
@@ -679 +942 @@
 
 
-        bool isTypedef( Declaration *decl ) {
-                return dynamic_cast< TypedefDecl * >( decl );
-        }
-
-        void EliminateTypedef::eliminateTypedef( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<EliminateTypedef> eliminator;
+        void ReplaceTypedef::replaceTypedef( std::list< Declaration * > &translationUnit ) {
+                PassVisitor<ReplaceTypedef> eliminator;
                 mutateAll( translationUnit, eliminator );
                 if ( eliminator.pass.typedefNames.count( "size_t" ) ) {
                         // grab and remember declaration of size_t
-                        SizeType = eliminator.pass.typedefNames["size_t"].first->get_base()->clone();
+                        Validate::SizeType = eliminator.pass.typedefNames["size_t"].first->base->clone();
                 } else {
                         // xxx - missing global typedef for size_t - default to long unsigned int, even though that may be wrong
                         // eventually should have a warning for this case.
-                        SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
-                }
-                filter( translationUnit, isTypedef, true );
-        }
-
-        Type * EliminateTypedef::postmutate( TypeInstType * typeInst ) {
+                        Validate::SizeType = new BasicType( Type::Qualifiers(), BasicType::LongUnsignedInt );
+                }
+        }
+
+        void ReplaceTypedef::premutate( QualifiedType * ) {
+                visit_children = false;
+        }
+
+        Type * ReplaceTypedef::postmutate( QualifiedType * qualType ) {
+                // replacing typedefs only makes sense for the 'oldest ancestor' of the qualified type
+                qualType->parent = qualType->parent->acceptMutator( * visitor );
+                return qualType;
+        }
+
+        Type * ReplaceTypedef::postmutate( TypeInstType * typeInst ) {
                 // instances of typedef types will come here. If it is an instance
                 // of a typdef type, link the instance to its actual type.
-                TypedefMap::const_iterator def = typedefNames.find( typeInst->get_name() );
+                TypedefMap::const_iterator def = typedefNames.find( typeInst->name );
                 if ( def != typedefNames.end() ) {
-                        Type *ret = def->second.first->base->clone();
+                        Type * ret = def->second.first->base->clone();
+                        ret->location = typeInst->location;
                         ret->get_qualifiers() |= typeInst->get_qualifiers();
                         // attributes are not carried over from typedef to function parameters/return values
@@ -713 +982 @@
                         // place instance parameters on the typedef'd type
                         if ( ! typeInst->parameters.empty() ) {
-                                ReferenceToType *rtt = dynamic_cast<ReferenceToType*>(ret);
+                                ReferenceToType * rtt = dynamic_cast<ReferenceToType *>(ret);
                                 if ( ! rtt ) {
                                         SemanticError( typeInst->location, "Cannot apply type parameters to base type of " + typeInst->name );
                                 }
-                                rtt->get_parameters().clear();
+                                rtt->parameters.clear();
                                 cloneAll( typeInst->parameters, rtt->parameters );
-                                mutateAll( rtt->parameters, *visitor );  // recursively fix typedefs on parameters
+                                mutateAll( rtt->parameters, * visitor );  // recursively fix typedefs on parameters
                         } // if
                         delete typeInst;
                         return ret;
                 } else {
-                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->get_name() );
-                        assertf( base != typedeclNames.end(), "Cannot find typedecl name %s", typeInst->name.c_str() );
+                        TypeDeclMap::const_iterator base = typedeclNames.find( typeInst->name );
+                        if ( base == typedeclNames.end() ) {
+                                SemanticError( typeInst->location, toString("Use of undefined type ", typeInst->name) );
+                        }
                         typeInst->set_baseType( base->second );
-                } // if
-                return typeInst;
+                        return typeInst;
+                } // if
+                assert( false );
         }
 
@@ -745 +1017 @@
         }
 
-        Declaration *EliminateTypedef::postmutate( TypedefDecl * tyDecl ) {
-                if ( typedefNames.count( tyDecl->get_name() ) == 1 && typedefNames[ tyDecl->get_name() ].second == scopeLevel ) {
+        Declaration * ReplaceTypedef::postmutate( TypedefDecl * tyDecl ) {
+                if ( typedefNames.count( tyDecl->name ) == 1 && typedefNames[ tyDecl->name ].second == scopeLevel ) {
                         // typedef to the same name from the same scope
                         // must be from the same type
 
-                        Type * t1 = tyDecl->get_base();
-                        Type * t2 = typedefNames[ tyDecl->get_name() ].first->get_base();
+                        Type * t1 = tyDecl->base;
+                        Type * t2 = typedefNames[ tyDecl->name ].first->base;
                         if ( ! ResolvExpr::typesCompatible( t1, t2, Indexer() ) ) {
                                 SemanticError( tyDecl->location, "Cannot redefine typedef: " + tyDecl->name );
@@ -763 +1035 @@
                         }
                 } else {
-                        typedefNames[ tyDecl->get_name() ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
+                        typedefNames[ tyDecl->name ] = std::make_pair( TypedefDeclPtr( tyDecl ), scopeLevel );
                 } // if
 
@@ -771 +1043 @@
                 //    struct screen;
                 // because the expansion of the typedef is:
-                //    void rtn( SCREEN *p ) => void rtn( struct screen *p )
+                //    void rtn( SCREEN * p ) => void rtn( struct screen * p )
                 // hence the type-name "screen" must be defined.
                 // Note, qualifiers on the typedef are superfluous for the forward declaration.
 
-                Type *designatorType = tyDecl->get_base()->stripDeclarator();
-                if ( StructInstType *aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
-                        return new StructDecl( aggDecl->get_name(), DeclarationNode::Struct, noAttributes, tyDecl->get_linkage() );
-                } else if ( UnionInstType *aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
-                        return new UnionDecl( aggDecl->get_name(), noAttributes, tyDecl->get_linkage() );
-                } else if ( EnumInstType *enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
-                        return new EnumDecl( enumDecl->get_name(), noAttributes, tyDecl->get_linkage() );
-                } else {
-                        return tyDecl->clone();
-                } // if
-        }
-
-        void EliminateTypedef::premutate( TypeDecl * typeDecl ) {
-                TypedefMap::iterator i = typedefNames.find( typeDecl->get_name() );
+                Type * designatorType = tyDecl->base->stripDeclarator();
+                if ( StructInstType * aggDecl = dynamic_cast< StructInstType * >( designatorType ) ) {
+                        declsToAddBefore.push_back( new StructDecl( aggDecl->name, DeclarationNode::Struct, noAttributes, tyDecl->linkage ) );
+                } else if ( UnionInstType * aggDecl = dynamic_cast< UnionInstType * >( designatorType ) ) {
+                        declsToAddBefore.push_back( new UnionDecl( aggDecl->name, noAttributes, tyDecl->linkage ) );
+                } else if ( EnumInstType * enumDecl = dynamic_cast< EnumInstType * >( designatorType ) ) {
+                        declsToAddBefore.push_back( new EnumDecl( enumDecl->name, noAttributes, tyDecl->linkage ) );
+                } // if
+                return tyDecl->clone();
+        }
+
+        void ReplaceTypedef::premutate( TypeDecl * typeDecl ) {
+                TypedefMap::iterator i = typedefNames.find( typeDecl->name );
                 if ( i != typedefNames.end() ) {
                         typedefNames.erase( i ) ;
                 } // if
 
-                typedeclNames[ typeDecl->get_name() ] = typeDecl;
-        }
-
-        void EliminateTypedef::premutate( FunctionDecl * ) {
+                typedeclNames.insert( typeDecl->name, typeDecl );
+        }
+
+        void ReplaceTypedef::premutate( FunctionDecl * ) {
                 GuardScope( typedefNames );
-        }
-
-        void EliminateTypedef::premutate( ObjectDecl * ) {
+                GuardScope( typedeclNames );
+        }
+
+        void ReplaceTypedef::premutate( ObjectDecl * ) {
                 GuardScope( typedefNames );
-        }
-
-        DeclarationWithType *EliminateTypedef::postmutate( ObjectDecl * objDecl ) {
-                if ( FunctionType *funtype = dynamic_cast<FunctionType *>( objDecl->get_type() ) ) { // function type?
+                GuardScope( typedeclNames );
+        }
+
+        DeclarationWithType * ReplaceTypedef::postmutate( ObjectDecl * objDecl ) {
+                if ( FunctionType * funtype = dynamic_cast<FunctionType *>( objDecl->type ) ) { // function type?
                         // replace the current object declaration with a function declaration
-                        FunctionDecl * newDecl = new FunctionDecl( objDecl->get_name(), objDecl->get_storageClasses(), objDecl->get_linkage(), funtype, 0, objDecl->get_attributes(), objDecl->get_funcSpec() );
-                        objDecl->get_attributes().clear();
+                        FunctionDecl * newDecl = new FunctionDecl( objDecl->name, objDecl->get_storageClasses(), objDecl->linkage, funtype, 0, objDecl->attributes, objDecl->get_funcSpec() );
+                        objDecl->attributes.clear();
                         objDecl->set_type( nullptr );
                         delete objDecl;
@@ -816 +1089 @@
         }
 
-        void EliminateTypedef::premutate( CastExpr * ) {
+        void ReplaceTypedef::premutate( CastExpr * ) {
                 GuardScope( typedefNames );
-        }
-
-        void EliminateTypedef::premutate( CompoundStmt * ) {
+                GuardScope( typedeclNames );
+        }
+
+        void ReplaceTypedef::premutate( CompoundStmt * ) {
                 GuardScope( typedefNames );
+                GuardScope( typedeclNames );
                 scopeLevel += 1;
                 GuardAction( [this](){ scopeLevel -= 1; } );
         }
 
-        CompoundStmt *EliminateTypedef::postmutate( CompoundStmt * compoundStmt ) {
-                // remove and delete decl stmts
-                filter( compoundStmt->kids, [](Statement * stmt) {
-                        if ( DeclStmt *declStmt = dynamic_cast< DeclStmt * >( stmt ) ) {
-                                if ( dynamic_cast< TypedefDecl * >( declStmt->get_decl() ) ) {
-                                        return true;
-                                } // if
-                        } // if
-                        return false;
-                }, true);
-                return compoundStmt;
-        }
-
-        // there may be typedefs nested within aggregates. in order for everything to work properly, these should be removed
-        // as well
         template<typename AggDecl>
-        AggDecl *EliminateTypedef::handleAggregate( AggDecl * aggDecl ) {
-                filter( aggDecl->members, isTypedef, true );
-                return aggDecl;
-        }
-
-        template<typename AggDecl>
-        void EliminateTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
+        void ReplaceTypedef::addImplicitTypedef( AggDecl * aggDecl ) {
                 if ( typedefNames.count( aggDecl->get_name() ) == 0 ) {
-                        Type *type = nullptr;
+                        Type * type = nullptr;
                         if ( StructDecl * newDeclStructDecl = dynamic_cast< StructDecl * >( aggDecl ) ) {
                                 type = new StructInstType( Type::Qualifiers(), newDeclStructDecl->get_name() );
@@ -860 +1114 @@
                         TypedefDeclPtr tyDecl( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type, aggDecl->get_linkage() ) );
                         typedefNames[ aggDecl->get_name() ] = std::make_pair( std::move( tyDecl ), scopeLevel );
-                } // if
-        }
-
-        void EliminateTypedef::premutate( StructDecl * structDecl ) {
+                        // add the implicit typedef to the AST
+                        declsToAddBefore.push_back( new TypedefDecl( aggDecl->get_name(), aggDecl->location, Type::StorageClasses(), type->clone(), aggDecl->get_linkage() ) );
+                } // if
+        }
+
+        template< typename AggDecl >
+        void ReplaceTypedef::handleAggregate( AggDecl * aggr ) {
+                SemanticErrorException errors;
+
+                ValueGuard< std::list<Declaration * > > oldBeforeDecls( declsToAddBefore );
+                ValueGuard< std::list<Declaration * > > oldAfterDecls ( declsToAddAfter  );
+                declsToAddBefore.clear();
+                declsToAddAfter.clear();
+
+                GuardScope( typedefNames );
+                GuardScope( typedeclNames );
+                mutateAll( aggr->parameters, * visitor );
+
+                // unroll mutateAll for aggr->members so that implicit typedefs for nested types are added to the aggregate body.
+                for ( std::list< Declaration * >::iterator i = aggr->members.begin(); i != aggr->members.end(); ++i ) {
+                        if ( !declsToAddAfter.empty() ) { aggr->members.splice( i, declsToAddAfter ); }
+
+                        try {
+                                * i = maybeMutate( * i, * visitor );
+                        } catch ( SemanticErrorException &e ) {
+                                errors.append( e );
+                        }
+
+                        if ( !declsToAddBefore.empty() ) { aggr->members.splice( i, declsToAddBefore ); }
+                }
+
+                if ( !declsToAddAfter.empty() ) { aggr->members.splice( aggr->members.end(), declsToAddAfter ); }
+                if ( !errors.isEmpty() ) { throw errors; }
+        }
+
+        void ReplaceTypedef::premutate( StructDecl * structDecl ) {
+                visit_children = false;
                 addImplicitTypedef( structDecl );
-        }
-
-
-        Declaration *EliminateTypedef::postmutate( StructDecl * structDecl ) {
-                return handleAggregate( structDecl );
-        }
-
-        void EliminateTypedef::premutate( UnionDecl * unionDecl ) {
+                handleAggregate( structDecl );
+        }
+
+        void ReplaceTypedef::premutate( UnionDecl * unionDecl ) {
+                visit_children = false;
                 addImplicitTypedef( unionDecl );
-        }
-
-        Declaration *EliminateTypedef::postmutate( UnionDecl * unionDecl ) {
-                return handleAggregate( unionDecl );
-        }
-
-        void EliminateTypedef::premutate( EnumDecl * enumDecl ) {
+                handleAggregate( unionDecl );
+        }
+
+        void ReplaceTypedef::premutate( EnumDecl * enumDecl ) {
                 addImplicitTypedef( enumDecl );
         }
 
-        Declaration *EliminateTypedef::postmutate( EnumDecl * enumDecl ) {
-                return handleAggregate( enumDecl );
-        }
-
-        Declaration *EliminateTypedef::postmutate( TraitDecl * traitDecl ) {
-                return handleAggregate( traitDecl );
-        }
-
-        void EliminateTypedef::premutate( FunctionType * ) {
+        void ReplaceTypedef::premutate( FunctionType * ) {
                 GuardValue( inFunctionType );
                 inFunctionType = true;
+        }
+
+        void ReplaceTypedef::premutate( TraitDecl * ) {
+                GuardScope( typedefNames );
+                GuardScope( typedeclNames);
         }
 
@@ -939 +1217 @@
                         for ( size_t i = 0; paramIter != params->end(); ++paramIter, ++i ) {
                                 if ( i < args.size() ) {
-                                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( *std::next( args.begin(), i ) );
-                                        sub.add( (*paramIter)->get_name(), expr->get_type()->clone() );
+                                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( * std::next( args.begin(), i ) );
+                                        sub.add( (* paramIter)->get_name(), expr->get_type()->clone() );
                                 } else if ( i == args.size() ) {
-                                        Type * defaultType = (*paramIter)->get_init();
+                                        Type * defaultType = (* paramIter)->get_init();
                                         if ( defaultType ) {
                                                 args.push_back( new TypeExpr( defaultType->clone() ) );
-                                                sub.add( (*paramIter)->get_name(), defaultType->clone() );
+                                                sub.add( (* paramIter)->get_name(), defaultType->clone() );
                                         }
                                 }
@@ -964 +1242 @@
         }
 
-        void CompoundLiteral::premutate( ObjectDecl *objectDecl ) {
+        void CompoundLiteral::premutate( ObjectDecl * objectDecl ) {
                 storageClasses = objectDecl->get_storageClasses();
         }
 
-        Expression *CompoundLiteral::postmutate( CompoundLiteralExpr *compLitExpr ) {
+        Expression * CompoundLiteral::postmutate( CompoundLiteralExpr * compLitExpr ) {
                 // transform [storage_class] ... (struct S){ 3, ... };
                 // into [storage_class] struct S temp =  { 3, ... };
                 static UniqueName indexName( "_compLit" );
 
-                ObjectDecl *tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
+                ObjectDecl * tempvar = new ObjectDecl( indexName.newName(), storageClasses, LinkageSpec::C, nullptr, compLitExpr->get_result(), compLitExpr->get_initializer() );
                 compLitExpr->set_result( nullptr );
                 compLitExpr->set_initializer( nullptr );
@@ -1011 +1289 @@
                         TupleType * tupleType = strict_dynamic_cast< TupleType * >( ResolvExpr::extractResultType( ftype ) );
                         // ensure return value is not destructed by explicitly creating an empty ListInit node wherein maybeConstruct is false.
-                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer*>(), noDesignators, false ) );
+                        ObjectDecl * newRet = new ObjectDecl( "", Type::StorageClasses(), LinkageSpec::Cforall, 0, tupleType, new ListInit( std::list<Initializer *>(), noDesignators, false ) );
                         deleteAll( retVals );
                         retVals.clear();
@@ -1018 +1296 @@
         }
 
+        void FixObjectType::fix( std::list< Declaration * > & translationUnit ) {
+                PassVisitor<FixObjectType> fixer;
+                acceptAll( translationUnit, fixer );
+        }
+
+        void FixObjectType::previsit( ObjectDecl * objDecl ) {
+                Type * new_type = ResolvExpr::resolveTypeof( objDecl->get_type(), indexer );
+                objDecl->set_type( new_type );
+        }
+
+        void FixObjectType::previsit( FunctionDecl * funcDecl ) {
+                Type * new_type = ResolvExpr::resolveTypeof( funcDecl->type, indexer );
+                funcDecl->set_type( new_type );
+        }
+
+        void FixObjectType::previsit( TypeDecl * typeDecl ) {
+                if ( typeDecl->get_base() ) {
+                        Type * new_type = ResolvExpr::resolveTypeof( typeDecl->get_base(), indexer );
+                        typeDecl->set_base( new_type );
+                } // if
+        }
+
         void ArrayLength::computeLength( std::list< Declaration * > & translationUnit ) {
                 PassVisitor<ArrayLength> len;
@@ -1024 +1324 @@
 
         void ArrayLength::previsit( ObjectDecl * objDecl ) {
-                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->get_type() ) ) {
-                        if ( at->get_dimension() ) return;
-                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->get_init() ) ) {
-                                at->set_dimension( new ConstantExpr( Constant::from_ulong( init->get_initializers().size() ) ) );
-                        }
+                if ( ArrayType * at = dynamic_cast< ArrayType * >( objDecl->type ) ) {
+                        if ( at->dimension ) return;
+                        if ( ListInit * init = dynamic_cast< ListInit * >( objDecl->init ) ) {
+                                at->dimension = new ConstantExpr( Constant::from_ulong( init->initializers.size() ) );
+                        }
+                }
+        }
+
+        void ArrayLength::previsit( ArrayType * type ) {
+                if ( type->dimension ) {
+                        // need to resolve array dimensions early so that constructor code can correctly determine
+                        // if a type is a VLA (and hence whether its elements need to be constructed)
+                        ResolvExpr::findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
+
+                        // must re-evaluate whether a type is a VLA, now that more information is available
+                        // (e.g. the dimension may have been an enumerator, which was unknown prior to this step)
+                        type->isVarLen = ! InitTweak::isConstExpr( type->dimension );
                 }
         }
@@ -1062 +1374 @@
         }
 
-        void FindSpecialDeclarations::previsit( FunctionDecl * funcDecl ) {
-                if ( ! dereferenceOperator ) {
-                        if ( funcDecl->get_name() == "*?" && funcDecl->get_linkage() == LinkageSpec::Intrinsic ) {
-                                FunctionType * ftype = funcDecl->get_functionType();
-                                if ( ftype->get_parameters().size() == 1 && ftype->get_parameters().front()->get_type()->get_qualifiers() == Type::Qualifiers() ) {
-                                        dereferenceOperator = funcDecl;
+namespace {
+        /// 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 ) {
+                        // set the type of each member of the enumeration to be EnumConstant
+                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
+                                // build new version of object with EnumConstant
+                                ast::ptr< ast::ObjectDecl > obj =
+                                        enumDecl->members[i].strict_as< ast::ObjectDecl >();
+                                obj.get_and_mutate()->type =
+                                        new ast::EnumInstType{ enumDecl->name, ast::CV::Const };
+
+                                // set into decl
+                                ast::EnumDecl * mut = mutate( enumDecl );
+                                mut->members[i] = obj.get();
+                                enumDecl = mut;
+                        }
+                        return enumDecl;
+                }
+
+                static const ast::FunctionType * fixFunctionList(
+                        const ast::FunctionType * func,
+                        std::vector< ast::ptr< ast::DeclWithType > > ast::FunctionType::* field,
+                        ast::ArgumentFlag isVarArgs = ast::FixedArgs
+                ) {
+                        const auto & dwts = func->* field;
+                        unsigned nvals = dwts.size();
+                        bool hasVoid = false;
+                        for ( unsigned i = 0; i < nvals; ++i ) {
+                                func = ast::mutate_field_index( func, field, i, fixFunction( dwts[i], hasVoid ) );
+                        }
+
+                        // the only case in which "void" is valid is where it is the only one in the list
+                        if ( hasVoid && ( nvals > 1 || isVarArgs ) ) {
+                                SemanticError(
+                                        dwts.front()->location, func, "invalid type void in function type" );
+                        }
+
+                        // one void is the only thing in the list, remove it
+                        if ( hasVoid ) {
+                                func = ast::mutate_field(
+                                        func, field, std::vector< ast::ptr< ast::DeclWithType > >{} );
+                        }
+
+                        return func;
+                }
+
+                const ast::FunctionType * previsit( const ast::FunctionType * func ) {
+                        func = fixFunctionList( func, &ast::FunctionType::params, func->isVarArgs );
+                        return fixFunctionList( func, &ast::FunctionType::returns );
+                }
+        };
+
+        /// expand assertions from a trait instance, performing appropriate type variable substitutions
+        void expandAssertions(
+                const ast::TraitInstType * inst, std::vector< ast::ptr< ast::DeclWithType > > & out
+        ) {
+                assertf( inst->base, "Trait instance not linked to base trait: %s", toCString( inst ) );
+
+                // build list of trait members, substituting trait decl parameters for instance parameters
+                ast::TypeSubstitution sub{
+                        inst->base->params.begin(), inst->base->params.end(), inst->params.begin() };
+                // deliberately take ast::ptr by-value to ensure this does not mutate inst->base
+                for ( ast::ptr< ast::Decl > decl : inst->base->members ) {
+                        auto member = decl.strict_as< ast::DeclWithType >();
+                        sub.apply( member );
+                        out.emplace_back( member );
+                }
+        }
+
+        /// Associates forward declarations of aggregates with their definitions
+        class LinkReferenceToTypes_new final
+        : public ast::WithSymbolTable, public ast::WithGuards, public
+          ast::WithVisitorRef<LinkReferenceToTypes_new>, public ast::WithShortCircuiting {
+
+                // these maps of uses of forward declarations of types need to have the actual type
+                // declaration switched in * after * they have been traversed. To enable this in the
+                // ast::Pass framework, any node that needs to be so mutated has mutate() called on it
+                // before it is placed in the map, properly updating its parents in the usual traversal,
+                // then can have the actual mutation applied later
+                using ForwardEnumsType = std::unordered_multimap< std::string, ast::EnumInstType * >;
+                using ForwardStructsType = std::unordered_multimap< std::string, ast::StructInstType * >;
+                using ForwardUnionsType = std::unordered_multimap< std::string, ast::UnionInstType * >;
+
+                const CodeLocation & location;
+                const ast::SymbolTable * localSymtab;
+
+                ForwardEnumsType forwardEnums;
+                ForwardStructsType forwardStructs;
+                ForwardUnionsType forwardUnions;
+
+                /// true if currently in a generic type body, so that type parameter instances can be
+                /// renamed appropriately
+                bool inGeneric = false;
+
+        public:
+                /// contstruct using running symbol table
+                LinkReferenceToTypes_new( const CodeLocation & loc )
+                : location( loc ), localSymtab( &symtab ) {}
+
+                /// construct using provided symbol table
+                LinkReferenceToTypes_new( const CodeLocation & loc, const ast::SymbolTable & syms )
+                : location( loc ), localSymtab( &syms ) {}
+
+                const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
+                        // ensure generic parameter instances are renamed like the base type
+                        if ( inGeneric && typeInst->base ) {
+                                typeInst = ast::mutate_field(
+                                        typeInst, &ast::TypeInstType::name, typeInst->base->name );
+                        }
+
+                        if (
+                                auto typeDecl = dynamic_cast< const ast::TypeDecl * >(
+                                        localSymtab->lookupType( typeInst->name ) )
+                        ) {
+                                typeInst = ast::mutate_field( typeInst, &ast::TypeInstType::kind, typeDecl->kind );
+                        }
+
+                        return typeInst;
+                }
+
+                const ast::Type * postvisit( const ast::EnumInstType * inst ) {
+                        const ast::EnumDecl * decl = localSymtab->lookupEnum( inst->name );
+                        // not a semantic error if the enum is not found, just an implicit forward declaration
+                        if ( decl ) {
+                                inst = ast::mutate_field( inst, &ast::EnumInstType::base, decl );
+                        }
+                        if ( ! decl || ! decl->body ) {
+                                // forward declaration
+                                auto mut = mutate( inst );
+                                forwardEnums.emplace( inst->name, mut );
+                                inst = mut;
+                        }
+                        return inst;
+                }
+
+                void checkGenericParameters( const ast::ReferenceToType * inst ) {
+                        for ( const ast::Expr * param : inst->params ) {
+                                if ( ! dynamic_cast< const ast::TypeExpr * >( param ) ) {
+                                        SemanticError(
+                                                location, inst, "Expression parameters for generic types are currently "
+                                                "unsupported: " );
                                 }
                         }
                 }
-        }
+
+                const ast::StructInstType * postvisit( const ast::StructInstType * inst ) {
+                        const ast::StructDecl * decl = localSymtab->lookupStruct( inst->name );
+                        // not a semantic error if the struct is not found, just an implicit forward declaration
+                        if ( decl ) {
+                                inst = ast::mutate_field( inst, &ast::StructInstType::base, decl );
+                        }
+                        if ( ! decl || ! decl->body ) {
+                                // forward declaration
+                                auto mut = mutate( inst );
+                                forwardStructs.emplace( inst->name, mut );
+                                inst = mut;
+                        }
+                        checkGenericParameters( inst );
+                        return inst;
+                }
+
+                const ast::UnionInstType * postvisit( const ast::UnionInstType * inst ) {
+                        const ast::UnionDecl * decl = localSymtab->lookupUnion( inst->name );
+                        // not a semantic error if the struct is not found, just an implicit forward declaration
+                        if ( decl ) {
+                                inst = ast::mutate_field( inst, &ast::UnionInstType::base, decl );
+                        }
+                        if ( ! decl || ! decl->body ) {
+                                // forward declaration
+                                auto mut = mutate( inst );
+                                forwardUnions.emplace( inst->name, mut );
+                                inst = mut;
+                        }
+                        checkGenericParameters( inst );
+                        return inst;
+                }
+
+                const ast::Type * postvisit( const ast::TraitInstType * traitInst ) {
+                        // handle other traits
+                        const ast::TraitDecl * traitDecl = localSymtab->lookupTrait( traitInst->name );
+                        if ( ! traitDecl )       {
+                                SemanticError( location, "use of undeclared trait " + traitInst->name );
+                        }
+                        if ( traitDecl->params.size() != traitInst->params.size() ) {
+                                SemanticError( location, traitInst, "incorrect number of trait parameters: " );
+                        }
+                        traitInst = ast::mutate_field( traitInst, &ast::TraitInstType::base, traitDecl );
+
+                        // need to carry over the "sized" status of each decl in the instance
+                        for ( unsigned i = 0; i < traitDecl->params.size(); ++i ) {
+                                auto expr = traitInst->params[i].as< ast::TypeExpr >();
+                                if ( ! expr ) {
+                                        SemanticError(
+                                                traitInst->params[i].get(), "Expression parameters for trait instances "
+                                                "are currently unsupported: " );
+                                }
+
+                                if ( auto inst = expr->type.as< ast::TypeInstType >() ) {
+                                        if ( traitDecl->params[i]->sized && ! inst->base->sized ) {
+                                                // traitInst = ast::mutate_field_index(
+                                                //      traitInst, &ast::TraitInstType::params, i,
+                                                //      ...
+                                                // );
+                                                ast::TraitInstType * mut = ast::mutate( traitInst );
+                                                ast::chain_mutate( mut->params[i] )
+                                                        ( &ast::TypeExpr::type )
+                                                                ( &ast::TypeInstType::base )->sized = true;
+                                                traitInst = mut;
+                                        }
+                                }
+                        }
+
+                        return traitInst;
+                }
+
+                void previsit( const ast::QualifiedType * ) { visit_children = false; }
+
+                const ast::Type * postvisit( const ast::QualifiedType * qualType ) {
+                        // linking only makes sense for the "oldest ancestor" of the qualified type
+                        return ast::mutate_field(
+                                qualType, &ast::QualifiedType::parent, qualType->parent->accept( * visitor ) );
+                }
+
+                const ast::Decl * postvisit( const ast::EnumDecl * enumDecl ) {
+                        // visit enum members first so that the types of self-referencing members are updated
+                        // properly
+                        if ( ! enumDecl->body ) return enumDecl;
+
+                        // update forward declarations to point here
+                        auto fwds = forwardEnums.equal_range( enumDecl->name );
+                        if ( fwds.first != fwds.second ) {
+                                auto inst = fwds.first;
+                                do {
+                                        // forward decl is stored * mutably * in map, can thus be updated
+                                        inst->second->base = enumDecl;
+                                } while ( ++inst != fwds.second );
+                                forwardEnums.erase( fwds.first, fwds.second );
+                        }
+
+                        // ensure that enumerator initializers are properly set
+                        for ( unsigned i = 0; i < enumDecl->members.size(); ++i ) {
+                                auto field = enumDecl->members[i].strict_as< ast::ObjectDecl >();
+                                if ( field->init ) {
+                                        // need to resolve enumerator initializers early so that other passes that
+                                        // determine if an expression is constexpr have appropriate information
+                                        auto init = field->init.strict_as< ast::SingleInit >();
+
+                                        enumDecl = ast::mutate_field_index(
+                                                enumDecl, &ast::EnumDecl::members, i,
+                                                ast::mutate_field( field, &ast::ObjectDecl::init,
+                                                        ast::mutate_field( init, &ast::SingleInit::value,
+                                                                ResolvExpr::findSingleExpression(
+                                                                        init->value, new ast::BasicType{ ast::BasicType::SignedInt },
+                                                                        symtab ) ) ) );
+                                }
+                        }
+
+                        return enumDecl;
+                }
+
+                /// rename generic type parameters uniquely so that they do not conflict with user defined
+                /// function forall parameters, e.g. the T in Box and the T in f, below
+                ///   forall(otype T)
+                ///   struct Box {
+                ///     T x;
+                ///   };
+                ///   forall(otype T)
+                ///   void f(Box(T) b) {
+                ///     ...
+                ///   }
+                template< typename AggrDecl >
+                const AggrDecl * renameGenericParams( const AggrDecl * aggr ) {
+                        GuardValue( inGeneric );
+                        inGeneric = ! aggr->params.empty();
+
+                        for ( unsigned i = 0; i < aggr->params.size(); ++i ) {
+                                const ast::TypeDecl * td = aggr->params[i];
+
+                                aggr = ast::mutate_field_index(
+                                        aggr, &AggrDecl::params, i,
+                                        ast::mutate_field( td, &ast::TypeDecl::name, "__" + td->name + "_generic_" ) );
+                        }
+                        return aggr;
+                }
+
+                const ast::StructDecl * previsit( const ast::StructDecl * structDecl ) {
+                        return renameGenericParams( structDecl );
+                }
+
+                void postvisit( const ast::StructDecl * structDecl ) {
+                        // visit struct members first so that the types of self-referencing members are
+                        // updated properly
+                        if ( ! structDecl->body ) return;
+
+                        // update forward declarations to point here
+                        auto fwds = forwardStructs.equal_range( structDecl->name );
+                        if ( fwds.first != fwds.second ) {
+                                auto inst = fwds.first;
+                                do {
+                                        // forward decl is stored * mutably * in map, can thus be updated
+                                        inst->second->base = structDecl;
+                                } while ( ++inst != fwds.second );
+                                forwardStructs.erase( fwds.first, fwds.second );
+                        }
+                }
+
+                const ast::UnionDecl * previsit( const ast::UnionDecl * unionDecl ) {
+                        return renameGenericParams( unionDecl );
+                }
+
+                void postvisit( const ast::UnionDecl * unionDecl ) {
+                        // visit union members first so that the types of self-referencing members are updated
+                        // properly
+                        if ( ! unionDecl->body ) return;
+
+                        // update forward declarations to point here
+                        auto fwds = forwardUnions.equal_range( unionDecl->name );
+                        if ( fwds.first != fwds.second ) {
+                                auto inst = fwds.first;
+                                do {
+                                        // forward decl is stored * mutably * in map, can thus be updated
+                                        inst->second->base = unionDecl;
+                                } while ( ++inst != fwds.second );
+                                forwardUnions.erase( fwds.first, fwds.second );
+                        }
+                }
+
+                const ast::Decl * postvisit( const ast::TraitDecl * traitDecl ) {
+                        // set the "sized" status for the special "sized" trait
+                        if ( traitDecl->name == "sized" ) {
+                                assertf( traitDecl->params.size() == 1, "Built-in trait 'sized' has incorrect "
+                                        "number of parameters: %zd", traitDecl->params.size() );
+
+                                traitDecl = ast::mutate_field_index(
+                                        traitDecl, &ast::TraitDecl::params, 0,
+                                        ast::mutate_field(
+                                                traitDecl->params.front().get(), &ast::TypeDecl::sized, true ) );
+                        }
+
+                        // move assertions from type parameters into the body of the trait
+                        std::vector< ast::ptr< ast::DeclWithType > > added;
+                        for ( const ast::TypeDecl * td : traitDecl->params ) {
+                                for ( const ast::DeclWithType * assn : td->assertions ) {
+                                        auto inst = dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
+                                        if ( inst ) {
+                                                expandAssertions( inst, added );
+                                        } else {
+                                                added.emplace_back( assn );
+                                        }
+                                }
+                        }
+                        if ( ! added.empty() ) {
+                                auto mut = mutate( traitDecl );
+                                for ( const ast::DeclWithType * decl : added ) {
+                                        mut->members.emplace_back( decl );
+                                }
+                                traitDecl = mut;
+                        }
+
+                        return traitDecl;
+                }
+        };
+
+        /// Replaces array and function types in forall lists by appropriate pointer type and assigns
+        /// each object and function declaration a unique ID
+        class ForallPointerDecay_new {
+                const CodeLocation & location;
+        public:
+                ForallPointerDecay_new( const CodeLocation & loc ) : location( loc ) {}
+
+                const ast::ObjectDecl * previsit( const ast::ObjectDecl * obj ) {
+                        // ensure that operator names only apply to functions or function pointers
+                        if (
+                                CodeGen::isOperator( obj->name )
+                                && ! dynamic_cast< const ast::FunctionType * >( obj->type->stripDeclarator() )
+                        ) {
+                                SemanticError( obj->location, toCString( "operator ", obj->name.c_str(), " is not "
+                                        "a function or function pointer." )  );
+                        }
+
+                        // ensure object has unique ID
+                        if ( obj->uniqueId ) return obj;
+                        auto mut = mutate( obj );
+                        mut->fixUniqueId();
+                        return mut;
+                }
+
+                const ast::FunctionDecl * previsit( const ast::FunctionDecl * func ) {
+                        // ensure function has unique ID
+                        if ( func->uniqueId ) return func;
+                        auto mut = mutate( func );
+                        mut->fixUniqueId();
+                        return mut;
+                }
+
+                /// Fix up assertions -- flattens assertion lists, removing all trait instances
+                template< typename node_t, typename parent_t >
+                static const node_t * forallFixer(
+                        const CodeLocation & loc, const node_t * node,
+                        ast::ParameterizedType::ForallList parent_t::* forallField
+                ) {
+                        for ( unsigned i = 0; i < (node->* forallField).size(); ++i ) {
+                                const ast::TypeDecl * type = (node->* forallField)[i];
+                                if ( type->assertions.empty() ) continue;
+
+                                std::vector< ast::ptr< ast::DeclWithType > > asserts;
+                                asserts.reserve( type->assertions.size() );
+
+                                // expand trait instances into their members
+                                for ( const ast::DeclWithType * assn : type->assertions ) {
+                                        auto traitInst =
+                                                dynamic_cast< const ast::TraitInstType * >( assn->get_type() );
+                                        if ( traitInst ) {
+                                                // expand trait instance to all its members
+                                                expandAssertions( traitInst, asserts );
+                                        } else {
+                                                // pass other assertions through
+                                                asserts.emplace_back( assn );
+                                        }
+                                }
+
+                                // apply FixFunction to every assertion to check for invalid void type
+                                for ( ast::ptr< ast::DeclWithType > & assn : asserts ) {
+                                        bool isVoid = false;
+                                        assn = fixFunction( assn, isVoid );
+                                        if ( isVoid ) {
+                                                SemanticError( loc, node, "invalid type void in assertion of function " );
+                                        }
+                                }
+
+                                // place mutated assertion list in node
+                                auto mut = mutate( type );
+                                mut->assertions = move( asserts );
+                                node = ast::mutate_field_index( node, forallField, i, mut );
+                        }
+                        return node;
+                }
+
+                const ast::FunctionType * previsit( const ast::FunctionType * ftype ) {
+                        return forallFixer( location, ftype, &ast::FunctionType::forall );
+                }
+
+                const ast::StructDecl * previsit( const ast::StructDecl * aggrDecl ) {
+                        return forallFixer( aggrDecl->location, aggrDecl, &ast::StructDecl::params );
+                }
+
+                const ast::UnionDecl * previsit( const ast::UnionDecl * aggrDecl ) {
+                        return forallFixer( aggrDecl->location, aggrDecl, &ast::UnionDecl::params );
+                }
+        };
+} // anonymous namespace
+
+const ast::Type * validateType(
+                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab ) {
+        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 );
+}
+
 } // namespace SymTab
 

src/SymTab/Validate.h

@@ -19 +19 @@
 #include <list>  // for list
 
-class Declaration;
-class Type;
+struct CodeLocation;
+class  Declaration;
+class  Type;
+
+namespace ast {
+        class Type;
+        class SymbolTable;
+}
 
 namespace SymTab {
@@ -28 +34 @@
         void validate( std::list< Declaration * > &translationUnit, bool doDebug = false );
         void validateType( Type *type, const Indexer *indexer );
+
+        const ast::Type * validateType(
+                const CodeLocation & loc, const ast::Type * type, const ast::SymbolTable & symtab );
 } // namespace SymTab
 

src/SymTab/module.mk

@@ -15 +15 @@
 ###############################################################################
 
-SRC += SymTab/Indexer.cc \
-       SymTab/Mangler.cc \
-       SymTab/Validate.cc \
-       SymTab/FixFunction.cc \
-       SymTab/Autogen.cc
+SRC_SYMTAB = \
+      SymTab/Autogen.cc \
+      SymTab/FixFunction.cc \
+      SymTab/Indexer.cc \
+      SymTab/Mangler.cc \
+      SymTab/ManglerCommon.cc \
+      SymTab/Validate.cc
+
+SRC += $(SRC_SYMTAB)
+SRCDEMANGLE += $(SRC_SYMTAB) SymTab/Demangle.cc