Changes in / [e23d20b:9cdfb4d0]

Location:

src

Files:

• CodeGen/GenType.cc (modified) (13 diffs)
• CodeTools/DeclStats.cc (modified) (18 diffs)
• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (1 diff)
• ControlStruct/ExceptTranslate.cc (modified) (1 diff)
• ResolvExpr/AlternativeFinder.cc (modified) (41 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (2 diffs)
• ResolvExpr/CommonType.cc (modified) (10 diffs)
• ResolvExpr/CurrentObject.cc (modified) (1 diff)
• ResolvExpr/PtrsAssignable.cc (modified) (6 diffs)
• ResolvExpr/PtrsCastable.cc (modified) (7 diffs)
• ResolvExpr/RenameVars.cc (modified) (2 diffs)
• ResolvExpr/RenameVars.h (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (1 diff)
• ResolvExpr/TypeMap.h (added)
• ResolvExpr/Unify.cc (modified) (10 diffs)
• SymTab/Mangler.cc (modified) (2 diffs)
• SymTab/Mangler.h (modified) (1 diff)
• SynTree/CompoundStmt.cc (modified) (1 diff)
• SynTree/FunctionDecl.cc (modified) (1 diff)
• SynTree/VarExprReplacer.cc (modified) (1 diff)
• SynTree/VarExprReplacer.h (modified) (1 diff)

src/CodeGen/GenType.cc

@@ -26 +26 @@
 
 namespace CodeGen {
-        struct GenType : public WithVisitorRef<GenType>, public WithShortCircuiting {
+        class GenType : public Visitor {
+          public:
                 GenType( const std::string &typeString, bool pretty = false, bool genC = false, bool lineMarks = false );
                 std::string get_typeString() const { return typeString; }
                 void set_typeString( const std::string &newValue ) { typeString = newValue; }
 
-                void previsit( BaseSyntaxNode * );
-                void postvisit( BaseSyntaxNode * );
-
-                void postvisit( FunctionType * funcType );
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( ReferenceType * refType );
-                void postvisit( StructInstType * structInst );
-                void postvisit( UnionInstType * unionInst );
-                void postvisit( EnumInstType * enumInst );
-                void postvisit( TypeInstType * typeInst );
-                void postvisit( TupleType  * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
+                virtual void visit( FunctionType *funcType );
+                virtual void visit( VoidType *voidType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
+                virtual void visit( StructInstType *structInst );
+                virtual void visit( UnionInstType *unionInst );
+                virtual void visit( EnumInstType *enumInst );
+                virtual void visit( TypeInstType *typeInst );
+                virtual void visit( TupleType * tupleType );
+                virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
           private:
@@ -61 +59 @@
 
         std::string genType( Type *type, const std::string &baseString, bool pretty, bool genC , bool lineMarks ) {
-                PassVisitor<GenType> gt( baseString, pretty, genC, lineMarks );
+                GenType gt( baseString, pretty, genC, lineMarks );
                 std::ostringstream os;
 
@@ -70 +68 @@
 
                 type->accept( gt );
-                return os.str() + gt.pass.get_typeString();
+                return os.str() + gt.get_typeString();
         }
 
@@ -79 +77 @@
         GenType::GenType( const std::string &typeString, bool pretty, bool genC, bool lineMarks ) : typeString( typeString ), pretty( pretty ), genC( genC ), lineMarks( lineMarks ) {}
 
-        // *** BaseSyntaxNode
-        void GenType::previsit( BaseSyntaxNode * ) {
-                // turn off automatic recursion for all nodes, to allow each visitor to
-                // precisely control the order in which its children are visited.
-                visit_children = false;
-        }
-
-        void GenType::postvisit( BaseSyntaxNode * node ) {
-                std::stringstream ss;
-                node->print( ss );
-                assertf( false, "Unhandled node reached in GenType: %s", ss.str().c_str() );
-        }
-
-        void GenType::postvisit( VoidType * voidType ) {
+        void GenType::visit( VoidType *voidType ) {
                 typeString = "void " + typeString;
                 handleQualifiers( voidType );
         }
 
-        void GenType::postvisit( BasicType * basicType ) {
-                BasicType::Kind kind = basicType->kind;
+        void GenType::visit( BasicType *basicType ) {
+                BasicType::Kind kind = basicType->get_kind();
                 assert( 0 <= kind && kind < BasicType::NUMBER_OF_BASIC_TYPES );
                 typeString = std::string( BasicType::typeNames[kind] ) + " " + typeString;
@@ -104 +89 @@
         }
 
-        void GenType::genArray( const Type::Qualifiers & qualifiers, Type * base, Expression *dimension, bool isVarLen, bool isStatic ) {
+        void GenType::genArray( const Type::Qualifiers &qualifiers, Type *base, Expression *dimension, bool isVarLen, bool isStatic ) {
                 std::ostringstream os;
                 if ( typeString != "" ) {
@@ -141 +126 @@
                 typeString = os.str();
 
-                base->accept( *visitor );
-        }
-
-        void GenType::postvisit( PointerType * pointerType ) {
-                assert( pointerType->base != 0);
-                if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->dimension ) {
-                        genArray( pointerType->get_qualifiers(), pointerType->base, pointerType->dimension, pointerType->get_isVarLen(), pointerType->get_isStatic() );
+                base->accept( *this );
+        }
+
+        void GenType::visit( PointerType *pointerType ) {
+                assert( pointerType->get_base() != 0);
+                if ( pointerType->get_isStatic() || pointerType->get_isVarLen() || pointerType->get_dimension() ) {
+                        genArray( pointerType->get_qualifiers(), pointerType->get_base(), pointerType->get_dimension(), pointerType->get_isVarLen(), pointerType->get_isStatic() );
                 } else {
                         handleQualifiers( pointerType );
@@ -155 +140 @@
                                 typeString = "*" + typeString;
                         } // if
-                        pointerType->base->accept( *visitor );
-                } // if
-        }
-
-        void GenType::postvisit( ArrayType * arrayType ) {
-                genArray( arrayType->get_qualifiers(), arrayType->base, arrayType->dimension, arrayType->get_isVarLen(), arrayType->get_isStatic() );
-        }
-
-        void GenType::postvisit( ReferenceType * refType ) {
-                assert( refType->base != 0);
+                        pointerType->get_base()->accept( *this );
+                } // if
+        }
+
+        void GenType::visit( ArrayType *arrayType ) {
+                genArray( arrayType->get_qualifiers(), arrayType->get_base(), arrayType->get_dimension(), arrayType->get_isVarLen(), arrayType->get_isStatic() );
+        }
+
+        void GenType::visit( ReferenceType *refType ) {
+                assert( refType->get_base() != 0);
                 assertf( ! genC, "Reference types should not reach code generation." );
                 handleQualifiers( refType );
                 typeString = "&" + typeString;
-                refType->base->accept( *visitor );
-        }
-
-        void GenType::postvisit( FunctionType * funcType ) {
+                refType->get_base()->accept( *this );
+        }
+
+        void GenType::visit( FunctionType *funcType ) {
                 std::ostringstream os;
 
@@ -184 +169 @@
                 /************* parameters ***************/
 
-                const std::list<DeclarationWithType *> &pars = funcType->parameters;
+                const std::list<DeclarationWithType *> &pars = funcType->get_parameters();
 
                 if ( pars.empty() ) {
@@ -206 +191 @@
                 typeString = os.str();
 
-                if ( funcType->returnVals.size() == 0 ) {
+                if ( funcType->get_returnVals().size() == 0 ) {
                         typeString = "void " + typeString;
                 } else {
-                        funcType->returnVals.front()->get_type()->accept( *visitor );
+                        funcType->get_returnVals().front()->get_type()->accept( *this );
                 } // if
 
                 // add forall
-                if( ! funcType->forall.empty() && ! genC ) {
+                if( ! funcType->get_forall().empty() && ! genC ) {
                         // assertf( ! genC, "Aggregate type parameters should not reach code generation." );
                         std::ostringstream os;
                         PassVisitor<CodeGenerator> cg( os, pretty, genC, lineMarks );
                         os << "forall(";
-                        cg.pass.genCommaList( funcType->forall.begin(), funcType->forall.end() );
+                        cg.pass.genCommaList( funcType->get_forall().begin(), funcType->get_forall().end() );
                         os << ")" << std::endl;
                         typeString = os.str() + typeString;
@@ -236 +221 @@
         }
 
-        void GenType::postvisit( StructInstType * structInst )  {
-                typeString = structInst->name + handleGeneric( structInst ) + " " + typeString;
+        void GenType::visit( StructInstType *structInst )  {
+                typeString = structInst->get_name() + handleGeneric( structInst ) + " " + typeString;
                 if ( genC ) typeString = "struct " + typeString;
                 handleQualifiers( structInst );
         }
 
-        void GenType::postvisit( UnionInstType * unionInst ) {
-                typeString = unionInst->name + handleGeneric( unionInst ) + " " + typeString;
+        void GenType::visit( UnionInstType *unionInst ) {
+                typeString = unionInst->get_name() + handleGeneric( unionInst ) + " " + typeString;
                 if ( genC ) typeString = "union " + typeString;
                 handleQualifiers( unionInst );
         }
 
-        void GenType::postvisit( EnumInstType * enumInst ) {
-                typeString = enumInst->name + " " + typeString;
+        void GenType::visit( EnumInstType *enumInst ) {
+                typeString = enumInst->get_name() + " " + typeString;
                 if ( genC ) typeString = "enum " + typeString;
                 handleQualifiers( enumInst );
         }
 
-        void GenType::postvisit( TypeInstType * typeInst ) {
-                typeString = typeInst->name + " " + typeString;
+        void GenType::visit( TypeInstType *typeInst ) {
+                typeString = typeInst->get_name() + " " + typeString;
                 handleQualifiers( typeInst );
         }
 
-        void GenType::postvisit( TupleType * tupleType ) {
+        void GenType::visit( TupleType * tupleType ) {
                 assertf( ! genC, "Tuple types should not reach code generation." );
                 unsigned int i = 0;
@@ -272 +257 @@
         }
 
-        void GenType::postvisit( VarArgsType * varArgsType ) {
+        void GenType::visit( VarArgsType *varArgsType ) {
                 typeString = "__builtin_va_list " + typeString;
                 handleQualifiers( varArgsType );
         }
 
-        void GenType::postvisit( ZeroType * zeroType ) {
+        void GenType::visit( ZeroType *zeroType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
                 typeString = (pretty ? "zero_t " : "long int ") + typeString;
@@ -283 +268 @@
         }
 
-        void GenType::postvisit( OneType * oneType ) {
+        void GenType::visit( OneType *oneType ) {
                 // ideally these wouldn't hit codegen at all, but should be safe to make them ints
                 typeString = (pretty ? "one_t " : "long int ") + typeString;
@@ -289 +274 @@
         }
 
-        void GenType::handleQualifiers( Type * type ) {
+        void GenType::handleQualifiers( Type *type ) {
                 if ( type->get_const() ) {
                         typeString = "const " + typeString;

src/CodeTools/DeclStats.cc

@@ -23 +23 @@
 #include <utility>                 // for pair, make_pair
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "Common/VectorMap.h"      // for VectorMap
@@ -36 +35 @@
 namespace CodeTools {
 
-        struct DeclStats : public WithShortCircuiting {
+        class DeclStats : public Visitor {
                 template<typename T>
                 static void sum(T& a, const T& b) { a += b; }
@@ -127 +126 @@
                         ArgPackStats assn_returns;
 
-                        Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(),
-                                by_name(), basic_type_names(), generic_type_names(), compound_type_names(),
-                                basic_type_decls(), generic_type_decls(), compound_type_decls(), params(),
+                        Stats() : n_decls(0), n_type_params(), n_generic_params(), n_generic_nesting(), 
+                                by_name(), basic_type_names(), generic_type_names(), compound_type_names(), 
+                                basic_type_decls(), generic_type_decls(), compound_type_decls(), params(), 
                                 returns(), n_assns(), assn_params(), assn_returns() {}
 
@@ -166 +165 @@
                 std::map<std::pair<unsigned, unsigned>, unsigned> exprs_by_fanout_at_depth;
 
-                void countType( const std::string& name, unsigned& n, std::unordered_map<std::string,
-                                unsigned>& names, std::unordered_map<std::string, unsigned>& decls,
+                void countType( const std::string& name, unsigned& n, std::unordered_map<std::string, 
+                                unsigned>& names, std::unordered_map<std::string, unsigned>& decls, 
                                 std::unordered_set<std::string>& elSeen ) {
                         ++n;
@@ -178 +177 @@
                 }
 
-                void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,
+                void analyzeSubtype( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen, 
                                 unsigned& n_poly, bool& seen_poly, unsigned& max_depth, unsigned depth ) {
                         unsigned x;
@@ -184 +183 @@
                 }
 
-                void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats,
-                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
+                void analyzeSubtypes( std::list<DeclarationWithType*>& tys, Stats& stats, 
+                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 
                                 unsigned& max_depth, unsigned depth, unsigned& n_subs ) {
                         for ( DeclarationWithType* dwt : tys ) {
@@ -194 +193 @@
                 }
 
-                void analyzeSubtypes( std::list<Expression*>& tys, Stats& stats,
-                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
+                void analyzeSubtypes( std::list<Expression*>& tys, Stats& stats, 
+                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 
                                 unsigned& max_depth, unsigned depth ) {
                         for ( Expression* expr : tys ) {
@@ -205 +204 @@
                 }
 
-                void analyzeSubtypes( std::list<Type*>& tys, Stats& stats,
-                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly,
+                void analyzeSubtypes( std::list<Type*>& tys, Stats& stats, 
+                                std::unordered_set<std::string>& elSeen, unsigned& n_poly, bool& seen_poly, 
                                 unsigned& max_depth, unsigned depth ) {
                         for ( Type* ty : tys ) {
@@ -213 +212 @@
                 }
 
-                void analyzeType( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen,
-                                unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg,
+                void analyzeType( Type* ty, Stats& stats, std::unordered_set<std::string>& elSeen, 
+                                unsigned& n_basic, unsigned& n_generic, unsigned& n_poly, unsigned& n_agg,  
                                 bool& seen_poly, unsigned& max_depth, unsigned depth = 0 ) {
                         if ( BasicType* bt = dynamic_cast<BasicType*>(ty) ) {
@@ -222 +221 @@
                         } else if ( PointerType* pt = dynamic_cast<PointerType*>(ty) ) {
                                 std::string name = "*";
-                                countType(
+                                countType( 
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
-                                analyzeSubtype(
+                                analyzeSubtype( 
                                         pt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
                                 ++stats.n_generic_params.at( 1 );
                         } else if ( ArrayType* at = dynamic_cast<ArrayType*>(ty) ) {
                                 std::string name = "[]";
-                                countType(
+                                countType( 
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
-                                analyzeSubtype(
+                                analyzeSubtype( 
                                         at->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
                                 ++stats.n_generic_params.at( 1 );
                         } else if ( ReferenceType* rt = dynamic_cast<ReferenceType*>(ty) ) {
                                 std::string name = "&";
-                                countType(
+                                countType( 
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
-                                analyzeSubtype(
+                                analyzeSubtype( 
                                         rt->get_base(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
                                 ++stats.n_generic_params.at( 1 );
                         } else if ( FunctionType* ft = dynamic_cast<FunctionType*>(ty) ) {
                                 std::string name = "(*)";
-                                countType(
+                                countType( 
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
                                 unsigned n_subs = 0;
-                                analyzeSubtypes(
-                                        ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
+                                analyzeSubtypes( 
+                                        ft->get_returnVals(), stats, elSeen, n_poly, seen_poly, max_depth, depth, 
                                         n_subs );
-                                analyzeSubtypes(
-                                        ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth,
+                                analyzeSubtypes( 
+                                        ft->get_parameters(), stats, elSeen, n_poly, seen_poly, max_depth, depth, 
                                         n_subs );
                                 ++stats.n_generic_params.at( n_subs );
@@ -258 +257 @@
                                         seen_poly = true;
                                 }
-                                countType(
-                                        vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls,
+                                countType( 
+                                        vt->get_name(), n_agg, stats.compound_type_names, stats.compound_type_decls, 
                                         elSeen );
                                 update_max( max_depth, depth );
@@ -265 +264 @@
                                 std::list<Expression*>& params = st->get_parameters();
                                 if ( params.empty() ) {
-                                        countType(
-                                                st->get_name(), n_agg, stats.compound_type_names,
+                                        countType( 
+                                                st->get_name(), n_agg, stats.compound_type_names, 
                                                 stats.compound_type_decls, elSeen );
                                         update_max( max_depth, depth );
                                 } else {
-                                        countType(
-                                                st->get_name(), n_generic, stats.generic_type_names,
+                                        countType( 
+                                                st->get_name(), n_generic, stats.generic_type_names, 
                                                 stats.generic_type_decls, elSeen);
                                         analyzeSubtypes( params, stats, elSeen, n_poly, seen_poly, max_depth, depth );
@@ -278 +277 @@
                         } else if ( TupleType* tt = dynamic_cast<TupleType*>(ty) ) {
                                 std::string name = "[,]";
-                                countType(
+                                countType( 
                                         name, n_generic, stats.generic_type_names, stats.generic_type_decls, elSeen);
-                                analyzeSubtypes(
+                                analyzeSubtypes( 
                                         tt->get_types(), stats, elSeen, n_poly, seen_poly, max_depth, depth );
                                 ++stats.n_generic_params.at( tt->size() );
                         } else if ( dynamic_cast<VarArgsType*>(ty) ) {
                                 std::string name = "...";
-                                countType(
+                                countType( 
                                         name, n_agg, stats.compound_type_names, stats.compound_type_decls, elSeen );
                                 update_max( max_depth, depth );
@@ -300 +299 @@
 
                 /// Update arg pack stats based on a declaration list
-                void analyze( Stats& stats, std::unordered_set<std::string>& seen,
-                                std::unordered_set<std::string>& elSeen, ArgPackStats& pstats,
+                void analyze( Stats& stats, std::unordered_set<std::string>& seen, 
+                                std::unordered_set<std::string>& elSeen, ArgPackStats& pstats, 
                                 std::list<DeclarationWithType*>& decls ) {
                         std::unordered_set<std::string> types;
@@ -310 +309 @@
                         unsigned n_agg = 0;             ///< number of non-generic aggregate types
                         unsigned n_new = 0;             ///< number of new types
-
+                        
                         for ( auto decl : decls ) {
                                 Type* dt = decl->get_type();
@@ -323 +322 @@
                                 bool seen_poly = false;
                                 unsigned max_depth = 0;
-                                analyzeType(
+                                analyzeType( 
                                         dt, stats, elSeen, n_basic, n_generic, n_poly, n_agg, seen_poly, max_depth );
                                 ++stats.n_generic_nesting.at( max_depth );
                         }
-
+                        
                         ++pstats.n.at( n );
                         ++pstats.n_basic.at( n_basic );
@@ -363 +362 @@
 
         public:
-                void previsit( FunctionDecl *decl ) {
+                using Visitor::visit;
+
+                virtual void visit( FunctionDecl *decl ) {
                         // skip if already seen declaration for this function
-                        const std::string& mangleName = decl->get_mangleName().empty() ? decl->name : decl->get_mangleName();
-                        if ( seen_names.insert( mangleName ).second ) {
-                                Stats& stats = for_linkage[ ind_for_linkage[ decl->linkage ] ];
-
-                                ++stats.n_decls;
-                                FunctionType* fnTy = decl->type;
-                                const Type::ForallList& forall = fnTy->forall;
-                                ++stats.n_type_params.at( forall.size() );
-                                unsigned n_assns = 0;
-                                for ( TypeDecl* fdecl : forall ) {
-                                        n_assns += fdecl->assertions.size();
-                                        for ( DeclarationWithType* assn : fdecl->assertions ) {
-                                                FunctionType *assnTy = nullptr;
-                                                if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) {
-                                                        if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) {
-                                                                assnTy = dynamic_cast<FunctionType*>(ptrTy->base);
-                                                        } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type());
-                                                } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) {
-                                                        assnTy = assnDecl->type;
-                                                }
-                                                if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
+                        const std::string& mangleName = decl->get_mangleName().empty() ? decl->get_name() : decl->get_mangleName();
+                        if ( ! seen_names.insert( mangleName ).second ) {
+                                maybeAccept( decl->get_statements(), *this );
+                                return;
+                        }
+
+                        Stats& stats = for_linkage[ ind_for_linkage[ decl->get_linkage() ] ];
+
+                        ++stats.n_decls;
+                        FunctionType* fnTy = decl->get_functionType();
+                        const Type::ForallList& forall = fnTy->get_forall();
+                        ++stats.n_type_params.at( forall.size() );
+                        unsigned n_assns = 0;
+                        for ( TypeDecl* fdecl : forall ) {
+                                n_assns += fdecl->get_assertions().size();
+                                for ( DeclarationWithType* assn : fdecl->get_assertions() ) {
+                                        FunctionType *assnTy = 0;
+                                        if ( ObjectDecl *assnObj = dynamic_cast<ObjectDecl*>(assn) ) {
+                                                if ( PointerType *ptrTy = dynamic_cast<PointerType*>(assnObj->get_type()) ) {
+                                                        assnTy = dynamic_cast<FunctionType*>(ptrTy->get_base());
+                                                } else assnTy = dynamic_cast<FunctionType*>(assnObj->get_type());
+                                        } else if ( FunctionDecl *assnDecl = dynamic_cast<FunctionDecl*>(assn) ) {
+                                                assnTy = assnDecl->get_functionType();
                                         }
-                                }
-                                ++stats.n_assns[ n_assns ];
-                                ++stats.by_name[ decl->name ];
-                                analyzeFunc( fnTy, stats, stats.params, stats.returns );
-                        }
-                }
-
-                void previsit( UntypedExpr *expr ) {
-                        visit_children = false;
+                                        if ( assnTy ) analyzeFunc( assnTy, stats, stats.assn_params, stats.assn_returns );
+                                }
+                        }
+                        ++stats.n_assns[ n_assns ];
+
+                        ++stats.by_name[ decl->get_name() ];
+
+                        analyzeFunc( fnTy, stats, stats.params, stats.returns );
+
+                        // analyze expressions in decl statements
+                        maybeAccept( decl->get_statements(), *this );
+                }
+
+                virtual void visit( UntypedExpr *expr ) {
                         analyzeExpr( expr, 0 );
                 }
@@ -528 +536 @@
         };
 
-        const unsigned DeclStats::ind_for_linkage[]
+        const unsigned DeclStats::ind_for_linkage[] 
                 = { 7, 7, 2, 1,   7, 7, 7, 3,   4, 7, 6, 5,   7, 7, 7, 0 };
 
         void printDeclStats( std::list< Declaration * > &translationUnit ) {
-                PassVisitor<DeclStats> stats;
+                DeclStats stats;
                 acceptAll( translationUnit, stats );
-                stats.pass.print();
+                stats.print();
         }
 

src/Common/PassVisitor.h

@@ -119 +119 @@
         virtual void visit( StmtExpr *  stmtExpr ) override final;
         virtual void visit( UniqueExpr *  uniqueExpr ) override final;
-        virtual void visit( UntypedInitExpr *  initExpr ) override final;
-        virtual void visit( InitExpr *  initExpr ) override final;
 
         virtual void visit( VoidType * basicType ) override final;
@@ -213 +211 @@
         virtual Expression * mutate( StmtExpr *  stmtExpr ) override final;
         virtual Expression * mutate( UniqueExpr *  uniqueExpr ) override final;
-        virtual Expression * mutate( UntypedInitExpr *  initExpr ) override final;
-        virtual Expression * mutate( InitExpr *  initExpr ) override final;
 
         virtual Type * mutate( VoidType * basicType ) override final;

src/Common/PassVisitor.impl.h

@@ -1853 +1853 @@
 }
 
-//--------------------------------------------------------------------------
-// UntypedInitExpr
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( UntypedInitExpr * node ) {
-        VISIT_START( node );
-
-        indexerScopedAccept( node->result, *this );
-        maybeAccept_impl   ( node->expr  , *this );
-        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( UntypedInitExpr * node ) {
-        MUTATE_START( node );
-
-        indexerScopedMutate( node->env   , *this );
-        indexerScopedMutate( node->result, *this );
-        maybeMutate_impl   ( node->expr  , *this );
-        // not currently visiting initAlts, but this doesn't matter since this node is only used in the resolver.
-
-        MUTATE_END( Expression, node );
-}
-
-//--------------------------------------------------------------------------
-// InitExpr
-template< typename pass_type >
-void PassVisitor< pass_type >::visit( InitExpr * node ) {
-        VISIT_START( node );
-
-        indexerScopedAccept( node->result, *this );
-        maybeAccept_impl   ( node->expr  , *this );
-        maybeAccept_impl   ( node->designation, *this );
-
-        VISIT_END( node );
-}
-
-template< typename pass_type >
-Expression * PassVisitor< pass_type >::mutate( InitExpr * node ) {
-        MUTATE_START( node );
-
-        indexerScopedMutate( node->env   , *this );
-        indexerScopedMutate( node->result, *this );
-        maybeMutate_impl   ( node->expr  , *this );
-        maybeMutate_impl   ( node->designation, *this );
-
-        MUTATE_END( Expression, node );
-}
-
 template< typename pass_type >
 void PassVisitor< pass_type >::visit( VoidType * node ) {

src/ControlStruct/ExceptTranslate.cc

@@ -316 +316 @@
                                 VarExprReplacer::DeclMap mapping;
                                 mapping[ handler_decl ] = local_except;
-                                VarExprReplacer::replace( handler->body, mapping );
+                                VarExprReplacer mapper( mapping );
+                                handler->get_body()->accept( mapper );
                         }
 

src/ResolvExpr/AlternativeFinder.cc

@@ -60 +60 @@
 
 namespace ResolvExpr {
-        struct AlternativeFinder::Finder : public WithShortCircuiting {
-                Finder( AlternativeFinder & altFinder ) : altFinder( altFinder ), indexer( altFinder.indexer ), alternatives( altFinder.alternatives ), env( altFinder.env ), targetType( altFinder.targetType )  {}
-
-                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-
-                void postvisit( ApplicationExpr * applicationExpr );
-                void postvisit( UntypedExpr * untypedExpr );
-                void postvisit( AddressExpr * addressExpr );
-                void postvisit( LabelAddressExpr * labelExpr );
-                void postvisit( CastExpr * castExpr );
-                void postvisit( VirtualCastExpr * castExpr );
-                void postvisit( UntypedMemberExpr * memberExpr );
-                void postvisit( MemberExpr * memberExpr );
-                void postvisit( NameExpr * variableExpr );
-                void postvisit( VariableExpr * variableExpr );
-                void postvisit( ConstantExpr * constantExpr );
-                void postvisit( SizeofExpr * sizeofExpr );
-                void postvisit( AlignofExpr * alignofExpr );
-                void postvisit( UntypedOffsetofExpr * offsetofExpr );
-                void postvisit( OffsetofExpr * offsetofExpr );
-                void postvisit( OffsetPackExpr * offsetPackExpr );
-                void postvisit( AttrExpr * attrExpr );
-                void postvisit( LogicalExpr * logicalExpr );
-                void postvisit( ConditionalExpr * conditionalExpr );
-                void postvisit( CommaExpr * commaExpr );
-                void postvisit( ImplicitCopyCtorExpr  * impCpCtorExpr );
-                void postvisit( ConstructorExpr  * ctorExpr );
-                void postvisit( RangeExpr  * rangeExpr );
-                void postvisit( UntypedTupleExpr * tupleExpr );
-                void postvisit( TupleExpr * tupleExpr );
-                void postvisit( TupleIndexExpr * tupleExpr );
-                void postvisit( TupleAssignExpr * tupleExpr );
-                void postvisit( UniqueExpr * unqExpr );
-                void postvisit( StmtExpr * stmtExpr );
-                void postvisit( UntypedInitExpr * initExpr );
-
-                /// Adds alternatives for anonymous members
-                void addAnonConversions( const Alternative & alt );
-                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
-                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
-                /// Adds alternatives for member expressions where the left side has tuple type
-                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
-                /// Adds alternatives for offsetof expressions, given the base type and name of the member
-                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
-                /// Takes a final result and checks if its assertions can be satisfied
-                template<typename OutputIterator>
-                void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
-                /// Finds matching alternatives for a function, given a set of arguments
-                template<typename OutputIterator>
-                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
-                /// Checks if assertion parameters match for a new alternative
-                template< typename OutputIterator >
-                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
-        private:
-                AlternativeFinder & altFinder;
-                const SymTab::Indexer &indexer;
-                AltList & alternatives;
-                const TypeEnvironment &env;
-                Type *& targetType;
-        };
-
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
                 CastExpr *castToVoid = new CastExpr( expr );
@@ -213 +152 @@
 
                 void renameTypes( Expression *expr ) {
-                        renameTyVars( expr->result );
+                        expr->get_result()->accept( global_renamer );
                 }
         } // namespace
@@ -246 +185 @@
 
         void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
-                PassVisitor<Finder> finder( *this );
-                expr->accept( finder );
+                expr->accept( *this );
                 if ( failFast && alternatives.empty() ) {
                         PRINT(
@@ -306 +244 @@
         }
 
-        void AlternativeFinder::Finder::addAnonConversions( const Alternative & alt ) {
+        void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
                 // adds anonymous member interpretations whenever an aggregate value type is seen.
                 // it's okay for the aggregate expression to have reference type -- cast it to the base type to treat the aggregate as the referenced value
@@ -327 +265 @@
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
                 // by this point, member must be a name expr
                 NameExpr * nameExpr = dynamic_cast< NameExpr * >( member );
@@ -346 +284 @@
         }
 
-        void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+        void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
@@ -370 +308 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) {
+        void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
                 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
         }
@@ -547 +485 @@
                         Type *adjType = candidate->get_type()->clone();
                         adjustExprType( adjType, newEnv, indexer );
-                        renameTyVars( adjType );
+                        adjType->accept( global_renamer );
                         PRINT(
                                 std::cerr << "unifying ";
@@ -603 +541 @@
 
         template< typename OutputIterator >
-        void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
+        void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
 //      PRINT(
 //          std::cerr << "inferParameters: assertions needed are" << std::endl;
@@ -657 +595 @@
 
                 ArgPack()
-                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
+                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0), 
                           tupleStart(0), nextExpl(0), explAlt(0) {}
 
@@ -768 +706 @@
 
                                                 if ( nTuples > 0 || ! results[i].expr ) {
-                                                        // first iteration or no expression to clone,
+                                                        // first iteration or no expression to clone, 
                                                         // push empty tuple expression
                                                         newResult.parent = i;
@@ -954 +892 @@
 
         template<typename OutputIterator>
-        void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
+        void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
                         const std::vector<ArgPack>& results, OutputIterator out ) {
                 ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
@@ -977 +915 @@
 
         template<typename OutputIterator>
-        void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func,
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
                         FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) {
                 OpenVarSet funcOpenVars;
@@ -1084 +1022 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) {
+        void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( untypedExpr->get_function() );
@@ -1091 +1029 @@
 
                 std::vector< AlternativeFinder > argAlternatives;
-                altFinder.findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
+                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
                         back_inserter( argAlternatives ) );
 
                 // take care of possible tuple assignments
                 // if not tuple assignment, assignment is taken care of as a normal function call
-                Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives );
+                Tuples::handleTupleAssignment( *this, untypedExpr, argAlternatives );
 
                 // find function operators
@@ -1234 +1172 @@
                         // fix this issue in a more robust way.
                         targetType = nullptr;
-                        postvisit( untypedExpr );
+                        visit( untypedExpr );
                 }
         }
@@ -1243 +1181 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) {
+        void AlternativeFinder::visit( AddressExpr *addressExpr ) {
                 AlternativeFinder finder( indexer, env );
                 finder.find( addressExpr->get_arg() );
@@ -1254 +1192 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
+        void AlternativeFinder::visit( LabelAddressExpr * expr ) {
                 alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
         }
@@ -1285 +1223 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) {
+        void AlternativeFinder::visit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
                 assert( toType );
@@ -1340 +1278 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) {
+        void AlternativeFinder::visit( VirtualCastExpr * castExpr ) {
                 assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
                 AlternativeFinder finder( indexer, env );
@@ -1352 +1290 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
+        void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
@@ -1374 +1312 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
+        void AlternativeFinder::visit( MemberExpr *memberExpr ) {
                 alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) {
+        void AlternativeFinder::visit( NameExpr *nameExpr ) {
                 std::list< SymTab::Indexer::IdData > declList;
                 indexer.lookupId( nameExpr->get_name(), declList );
@@ -1399 +1337 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) {
+        void AlternativeFinder::visit( VariableExpr *variableExpr ) {
                 // not sufficient to clone here, because variable's type may have changed
                 // since the VariableExpr was originally created.
@@ -1405 +1343 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) {
+        void AlternativeFinder::visit( ConstantExpr *constantExpr ) {
                 alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) {
+        void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
                         Type * newType = sizeofExpr->get_type()->clone();
@@ -1430 +1368 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) {
+        void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
                         Type * newType = alignofExpr->get_type()->clone();
@@ -1452 +1390 @@
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
+        void AlternativeFinder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -1465 +1403 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) {
+        void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 // xxx - resolveTypeof?
@@ -1475 +1413 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) {
+        void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) {
                 alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) {
+        void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
                 alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
         }
@@ -1506 +1444 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) {
+        void AlternativeFinder::visit( AttrExpr *attrExpr ) {
                 // assume no 'pointer-to-attribute'
                 NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
@@ -1520 +1458 @@
                                         if ( function->get_parameters().size() == 1 ) {
                                                 if ( attrExpr->get_isType() ) {
-                                                        resolveAttr( data, function, attrExpr->get_type(), env, altFinder);
+                                                        resolveAttr( data, function, attrExpr->get_type(), env, *this );
                                                 } else {
                                                         AlternativeFinder finder( indexer, env );
@@ -1526 +1464 @@
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
                                                                 if ( choice->expr->get_result()->size() == 1 ) {
-                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder );
+                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, *this );
                                                                 } // fi
                                                         } // for
@@ -1541 +1479 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) {
+        void AlternativeFinder::visit( LogicalExpr *logicalExpr ) {
                 AlternativeFinder firstFinder( indexer, env );
                 firstFinder.findWithAdjustment( logicalExpr->get_arg1() );
@@ -1554 +1492 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) {
+        void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) {
                 // find alternatives for condition
                 AlternativeFinder firstFinder( indexer, env );
@@ -1586 +1524 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) {
+        void AlternativeFinder::visit( CommaExpr *commaExpr ) {
                 TypeEnvironment newEnv( env );
                 Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv );
@@ -1597 +1535 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) {
+        void AlternativeFinder::visit( RangeExpr * rangeExpr ) {
                 // resolve low and high, accept alternatives whose low and high types unify
                 AlternativeFinder firstFinder( indexer, env );
@@ -1619 +1557 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) {
+        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
                 std::vector< AlternativeFinder > subExprAlternatives;
-                altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
+                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
                         back_inserter( subExprAlternatives ) );
                 std::vector< AltList > possibilities;
@@ -1637 +1575 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) {
+        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+        void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                 alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) {
+        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
                 AlternativeFinder finder( indexer, env );
                 // don't prune here, since it's guaranteed all alternatives will have the same type
@@ -1655 +1593 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) {
+        void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) {
+        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
                 alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) {
+        void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
                 AlternativeFinder finder( indexer, env );
                 finder.findWithAdjustment( unqExpr->get_expr() );
@@ -1673 +1611 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) {
+        void AlternativeFinder::visit( StmtExpr *stmtExpr ) {
                 StmtExpr * newStmtExpr = stmtExpr->clone();
                 ResolvExpr::resolveStmtExpr( newStmtExpr, indexer );
@@ -1680 +1618 @@
         }
 
-        void AlternativeFinder::Finder::postvisit( UntypedInitExpr *initExpr ) {
+        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
                 // handle each option like a cast
                 AltList candidates;
-                PRINT(
-                        std::cerr << "untyped init expr: " << initExpr << std::endl;
-                )
+                PRINT( std::cerr << "untyped init expr: " << initExpr << std::endl; )
                 // O(N^2) checks of d-types with e-types
                 for ( InitAlternative & initAlt : initExpr->get_initAlts() ) {
@@ -1701 +1637 @@
                                 AssertionSet needAssertions, haveAssertions;
                                 OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
-                                PRINT(
-                                        std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
-                                 )
+                                PRINT( std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl; )
                                 // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
                                 // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results

src/ResolvExpr/AlternativeFinder.h

@@ -38 +38 @@
         using ExplodedArgs = std::vector< std::vector< ExplodedActual > >;
 
-        class AlternativeFinder {
+        class AlternativeFinder : public Visitor {
           public:
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
@@ -94 +94 @@
                 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
-                struct Finder;
+                virtual void visit( ApplicationExpr *applicationExpr );
+                virtual void visit( UntypedExpr *untypedExpr );
+                virtual void visit( AddressExpr *addressExpr );
+                virtual void visit( LabelAddressExpr *labelExpr );
+                virtual void visit( CastExpr *castExpr );
+                virtual void visit( VirtualCastExpr *castExpr );
+                virtual void visit( UntypedMemberExpr *memberExpr );
+                virtual void visit( MemberExpr *memberExpr );
+                virtual void visit( NameExpr *variableExpr );
+                virtual void visit( VariableExpr *variableExpr );
+                virtual void visit( ConstantExpr *constantExpr );
+                virtual void visit( SizeofExpr *sizeofExpr );
+                virtual void visit( AlignofExpr *alignofExpr );
+                virtual void visit( UntypedOffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetofExpr *offsetofExpr );
+                virtual void visit( OffsetPackExpr *offsetPackExpr );
+                virtual void visit( AttrExpr *attrExpr );
+                virtual void visit( LogicalExpr *logicalExpr );
+                virtual void visit( ConditionalExpr *conditionalExpr );
+                virtual void visit( CommaExpr *commaExpr );
+                virtual void visit( ImplicitCopyCtorExpr * impCpCtorExpr );
+                virtual void visit( ConstructorExpr * ctorExpr );
+                virtual void visit( RangeExpr * rangeExpr );
+                virtual void visit( UntypedTupleExpr *tupleExpr );
+                virtual void visit( TupleExpr *tupleExpr );
+                virtual void visit( TupleIndexExpr *tupleExpr );
+                virtual void visit( TupleAssignExpr *tupleExpr );
+                virtual void visit( UniqueExpr *unqExpr );
+                virtual void visit( StmtExpr *stmtExpr );
+                virtual void visit( UntypedInitExpr *initExpr );
+
+                /// Adds alternatives for anonymous members
+                void addAnonConversions( const Alternative & alt );
+                /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                /// Adds alternatives for member expressions where the left side has tuple type
+                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                /// Adds alternatives for offsetof expressions, given the base type and name of the member
+                template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
+                /// Takes a final result and checks if its assertions can be satisfied
+                template<typename OutputIterator>
+                void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
+                /// Finds matching alternatives for a function, given a set of arguments
+                template<typename OutputIterator>
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
+                /// Checks if assertion parameters match for a new alternative
+                template< typename OutputIterator >
+                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
+
                 const SymTab::Indexer &indexer;
                 AltList alternatives;

src/ResolvExpr/CommonType.cc

@@ -18 +18 @@
 #include <utility>                       // for pair
 
-#include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for OpenVarSet, AssertionSet
 #include "SymTab/Indexer.h"              // for Indexer
@@ -30 +29 @@
 
 namespace ResolvExpr {
-        struct CommonType : public WithShortCircuiting {
+        class CommonType : public Visitor {
+          public:
                 CommonType( Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars );
                 Type *get_result() const { return result; }
-
-                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-
-                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( TraitInstType * aggregateUseType );
-                void postvisit( TypeInstType * aggregateUseType );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
-
           private:
+                virtual void visit( VoidType *voidType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
+                virtual void visit( FunctionType *functionType );
+                virtual void visit( StructInstType *aggregateUseType );
+                virtual void visit( UnionInstType *aggregateUseType );
+                virtual void visit( EnumInstType *aggregateUseType );
+                virtual void visit( TraitInstType *aggregateUseType );
+                virtual void visit( TypeInstType *aggregateUseType );
+                virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
+
                 template< typename Pointer > void getCommonWithVoidPointer( Pointer* voidPointer, Pointer* otherPointer );
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
@@ -83 +80 @@
 
         Type *commonType( Type *type1, Type *type2, bool widenFirst, bool widenSecond, const SymTab::Indexer &indexer, TypeEnvironment &env, const OpenVarSet &openVars ) {
-                PassVisitor<CommonType> visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
+                CommonType visitor( type2, widenFirst, widenSecond, indexer, env, openVars );
 
                 int depth1 = type1->referenceDepth();
@@ -119 +116 @@
 
                 type1->accept( visitor );
-                Type *result = visitor.pass.get_result();
+                Type *result = visitor.get_result();
                 if ( ! result ) {
                         // this appears to be handling for opaque type declarations
@@ -191 +188 @@
         }
 
-        void CommonType::postvisit( VoidType * ) {}
-
-        void CommonType::postvisit( BasicType *basicType ) {
+        void CommonType::visit( VoidType * ) {}
+
+        void CommonType::visit( BasicType *basicType ) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
                         BasicType::Kind newType = combinedType[ basicType->get_kind() ][ otherBasic->get_kind() ];
@@ -222 +219 @@
         }
 
-        void CommonType::postvisit( PointerType *pointerType ) {
+        void CommonType::visit( PointerType *pointerType ) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
                         // std::cerr << "commonType: two pointers: " << pointerType << " / " << otherPointer << std::endl;
@@ -257 +254 @@
         }
 
-        void CommonType::postvisit( ArrayType * ) {}
-
-        void CommonType::postvisit( ReferenceType *refType ) {
+        void CommonType::visit( ArrayType * ) {}
+
+        void CommonType::visit( ReferenceType *refType ) {
                 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
                         // std::cerr << "commonType: both references: " << refType << " / " << otherRef << std::endl;
@@ -294 +291 @@
         }
 
-        void CommonType::postvisit( FunctionType * ) {}
-        void CommonType::postvisit( StructInstType * ) {}
-        void CommonType::postvisit( UnionInstType * ) {}
-
-        void CommonType::postvisit( EnumInstType *enumInstType ) {
+        void CommonType::visit( FunctionType * ) {}
+        void CommonType::visit( StructInstType * ) {}
+        void CommonType::visit( UnionInstType * ) {}
+
+        void CommonType::visit( EnumInstType *enumInstType ) {
                 if ( dynamic_cast< BasicType * >( type2 ) || dynamic_cast< ZeroType* >( type2 ) || dynamic_cast< OneType* >( type2 ) ) {
                         // reuse BasicType, EnumInstType code by swapping type2 with enumInstType
-                        result = commonType( type2, enumInstType, widenSecond, widenFirst, indexer, env, openVars );
-                } // if
-        }
-
-        void CommonType::postvisit( TraitInstType * ) {
-        }
-
-        void CommonType::postvisit( TypeInstType *inst ) {
+                        ValueGuard< Type * > temp( type2 );
+                        type2 = enumInstType;
+                        temp.old->accept( *this );
+                } // if
+        }
+
+        void CommonType::visit( TraitInstType * ) {
+        }
+
+        void CommonType::visit( TypeInstType *inst ) {
                 if ( widenFirst ) {
                         NamedTypeDecl *nt = indexer.lookupType( inst->get_name() );
@@ -330 +329 @@
         }
 
-        void CommonType::postvisit( TupleType * ) {}
-        void CommonType::postvisit( VarArgsType * ) {}
-
-        void CommonType::postvisit( ZeroType *zeroType ) {
+        void CommonType::visit( TupleType * ) {}
+        void CommonType::visit( VarArgsType * ) {}
+
+        void CommonType::visit( ZeroType *zeroType ) {
                 if ( widenFirst ) {
                         if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< PointerType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {
@@ -347 +346 @@
         }
 
-        void CommonType::postvisit( OneType *oneType ) {
+        void CommonType::visit( OneType *oneType ) {
                 if ( widenFirst ) {
                         if ( dynamic_cast< BasicType* >( type2 ) || dynamic_cast< EnumInstType* >( type2 ) ) {

src/ResolvExpr/CurrentObject.cc

@@ -443 +443 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
+                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
                                 return new SimpleIterator( type );
                         }

src/ResolvExpr/PtrsAssignable.cc

@@ -14 +14 @@
 //
 
-#include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 #include "SynTree/Type.h"                // for TypeInstType, Type, BasicType
@@ -21 +20 @@
 
 namespace ResolvExpr {
-        struct PtrsAssignable : public WithShortCircuiting {
+        class PtrsAssignable : public Visitor {
+          public:
                 PtrsAssignable( Type *dest, const TypeEnvironment &env );
 
                 int get_result() const { return result; }
 
-                void previsit( Type * ) { visit_children = false; }
-
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * inst );
-                void postvisit( UnionInstType * inst );
-                void postvisit( EnumInstType * inst );
-                void postvisit( TraitInstType * inst );
-                void postvisit( TypeInstType * inst );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
+                virtual void visit( VoidType *voidType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( FunctionType *functionType );
+                virtual void visit( StructInstType *inst );
+                virtual void visit( UnionInstType *inst );
+                virtual void visit( EnumInstType *inst );
+                virtual void visit( TraitInstType *inst );
+                virtual void visit( TypeInstType *inst );
+                virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
           private:
                 Type *dest;
@@ -61 +59 @@
                         return -1;
                 } else {
-                        PassVisitor<PtrsAssignable> ptrs( dest, env );
+                        PtrsAssignable ptrs( dest, env );
                         src->accept( ptrs );
-                        return ptrs.pass.get_result();
+                        return ptrs.get_result();
                 } // if
         }
@@ -69 +67 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::postvisit( VoidType * ) {
+        void PtrsAssignable::visit( VoidType * ) {
                 // T * = void * is disallowed - this is a change from C, where any
                 // void * can be assigned or passed to a non-void pointer without a cast.
         }
 
-        void PtrsAssignable::postvisit( __attribute__((unused)) BasicType *basicType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) PointerType *pointerType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) ArrayType *arrayType ) {}
-        void PtrsAssignable::postvisit( __attribute__((unused)) FunctionType *functionType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) BasicType *basicType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) PointerType *pointerType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) ArrayType *arrayType ) {}
+        void PtrsAssignable::visit( __attribute__((unused)) FunctionType *functionType ) {}
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
 
-        void PtrsAssignable::postvisit( EnumInstType * ) {
+        void PtrsAssignable::visit( EnumInstType * ) {
                 if ( dynamic_cast< BasicType* >( dest ) ) {
                         // int * = E *, etc. is safe. This isn't technically correct, as each
@@ -93 +91 @@
         }
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
-        void PtrsAssignable::postvisit( TypeInstType *inst ) {
+        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsAssignable::visit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
@@ -102 +100 @@
         }
 
-        void PtrsAssignable::postvisit(  __attribute__((unused)) TupleType *tupleType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) ZeroType *zeroType ) {}
-        void PtrsAssignable::postvisit(  __attribute__((unused)) OneType *oneType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) TupleType *tupleType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) VarArgsType *varArgsType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) ZeroType *zeroType ) {}
+        void PtrsAssignable::visit(  __attribute__((unused)) OneType *oneType ) {}
 
 } // namespace ResolvExpr

src/ResolvExpr/PtrsCastable.cc

@@ -14 +14 @@
 //
 
-#include "Common/PassVisitor.h"
 #include "ResolvExpr/TypeEnvironment.h"  // for EqvClass, TypeEnvironment
 #include "SymTab/Indexer.h"              // for Indexer
@@ -22 +21 @@
 #include "typeops.h"                     // for ptrsAssignable
 
+
 namespace ResolvExpr {
-        struct PtrsCastable : public WithShortCircuiting  {
+        class PtrsCastable : public Visitor {
           public:
                 PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
@@ -29 +29 @@
                 int get_result() const { return result; }
 
-                void previsit( Type * ) { visit_children = false; }
-
-                void postvisit( VoidType * voidType );
-                void postvisit( BasicType * basicType );
-                void postvisit( PointerType * pointerType );
-                void postvisit( ArrayType * arrayType );
-                void postvisit( FunctionType * functionType );
-                void postvisit( StructInstType * inst );
-                void postvisit( UnionInstType * inst );
-                void postvisit( EnumInstType * inst );
-                void postvisit( TraitInstType * inst );
-                void postvisit( TypeInstType * inst );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
+                virtual void visit(VoidType *voidType);
+                virtual void visit(BasicType *basicType);
+                virtual void visit(PointerType *pointerType);
+                virtual void visit(ArrayType *arrayType);
+                virtual void visit(FunctionType *functionType);
+                virtual void visit(StructInstType *inst);
+                virtual void visit(UnionInstType *inst);
+                virtual void visit(EnumInstType *inst);
+                virtual void visit(TraitInstType *inst);
+                virtual void visit(TypeInstType *inst);
+                virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
           private:
                 Type *dest;
@@ -81 +79 @@
                         EqvClass eqvClass;
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
-                                // xxx - should this be ptrsCastable?
                                 return ptrsAssignable( src, eqvClass.type, env );
                         } // if
@@ -88 +85 @@
                         return objectCast( src, env, indexer );
                 } else {
-                        PassVisitor<PtrsCastable> ptrs( dest, env, indexer );
+                        PtrsCastable ptrs( dest, env, indexer );
                         src->accept( ptrs );
-                        return ptrs.pass.get_result();
+                        return ptrs.get_result();
                 } // if
         }
@@ -98 +95 @@
         }
 
-        void PtrsCastable::postvisit( VoidType * ) {
+        void PtrsCastable::visit( VoidType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( BasicType * ) {
+        void PtrsCastable::visit( BasicType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( PointerType * ) {
+        void PtrsCastable::visit( PointerType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( ArrayType * ) {
+        void PtrsCastable::visit( ArrayType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( FunctionType * ) {
+        void PtrsCastable::visit( FunctionType * ) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( StructInstType * ) {
+        void PtrsCastable::visit( StructInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( UnionInstType * ) {
+        void PtrsCastable::visit( UnionInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( EnumInstType * ) {
+        void PtrsCastable::visit( EnumInstType * ) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -141 +138 @@
         }
 
-        void PtrsCastable::postvisit( TraitInstType * ) {}
+        void PtrsCastable::visit( TraitInstType * ) {}
 
-        void PtrsCastable::postvisit(TypeInstType *inst) {
+        void PtrsCastable::visit(TypeInstType *inst) {
                 //result = objectCast( inst, env, indexer ) > 0 && objectCast( dest, env, indexer ) > 0 ? 1 : -1;
                 result = objectCast( inst, env, indexer ) == objectCast( dest, env, indexer ) ? 1 : -1;
         }
 
-        void PtrsCastable::postvisit( TupleType * ) {
+        void PtrsCastable::visit( TupleType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( VarArgsType * ) {
+        void PtrsCastable::visit( VarArgsType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( ZeroType * ) {
+        void PtrsCastable::visit( ZeroType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::postvisit( OneType * ) {
+        void PtrsCastable::visit( OneType * ) {
                 result = objectCast( dest, env, indexer );
         }

src/ResolvExpr/RenameVars.cc

@@ -19 +19 @@
 #include <utility>                 // for pair
 
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "RenameVars.h"
@@ -28 +27 @@
 
 namespace ResolvExpr {
-        namespace {
-                struct RenameVars {
-                        RenameVars();
-                        void reset();
+        RenameVars global_renamer;
 
-                        void previsit( TypeInstType * instType );
-                        void previsit( Type * );
-                        void postvisit( Type * );
-
-                  private:
-                        int level, resetCount;
-                        std::list< std::map< std::string, std::string > > mapStack;
-                };
-
-                PassVisitor<RenameVars> global_renamer;
-        } // namespace
-
-        void renameTyVars( Type * t ) {
-                t->accept( global_renamer );
+        RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
+                mapStack.push_front( std::map< std::string, std::string >() );
         }
 
-        void resetTyVarRenaming() {
-                global_renamer.pass.reset();
+        void RenameVars::reset() {
+                level = 0;
+                resetCount++;
         }
 
-        namespace {
-                RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
-                        mapStack.push_front( std::map< std::string, std::string >() );
-                }
+        void RenameVars::visit( VoidType *voidType ) {
+                typeBefore( voidType );
+                typeAfter( voidType );
+        }
 
-                void RenameVars::reset() {
-                        level = 0;
-                        resetCount++;
-                }
+        void RenameVars::visit( BasicType *basicType ) {
+                typeBefore( basicType );
+                typeAfter( basicType );
+        }
 
-                void RenameVars::previsit( TypeInstType * instType ) {
-                        previsit( (Type *)instType );
-                        std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->name );
-                        if ( i != mapStack.front().end() ) {
-                                instType->name = i->second;
-                        } // if
-                }
+        void RenameVars::visit( PointerType *pointerType ) {
+                typeBefore( pointerType );
+                maybeAccept( pointerType->get_base(), *this );
+                typeAfter( pointerType );
+        }
 
-                void RenameVars::previsit( Type * type ) {
-                        if ( ! type->forall.empty() ) {
-                                // copies current name mapping into new mapping
-                                mapStack.push_front( mapStack.front() );
-                                // renames all "forall" type names to `_${level}_${name}'
-                                for ( auto td : type->forall ) {
-                                        std::ostringstream output;
-                                        output << "_" << resetCount << "_" << level << "_" << td->name;
-                                        std::string newname( output.str() );
-                                        mapStack.front()[ td->get_name() ] = newname;
-                                        td->name = newname;
-                                        // ditto for assertion names, the next level in
-                                        level++;
-                                        // acceptAll( td->assertions, *this );
-                                } // for
-                        } // if
-                }
+        void RenameVars::visit( ArrayType *arrayType ) {
+                typeBefore( arrayType );
+                maybeAccept( arrayType->get_dimension(), *this );
+                maybeAccept( arrayType->get_base(), *this );
+                typeAfter( arrayType );
+        }
 
-                void RenameVars::postvisit( Type * type ) {
-                        // clears name mapping added by typeBefore()
-                        if ( ! type->forall.empty() ) {
-                                mapStack.pop_front();
-                        } // if
-                }
-        } // namespace
+        void RenameVars::visit( FunctionType *functionType ) {
+                typeBefore( functionType );
+                acceptAll( functionType->get_returnVals(), *this );
+                acceptAll( functionType->get_parameters(), *this );
+                typeAfter( functionType );
+        }
+
+        void RenameVars::visit( StructInstType *aggregateUseType ) {
+                typeBefore( aggregateUseType );
+                acceptAll( aggregateUseType->get_parameters(), *this );
+                typeAfter( aggregateUseType );
+        }
+
+        void RenameVars::visit( UnionInstType *aggregateUseType ) {
+                typeBefore( aggregateUseType );
+                acceptAll( aggregateUseType->get_parameters(), *this );
+                typeAfter( aggregateUseType );
+        }
+
+        void RenameVars::visit( EnumInstType *aggregateUseType ) {
+                typeBefore( aggregateUseType );
+                acceptAll( aggregateUseType->get_parameters(), *this );
+                typeAfter( aggregateUseType );
+        }
+
+        void RenameVars::visit( TraitInstType *aggregateUseType ) {
+                typeBefore( aggregateUseType );
+                acceptAll( aggregateUseType->get_parameters(), *this );
+                typeAfter( aggregateUseType );
+        }
+
+        void RenameVars::visit( TypeInstType *instType ) {
+                typeBefore( instType );
+                std::map< std::string, std::string >::const_iterator i = mapStack.front().find( instType->get_name() );
+                if ( i != mapStack.front().end() ) {
+                        instType->set_name( i->second );
+                } else {
+                } // if
+                acceptAll( instType->get_parameters(), *this );
+                typeAfter( instType );
+        }
+
+        void RenameVars::visit( TupleType *tupleType ) {
+                typeBefore( tupleType );
+                acceptAll( tupleType->get_types(), *this );
+                typeAfter( tupleType );
+        }
+
+        void RenameVars::visit( VarArgsType *varArgsType ) {
+                typeBefore( varArgsType );
+                typeAfter( varArgsType );
+        }
+
+        void RenameVars::visit( ZeroType *zeroType ) {
+                typeBefore( zeroType );
+                typeAfter( zeroType );
+        }
+
+        void RenameVars::visit( OneType *oneType ) {
+                typeBefore( oneType );
+                typeAfter( oneType );
+        }
+
+        void RenameVars::typeBefore( Type *type ) {
+                if ( ! type->get_forall().empty() ) {
+                        // copies current name mapping into new mapping
+                        mapStack.push_front( mapStack.front() );
+                        // renames all "forall" type names to `_${level}_${name}'
+                        for ( Type::ForallList::iterator i = type->get_forall().begin(); i != type->get_forall().end(); ++i ) {
+                                std::ostringstream output;
+                                output << "_" << resetCount << "_" << level << "_" << (*i)->get_name();
+                                std::string newname( output.str() );
+                                mapStack.front()[ (*i)->get_name() ] = newname;
+                                (*i)->set_name( newname );
+                                // ditto for assertion names, the next level in
+                                level++;
+                                acceptAll( (*i)->get_assertions(), *this );
+                        } // for
+                } // if
+        }
+
+        void RenameVars::typeAfter( Type *type ) {
+                // clears name mapping added by typeBefore()
+                if ( ! type->get_forall().empty() ) {
+                        mapStack.pop_front();
+                } // if
+        }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/RenameVars.h

@@ -24 +24 @@
 
 namespace ResolvExpr {
+
         /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
-        void renameTyVars( Type * );
+        class RenameVars : public Visitor {
+          public:
+                RenameVars();
+                void reset();
+          private:
+                virtual void visit( VoidType *basicType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( FunctionType *functionType );
+                virtual void visit( StructInstType *aggregateUseType );
+                virtual void visit( UnionInstType *aggregateUseType );
+                virtual void visit( EnumInstType *aggregateUseType );
+                virtual void visit( TraitInstType *aggregateUseType );
+                virtual void visit( TypeInstType *aggregateUseType );
+                virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
 
-        /// resets internal state of renamer to avoid overflow
-        void resetTyVarRenaming();
+                void typeBefore( Type *type );
+                void typeAfter( Type *type );
+                int level, resetCount;
+                std::list< std::map< std::string, std::string > > mapStack;
+        };
+
+        extern RenameVars global_renamer;
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -132 +132 @@
 
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                resetTyVarRenaming();
+                global_renamer.reset();
                 TypeEnvironment env;
                 Expression *newExpr = resolveInVoidContext( untyped, indexer, env );

src/ResolvExpr/Unify.cc

@@ -44 +44 @@
 namespace ResolvExpr {
 
-        struct Unify : public WithShortCircuiting {
+        class Unify : public Visitor {
+          public:
                 Unify( Type *type2, TypeEnvironment &env, AssertionSet &needAssertions, AssertionSet &haveAssertions, const OpenVarSet &openVars, WidenMode widenMode, const SymTab::Indexer &indexer );
 
                 bool get_result() const { return result; }
-
-                void previsit( BaseSyntaxNode * ) { visit_children = false; }
-
-                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( TraitInstType * aggregateUseType );
-                void postvisit( TypeInstType * aggregateUseType );
-                void postvisit( TupleType * tupleType );
-                void postvisit( VarArgsType * varArgsType );
-                void postvisit( ZeroType * zeroType );
-                void postvisit( OneType * oneType );
-
           private:
+                virtual void visit(VoidType *voidType);
+                virtual void visit(BasicType *basicType);
+                virtual void visit(PointerType *pointerType);
+                virtual void visit(ArrayType *arrayType);
+                virtual void visit(ReferenceType *refType);
+                virtual void visit(FunctionType *functionType);
+                virtual void visit(StructInstType *aggregateUseType);
+                virtual void visit(UnionInstType *aggregateUseType);
+                virtual void visit(EnumInstType *aggregateUseType);
+                virtual void visit(TraitInstType *aggregateUseType);
+                virtual void visit(TypeInstType *aggregateUseType);
+                virtual void visit(TupleType *tupleType);
+                virtual void visit(VarArgsType *varArgsType);
+                virtual void visit(ZeroType *zeroType);
+                virtual void visit(OneType *oneType);
+
                 template< typename RefType > void handleRefType( RefType *inst, Type *other );
                 template< typename RefType > void handleGenericRefType( RefType *inst, Type *other );
@@ -327 +325 @@
                         result = bindVar( var2, type1, entry2->second, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
                 } else {
-                        PassVisitor<Unify> comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
+                        Unify comparator( type2, env, needAssertions, haveAssertions, openVars, widenMode, indexer );
                         type1->accept( comparator );
-                        result = comparator.pass.get_result();
+                        result = comparator.get_result();
                 } // if
 #ifdef DEBUG
@@ -406 +404 @@
         }
 
-        void Unify::postvisit( __attribute__((unused)) VoidType *voidType) {
+        void Unify::visit( __attribute__((unused)) VoidType *voidType) {
                 result = dynamic_cast< VoidType* >( type2 );
         }
 
-        void Unify::postvisit(BasicType *basicType) {
+        void Unify::visit(BasicType *basicType) {
                 if ( BasicType *otherBasic = dynamic_cast< BasicType* >( type2 ) ) {
                         result = basicType->get_kind() == otherBasic->get_kind();
@@ -438 +436 @@
         }
 
-        void Unify::postvisit(PointerType *pointerType) {
+        void Unify::visit(PointerType *pointerType) {
                 if ( PointerType *otherPointer = dynamic_cast< PointerType* >( type2 ) ) {
                         result = unifyExact( pointerType->get_base(), otherPointer->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
@@ -446 +444 @@
         }
 
-        void Unify::postvisit(ReferenceType *refType) {
+        void Unify::visit(ReferenceType *refType) {
                 if ( ReferenceType *otherRef = dynamic_cast< ReferenceType* >( type2 ) ) {
                         result = unifyExact( refType->get_base(), otherRef->get_base(), env, needAssertions, haveAssertions, openVars, WidenMode( false, false ), indexer );
@@ -454 +452 @@
         }
 
-        void Unify::postvisit(ArrayType *arrayType) {
+        void Unify::visit(ArrayType *arrayType) {
                 ArrayType *otherArray = dynamic_cast< ArrayType* >( type2 );
                 // to unify, array types must both be VLA or both not VLA
@@ -569 +567 @@
         }
 
-        void Unify::postvisit(FunctionType *functionType) {
+        void Unify::visit(FunctionType *functionType) {
                 FunctionType *otherFunction = dynamic_cast< FunctionType* >( type2 );
                 if ( otherFunction && functionType->get_isVarArgs() == otherFunction->get_isVarArgs() ) {
@@ -671 +669 @@
         }
 
-        void Unify::postvisit(StructInstType *structInst) {
+        void Unify::visit(StructInstType *structInst) {
                 handleGenericRefType( structInst, type2 );
         }
 
-        void Unify::postvisit(UnionInstType *unionInst) {
+        void Unify::visit(UnionInstType *unionInst) {
                 handleGenericRefType( unionInst, type2 );
         }
 
-        void Unify::postvisit(EnumInstType *enumInst) {
+        void Unify::visit(EnumInstType *enumInst) {
                 handleRefType( enumInst, type2 );
         }
 
-        void Unify::postvisit(TraitInstType *contextInst) {
+        void Unify::visit(TraitInstType *contextInst) {
                 handleRefType( contextInst, type2 );
         }
 
-        void Unify::postvisit(TypeInstType *typeInst) {
+        void Unify::visit(TypeInstType *typeInst) {
                 assert( openVars.find( typeInst->get_name() ) == openVars.end() );
                 TypeInstType *otherInst = dynamic_cast< TypeInstType* >( type2 );
@@ -742 +740 @@
         }
 
-        void Unify::postvisit(TupleType *tupleType) {
+        void Unify::visit(TupleType *tupleType) {
                 if ( TupleType *otherTuple = dynamic_cast< TupleType* >( type2 ) ) {
                         std::unique_ptr<TupleType> flat1( tupleType->clone() );
@@ -759 +757 @@
         }
 
-        void Unify::postvisit( __attribute__((unused)) VarArgsType *varArgsType ) {
+        void Unify::visit( __attribute__((unused)) VarArgsType *varArgsType ) {
                 result = dynamic_cast< VarArgsType* >( type2 );
         }
 
-        void Unify::postvisit( __attribute__((unused)) ZeroType *zeroType ) {
+        void Unify::visit( __attribute__((unused)) ZeroType *zeroType ) {
                 result = dynamic_cast< ZeroType* >( type2 );
         }
 
-        void Unify::postvisit( __attribute__((unused)) OneType *oneType ) {
+        void Unify::visit( __attribute__((unused)) OneType *oneType ) {
                 result = dynamic_cast< OneType* >( type2 );
         }

src/SymTab/Mangler.cc

@@ -23 +23 @@
 
 #include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
-#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"   // for SemanticError
 #include "Common/utility.h"         // for toString
@@ -32 +31 @@
 
 namespace SymTab {
-        namespace Mangler {
-                namespace {
-                        /// Mangles names to a unique C identifier
-                        struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler> {
-                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
-                                Mangler( const Mangler & );
-
-                                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( TupleType * tupleType );
-                                void postvisit( VarArgsType * varArgsType );
-                                void postvisit( ZeroType * zeroType );
-                                void postvisit( OneType * oneType );
-
-                                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
-
-                                void mangleDecl( DeclarationWithType *declaration );
-                                void mangleRef( ReferenceToType *refType, std::string prefix );
-
-                                void printQualifiers( Type *type );
-                        }; // Mangler
-                } // namespace
-
-                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
-                        PassVisitor<Mangler> mangler( mangleOverridable, typeMode, mangleGenericParams );
-                        maybeAccept( decl, mangler );
-                        return mangler.pass.get_mangleName();
+        std::string Mangler::mangleType( Type * ty ) {
+                Mangler mangler( false, true, true );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+
+        std::string Mangler::mangleConcrete( Type* ty ) {
+                Mangler mangler( false, false, false );
+                maybeAccept( ty, mangler );
+                return mangler.get_mangleName();
+        }
+
+        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
+                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
+
+        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
+                varNums = rhs.varNums;
+                nextVarNum = rhs.nextVarNum;
+                isTopLevel = rhs.isTopLevel;
+                mangleOverridable = rhs.mangleOverridable;
+                typeMode = rhs.typeMode;
+        }
+
+        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
+                bool wasTopLevel = isTopLevel;
+                if ( isTopLevel ) {
+                        varNums.clear();
+                        nextVarNum = 0;
+                        isTopLevel = false;
+                } // if
+                mangleName << "__";
+                CodeGen::OperatorInfo opInfo;
+                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
+                        mangleName << opInfo.outputName;
+                } else {
+                        mangleName << declaration->get_name();
+                } // if
+                mangleName << "__";
+                maybeAccept( declaration->get_type(), *this );
+                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
+                        // want to be able to override autogenerated and intrinsic routines,
+                        // so they need a different name mangling
+                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
+                                mangleName << "autogen__";
+                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
+                                mangleName << "intrinsic__";
+                        } else {
+                                // if we add another kind of overridable function, this has to change
+                                assert( false && "unknown overrideable linkage" );
+                        } // if
                 }
-
-                std::string mangleType( Type * ty ) {
-                        PassVisitor<Mangler> mangler( false, true, true );
-                        maybeAccept( ty, mangler );
-                        return mangler.pass.get_mangleName();
+                isTopLevel = wasTopLevel;
+        }
+
+        void Mangler::visit( ObjectDecl * declaration ) {
+                mangleDecl( declaration );
+        }
+
+        void Mangler::visit( FunctionDecl * declaration ) {
+                mangleDecl( declaration );
+        }
+
+        void Mangler::visit( VoidType * voidType ) {
+                printQualifiers( voidType );
+                mangleName << "v";
+        }
+
+        void Mangler::visit( 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
+                };
+
+                printQualifiers( basicType );
+                mangleName << btLetter[ basicType->get_kind() ];
+        }
+
+        void Mangler::visit( PointerType * pointerType ) {
+                printQualifiers( pointerType );
+                mangleName << "P";
+                maybeAccept( pointerType->get_base(), *this );
+        }
+
+        void Mangler::visit( ArrayType * arrayType ) {
+                // TODO: encode dimension
+                printQualifiers( arrayType );
+                mangleName << "A0";
+                maybeAccept( arrayType->get_base(), *this );
+        }
+
+        void Mangler::visit( ReferenceType * refType ) {
+                printQualifiers( refType );
+                mangleName << "R";
+                maybeAccept( refType->get_base(), *this );
+        }
+
+        namespace {
+                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
+                        std::list< Type* > ret;
+                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
+                                                        std::mem_fun( &DeclarationWithType::get_type ) );
+                        return ret;
                 }
-
-                std::string mangleConcrete( Type * ty ) {
-                        PassVisitor<Mangler> mangler( false, false, false );
-                        maybeAccept( ty, mangler );
-                        return mangler.pass.get_mangleName();
-                }
-
-                namespace {
-                        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
-
-                        Mangler::Mangler( const Mangler &rhs ) : mangleName() {
-                                varNums = rhs.varNums;
-                                nextVarNum = rhs.nextVarNum;
-                                isTopLevel = rhs.isTopLevel;
-                                mangleOverridable = rhs.mangleOverridable;
-                                typeMode = rhs.typeMode;
-                        }
-
-                        void Mangler::mangleDecl( DeclarationWithType * declaration ) {
-                                bool wasTopLevel = isTopLevel;
-                                if ( isTopLevel ) {
-                                        varNums.clear();
-                                        nextVarNum = 0;
-                                        isTopLevel = false;
-                                } // if
-                                mangleName << "__";
-                                CodeGen::OperatorInfo opInfo;
-                                if ( operatorLookup( declaration->get_name(), opInfo ) ) {
-                                        mangleName << opInfo.outputName;
-                                } else {
-                                        mangleName << declaration->get_name();
-                                } // if
-                                mangleName << "__";
-                                maybeAccept( declaration->get_type(), *visitor );
-                                if ( mangleOverridable && LinkageSpec::isOverridable( declaration->get_linkage() ) ) {
-                                        // want to be able to override autogenerated and intrinsic routines,
-                                        // so they need a different name mangling
-                                        if ( declaration->get_linkage() == LinkageSpec::AutoGen ) {
-                                                mangleName << "autogen__";
-                                        } else if ( declaration->get_linkage() == LinkageSpec::Intrinsic ) {
-                                                mangleName << "intrinsic__";
-                                        } else {
-                                                // if we add another kind of overridable function, this has to change
-                                                assert( false && "unknown overrideable linkage" );
-                                        } // if
+        }
+
+        void Mangler::visit( FunctionType * functionType ) {
+                printQualifiers( functionType );
+                mangleName << "F";
+                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
+                acceptAll( returnTypes, *this );
+                mangleName << "_";
+                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
+                acceptAll( paramTypes, *this );
+                mangleName << "_";
+        }
+
+        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
+                printQualifiers( refType );
+
+                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
+
+                if ( mangleGenericParams ) {
+                        std::list< Expression* >& params = refType->get_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", toString(*param).c_str());
+                                        maybeAccept( paramType->get_type(), *this );
                                 }
-                                isTopLevel = wasTopLevel;
-                        }
-
-                        void Mangler::postvisit( ObjectDecl * declaration ) {
-                                mangleDecl( declaration );
-                        }
-
-                        void Mangler::postvisit( FunctionDecl * declaration ) {
-                                mangleDecl( declaration );
-                        }
-
-                        void Mangler::postvisit( 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
-                                };
-
-                                printQualifiers( basicType );
-                                mangleName << btLetter[ basicType->get_kind() ];
-                        }
-
-                        void Mangler::postvisit( PointerType * pointerType ) {
-                                printQualifiers( pointerType );
-                                mangleName << "P";
-                                maybeAccept( pointerType->get_base(), *visitor );
-                        }
-
-                        void Mangler::postvisit( ArrayType * arrayType ) {
-                                // TODO: encode dimension
-                                printQualifiers( arrayType );
-                                mangleName << "A0";
-                                maybeAccept( arrayType->get_base(), *visitor );
-                        }
-
-                        void Mangler::postvisit( ReferenceType * refType ) {
-                                printQualifiers( refType );
-                                mangleName << "R";
-                                maybeAccept( refType->get_base(), *visitor );
-                        }
-
-                        namespace {
-                                inline std::list< Type* > getTypes( const std::list< DeclarationWithType* > decls ) {
-                                        std::list< Type* > ret;
-                                        std::transform( decls.begin(), decls.end(), std::back_inserter( ret ),
-                                                                        std::mem_fun( &DeclarationWithType::get_type ) );
-                                        return ret;
-                                }
-                        }
-
-                        void Mangler::postvisit( FunctionType * functionType ) {
-                                printQualifiers( functionType );
-                                mangleName << "F";
-                                std::list< Type* > returnTypes = getTypes( functionType->get_returnVals() );
-                                acceptAll( returnTypes, *visitor );
-                                mangleName << "_";
-                                std::list< Type* > paramTypes = getTypes( functionType->get_parameters() );
-                                acceptAll( paramTypes, *visitor );
                                 mangleName << "_";
                         }
-
-                        void Mangler::mangleRef( ReferenceToType * refType, std::string prefix ) {
-                                printQualifiers( refType );
-
-                                mangleName << ( refType->get_name().length() + prefix.length() ) << prefix << refType->get_name();
-
-                                if ( mangleGenericParams ) {
-                                        std::list< Expression* >& params = refType->get_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", toString(*param).c_str());
-                                                        maybeAccept( paramType->get_type(), *visitor );
-                                                }
-                                                mangleName << "_";
-                                        }
-                                }
-                        }
-
-                        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 ) {
-                                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
-                                if ( varNum == varNums.end() ) {
-                                        mangleRef( typeInst, "t" );
-                                } 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( TupleType * tupleType ) {
-                                printQualifiers( tupleType );
-                                mangleName << "T";
-                                acceptAll( tupleType->types, *visitor );
-                                mangleName << "_";
-                        }
-
-                        void Mangler::postvisit( 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;
-                        }
-
-                        __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;
+                }
+        }
+
+        void Mangler::visit( StructInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "s" );
+        }
+
+        void Mangler::visit( UnionInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "u" );
+        }
+
+        void Mangler::visit( EnumInstType * aggregateUseType ) {
+                mangleRef( aggregateUseType, "e" );
+        }
+
+        void Mangler::visit( TypeInstType * typeInst ) {
+                VarMapType::iterator varNum = varNums.find( typeInst->get_name() );
+                if ( varNum == varNums.end() ) {
+                        mangleRef( typeInst, "t" );
+                } 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::visit( TupleType * tupleType ) {
+                printQualifiers( tupleType );
+                mangleName << "T";
+                acceptAll( tupleType->types, *this );
+                mangleName << "_";
+        }
+
+        void Mangler::visit( VarArgsType * varArgsType ) {
+                printQualifiers( varArgsType );
+                mangleName << "VARGS";
+        }
+
+        void Mangler::visit( ZeroType * ) {
+                mangleName << "Z";
+        }
+
+        void Mangler::visit( OneType * ) {
+                mangleName << "O";
+        }
+
+        void Mangler::visit( TypeDecl * decl ) {
+                static const char *typePrefix[] = { "BT", "BD", "BF" };
+                mangleName << typePrefix[ decl->get_kind() ] << ( decl->name.length() + 1 ) << decl->name;
+        }
+
+        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::printQualifiers( Type * type ) {
+                // skip if not including qualifiers
+                if ( typeMode ) return;
+
+                if ( ! type->get_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() ) {
+                                  case TypeDecl::Dtype:
+                                        dcount++;
+                                        break;
+                                  case TypeDecl::Ftype:
+                                        fcount++;
+                                        break;
+                                  case TypeDecl::Ttype:
+                                        vcount++;
+                                        break;
+                                  default:
+                                        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 ) {
+                                        Mangler sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
+                                        sub_mangler.nextVarNum = nextVarNum;
+                                        sub_mangler.isTopLevel = false;
+                                        sub_mangler.varNums = varNums;
+                                        (*assert)->accept( sub_mangler );
+                                        assertionNames.push_back( sub_mangler.mangleName.str() );
                                 } // for
-                        }
-
-                        void Mangler::printQualifiers( Type * type ) {
-                                // skip if not including qualifiers
-                                if ( typeMode ) return;
-
-                                if ( ! type->get_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() ) {
-                                                  case TypeDecl::Dtype:
-                                                        dcount++;
-                                                        break;
-                                                  case TypeDecl::Ftype:
-                                                        fcount++;
-                                                        break;
-                                                  case TypeDecl::Ttype:
-                                                        vcount++;
-                                                        break;
-                                                  default:
-                                                        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() );
-                                                } // for
-                                        } // for
-                                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
-                                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
-                                        mangleName << "_";
-                                } // if
-                                if ( type->get_const() ) {
-                                        mangleName << "C";
-                                } // if
-                                if ( type->get_volatile() ) {
-                                        mangleName << "V";
-                                } // if
-                                if ( type->get_mutex() ) {
-                                        mangleName << "M";
-                                } // if
-                                // Removed due to restrict not affecting function compatibility in GCC
-                //              if ( type->get_isRestrict() ) {
-                //                      mangleName << "E";
-                //              } // if
-                                if ( type->get_lvalue() ) {
-                                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
-                                        mangleName << "L";
-                                }
-                                if ( type->get_atomic() ) {
-                                        mangleName << "A";
-                                } // if
-                        }
-                }       // namespace
-        } // namespace Mangler
+                        } // for
+                        mangleName << tcount << "_" << dcount << "_" << fcount << "_" << vcount << "_";
+                        std::copy( assertionNames.begin(), assertionNames.end(), std::ostream_iterator< std::string >( mangleName, "" ) );
+                        mangleName << "_";
+                } // if
+                if ( type->get_const() ) {
+                        mangleName << "C";
+                } // if
+                if ( type->get_volatile() ) {
+                        mangleName << "V";
+                } // if
+                if ( type->get_mutex() ) {
+                        mangleName << "M";
+                } // if
+                // Removed due to restrict not affecting function compatibility in GCC
+//              if ( type->get_isRestrict() ) {
+//                      mangleName << "E";
+//              } // if
+                if ( type->get_lvalue() ) {
+                        // mangle based on whether the type is lvalue, so that the resolver can differentiate lvalues and rvalues
+                        mangleName << "L";
+                }
+                if ( type->get_atomic() ) {
+                        mangleName << "A";
+                } // if
+        }
 } // namespace SymTab
 

src/SymTab/Mangler.h

@@ -25 +25 @@
 
 namespace SymTab {
-        namespace Mangler {
+        /// Mangles names to a unique C identifier
+        class Mangler : public Visitor {
+          public:
                 /// Mangle syntax tree object; primary interface to clients
-                std::string mangle( BaseSyntaxNode * decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+                template< typename SynTreeClass >
+            static std::string mangle( SynTreeClass *decl, bool mangleOverridable = true, bool typeMode = false, bool mangleGenericParams = true );
+                /// Mangle a type name; secondary interface
+                static std::string mangleType( Type* ty );
+                /// Mangle ignoring generic type parameters
+                static std::string mangleConcrete( Type* ty );
 
-                /// Mangle a type name; secondary interface
-                std::string mangleType( Type* ty );
-                /// Mangle ignoring generic type parameters
-                std::string mangleConcrete( Type* ty );
-        } // Mangler
+
+                virtual void visit( ObjectDecl *declaration );
+                virtual void visit( FunctionDecl *declaration );
+                virtual void visit( TypeDecl *declaration );
+
+                virtual void visit( VoidType *voidType );
+                virtual void visit( BasicType *basicType );
+                virtual void visit( PointerType *pointerType );
+                virtual void visit( ArrayType *arrayType );
+                virtual void visit( ReferenceType *refType );
+                virtual void visit( FunctionType *functionType );
+                virtual void visit( StructInstType *aggregateUseType );
+                virtual void visit( UnionInstType *aggregateUseType );
+                virtual void visit( EnumInstType *aggregateUseType );
+                virtual void visit( TypeInstType *aggregateUseType );
+                virtual void visit( TupleType *tupleType );
+                virtual void visit( VarArgsType *varArgsType );
+                virtual void visit( ZeroType *zeroType );
+                virtual void visit( OneType *oneType );
+
+                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
+
+                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                Mangler( const Mangler & );
+
+                void mangleDecl( DeclarationWithType *declaration );
+                void mangleRef( ReferenceToType *refType, std::string prefix );
+
+                void printQualifiers( Type *type );
+        }; // Mangler
+
+        template< typename SynTreeClass >
+        std::string Mangler::mangle( SynTreeClass *decl, bool mangleOverridable, bool typeMode, bool mangleGenericParams ) {
+                Mangler mangler( mangleOverridable, typeMode, mangleGenericParams );
+                maybeAccept( decl, mangler );
+                return mangler.get_mangleName();
+        }
 } // SymTab
 

src/SynTree/CompoundStmt.cc

@@ -64 +64 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                VarExprReplacer replacer( declMap );
+                accept( replacer );
         }
 }

src/SynTree/FunctionDecl.cc

@@ -49 +49 @@
         }
         if ( ! declMap.empty() ) {
-                VarExprReplacer::replace( this, declMap );
+                VarExprReplacer replacer( declMap );
+                accept( replacer );
         }
 }

src/SynTree/VarExprReplacer.cc

@@ -16 +16 @@
 #include <iostream>       // for operator<<, basic_ostream, ostream, basic_o...
 
-#include "Common/PassVisitor.h"
 #include "Declaration.h"  // for operator<<, DeclarationWithType
 #include "Expression.h"   // for VariableExpr
 #include "VarExprReplacer.h"
 
-namespace VarExprReplacer {
-        namespace {
-                /// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping
-                struct VarExprReplacer {
-                private:
-                        const DeclMap & declMap;
-                        bool debug;
-                public:
-                        VarExprReplacer( const DeclMap & declMap, bool debug = false );
+VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
 
-                        // replace variable with new node from decl map
-                        void previsit( VariableExpr * varExpr );
-                };
+// replace variable with new node from decl map
+void VarExprReplacer::visit( VariableExpr * varExpr ) {
+        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
+        if ( declMap.count( varExpr->get_var() ) ) {
+                if ( debug ) {
+                        std::cerr << "replacing variable reference: " << (void*)varExpr->get_var() << " " << varExpr->get_var() << " with " << (void*)declMap.at( varExpr->get_var() ) << " " << declMap.at( varExpr->get_var() ) << std::endl;
+                }
+                varExpr->set_var( declMap.at( varExpr->get_var() ) );
         }
-
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug ) {
-                PassVisitor<VarExprReplacer> replacer( declMap, debug );
-                maybeAccept( node, replacer );
-        }
-
-        namespace {
-                VarExprReplacer::VarExprReplacer( const DeclMap & declMap, bool debug ) : declMap( declMap ), debug( debug ) {}
-
-                // replace variable with new node from decl map
-                void VarExprReplacer::previsit( VariableExpr * varExpr ) {
-                        // xxx - assertions and parameters aren't accounted for in this... (i.e. they aren't inserted into the map when it's made, only DeclStmts are)
-                        if ( declMap.count( varExpr->var ) ) {
-                                if ( debug ) {
-                                        std::cerr << "replacing variable reference: " << (void*)varExpr->var << " " << varExpr->var << " with " << (void*)declMap.at( varExpr->var ) << " " << declMap.at( varExpr->var ) << std::endl;
-                                }
-                                varExpr->var = declMap.at( varExpr->var );
-                        }
-                }
-        }
-} // namespace VarExprReplacer
-
-
-
-
-
-
-
+}

src/SynTree/VarExprReplacer.h

@@ -23 +23 @@
 class VariableExpr;
 
-namespace VarExprReplacer {
+/// Visitor that replaces the declarations that VariableExprs refer to, according to the supplied mapping
+class VarExprReplacer : public Visitor {
+public:
         typedef std::map< DeclarationWithType *, DeclarationWithType * > DeclMap;
+private:
+        const DeclMap & declMap;
+        bool debug;
+public:
+        VarExprReplacer( const DeclMap & declMap, bool debug = false );
 
-        void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false );
-}
+        // replace variable with new node from decl map
+        virtual void visit( VariableExpr * varExpr );
+
+        static void replace( BaseSyntaxNode * node, const DeclMap & declMap, bool debug = false ) {
+                VarExprReplacer replacer( declMap, debug );
+                maybeAccept( node, replacer );
+        }
+};
 
 // Local Variables: //