Changeset 7416d46a for src/ResolvExpr

Timestamp:

Jan 30, 2018, 3:54:32 PM (8 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

ADT, aaron-thesis, arm-eh, ast-experimental, cleanup-dtors, deferred_resn, demangler, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, pthread-emulation, qualifiedEnum, resolv-new, stuck-waitfor-destruct, with_gc

Children:

633a642

Parents:

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

Message:

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

Location:

src/ResolvExpr

Files:

• AlternativeFinder.cc (modified) (40 diffs)
• AlternativeFinder.h (modified) (2 diffs)
• CastCost.cc (modified) (4 diffs)
• CommonType.cc (modified) (10 diffs)
• ConversionCost.cc (modified) (22 diffs)
• ConversionCost.h (modified) (3 diffs)
• CurrentObject.cc (modified) (4 diffs)
• PtrsAssignable.cc (modified) (6 diffs)
• PtrsCastable.cc (modified) (7 diffs)
• RenameVars.cc (modified) (2 diffs)
• RenameVars.h (modified) (1 diff)
• Resolver.cc (modified) (6 diffs)
• TypeMap.h (deleted)
• Unify.cc (modified) (10 diffs)

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 );
@@ -152 +213 @@
 
                 void renameTypes( Expression *expr ) {
-                        expr->get_result()->accept( global_renamer );
+                        renameTyVars( expr->result );
                 }
         } // namespace
@@ -185 +246 @@
 
         void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
-                expr->accept( *this );
+                PassVisitor<Finder> finder( *this );
+                expr->accept( finder );
                 if ( failFast && alternatives.empty() ) {
                         PRINT(
@@ -244 +306 @@
         }
 
-        void AlternativeFinder::addAnonConversions( const Alternative & alt ) {
+        void AlternativeFinder::Finder::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
@@ -265 +327 @@
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+        void AlternativeFinder::Finder::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 );
@@ -284 +346 @@
         }
 
-        void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+        void AlternativeFinder::Finder::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
@@ -308 +370 @@
         }
 
-        void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
+        void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) {
                 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
         }
@@ -485 +547 @@
                         Type *adjType = candidate->get_type()->clone();
                         adjustExprType( adjType, newEnv, indexer );
-                        adjType->accept( global_renamer );
+                        renameTyVars( adjType );
                         PRINT(
                                 std::cerr << "unifying ";
@@ -541 +603 @@
 
         template< typename OutputIterator >
-        void AlternativeFinder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
+        void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
 //      PRINT(
 //          std::cerr << "inferParameters: assertions needed are" << std::endl;
@@ -595 +657 @@
 
                 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) {}
 
@@ -706 +768 @@
 
                                                 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;
@@ -892 +954 @@
 
         template<typename OutputIterator>
-        void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
+        void AlternativeFinder::Finder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
                         const std::vector<ArgPack>& results, OutputIterator out ) {
                 ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
@@ -915 +977 @@
 
         template<typename OutputIterator>
-        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
+        void AlternativeFinder::Finder::makeFunctionAlternatives( const Alternative &func,
                         FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) {
                 OpenVarSet funcOpenVars;
@@ -1022 +1084 @@
         }
 
-        void AlternativeFinder::visit( UntypedExpr *untypedExpr ) {
+        void AlternativeFinder::Finder::postvisit( UntypedExpr *untypedExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( untypedExpr->get_function() );
@@ -1029 +1091 @@
 
                 std::vector< AlternativeFinder > argAlternatives;
-                findSubExprs( untypedExpr->begin_args(), untypedExpr->end_args(),
+                altFinder.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( *this, untypedExpr, argAlternatives );
+                Tuples::handleTupleAssignment( altFinder, untypedExpr, argAlternatives );
 
                 // find function operators
@@ -1172 +1234 @@
                         // fix this issue in a more robust way.
                         targetType = nullptr;
-                        visit( untypedExpr );
+                        postvisit( untypedExpr );
                 }
         }
@@ -1181 +1243 @@
         }
 
-        void AlternativeFinder::visit( AddressExpr *addressExpr ) {
+        void AlternativeFinder::Finder::postvisit( AddressExpr *addressExpr ) {
                 AlternativeFinder finder( indexer, env );
                 finder.find( addressExpr->get_arg() );
@@ -1192 +1254 @@
         }
 
-        void AlternativeFinder::visit( LabelAddressExpr * expr ) {
+        void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
                 alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
         }
@@ -1223 +1285 @@
         }
 
-        void AlternativeFinder::visit( CastExpr *castExpr ) {
+        void AlternativeFinder::Finder::postvisit( CastExpr *castExpr ) {
                 Type *& toType = castExpr->get_result();
                 assert( toType );
@@ -1278 +1340 @@
         }
 
-        void AlternativeFinder::visit( VirtualCastExpr * castExpr ) {
+        void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) {
                 assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
                 AlternativeFinder finder( indexer, env );
@@ -1290 +1352 @@
         }
 
-        void AlternativeFinder::visit( UntypedMemberExpr *memberExpr ) {
+        void AlternativeFinder::Finder::postvisit( UntypedMemberExpr *memberExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 funcFinder.findWithAdjustment( memberExpr->get_aggregate() );
@@ -1312 +1374 @@
         }
 
-        void AlternativeFinder::visit( MemberExpr *memberExpr ) {
+        void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
                 alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( NameExpr *nameExpr ) {
+        void AlternativeFinder::Finder::postvisit( NameExpr *nameExpr ) {
                 std::list< SymTab::Indexer::IdData > declList;
                 indexer.lookupId( nameExpr->get_name(), declList );
@@ -1337 +1399 @@
         }
 
-        void AlternativeFinder::visit( VariableExpr *variableExpr ) {
+        void AlternativeFinder::Finder::postvisit( VariableExpr *variableExpr ) {
                 // not sufficient to clone here, because variable's type may have changed
                 // since the VariableExpr was originally created.
@@ -1343 +1405 @@
         }
 
-        void AlternativeFinder::visit( ConstantExpr *constantExpr ) {
+        void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) {
                 alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( SizeofExpr *sizeofExpr ) {
+        void AlternativeFinder::Finder::postvisit( SizeofExpr *sizeofExpr ) {
                 if ( sizeofExpr->get_isType() ) {
                         Type * newType = sizeofExpr->get_type()->clone();
@@ -1368 +1430 @@
         }
 
-        void AlternativeFinder::visit( AlignofExpr *alignofExpr ) {
+        void AlternativeFinder::Finder::postvisit( AlignofExpr *alignofExpr ) {
                 if ( alignofExpr->get_isType() ) {
                         Type * newType = alignofExpr->get_type()->clone();
@@ -1390 +1452 @@
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
+        void AlternativeFinder::Finder::addOffsetof( StructOrUnionType *aggInst, const std::string &name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -1403 +1465 @@
         }
 
-        void AlternativeFinder::visit( UntypedOffsetofExpr *offsetofExpr ) {
+        void AlternativeFinder::Finder::postvisit( UntypedOffsetofExpr *offsetofExpr ) {
                 AlternativeFinder funcFinder( indexer, env );
                 // xxx - resolveTypeof?
@@ -1413 +1475 @@
         }
 
-        void AlternativeFinder::visit( OffsetofExpr *offsetofExpr ) {
+        void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) {
                 alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( OffsetPackExpr *offsetPackExpr ) {
+        void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) {
                 alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
         }
@@ -1444 +1506 @@
         }
 
-        void AlternativeFinder::visit( AttrExpr *attrExpr ) {
+        void AlternativeFinder::Finder::postvisit( AttrExpr *attrExpr ) {
                 // assume no 'pointer-to-attribute'
                 NameExpr *nameExpr = dynamic_cast< NameExpr* >( attrExpr->get_attr() );
@@ -1458 +1520 @@
                                         if ( function->get_parameters().size() == 1 ) {
                                                 if ( attrExpr->get_isType() ) {
-                                                        resolveAttr( data, function, attrExpr->get_type(), env, *this );
+                                                        resolveAttr( data, function, attrExpr->get_type(), env, altFinder);
                                                 } else {
                                                         AlternativeFinder finder( indexer, env );
@@ -1464 +1526 @@
                                                         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, *this );
+                                                                        resolveAttr(data, function, choice->expr->get_result(), choice->env, altFinder );
                                                                 } // fi
                                                         } // for
@@ -1479 +1541 @@
         }
 
-        void AlternativeFinder::visit( LogicalExpr *logicalExpr ) {
+        void AlternativeFinder::Finder::postvisit( LogicalExpr *logicalExpr ) {
                 AlternativeFinder firstFinder( indexer, env );
                 firstFinder.findWithAdjustment( logicalExpr->get_arg1() );
+                if ( firstFinder.alternatives.empty() ) return;
+                AlternativeFinder secondFinder( indexer, env );
+                secondFinder.findWithAdjustment( logicalExpr->get_arg2() );
+                if ( secondFinder.alternatives.empty() ) return;
                 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        AlternativeFinder secondFinder( indexer, first->env );
-                        secondFinder.findWithAdjustment( logicalExpr->get_arg2() );
                         for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                                TypeEnvironment compositeEnv;
+                                compositeEnv.simpleCombine( first->env );
+                                compositeEnv.simpleCombine( second->env );
+
                                 LogicalExpr *newExpr = new LogicalExpr( first->expr->clone(), second->expr->clone(), logicalExpr->get_isAnd() );
-                                alternatives.push_back( Alternative( newExpr, second->env, first->cost + second->cost ) );
-                        }
-                }
-        }
-
-        void AlternativeFinder::visit( ConditionalExpr *conditionalExpr ) {
+                                alternatives.push_back( Alternative( newExpr, compositeEnv, first->cost + second->cost ) );
+                        }
+                }
+        }
+
+        void AlternativeFinder::Finder::postvisit( ConditionalExpr *conditionalExpr ) {
                 // find alternatives for condition
                 AlternativeFinder firstFinder( indexer, env );
                 firstFinder.findWithAdjustment( conditionalExpr->get_arg1() );
+                if ( firstFinder.alternatives.empty() ) return;
+                // find alternatives for true expression
+                AlternativeFinder secondFinder( indexer, env );
+                secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );
+                if ( secondFinder.alternatives.empty() ) return;
+                // find alterantives for false expression
+                AlternativeFinder thirdFinder( indexer, env );
+                thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );
+                if ( thirdFinder.alternatives.empty() ) return;
                 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        // find alternatives for true expression
-                        AlternativeFinder secondFinder( indexer, first->env );
-                        secondFinder.findWithAdjustment( conditionalExpr->get_arg2() );
                         for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
-                                // find alterantives for false expression
-                                AlternativeFinder thirdFinder( indexer, second->env );
-                                thirdFinder.findWithAdjustment( conditionalExpr->get_arg3() );
                                 for ( AltList::const_iterator third = thirdFinder.alternatives.begin(); third != thirdFinder.alternatives.end(); ++third ) {
+                                        TypeEnvironment compositeEnv;
+                                        compositeEnv.simpleCombine( first->env );
+                                        compositeEnv.simpleCombine( second->env );
+                                        compositeEnv.simpleCombine( third->env );
+
                                         // unify true and false types, then infer parameters to produce new alternatives
                                         OpenVarSet openVars;
                                         AssertionSet needAssertions, haveAssertions;
-                                        Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
+                                        Alternative newAlt( 0, compositeEnv, first->cost + second->cost + third->cost );
                                         Type* commonType = nullptr;
                                         if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
@@ -1524 +1600 @@
         }
 
-        void AlternativeFinder::visit( CommaExpr *commaExpr ) {
+        void AlternativeFinder::Finder::postvisit( CommaExpr *commaExpr ) {
                 TypeEnvironment newEnv( env );
                 Expression *newFirstArg = resolveInVoidContext( commaExpr->get_arg1(), indexer, newEnv );
@@ -1535 +1611 @@
         }
 
-        void AlternativeFinder::visit( RangeExpr * rangeExpr ) {
+        void AlternativeFinder::Finder::postvisit( RangeExpr * rangeExpr ) {
                 // resolve low and high, accept alternatives whose low and high types unify
                 AlternativeFinder firstFinder( indexer, env );
                 firstFinder.findWithAdjustment( rangeExpr->get_low() );
+                if ( firstFinder.alternatives.empty() ) return;
+                AlternativeFinder secondFinder( indexer, env );
+                secondFinder.findWithAdjustment( rangeExpr->get_high() );
+                if ( secondFinder.alternatives.empty() ) return;
                 for ( AltList::const_iterator first = firstFinder.alternatives.begin(); first != firstFinder.alternatives.end(); ++first ) {
-                        AlternativeFinder secondFinder( indexer, first->env );
-                        secondFinder.findWithAdjustment( rangeExpr->get_high() );
                         for ( AltList::const_iterator second = secondFinder.alternatives.begin(); second != secondFinder.alternatives.end(); ++second ) {
+                                TypeEnvironment compositeEnv;
+                                compositeEnv.simpleCombine( first->env );
+                                compositeEnv.simpleCombine( second->env );
                                 OpenVarSet openVars;
                                 AssertionSet needAssertions, haveAssertions;
-                                Alternative newAlt( 0, second->env, first->cost + second->cost );
+                                Alternative newAlt( 0, compositeEnv, first->cost + second->cost );
                                 Type* commonType = nullptr;
                                 if ( unify( first->expr->get_result(), second->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
@@ -1557 +1638 @@
         }
 
-        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
+        void AlternativeFinder::Finder::postvisit( UntypedTupleExpr *tupleExpr ) {
                 std::vector< AlternativeFinder > subExprAlternatives;
-                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
+                altFinder.findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
                         back_inserter( subExprAlternatives ) );
                 std::vector< AltList > possibilities;
@@ -1575 +1656 @@
         }
 
-        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
+        void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) {
                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
+        void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
                 alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
+        void AlternativeFinder::Finder::postvisit( ConstructorExpr * ctorExpr ) {
                 AlternativeFinder finder( indexer, env );
                 // don't prune here, since it's guaranteed all alternatives will have the same type
@@ -1593 +1674 @@
         }
 
-        void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
+        void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) {
                 alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
+        void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) {
                 alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
         }
 
-        void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
+        void AlternativeFinder::Finder::postvisit( UniqueExpr *unqExpr ) {
                 AlternativeFinder finder( indexer, env );
                 finder.findWithAdjustment( unqExpr->get_expr() );
@@ -1611 +1692 @@
         }
 
-        void AlternativeFinder::visit( StmtExpr *stmtExpr ) {
+        void AlternativeFinder::Finder::postvisit( StmtExpr *stmtExpr ) {
                 StmtExpr * newStmtExpr = stmtExpr->clone();
                 ResolvExpr::resolveStmtExpr( newStmtExpr, indexer );
@@ -1618 +1699 @@
         }
 
-        void AlternativeFinder::visit( UntypedInitExpr *initExpr ) {
+        void AlternativeFinder::Finder::postvisit( 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() ) {
@@ -1637 +1720 @@
                                 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 : public Visitor {
+        class AlternativeFinder {
           public:
                 AlternativeFinder( const SymTab::Indexer &indexer, const TypeEnvironment &env );
@@ -94 +94 @@
                 void findSubExprs( InputIterator begin, InputIterator end, OutputIterator out );
           private:
-                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 );
-
+                struct Finder;
                 const SymTab::Indexer &indexer;
                 AltList alternatives;

src/ResolvExpr/CastCost.cc

@@ -31 +31 @@
 
 namespace ResolvExpr {
-        class CastCost : public ConversionCost {
+        struct CastCost : public ConversionCost {
           public:
-                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc );
 
-                virtual void visit( BasicType *basicType );
-                virtual void visit( PointerType *pointerType );
+                using ConversionCost::previsit;
+                using ConversionCost::postvisit;
+                void postvisit( BasicType * basicType );
+                void postvisit( PointerType * pointerType );
         };
 
@@ -52 +54 @@
                                 // all typedefs should be gone by this point
                                 TypeDecl *type = strict_dynamic_cast< TypeDecl* >( namedType );
-                                if ( type->get_base() ) {
-                                        return castCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                if ( type->base ) {
+                                        return castCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -74 +76 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer & indexer) {
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer & indexer, const TypeEnvironment & env ) {
                                 return ptrsCastable( t1, t2, env, indexer );
                         });
                 } else {
-                        CastCost converter( dest, indexer, env );
+                        PassVisitor<CastCost> converter( dest, indexer, env, castCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
                                 // xxx - why are we adding cost 0 here?
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
         }
 
-        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : ConversionCost( dest, indexer, env ) {
+        CastCost::CastCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : ConversionCost( dest, indexer, env, costFunc ) {
         }
 
-        void CastCost::visit( BasicType *basicType ) {
+        void CastCost::postvisit( BasicType *basicType ) {
                 PointerType *destAsPointer = dynamic_cast< PointerType* >( dest );
                 if ( destAsPointer && basicType->isInteger() ) {
@@ -103 +105 @@
         }
 
-        void CastCost::visit( PointerType *pointerType ) {
+        void CastCost::postvisit( PointerType *pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
-                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                        if ( pointerType->get_qualifiers() <= destAsPtr->get_qualifiers() && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 cost = Cost::safe;
                         } else {
                                 TypeEnvironment newEnv( env );
-                                newEnv.add( pointerType->get_forall() );
-                                newEnv.add( pointerType->get_base()->get_forall() );
-                                int castResult = ptrsCastable( pointerType->get_base(), destAsPtr->get_base(), newEnv, indexer );
+                                newEnv.add( pointerType->forall );
+                                newEnv.add( pointerType->base->forall );
+                                int castResult = ptrsCastable( pointerType->base, destAsPtr->base, newEnv, indexer );
                                 if ( castResult > 0 ) {
                                         cost = Cost::safe;

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

src/ResolvExpr/ConversionCost.cc

@@ -44 +44 @@
                         EqvClass eqvClass;
                         NamedTypeDecl *namedType;
-                        PRINT( std::cerr << "type inst " << destAsTypeInst->get_name(); )
-                        if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                        PRINT( std::cerr << "type inst " << destAsTypeInst->name; )
+                        if ( env.lookup( destAsTypeInst->name, eqvClass ) ) {
                                 if ( eqvClass.type ) {
                                         return conversionCost( src, eqvClass.type, indexer, env );
@@ -51 +51 @@
                                         return Cost::infinity;
                                 }
-                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->get_name() ) ) ) {
+                        } else if ( ( namedType = indexer.lookupType( destAsTypeInst->name ) ) ) {
                                 PRINT( std::cerr << " found" << std::endl; )
                                 TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                                 // all typedefs should be gone by this point
                                 assert( type );
-                                if ( type->get_base() ) {
-                                        return conversionCost( src, type->get_base(), indexer, env ) + Cost::safe;
+                                if ( type->base ) {
+                                        return conversionCost( src, type->base, indexer, env ) + Cost::safe;
                                 } // if
                         } // if
@@ -77 +77 @@
                 } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * > ( dest ) ) {
                         PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const TypeEnvironment & env, const SymTab::Indexer &){
+                        return convertToReferenceCost( src, refType, indexer, env, [](Type * t1, Type * t2, const SymTab::Indexer &, const TypeEnvironment & env ){
                                 return ptrsAssignable( t1, t2, env );
                         });
                 } else {
-                        ConversionCost converter( dest, indexer, env );
+                        PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                         src->accept( converter );
-                        if ( converter.get_cost() == Cost::infinity ) {
+                        if ( converter.pass.get_cost() == Cost::infinity ) {
                                 return Cost::infinity;
                         } else {
-                                return converter.get_cost() + Cost::zero;
+                                return converter.pass.get_cost() + Cost::zero;
                         } // if
                 } // if
@@ -95 +95 @@
                 if ( diff > 0 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->get_base(), dest, diff-1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( strict_dynamic_cast< ReferenceType * >( src )->base, dest, diff-1, indexer, env, func );
                         cost.incReference();
                         return cost;
                 } else if ( diff < -1 ) {
                         // TODO: document this
-                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->get_base(), diff+1, indexer, env, func );
+                        Cost cost = convertToReferenceCost( src, strict_dynamic_cast< ReferenceType * >( dest )->base, diff+1, indexer, env, func );
                         cost.incReference();
                         return cost;
@@ -108 +108 @@
                         if ( srcAsRef && destAsRef ) { // pointer-like conversions between references
                                 PRINT( std::cerr << "converting between references" << std::endl; )
-                                Type::Qualifiers tq1 = srcAsRef->get_base()->get_qualifiers();
-                                Type::Qualifiers tq2 = destAsRef->get_base()->get_qualifiers();
-                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->get_base(), destAsRef->get_base(), indexer, env ) ) {
+                                Type::Qualifiers tq1 = srcAsRef->base->get_qualifiers();
+                                Type::Qualifiers tq2 = destAsRef->base->get_qualifiers();
+                                if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( srcAsRef->base, destAsRef->base, indexer, env ) ) {
                                         PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                         if ( tq1 == tq2 ) {
@@ -120 +120 @@
                                         }
                                 } else {  // xxx - this discards reference qualifiers from consideration -- reducing qualifiers is a safe conversion; is this right?
-                                        int assignResult = func( srcAsRef->get_base(), destAsRef->get_base(), env, indexer );
+                                        int assignResult = func( srcAsRef->base, destAsRef->base, indexer, env );
                                         PRINT( std::cerr << "comparing references: " << assignResult << " " << srcAsRef << " " << destAsRef << std::endl; )
                                         if ( assignResult > 0 ) {
@@ -130 +130 @@
                         } else {
                                 PRINT( std::cerr << "reference to rvalue conversion" << std::endl; )
-                                ConversionCost converter( dest, indexer, env );
+                                PassVisitor<ConversionCost> converter( dest, indexer, env, conversionCost );
                                 src->accept( converter );
-                                return converter.get_cost();
+                                return converter.pass.get_cost();
                         } // if
                 } else {
@@ -138 +138 @@
                         assert( diff == -1 && destAsRef );
                         PRINT( std::cerr << "dest is: " << dest << " / src is: " << src << std::endl; )
-                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->get_base(), indexer, env ) ) {
+                        if ( typesCompatibleIgnoreQualifiers( src, destAsRef->base, indexer, env ) ) {
                                 PRINT( std::cerr << "converting compatible base type" << std::endl; )
                                 if ( src->get_lvalue() ) {
@@ -146 +146 @@
                                         )
                                         // lvalue-to-reference conversion:  cv lvalue T => cv T &
-                                        if ( src->get_qualifiers() == destAsRef->get_base()->get_qualifiers() ) {
+                                        if ( src->get_qualifiers() == destAsRef->base->get_qualifiers() ) {
                                                 return Cost::reference; // cost needs to be non-zero to add cast
-                                        } if ( src->get_qualifiers() < destAsRef->get_base()->get_qualifiers() ) {
+                                        } if ( src->get_qualifiers() < destAsRef->base->get_qualifiers() ) {
                                                 return Cost::safe; // cost needs to be higher than previous cast to differentiate adding qualifiers vs. keeping same
                                         } else {
                                                 return Cost::unsafe;
                                         } // if
-                                } else if ( destAsRef->get_base()->get_const() ) {
+                                } else if ( destAsRef->base->get_const() ) {
                                         PRINT( std::cerr << "rvalue to const ref conversion" << std::endl; )
                                         // rvalue-to-const-reference conversion: T => const T &
@@ -173 +173 @@
         }
 
-        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env )
-                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ) {
+        ConversionCost::ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction costFunc )
+                : dest( dest ), indexer( indexer ), cost( Cost::infinity ), env( env ), costFunc( costFunc ) {
         }
 
@@ -257 +257 @@
         };
 
-        void ConversionCost::visit( VoidType * ) {
+        void ConversionCost::postvisit( VoidType * ) {
                 cost = Cost::infinity;
         }
 
-        void ConversionCost::visit(BasicType *basicType) {
+        void ConversionCost::postvisit(BasicType *basicType) {
                 if ( BasicType *destAsBasic = dynamic_cast< BasicType* >( dest ) ) {
                         int tableResult = costMatrix[ basicType->get_kind() ][ destAsBasic->get_kind() ];
@@ -278 +278 @@
         }
 
-        void ConversionCost::visit( PointerType * pointerType ) {
+        void ConversionCost::postvisit( PointerType * pointerType ) {
                 if ( PointerType *destAsPtr = dynamic_cast< PointerType* >( dest ) ) {
                         PRINT( std::cerr << pointerType << " ===> " << destAsPtr << std::endl; )
-                        Type::Qualifiers tq1 = pointerType->get_base()->get_qualifiers();
-                        Type::Qualifiers tq2 = destAsPtr->get_base()->get_qualifiers();
-                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->get_base(), destAsPtr->get_base(), indexer, env ) ) {
+                        Type::Qualifiers tq1 = pointerType->base->get_qualifiers();
+                        Type::Qualifiers tq2 = destAsPtr->base->get_qualifiers();
+                        if ( tq1 <= tq2 && typesCompatibleIgnoreQualifiers( pointerType->base, destAsPtr->base, indexer, env ) ) {
                                 PRINT( std::cerr << " :: compatible and good qualifiers" << std::endl; )
                                 if ( tq1 == tq2 ) {
@@ -312 +312 @@
         }
 
-        void ConversionCost::visit( ArrayType * ) {}
-
-        void ConversionCost::visit( ReferenceType * refType ) {
+        void ConversionCost::postvisit( ArrayType * ) {}
+
+        void ConversionCost::postvisit( ReferenceType * refType ) {
                 // Note: dest can never be a reference, since it would have been caught in an earlier check
                 assert( ! dynamic_cast< ReferenceType * >( dest ) );
@@ -320 +320 @@
                 // recursively compute conversion cost from T1 to T2.
                 // cv can be safely dropped because of 'implicit dereference' behavior.
-                refType->base->accept( *this );
+                cost = costFunc( refType->base, dest, indexer, env );
                 if ( refType->base->get_qualifiers() == dest->get_qualifiers() ) {
                         cost.incReference();  // prefer exact qualifiers
@@ -331 +331 @@
         }
 
-        void ConversionCost::visit( FunctionType * ) {}
-
-        void ConversionCost::visit( StructInstType * inst ) {
+        void ConversionCost::postvisit( FunctionType * ) {}
+
+        void ConversionCost::postvisit( StructInstType * inst ) {
                 if ( StructInstType *destAsInst = dynamic_cast< StructInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -341 +341 @@
         }
 
-        void ConversionCost::visit( UnionInstType * inst ) {
+        void ConversionCost::postvisit( UnionInstType * inst ) {
                 if ( UnionInstType *destAsInst = dynamic_cast< UnionInstType* >( dest ) ) {
                         if ( inst->name == destAsInst->name ) {
@@ -349 +349 @@
         }
 
-        void ConversionCost::visit( EnumInstType * ) {
+        void ConversionCost::postvisit( EnumInstType * ) {
                 static Type::Qualifiers q;
                 static BasicType integer( q, BasicType::SignedInt );
-                integer.accept( *this );  // safe if dest >= int
+                cost = costFunc( &integer, dest, indexer, env );  // safe if dest >= int
                 if ( cost < Cost::unsafe ) {
                         cost.incSafe();
@@ -358 +358 @@
         }
 
-        void ConversionCost::visit( TraitInstType * ) {}
-
-        void ConversionCost::visit( TypeInstType *inst ) {
+        void ConversionCost::postvisit( TraitInstType * ) {}
+
+        void ConversionCost::postvisit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 NamedTypeDecl *namedType;
-                if ( env.lookup( inst->get_name(), eqvClass ) ) {
-                        cost = conversionCost( eqvClass.type, dest, indexer, env );
+                if ( env.lookup( inst->name, eqvClass ) ) {
+                        cost = costFunc( eqvClass.type, dest, indexer, env );
                 } else if ( TypeInstType *destAsInst = dynamic_cast< TypeInstType* >( dest ) ) {
-                        if ( inst->get_name() == destAsInst->get_name() ) {
+                        if ( inst->name == destAsInst->name ) {
                                 cost = Cost::zero;
                         }
-                } else if ( ( namedType = indexer.lookupType( inst->get_name() ) ) ) {
+                } else if ( ( namedType = indexer.lookupType( inst->name ) ) ) {
                         TypeDecl *type = dynamic_cast< TypeDecl* >( namedType );
                         // all typedefs should be gone by this point
                         assert( type );
-                        if ( type->get_base() ) {
-                                cost = conversionCost( type->get_base(), dest, indexer, env ) + Cost::safe;
-                        } // if
-                } // if
-        }
-
-        void ConversionCost::visit( TupleType * tupleType ) {
+                        if ( type->base ) {
+                                cost = costFunc( type->base, dest, indexer, env ) + Cost::safe;
+                        } // if
+                } // if
+        }
+
+        void ConversionCost::postvisit( TupleType * tupleType ) {
                 Cost c = Cost::zero;
                 if ( TupleType * destAsTuple = dynamic_cast< TupleType * >( dest ) ) {
-                        std::list< Type * >::const_iterator srcIt = tupleType->get_types().begin();
-                        std::list< Type * >::const_iterator destIt = destAsTuple->get_types().begin();
-                        while ( srcIt != tupleType->get_types().end() && destIt != destAsTuple->get_types().end() ) {
-                                Cost newCost = conversionCost( *srcIt++, *destIt++, indexer, env );
+                        std::list< Type * >::const_iterator srcIt = tupleType->types.begin();
+                        std::list< Type * >::const_iterator destIt = destAsTuple->types.begin();
+                        while ( srcIt != tupleType->types.end() && destIt != destAsTuple->types.end() ) {
+                                Cost newCost = costFunc( *srcIt++, *destIt++, indexer, env );
                                 if ( newCost == Cost::infinity ) {
                                         return;
@@ -391 +391 @@
                                 c += newCost;
                         } // while
-                        if ( destIt != destAsTuple->get_types().end() ) {
+                        if ( destIt != destAsTuple->types.end() ) {
                                 cost = Cost::infinity;
                         } else {
@@ -399 +399 @@
         }
 
-        void ConversionCost::visit( VarArgsType * ) {
+        void ConversionCost::postvisit( VarArgsType * ) {
                 if ( dynamic_cast< VarArgsType* >( dest ) ) {
                         cost = Cost::zero;
@@ -405 +405 @@
         }
 
-        void ConversionCost::visit( ZeroType * ) {
+        void ConversionCost::postvisit( ZeroType * ) {
                 if ( dynamic_cast< ZeroType * >( dest ) ) {
                         cost = Cost::zero;
@@ -422 +422 @@
         }
 
-        void ConversionCost::visit( OneType * ) {
+        void ConversionCost::postvisit( OneType * ) {
                 if ( dynamic_cast< OneType * >( dest ) ) {
                         cost = Cost::zero;

src/ResolvExpr/ConversionCost.h

@@ -19 +19 @@
 
 #include "Cost.h"             // for Cost
+
+#include "Common/PassVisitor.h"
 #include "SynTree/Visitor.h"  // for Visitor
 #include "SynTree/SynTree.h"  // for Visitor Nodes
@@ -29 +31 @@
         class TypeEnvironment;
 
-        class ConversionCost : public Visitor {
+        typedef std::function<Cost(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> CostFunction;
+        struct ConversionCost : public WithShortCircuiting {
           public:
-                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
+                ConversionCost( Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env, CostFunction );
 
                 Cost get_cost() const { return cost; }
 
-                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);
+                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 );
           protected:
                 Type *dest;
@@ -55 +60 @@
                 Cost cost;
                 const TypeEnvironment &env;
+                CostFunction costFunc;
         };
 
-        typedef std::function<int(Type *, Type *, const TypeEnvironment &, const SymTab::Indexer &)> PtrsFunction;
+        typedef std::function<int(Type *, Type *, const SymTab::Indexer &, const TypeEnvironment &)> PtrsFunction;
         Cost convertToReferenceCost( Type * src, ReferenceType * dest, const SymTab::Indexer & indexer, const TypeEnvironment & env, PtrsFunction func );
 } // namespace ResolvExpr

src/ResolvExpr/CurrentObject.cc

@@ -62 +62 @@
                 virtual ~MemberIterator() {}
 
+                /// walks the current object using the given designators as a guide
                 virtual void setPosition( std::list< Expression * > & designators ) = 0;
+
+                /// retrieve the list of possible Type/Designaton pairs for the current position in the currect object
                 virtual std::list<InitAlternative> operator*() const = 0;
+
+                /// true if the iterator is not currently at the end
                 virtual operator bool() const = 0;
+
+                /// moves the iterator by one member in the current object
                 virtual MemberIterator & bigStep() = 0;
+
+                /// moves the iterator by one member in the current subobject
                 virtual MemberIterator & smallStep() = 0;
+
+                /// the type of the current object
                 virtual Type * getType() = 0;
+
+                /// the type of the current subobject
                 virtual Type * getNext() = 0;
 
+                /// printing for debug
                 virtual void print( std::ostream & out, Indenter indent ) const = 0;
 
+                /// helper for operator*; aggregates must add designator to each init alternative, but
+                /// adding designators in operator* creates duplicates.
                 virtual std::list<InitAlternative> first() const = 0; // should be protected
         };
@@ -354 +370 @@
                                 }
                         }
-                        // if ( curMember == std::next( decl->get_members().begin(), 1 ) ) { // xxx - this never triggers because curMember is incremented immediately on construction
-                        if ( atbegin ) { // xxx - this never triggers because curMember is incremented immediately on construction
+                        if ( atbegin ) {
                                 // xxx - what about case of empty struct??
                                 // only add self if at the very beginning of the structure
@@ -389 +404 @@
                         return *this;
                 }
-                virtual std::list<InitAlternative> first() const { return std::list<InitAlternative>{}; }
         };
 
@@ -443 +457 @@
                                 return new UnionIterator( uit );
                         } else {
-                                assertf( dynamic_cast< TypeInstType * >( type ), "some other reftotype" );
+                                assertf( dynamic_cast< EnumInstType * >( type ) || dynamic_cast< TypeInstType * >( type ), "Encountered unhandled ReferenceToType in createMemberIterator: %s", toString( type ).c_str() );
                                 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
@@ -20 +21 @@
 
 namespace ResolvExpr {
-        class PtrsAssignable : public Visitor {
-          public:
+        struct PtrsAssignable : public WithShortCircuiting {
                 PtrsAssignable( Type *dest, const TypeEnvironment &env );
 
                 int get_result() const { return result; }
 
-                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 );
+                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 );
           private:
                 Type *dest;
@@ -59 +61 @@
                         return -1;
                 } else {
-                        PtrsAssignable ptrs( dest, env );
+                        PassVisitor<PtrsAssignable> ptrs( dest, env );
                         src->accept( ptrs );
-                        return ptrs.get_result();
+                        return ptrs.pass.get_result();
                 } // if
         }
@@ -67 +69 @@
         PtrsAssignable::PtrsAssignable( Type *dest, const TypeEnvironment &env ) : dest( dest ), result( 0 ), env( env ) {}
 
-        void PtrsAssignable::visit( VoidType * ) {
+        void PtrsAssignable::postvisit( 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::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)) 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)) StructInstType *inst ) {}
-        void PtrsAssignable::visit(  __attribute__((unused)) UnionInstType *inst ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) StructInstType *inst ) {}
+        void PtrsAssignable::postvisit(  __attribute__((unused)) UnionInstType *inst ) {}
 
-        void PtrsAssignable::visit( EnumInstType * ) {
+        void PtrsAssignable::postvisit( EnumInstType * ) {
                 if ( dynamic_cast< BasicType* >( dest ) ) {
                         // int * = E *, etc. is safe. This isn't technically correct, as each
@@ -91 +93 @@
         }
 
-        void PtrsAssignable::visit(  __attribute__((unused)) TraitInstType *inst ) {}
-        void PtrsAssignable::visit( TypeInstType *inst ) {
+        void PtrsAssignable::postvisit(  __attribute__((unused)) TraitInstType *inst ) {}
+        void PtrsAssignable::postvisit( TypeInstType *inst ) {
                 EqvClass eqvClass;
                 if ( env.lookup( inst->get_name(), eqvClass ) && eqvClass.type ) {
@@ -100 +102 @@
         }
 
-        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 ) {}
+        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 ) {}
 
 } // 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
@@ -21 +22 @@
 #include "typeops.h"                     // for ptrsAssignable
 
-
 namespace ResolvExpr {
-        class PtrsCastable : public Visitor {
+        struct PtrsCastable : public WithShortCircuiting  {
           public:
                 PtrsCastable( Type *dest, const TypeEnvironment &env, const SymTab::Indexer &indexer );
@@ -29 +29 @@
                 int get_result() const { return result; }
 
-                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);
+                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 );
           private:
                 Type *dest;
@@ -79 +81 @@
                         EqvClass eqvClass;
                         if ( env.lookup( destAsTypeInst->get_name(), eqvClass ) ) {
+                                // xxx - should this be ptrsCastable?
                                 return ptrsAssignable( src, eqvClass.type, env );
                         } // if
@@ -85 +88 @@
                         return objectCast( src, env, indexer );
                 } else {
-                        PtrsCastable ptrs( dest, env, indexer );
+                        PassVisitor<PtrsCastable> ptrs( dest, env, indexer );
                         src->accept( ptrs );
-                        return ptrs.get_result();
+                        return ptrs.pass.get_result();
                 } // if
         }
@@ -95 +98 @@
         }
 
-        void PtrsCastable::visit( VoidType * ) {
+        void PtrsCastable::postvisit( VoidType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( BasicType * ) {
+        void PtrsCastable::postvisit( BasicType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( PointerType * ) {
+        void PtrsCastable::postvisit( PointerType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( ArrayType * ) {
+        void PtrsCastable::postvisit( ArrayType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( FunctionType * ) {
+        void PtrsCastable::postvisit( FunctionType * ) {
                 // result = -1;
                 result = functionCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( StructInstType * ) {
+        void PtrsCastable::postvisit( StructInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( UnionInstType * ) {
+        void PtrsCastable::postvisit( UnionInstType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( EnumInstType * ) {
+        void PtrsCastable::postvisit( EnumInstType * ) {
                 if ( dynamic_cast< EnumInstType* >( dest ) ) {
                         result = 1;
@@ -138 +141 @@
         }
 
-        void PtrsCastable::visit( TraitInstType * ) {}
+        void PtrsCastable::postvisit( TraitInstType * ) {}
 
-        void PtrsCastable::visit(TypeInstType *inst) {
+        void PtrsCastable::postvisit(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::visit( TupleType * ) {
+        void PtrsCastable::postvisit( TupleType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( VarArgsType * ) {
+        void PtrsCastable::postvisit( VarArgsType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( ZeroType * ) {
+        void PtrsCastable::postvisit( ZeroType * ) {
                 result = objectCast( dest, env, indexer );
         }
 
-        void PtrsCastable::visit( OneType * ) {
+        void PtrsCastable::postvisit( 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"
@@ -27 +28 @@
 
 namespace ResolvExpr {
-        RenameVars global_renamer;
+        namespace {
+                struct RenameVars {
+                        RenameVars();
+                        void reset();
 
-        RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
-                mapStack.push_front( std::map< std::string, std::string >() );
+                        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 );
         }
 
-        void RenameVars::reset() {
-                level = 0;
-                resetCount++;
+        void resetTyVarRenaming() {
+                global_renamer.pass.reset();
         }
 
-        void RenameVars::visit( VoidType *voidType ) {
-                typeBefore( voidType );
-                typeAfter( voidType );
-        }
+        namespace {
+                RenameVars::RenameVars() : level( 0 ), resetCount( 0 ) {
+                        mapStack.push_front( std::map< std::string, std::string >() );
+                }
 
-        void RenameVars::visit( BasicType *basicType ) {
-                typeBefore( basicType );
-                typeAfter( basicType );
-        }
+                void RenameVars::reset() {
+                        level = 0;
+                        resetCount++;
+                }
 
-        void RenameVars::visit( PointerType *pointerType ) {
-                typeBefore( pointerType );
-                maybeAccept( pointerType->get_base(), *this );
-                typeAfter( pointerType );
-        }
+                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( ArrayType *arrayType ) {
-                typeBefore( arrayType );
-                maybeAccept( arrayType->get_dimension(), *this );
-                maybeAccept( arrayType->get_base(), *this );
-                typeAfter( arrayType );
-        }
+                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( 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
-        }
-
+                void RenameVars::postvisit( Type * type ) {
+                        // clears name mapping added by typeBefore()
+                        if ( ! type->forall.empty() ) {
+                                mapStack.pop_front();
+                        } // if
+                }
+        } // namespace
 } // 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 * );
 
-        /// Provides a consistent renaming of forall type names in a hierarchy by prefixing them with a unique "level" ID
-        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 );
-
-                void typeBefore( Type *type );
-                void typeAfter( Type *type );
-                int level, resetCount;
-                std::list< std::map< std::string, std::string > > mapStack;
-        };
-
-        extern RenameVars global_renamer;
+        /// resets internal state of renamer to avoid overflow
+        void resetTyVarRenaming();
 } // namespace ResolvExpr
 

src/ResolvExpr/Resolver.cc

@@ -132 +132 @@
 
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                global_renamer.reset();
+                resetTyVarRenaming();
                 TypeEnvironment env;
                 Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
@@ -155 +155 @@
                 } // if
                 #endif
-                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
+                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end: (%zd) %s", finder.get_alternatives().size(), toString( untyped ).c_str() );
                 Alternative &choice = finder.get_alternatives().front();
                 Expression *newExpr = choice.expr->clone();
@@ -171 +171 @@
 
         namespace {
+                /// resolve `untyped` to the expression whose type satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
+                template<typename Pred>
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, Pred pred) {
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.findWithAdjustment( untyped );
+
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( pred( alt.expr->result ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
+                                throw SemanticError( "No reasonable alternatives for " + kindStr + " expression: ", untyped );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " + kindStr +  " expression\n";
+                                untyped->print( stream );
+                                stream << "Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                throw SemanticError( stream.str() );
+                        }
+
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & alt = winners.front();
+                        finishExpr( alt.expr, alt.env, untyped->env );
+                        delete untyped;
+                        untyped = alt.expr;
+                        alt.expr = nullptr;
+                }
+
                 bool isIntegralType( Type *type ) {
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
@@ -184 +220 @@
 
                 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        Expression *newExpr = 0;
-                        const TypeEnvironment *newEnv = 0;
-                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
-                                        if ( newExpr ) {
-                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
-                                        } else {
-                                                newExpr = i->expr->clone();
-                                                newEnv = &i->env;
-                                        } // if
-                                } // if
-                        } // for
-                        if ( ! newExpr ) {
-                                throw SemanticError( "No interpretations for case control expression", untyped );
-                        } // if
-                        finishExpr( newExpr, *newEnv, untyped->env );
-                        delete untyped;
-                        untyped = newExpr;
-                }
-
+                        findKindExpression( untyped, indexer, "condition", isIntegralType );
+                }
         }
 
@@ -311 +316 @@
 
         void Resolver::previsit( IfStmt *ifStmt ) {
-                findSingleExpression( ifStmt->condition, indexer );
+                findIntegralExpression( ifStmt->condition, indexer );
         }
 
         void Resolver::previsit( WhileStmt *whileStmt ) {
-                findSingleExpression( whileStmt->condition, indexer );
+                findIntegralExpression( whileStmt->condition, indexer );
         }
 
         void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->condition ) {
-                        findSingleExpression( forStmt->condition, indexer );
+                        findIntegralExpression( forStmt->condition, indexer );
                 } // if
 
@@ -579 +584 @@
         }
 
+
         void Resolver::previsit( WithStmt * withStmt ) {
                 for ( Expression *& expr : withStmt->exprs )  {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.findWithAdjustment( expr );
-
                         // only struct- and union-typed expressions are viable candidates
-                        AltList candidates;
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                if ( isStructOrUnion( alt.expr->result ) ) {
-                                        candidates.push_back( std::move( alt ) );
-                                }
-                        }
-
-                        // choose the lowest cost expression among the candidates
-                        AltList winners;
-                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
-                        if ( winners.size() == 0 ) {
-                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
-                        } else if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
-                                expr->print( stream );
-                                stream << "Alternatives are:\n";
-                                printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
-                        }
-
-                        // there is one unambiguous interpretation - move the expression into the with statement
-                        Alternative & alt = winners.front();
-                        finishExpr( alt.expr, alt.env, expr->env );
-                        delete expr;
-                        expr = alt.expr;
-                        alt.expr = nullptr;
+                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
 
                         // if with expression might be impure, create a temporary so that it is evaluated once

src/ResolvExpr/Unify.cc

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