Changes in / [2b72090:bee7f04]

Location:

src

Files:

• Common/PassVisitor.h (modified) (2 diffs)
• Common/PassVisitor.impl.h (modified) (2 diffs)
• ControlStruct/LabelFixer.cc (modified) (1 diff)
• ControlStruct/MLEMutator.cc (modified) (8 diffs)
• ControlStruct/MLEMutator.h (modified) (4 diffs)
• GenPoly/Box.cc (modified) (4 diffs)
• GenPoly/Lvalue.cc (modified) (7 diffs)
• GenPoly/ScrubTyVars.cc (modified) (6 diffs)
• GenPoly/ScrubTyVars.h (modified) (6 diffs)
• InitTweak/FixInit.cc (modified) (11 diffs)
• ResolvExpr/CastCost.cc (modified) (4 diffs)
• ResolvExpr/ConversionCost.cc (modified) (22 diffs)
• ResolvExpr/ConversionCost.h (modified) (3 diffs)
• ResolvExpr/Resolver.cc (modified) (5 diffs)
• SynTree/AggregateDecl.cc (modified) (1 diff)
• SynTree/Expression.cc (modified) (2 diffs)
• SynTree/Label.h (modified) (1 diff)
• SynTree/TypeSubstitution.cc (modified) (3 diffs)
• SynTree/TypeSubstitution.h (modified) (5 diffs)
• Tuples/TupleExpansion.cc (modified) (5 diffs)
• tests/.expect/ctor-autogen-ERR1.txt (deleted)
• tests/.expect/ctor-autogen.txt (deleted)
• tests/.expect/dtor-early-exit-ERR1.txt (deleted)
• tests/.expect/dtor-early-exit-ERR2.txt (deleted)
• tests/.expect/dtor-early-exit.txt (deleted)
• tests/.expect/globals.txt (deleted)
• tests/.expect/init_once.txt (deleted)
• tests/.expect/memberCtors-ERR1.txt (deleted)
• tests/.expect/memberCtors.txt (deleted)
• tests/.expect/multiDimension.txt (deleted)
• tests/Makefile.am (modified) (3 diffs)
• tests/Makefile.in (modified) (3 diffs)
• tests/ctor-autogen.c (deleted)
• tests/dtor-early-exit.c (deleted)
• tests/globals.c (deleted)
• tests/init_once.c (deleted)
• tests/memberCtors.c (deleted)
• tests/multiDimension.c (deleted)
• tests/raii/.expect/ctor-autogen-ERR1.txt (added)
• tests/raii/.expect/ctor-autogen.txt (added)
• tests/raii/.expect/dtor-early-exit-ERR1.txt (added)
• tests/raii/.expect/dtor-early-exit-ERR2.txt (added)
• tests/raii/.expect/dtor-early-exit.txt (added)
• tests/raii/.expect/globals.txt (added)
• tests/raii/.expect/init_once.txt (added)
• tests/raii/.expect/memberCtors-ERR1.txt (added)
• tests/raii/.expect/memberCtors.txt (added)
• tests/raii/ctor-autogen.c (added)
• tests/raii/dtor-early-exit.c (added)
• tests/raii/globals.c (added)
• tests/raii/init_once.c (added)
• tests/raii/memberCtors.c (added)
• tests/raii/multiDimension.c (added)
• tests/raii/multiDimension.txt (added)

src/Common/PassVisitor.h

@@ -19 +19 @@
 #include "SynTree/Expression.h"
 #include "SynTree/Constant.h"
-#include "SynTree/TypeSubstitution.h"
+
+class TypeSubstitution;
 
 #include "PassVisitor.proto.h"
@@ -403 +404 @@
 };
 
+#include "SynTree/TypeSubstitution.h"
 #include "PassVisitor.impl.h"

src/Common/PassVisitor.impl.h

@@ -62 +62 @@
 
 template< typename pass_type >
-static inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
+inline void acceptAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& visitor ) {
         DeclList_t* beforeDecls = visitor.get_beforeDecls();
         DeclList_t* afterDecls  = visitor.get_afterDecls();
@@ -90 +90 @@
 
 template< typename pass_type >
-static inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
+inline void mutateAll( std::list< Declaration* > &decls, PassVisitor< pass_type >& mutator ) {
         DeclList_t* beforeDecls = mutator.get_beforeDecls();
         DeclList_t* afterDecls  = mutator.get_afterDecls();

src/ControlStruct/LabelFixer.cc

@@ -44 +44 @@
 
         void LabelFixer::postvisit( FunctionDecl * functionDecl ) {
-                MLEMutator mlemut( resolveJumps(), generator );
+                PassVisitor<MLEMutator> mlemut( resolveJumps(), generator );
                 functionDecl->acceptMutator( mlemut );
         }

src/ControlStruct/MLEMutator.cc

@@ -46 +46 @@
         void MLEMutator::fixBlock( std::list< Statement * > &kids ) {
                 for ( std::list< Statement * >::iterator k = kids.begin(); k != kids.end(); k++ ) {
-                        *k = (*k)->acceptMutator(*this);
+                        *k = (*k)->acceptMutator(*visitor);
 
                         if ( ! get_breakLabel().empty() ) {
@@ -57 +57 @@
         }
 
-        CompoundStmt* MLEMutator::mutate( CompoundStmt *cmpndStmt ) {
-                bool labeledBlock = !(cmpndStmt->get_labels().empty());
+        void MLEMutator::premutate( CompoundStmt *cmpndStmt ) {
+                visit_children = false;
+                bool labeledBlock = !(cmpndStmt->labels.empty());
                 if ( labeledBlock ) {
                         Label brkLabel = generator->newLabel("blockBreak", cmpndStmt);
@@ -65 +66 @@
 
                 // a child statement may set the break label - if they do, attach it to the next statement
-                std::list< Statement * > &kids = cmpndStmt->get_kids();
+                std::list< Statement * > &kids = cmpndStmt->kids;
                 fixBlock( kids );
 
@@ -75 +76 @@
                         enclosingControlStructures.pop_back();
                 } // if
-
-                return cmpndStmt;
-        }
-
-        template< typename LoopClass >
-        Statement *MLEMutator::handleLoopStmt( LoopClass *loopStmt ) {
-                // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
-                // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
-                // loops
-                Label brkLabel = generator->newLabel("loopBreak", loopStmt);
-                Label contLabel = generator->newLabel("loopContinue", loopStmt);
-                enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
-                loopStmt->set_body ( loopStmt->get_body()->acceptMutator( *this ) );
-
-                assert( ! enclosingControlStructures.empty() );
-                Entry &e = enclosingControlStructures.back();
-                // sanity check that the enclosing loops have been popped correctly
-                assert ( e == loopStmt );
-
-                // this will take the necessary steps to add definitions of the previous two labels, if they are used.
-                loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
-                enclosingControlStructures.pop_back();
-
-                return loopStmt;
-        }
-
-        Statement *MLEMutator::mutate( CaseStmt *caseStmt ) {
-                caseStmt->set_condition( maybeMutate( caseStmt->get_condition(), *this ) );
-                fixBlock( caseStmt->get_statements() );
-
-                return caseStmt;
-        }
-
-        template< typename IfClass >
-        Statement *MLEMutator::handleIfStmt( IfClass *ifStmt ) {
-                // generate a label for breaking out of a labeled if
-                bool labeledBlock = !(ifStmt->get_labels().empty());
-                if ( labeledBlock ) {
-                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
-                        enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
-                } // if
-
-                Parent::mutate( ifStmt );
-
-                if ( labeledBlock ) {
-                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
-                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
-                        } // if
-                        enclosingControlStructures.pop_back();
-                } // if
-                return ifStmt;
-        }
-
-        template< typename SwitchClass >
-        Statement *MLEMutator::handleSwitchStmt( SwitchClass *switchStmt ) {
-                // generate a label for breaking out of a labeled switch
-                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
-                enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
-                mutateAll( switchStmt->get_statements(), *this );
-
-                Entry &e = enclosingControlStructures.back();
-                assert ( e == switchStmt );
-
-                // only generate break label if labeled break is used
-                if ( e.isBreakUsed() ) {
-                        // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a
-                        // switch should be CastStmts), append the exit label + break to the last case statement; create a default
-                        // case if there are no cases
-                        std::list< Statement * > &statements = switchStmt->get_statements();
-                        if ( statements.empty() ) {
-                                statements.push_back( CaseStmt::makeDefault() );
-                        } // if
-
-                        if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
-                                Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
-                                stmt->labels.push_back( brkLabel );
-                                c->get_statements().push_back( stmt );
-                        } else assert(0); // as of this point, all statements of a switch are still CaseStmts
-                } // if
-
-                assert ( enclosingControlStructures.back() == switchStmt );
-                enclosingControlStructures.pop_back();
-                return switchStmt;
-        }
+        }
+
 
         void addUnused( Statement * stmt, const Label & originalTarget ) {
@@ -179 +98 @@
 
 
-        Statement *MLEMutator::mutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
-                std::string originalTarget = branchStmt->get_originalTarget();
+        Statement *MLEMutator::postmutate( BranchStmt *branchStmt ) throw ( SemanticError ) {
+                std::string originalTarget = branchStmt->originalTarget;
 
                 std::list< Entry >::reverse_iterator targetEntry;
@@ -215 +134 @@
                 // branch error checks, get the appropriate label name and create a goto
                 Label exitLabel;
-                switch ( branchStmt->get_type() ) {
+                switch ( branchStmt->type ) {
                   case BranchStmt::Break:
                                 assert( targetEntry->useBreakExit() != "");
@@ -229 +148 @@
 
                 // add unused attribute to label to silence warnings
-                addUnused( targetEntry->get_controlStructure(), branchStmt->get_originalTarget() );
+                addUnused( targetEntry->get_controlStructure(), branchStmt->originalTarget );
 
                 // transform break/continue statements into goto to simplify later handling of branches
@@ -260 +179 @@
         }
 
-        Statement *MLEMutator::mutate( WhileStmt *whileStmt ) {
-                return handleLoopStmt( whileStmt );
-        }
-
-        Statement *MLEMutator::mutate( ForStmt *forStmt ) {
-                return handleLoopStmt( forStmt );
-        }
-
-        Statement *MLEMutator::mutate( IfStmt *ifStmt ) {
-                return handleIfStmt( ifStmt );
-        }
-
-        Statement *MLEMutator::mutate( SwitchStmt *switchStmt ) {
-                return handleSwitchStmt( switchStmt );
+        template< typename LoopClass >
+        void MLEMutator::prehandleLoopStmt( LoopClass * loopStmt ) {
+                // remember this as the most recent enclosing loop, then mutate the body of the loop -- this will determine
+                // whether brkLabel and contLabel are used with branch statements and will recursively do the same to nested
+                // loops
+                Label brkLabel = generator->newLabel("loopBreak", loopStmt);
+                Label contLabel = generator->newLabel("loopContinue", loopStmt);
+                enclosingControlStructures.push_back( Entry( loopStmt, brkLabel, contLabel ) );
+        }
+
+        template< typename LoopClass >
+        Statement * MLEMutator::posthandleLoopStmt( LoopClass * loopStmt ) {
+                assert( ! enclosingControlStructures.empty() );
+                Entry &e = enclosingControlStructures.back();
+                // sanity check that the enclosing loops have been popped correctly
+                assert ( e == loopStmt );
+
+                // this will take the necessary steps to add definitions of the previous two labels, if they are used.
+                loopStmt->set_body( mutateLoop( loopStmt->get_body(), e ) );
+                enclosingControlStructures.pop_back();
+                return loopStmt;
+        }
+
+        void MLEMutator::premutate( WhileStmt * whileStmt ) {
+                return prehandleLoopStmt( whileStmt );
+        }
+
+        void MLEMutator::premutate( ForStmt * forStmt ) {
+                return prehandleLoopStmt( forStmt );
+        }
+
+        Statement * MLEMutator::postmutate( WhileStmt * whileStmt ) {
+                return posthandleLoopStmt( whileStmt );
+        }
+
+        Statement * MLEMutator::postmutate( ForStmt * forStmt ) {
+                return posthandleLoopStmt( forStmt );
+        }
+
+        void MLEMutator::premutate( IfStmt * ifStmt ) {
+                // generate a label for breaking out of a labeled if
+                bool labeledBlock = !(ifStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        Label brkLabel = generator->newLabel("blockBreak", ifStmt);
+                        enclosingControlStructures.push_back( Entry( ifStmt, brkLabel ) );
+                } // if
+        }
+
+        Statement * MLEMutator::postmutate( IfStmt * ifStmt ) {
+                bool labeledBlock = !(ifStmt->get_labels().empty());
+                if ( labeledBlock ) {
+                        if ( ! enclosingControlStructures.back().useBreakExit().empty() ) {
+                                set_breakLabel( enclosingControlStructures.back().useBreakExit() );
+                        } // if
+                        enclosingControlStructures.pop_back();
+                } // if
+                return ifStmt;
+        }
+
+        void MLEMutator::premutate( CaseStmt *caseStmt ) {
+                visit_children = false;
+                caseStmt->condition = maybeMutate( caseStmt->condition, *visitor );
+                fixBlock( caseStmt->stmts );
+        }
+
+        void MLEMutator::premutate( SwitchStmt *switchStmt ) {
+                // generate a label for breaking out of a labeled switch
+                Label brkLabel = generator->newLabel("switchBreak", switchStmt);
+                enclosingControlStructures.push_back( Entry(switchStmt, brkLabel) );
+        }
+
+        Statement * MLEMutator::postmutate( SwitchStmt * switchStmt ) {
+                Entry &e = enclosingControlStructures.back();
+                assert ( e == switchStmt );
+
+                // only generate break label if labeled break is used
+                if ( e.isBreakUsed() ) {
+                        // for the purposes of keeping switch statements uniform (i.e. all statements that are direct children of a
+                        // switch should be CastStmts), append the exit label + break to the last case statement; create a default
+                        // case if there are no cases
+                        std::list< Statement * > &statements = switchStmt->statements;
+                        if ( statements.empty() ) {
+                                statements.push_back( CaseStmt::makeDefault() );
+                        } // if
+
+                        if ( CaseStmt * c = dynamic_cast< CaseStmt * >( statements.back() ) ) {
+                                Statement * stmt = new BranchStmt( Label("brkLabel"), BranchStmt::Break );
+                                stmt->labels.push_back( e.useBreakExit() );
+                                c->stmts.push_back( stmt );
+                        } else assert(0); // as of this point, all statements of a switch are still CaseStmts
+                } // if
+
+                assert ( enclosingControlStructures.back() == switchStmt );
+                enclosingControlStructures.pop_back();
+                return switchStmt;
         }
 } // namespace ControlStruct

src/ControlStruct/MLEMutator.h

@@ -20 +20 @@
 #include <string>                  // for string
 
+#include "Common/PassVisitor.h"
 #include "Common/SemanticError.h"  // for SemanticError
 #include "SynTree/Label.h"         // for Label
@@ -26 +27 @@
 
 namespace ControlStruct {
-class LabelGenerator;
+        class LabelGenerator;
 
-        class MLEMutator : public Mutator {
+        class MLEMutator : public WithVisitorRef<MLEMutator>, public WithShortCircuiting {
                 class Entry;
 
-                typedef Mutator Parent;
           public:
                 MLEMutator( std::map<Label, Statement *> *t, LabelGenerator *gen = 0 ) : targetTable( t ), breakLabel(std::string("")), generator( gen ) {}
                 ~MLEMutator();
 
-                virtual CompoundStmt *mutate( CompoundStmt *cmpndStmt ) override;
-                virtual Statement *mutate( WhileStmt *whileStmt ) override;
-                virtual Statement *mutate( ForStmt *forStmt ) override;
-                virtual Statement *mutate( BranchStmt *branchStmt ) throw ( SemanticError ) override;
-                virtual Statement *mutate( CaseStmt *caseStmt ) override;
-                virtual Statement *mutate( IfStmt *ifStmt ) override;
-                virtual Statement *mutate( SwitchStmt *switchStmt ) override;
+                void premutate( CompoundStmt *cmpndStmt );
+                Statement * postmutate( BranchStmt *branchStmt ) throw ( SemanticError );
+                void premutate( WhileStmt *whileStmt );
+                Statement * postmutate( WhileStmt *whileStmt );
+                void premutate( ForStmt *forStmt );
+                Statement * postmutate( ForStmt *forStmt );
+                void premutate( CaseStmt *caseStmt );
+                void premutate( IfStmt *ifStmt );
+                Statement * postmutate( IfStmt *ifStmt );
+                void premutate( SwitchStmt *switchStmt );
+                Statement * postmutate( SwitchStmt *switchStmt );
 
                 Statement *mutateLoop( Statement *bodyLoop, Entry &e );
@@ -54 +58 @@
                                 loop( _loop ), breakExit( _breakExit ), contExit( _contExit ), breakUsed(false), contUsed(false) {}
 
-                        bool operator==( const Statement *stmt ) { return ( loop == stmt ); }
-                        bool operator!=( const Statement *stmt ) { return ( loop != stmt ); }
+                        bool operator==( const Statement *stmt ) { return loop == stmt; }
+                        bool operator!=( const Statement *stmt ) { return loop != stmt; }
 
-                        bool operator==( const Entry &other ) { return ( loop == other.get_controlStructure() ); }
+                        bool operator==( const Entry &other ) { return loop == other.get_controlStructure(); }
 
                         Statement *get_controlStructure() const { return loop; }
@@ -78 +82 @@
 
                 template< typename LoopClass >
-                Statement *handleLoopStmt( LoopClass *loopStmt );
+                void prehandleLoopStmt( LoopClass * loopStmt );
 
-                template< typename IfClass >
-                Statement *handleIfStmt( IfClass *switchStmt );
-
-                template< typename SwitchClass >
-                Statement *handleSwitchStmt( SwitchClass *switchStmt );
+                template< typename LoopClass >
+                Statement * posthandleLoopStmt( LoopClass * loopStmt );
 
                 void fixBlock( std::list< Statement * > &kids );

src/GenPoly/Box.cc

@@ -302 +302 @@
         Expression *makeOp( const std::string &name, Expression *arg ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( arg );
+                expr->args.push_back( arg );
                 return expr;
         }
@@ -309 +309 @@
         Expression *makeOp( const std::string &name, Expression *lhs, Expression *rhs ) {
                 UntypedExpr *expr = new UntypedExpr( new NameExpr( name ) );
-                expr->get_args().push_back( lhs );
-                expr->get_args().push_back( rhs );
+                expr->args.push_back( lhs );
+                expr->args.push_back( rhs );
                 return expr;
         }
@@ -316 +316 @@
         /// Returns the dereference of a local pointer variable
         Expression *derefVar( ObjectDecl *var ) {
-                return makeOp( "*?", new VariableExpr( var ) );
+                return UntypedExpr::createDeref( new VariableExpr( var ) );
         }
 
@@ -831 +831 @@
                                 if ( ! isPolyType( arg->get_type() ) ) {
                                         UntypedExpr *deref = new UntypedExpr( new NameExpr( "*?" ) );
-                                        deref->get_args().push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
-                                        deref->set_result( arg->get_type()->clone() );
+                                        deref->args.push_back( new CastExpr( new VariableExpr( param ), new PointerType( Type::Qualifiers(), arg->get_type()->clone() ) ) );
+                                        deref->result = arg->get_type()->clone();
+                                        deref->result->set_lvalue( true );
                                         return deref;
                                 } // if

src/GenPoly/Lvalue.cc

@@ -47 +47 @@
                         if ( SymTab::dereferenceOperator ) {
                                 VariableExpr * deref = new VariableExpr( SymTab::dereferenceOperator );
-                                deref->set_result( new PointerType( Type::Qualifiers(), deref->get_result() ) );
-                                Type * base = InitTweak::getPointerBase( arg->get_result() );
-                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->get_result() ).c_str() );
+                                deref->result = new PointerType( Type::Qualifiers(), deref->result );
+                                Type * base = InitTweak::getPointerBase( arg->result );
+                                assertf( base, "expected pointer type in dereference (type was %s)", toString( arg->result ).c_str() );
                                 ApplicationExpr * ret = new ApplicationExpr( deref, { arg } );
-                                delete ret->get_result();
-                                ret->set_result( base->clone() );
-                                ret->get_result()->set_lvalue( true );
+                                delete ret->result;
+                                ret->result = base->clone();
+                                ret->result->set_lvalue( true );
                                 return ret;
                         } else {
@@ -308 +308 @@
                                         int diff = depth1-depth2;
                                         if ( diff == 0 ) {
+                                                // conversion between references of the same depth
                                                 assertf( depth1 == depth2, "non-intrinsic reference with cast of reference to reference not yet supported: %d %d %s", depth1, depth2, toString( castExpr ).c_str() );
                                                 PRINT( std::cerr << castExpr << std::endl; )
                                                 return castExpr;
                                         } else if ( diff < 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with less depth (e.g. int && -> int &): add dereferences
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = mkDeref( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                ret->result->set_lvalue( true ); // ensure result is lvalue
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
                                         } else if ( diff > 0 ) {
-                                                Expression * ret = castExpr->get_arg();
+                                                // conversion from reference to reference with more depth (e.g. int & -> int &&): add address-of
+                                                Expression * ret = castExpr->arg;
                                                 for ( int i = 0; i < diff; ++i ) {
                                                         ret = new AddressExpr( ret );
                                                 }
-                                                ret->set_env( castExpr->get_env() );
-                                                delete ret->get_result();
-                                                ret->set_result( castExpr->get_result() );
-                                                castExpr->set_env( nullptr );
-                                                castExpr->set_arg( nullptr );
-                                                castExpr->set_result( nullptr );
+                                                ret->env = castExpr->env;
+                                                delete ret->result;
+                                                ret->result = castExpr->result;
+                                                castExpr->env = nullptr;
+                                                castExpr->arg = nullptr;
+                                                castExpr->result = nullptr;
                                                 delete castExpr;
                                                 return ret;
@@ -342 +346 @@
                                         PRINT( std::cerr << castExpr << std::endl; )
                                         return castExpr;
-                                } else if ( castExpr->get_arg()->get_result()->get_lvalue() ) {
+                                } else if ( castExpr->arg->result->get_lvalue() ) {
                                         // conversion from lvalue to reference
                                         // xxx - keep cast, but turn into pointer cast??
@@ -348 +352 @@
                                         PRINT(
                                                 std::cerr << "convert lvalue to reference -- &" << std::endl;
-                                                std::cerr << castExpr->get_arg() << std::endl;
+                                                std::cerr << castExpr->arg << std::endl;
                                         )
-                                        AddressExpr * ret = new AddressExpr( castExpr->get_arg() );
-                                        if ( refType->get_base()->get_qualifiers() != castExpr->get_arg()->get_result()->get_qualifiers() ) {
+                                        AddressExpr * ret = new AddressExpr( castExpr->arg );
+                                        if ( refType->base->get_qualifiers() != castExpr->arg->result->get_qualifiers() ) {
                                                 // must keep cast if cast-to type is different from the actual type
-                                                castExpr->set_arg( ret );
+                                                castExpr->arg = ret;
                                                 return castExpr;
                                         }
-                                        ret->set_env( castExpr->get_env() );
-                                        delete ret->get_result();
-                                        ret->set_result( castExpr->get_result() );
-                                        castExpr->set_env( nullptr );
-                                        castExpr->set_arg( nullptr );
-                                        castExpr->set_result( nullptr );
+                                        ret->env = castExpr->env;
+                                        delete ret->result;
+                                        ret->result = castExpr->result;
+                                        castExpr->env = nullptr;
+                                        castExpr->arg = nullptr;
+                                        castExpr->result = nullptr;
                                         delete castExpr;
                                         return ret;
@@ -368 +372 @@
                                 }
                                 assertf( false, "Only conversions to reference from lvalue are currently supported: %s", toString( castExpr ).c_str() );
-                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->get_arg()->get_result() ) ) {
+                        } else if ( ReferenceType * refType = dynamic_cast< ReferenceType * >( castExpr->arg->result ) ) {
                                 (void)refType;
                                 // conversion from reference to rvalue
@@ -375 +379 @@
                                         std::cerr << "was = " << castExpr << std::endl;
                                 )
-                                Expression * ret = castExpr->get_arg();
-                                TypeSubstitution * env = castExpr->get_env();
+                                Expression * ret = castExpr->arg;
+                                TypeSubstitution * env = castExpr->env;
                                 castExpr->set_env( nullptr );
                                 if ( ! isIntrinsicReference( ret ) ) {
@@ -382 +386 @@
                                         ret = mkDeref( ret );
                                 }
-                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->get_result(), castExpr->get_arg()->get_result()->stripReferences(), SymTab::Indexer() ) ) {
+                                if ( ResolvExpr::typesCompatibleIgnoreQualifiers( castExpr->result, castExpr->arg->result->stripReferences(), SymTab::Indexer() ) ) {
                                         // can remove cast if types are compatible, changing expression type to value type
-                                        ret->set_result( castExpr->get_result()->clone() );
-                                        castExpr->set_arg( nullptr );
+                                        ret->result = castExpr->result->clone();
+                                        ret->result->set_lvalue( true );  // ensure result is lvalue
+                                        castExpr->arg = nullptr;
                                         delete castExpr;
                                 } else {
                                         // must keep cast if types are different
-                                        castExpr->set_arg( ret );
+                                        castExpr->arg = ret;
                                         ret = castExpr;
                                 }

src/GenPoly/ScrubTyVars.cc

@@ -25 +25 @@
 
 namespace GenPoly {
-        Type * ScrubTyVars::mutate( TypeInstType *typeInst ) {
+        Type * ScrubTyVars::postmutate( TypeInstType * typeInst ) {
                 if ( ! tyVars ) {
                         if ( typeInst->get_isFtype() ) {
@@ -31 +31 @@
                                 return new PointerType( Type::Qualifiers(), new FunctionType( Type::Qualifiers(), true ) );
                         } else {
-                                PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
+                                PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
                                 delete typeInst;
                                 return ret;
@@ -37 +37 @@
                 }
 
-                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->get_name() );
+                TyVarMap::const_iterator tyVar = tyVars->find( typeInst->name );
                 if ( tyVar != tyVars->end() ) {
                         switch ( tyVar->second.kind ) {
@@ -43 +43 @@
                           case TypeDecl::Ttype:
                                 {
-                                        PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
+                                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( typeInst->get_qualifiers() ) );
                                         delete typeInst;
                                         return ret;
@@ -55 +55 @@
         }
 
-        Type * ScrubTyVars::mutateAggregateType( Type *ty ) {
+        Type * ScrubTyVars::mutateAggregateType( Type * ty ) {
                 if ( shouldScrub( ty ) ) {
-                        PointerType *ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
+                        PointerType * ret = new PointerType( Type::Qualifiers(), new VoidType( ty->get_qualifiers() ) );
                         delete ty;
                         return ret;
@@ -64 +64 @@
         }
 
-        Type * ScrubTyVars::mutate( StructInstType *structInst ) {
+        Type * ScrubTyVars::postmutate( StructInstType * structInst ) {
                 return mutateAggregateType( structInst );
         }
 
-        Type * ScrubTyVars::mutate( UnionInstType *unionInst ) {
+        Type * ScrubTyVars::postmutate( UnionInstType * unionInst ) {
                 return mutateAggregateType( unionInst );
         }
 
-        Expression * ScrubTyVars::mutate( SizeofExpr *szeof ) {
+        void ScrubTyVars::primeBaseScrub( Type * type ) {
+                // need to determine whether type needs to be scrubbed to determine whether
+                // automatic recursion is necessary
+                if ( Type * t = shouldScrub( type ) ) {
+                        visit_children = false;
+                        GuardValue( dynType );
+                        dynType = t;
+                }
+        }
+
+        Expression * ScrubTyVars::postmutate( SizeofExpr * szeof ) {
                 // sizeof( T ) => _sizeof_T parameter, which is the size of T
-                if ( Type *dynType = shouldScrub( szeof->get_type() ) ) {
+                if ( dynType ) {
                         Expression *expr = new NameExpr( sizeofName( mangleType( dynType ) ) );
                         return expr;
-                } else {
-                        return Mutator::mutate( szeof );
                 } // if
+                return szeof;
         }
 
-        Expression * ScrubTyVars::mutate( AlignofExpr *algnof ) {
+        Expression * ScrubTyVars::postmutate( AlignofExpr * algnof ) {
                 // alignof( T ) => _alignof_T parameter, which is the alignment of T
-                if ( Type *dynType = shouldScrub( algnof->get_type() ) ) {
+                if ( dynType ) {
                         Expression *expr = new NameExpr( alignofName( mangleType( dynType ) ) );
                         return expr;
-                } else {
-                        return Mutator::mutate( algnof );
                 } // if
+                return algnof;
         }
 
-        Type * ScrubTyVars::mutate( PointerType *pointer ) {
-//              // special case of shouldScrub that takes all TypeInstType pointer bases, even if they're not dynamic
-//              Type *base = pointer->get_base();
-//              Type *dynType = 0;
-//              if ( dynamicOnly ) {
-//                      if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( base ) ) {
-//                              if ( tyVars.find( typeInst->get_name() ) != tyVars.end() ) { dynType = typeInst; }
-//                      } else {
-//                              dynType = isDynType( base, tyVars );
-//                      }
-//              } else {
-//                      dynType = isPolyType( base, tyVars );
-//              }
-//              if ( dynType ) {
-                if ( Type *dynType = shouldScrub( pointer->get_base() ) ) {
-                        Type *ret = dynType->acceptMutator( *this );
+        Type * ScrubTyVars::postmutate( PointerType * pointer ) {
+                if ( dynType ) {
+                        Type * ret = dynType->acceptMutator( *visitor );
                         ret->get_qualifiers() |= pointer->get_qualifiers();
-                        pointer->set_base( 0 );
+                        pointer->base = nullptr;
                         delete pointer;
                         return ret;
                 }
-                return Mutator::mutate( pointer );
+                return pointer;
         }
 } // namespace GenPoly

src/GenPoly/ScrubTyVars.h

@@ -18 +18 @@
 #include <cassert>            // for assert
 
+#include "Common/PassVisitor.h"
 #include "GenPoly.h"          // for TyVarMap, isPolyType, isDynType
 #include "SynTree/Mutator.h"  // for Mutator
@@ -27 +28 @@
 
 namespace GenPoly {
-        class ScrubTyVars : public Mutator {
+        struct ScrubTyVars : public WithVisitorRef<ScrubTyVars>, public WithShortCircuiting, public WithGuards {
                 /// Whether to scrub all type variables from the provided map, dynamic type variables from the provided map, or all type variables
                 enum ScrubMode { FromMap, DynamicFromMap, All };
@@ -51 +52 @@
                 static SynTreeClass *scrubAll( SynTreeClass *target );
 
-                virtual Type* mutate( TypeInstType *typeInst );
-                virtual Type* mutate( StructInstType *structInst );
-                virtual Type* mutate( UnionInstType *unionInst );
-                virtual Expression* mutate( SizeofExpr *szeof );
-                virtual Expression* mutate( AlignofExpr *algnof );
-                virtual Type* mutate( PointerType *pointer );
+                /// determine if children should be visited based on whether base type should be scrubbed.
+                void primeBaseScrub( Type * );
+
+                void premutate( TypeInstType * ) { visit_children = false; }
+                void premutate( StructInstType * ) { visit_children = false; }
+                void premutate( UnionInstType * ) { visit_children = false; }
+                void premutate( SizeofExpr * szeof ) { primeBaseScrub( szeof->type ); }
+                void premutate( AlignofExpr * algnof ) { primeBaseScrub( algnof->type ); }
+                void premutate( PointerType * pointer ) { primeBaseScrub( pointer->base ); }
+
+                Type * postmutate( TypeInstType * typeInst );
+                Type * postmutate( StructInstType * structInst );
+                Type * postmutate( UnionInstType * unionInst );
+                Expression * postmutate( SizeofExpr * szeof );
+                Expression * postmutate( AlignofExpr * algnof );
+                Type * postmutate( PointerType * pointer );
 
           private:
@@ -75 +86 @@
                 const TyVarMap *tyVars;  ///< Type variables to scrub
                 ScrubMode mode;          ///< which type variables to scrub? [FromMap]
+
+                Type * dynType = nullptr; ///< result of shouldScrub
         };
 
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrub( SynTreeClass *target, const TyVarMap &tyVars ) {
-                ScrubTyVars scrubber( tyVars );
+                PassVisitor<ScrubTyVars> scrubber( tyVars );
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }
@@ -85 +98 @@
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrubDynamic( SynTreeClass *target, const TyVarMap &tyVars ) {
-                ScrubTyVars scrubber( tyVars, ScrubTyVars::DynamicFromMap );
+                PassVisitor<ScrubTyVars> scrubber( tyVars, ScrubTyVars::DynamicFromMap );
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }
@@ -91 +104 @@
         template< typename SynTreeClass >
         SynTreeClass * ScrubTyVars::scrubAll( SynTreeClass *target ) {
-                ScrubTyVars scrubber;
+                PassVisitor<ScrubTyVars> scrubber;
                 return static_cast< SynTreeClass * >( target->acceptMutator( scrubber ) );
         }

src/InitTweak/FixInit.cc

@@ -197 +197 @@
                 };
 
-                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer {
+                struct GenStructMemberCalls final : public WithGuards, public WithShortCircuiting, public WithIndexer, public WithVisitorRef<GenStructMemberCalls> {
                         /// generate default/copy ctor and dtor calls for user-defined struct ctor/dtors
                         /// for any member that is missing a corresponding ctor/dtor call.
@@ -203 +203 @@
                         static void generate( std::list< Declaration * > & translationUnit );
 
-                        void previsit( FunctionDecl * funcDecl );
-                        void postvisit( FunctionDecl * funcDecl );
-
-                        void previsit( MemberExpr * memberExpr );
-                        void previsit( ApplicationExpr * appExpr );
+                        void premutate( FunctionDecl * funcDecl );
+                        DeclarationWithType * postmutate( FunctionDecl * funcDecl );
+
+                        void premutate( MemberExpr * memberExpr );
+                        void premutate( ApplicationExpr * appExpr );
+
+                        /// Note: this post mutate used to be in a separate visitor. If this pass breaks, one place to examine is whether it is
+                        /// okay for this part of the recursion to occur alongside the rest.
+                        Expression * postmutate( UntypedExpr * expr );
 
                         SemanticError errors;
@@ -220 +224 @@
                         bool isCtor = false; // true if current function is a constructor
                         StructDecl * structDecl = nullptr;
-                };
-
-                // very simple resolver-like mutator class - used to
-                // resolve UntypedExprs that are found within newly
-                // generated constructor/destructor calls
-                class MutatingResolver final : public Mutator {
-                  public:
-                        MutatingResolver( SymTab::Indexer & indexer ) : indexer( indexer ) {}
-
-                        using Mutator::mutate;
-                        virtual DeclarationWithType* mutate( ObjectDecl *objectDecl ) override;
-                        virtual Expression* mutate( UntypedExpr *untypedExpr ) override;
-
-                  private:
-                        SymTab::Indexer & indexer;
                 };
 
@@ -315 +304 @@
                 void GenStructMemberCalls::generate( std::list< Declaration * > & translationUnit ) {
                         PassVisitor<GenStructMemberCalls> warner;
-                        acceptAll( translationUnit, warner );
+                        mutateAll( translationUnit, warner );
                 }
 
@@ -950 +939 @@
                 }
 
-                void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
+                void GenStructMemberCalls::premutate( FunctionDecl * funcDecl ) {
                         GuardValue( function );
                         GuardValue( unhandled );
@@ -984 +973 @@
                 }
 
-                void GenStructMemberCalls::postvisit( FunctionDecl * funcDecl ) {
+                DeclarationWithType * GenStructMemberCalls::postmutate( FunctionDecl * funcDecl ) {
                         // remove the unhandled objects from usedUninit, because a call is inserted
                         // to handle them - only objects that are later constructed are used uninitialized.
@@ -1038 +1027 @@
                                                 Statement * callStmt = stmt.front();
 
-                                                MutatingResolver resolver( indexer );
                                                 try {
-                                                        callStmt->acceptMutator( resolver );
+                                                        callStmt->acceptMutator( *visitor );
                                                         if ( isCtor ) {
                                                                 function->get_statements()->push_front( callStmt );
@@ -1056 +1044 @@
                                 throw errors;
                         }
+                        return funcDecl;
                 }
 
@@ -1081 +1070 @@
                 }
 
-                void GenStructMemberCalls::previsit( ApplicationExpr * appExpr ) {
+                void GenStructMemberCalls::premutate( ApplicationExpr * appExpr ) {
                         if ( ! checkWarnings( function ) ) {
                                 visit_children = false;
@@ -1106 +1095 @@
                 }
 
-                void GenStructMemberCalls::previsit( MemberExpr * memberExpr ) {
+                void GenStructMemberCalls::premutate( MemberExpr * memberExpr ) {
                         if ( ! checkWarnings( function ) || ! isCtor ) {
                                 visit_children = false;
@@ -1134 +1123 @@
                 }
 
-                DeclarationWithType * MutatingResolver::mutate( ObjectDecl * objectDecl ) {
-                        // add object to the indexer assumes that there will be no name collisions
-                        // in generated code. If this changes, add mutate methods for entities with
-                        // scope and call {enter,leave}Scope explicitly.
-                        indexer.addId( objectDecl );
-                        return objectDecl;
-                }
-
-                Expression * MutatingResolver::mutate( UntypedExpr * untypedExpr ) {
+                Expression * GenStructMemberCalls::postmutate( UntypedExpr * untypedExpr ) {
                         Expression * newExpr = untypedExpr;
                         ResolvExpr::findVoidExpression( newExpr, indexer );

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/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/Resolver.cc

@@ -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/SynTree/AggregateDecl.cc

@@ -92 +92 @@
                 } else if ( ConstantExpr * constExpr = dynamic_cast< ConstantExpr * >( expr ) ) {
                         return constExpr->intValue();
+                // can be -1, +1, etc.
+                // } else if ( UntypedExpr * untypedExpr = dynamic_cast< UntypedExpr * >( expr ) ) {
+                //      if ( untypedExpr-> )
                 } else {
                         assertf( false, "Unhandled expression type in getConstValue for enumerators: %s", toString( expr ).c_str() );

src/SynTree/Expression.cc

@@ -108 +108 @@
         //      assert( inst->baseEnum );
         //      EnumDecl * decl = inst->baseEnum;
-        //      for ( Declaration * member : decl->members ) {
-        //              if ( member == _var ) {
-        //                      type->set_lvalue( false );
-        //              }
+        //      long long int value;
+        //      if ( decl->valueOf( var, value ) ) {
+        //              type->set_lvalue( false );
         //      }
         // }
@@ -416 +415 @@
                 } else {
                         // references have been removed, in which case dereference returns an lvalue of the base type.
-                        ret->get_result()->set_lvalue( true );
+                        ret->result->set_lvalue( true );
                 }
         }

src/SynTree/Label.h

@@ -33 +33 @@
         std::list< Attribute * >& get_attributes() { return attributes; }
 
-        operator std::string() { return name; }
+        operator std::string() const { return name; }
         bool empty() { return name.empty(); }
   private:

src/SynTree/TypeSubstitution.cc

@@ -107 +107 @@
 
 void TypeSubstitution::normalize() {
+        PassVisitor<Substituter> sub( *this, true );
         do {
-                subCount = 0;
-                freeOnly = true;
+                sub.pass.subCount = 0;
+                sub.pass.freeOnly = true;
                 for ( TypeEnvType::iterator i = typeEnv.begin(); i != typeEnv.end(); ++i ) {
-                        i->second = i->second->acceptMutator( *this );
+                        i->second = i->second->acceptMutator( sub );
                 }
-        } while ( subCount );
-}
-
-Type * TypeSubstitution::mutate( TypeInstType *inst ) {
-        BoundVarsType::const_iterator bound = boundVars.find( inst->get_name() );
+        } while ( sub.pass.subCount );
+}
+
+Type * TypeSubstitution::Substituter::postmutate( TypeInstType *inst ) {
+        BoundVarsType::const_iterator bound = boundVars.find( inst->name );
         if ( bound != boundVars.end() ) return inst;
 
-        TypeEnvType::const_iterator i = typeEnv.find( inst->get_name() );
-        if ( i == typeEnv.end() ) {
+        TypeEnvType::const_iterator i = sub.typeEnv.find( inst->get_name() );
+        if ( i == sub.typeEnv.end() ) {
                 return inst;
         } else {
-///         std::cout << "found " << inst->get_name() << ", replacing with ";
-///         i->second->print( std::cout );
-///         std::cout << std::endl;
+///         std::cerr << "found " << inst->get_name() << ", replacing with ";
+///         i->second->print( std::cerr );
+///         std::cerr << std::endl;
                 subCount++;
-                Type *newtype = i->second->clone();
+                Type * newtype = i->second->clone();
                 newtype->get_qualifiers() |= inst->get_qualifiers();
                 delete inst;
@@ -135 +136 @@
 }
 
-Expression * TypeSubstitution::mutate( NameExpr *nameExpr ) {
-        VarEnvType::const_iterator i = varEnv.find( nameExpr->get_name() );
-        if ( i == varEnv.end() ) {
+Expression * TypeSubstitution::Substituter::postmutate( NameExpr * nameExpr ) {
+        VarEnvType::const_iterator i = sub.varEnv.find( nameExpr->name );
+        if ( i == sub.varEnv.end() ) {
                 return nameExpr;
         } else {
@@ -146 +147 @@
 }
 
-template< typename TypeClass >
-Type *TypeSubstitution::handleType( TypeClass *type ) {
-        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
+void TypeSubstitution::Substituter::premutate( Type * type ) {
+        GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar )->get_name() );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
         } // if
-        Type *ret = Mutator::mutate( type );
-        return ret;
 }
 
 template< typename TypeClass >
-Type *TypeSubstitution::handleAggregateType( TypeClass *type ) {
-        ValueGuard<BoundVarsType> oldBoundVars( boundVars );
+void TypeSubstitution::Substituter::handleAggregateType( TypeClass * type ) {
+        GuardValue( boundVars );
         // bind type variables from forall-qualifiers
         if ( freeOnly ) {
-                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
-                        boundVars.insert( (*tyvar )->get_name() );
+                for ( Type::ForallList::const_iterator tyvar = type->forall.begin(); tyvar != type->forall.end(); ++tyvar ) {
+                        boundVars.insert( (*tyvar)->name );
                 } // for
                 // bind type variables from generic type instantiations
                 std::list< TypeDecl* > *baseParameters = type->get_baseParameters();
-                if ( baseParameters && ! type->get_parameters().empty() ) {
+                if ( baseParameters && ! type->parameters.empty() ) {
                         for ( std::list< TypeDecl* >::const_iterator tyvar = baseParameters->begin(); tyvar != baseParameters->end(); ++tyvar ) {
-                                boundVars.insert( (*tyvar)->get_name() );
+                                boundVars.insert( (*tyvar)->name );
                         } // for
                 } // if
         } // if
-        Type *ret = Mutator::mutate( type );
-        return ret;
-}
-
-Type * TypeSubstitution::mutate( VoidType *voidType ) {
-        return handleType( voidType );
-}
-
-Type * TypeSubstitution::mutate( BasicType *basicType ) {
-        return handleType( basicType );
-}
-
-Type * TypeSubstitution::mutate( PointerType *pointerType ) {
-        return handleType( pointerType );
-}
-
-Type * TypeSubstitution::mutate( ArrayType *arrayType ) {
-        return handleType( arrayType );
-}
-
-Type * TypeSubstitution::mutate( FunctionType *functionType ) {
-        return handleType( functionType );
-}
-
-Type * TypeSubstitution::mutate( StructInstType *aggregateUseType ) {
-        return handleAggregateType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( UnionInstType *aggregateUseType ) {
-        return handleAggregateType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( EnumInstType *aggregateUseType ) {
-        return handleType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( TraitInstType *aggregateUseType ) {
-        return handleType( aggregateUseType );
-}
-
-Type * TypeSubstitution::mutate( TupleType *tupleType ) {
-        return handleType( tupleType );
-}
-
-Type * TypeSubstitution::mutate( VarArgsType *varArgsType ) {
-        return handleType( varArgsType );
-}
-
-Type * TypeSubstitution::mutate( ZeroType *zeroType ) {
-        return handleType( zeroType );
-}
-
-Type * TypeSubstitution::mutate( OneType *oneType ) {
-        return handleType( oneType );
+}
+
+void TypeSubstitution::Substituter::premutate( StructInstType * aggregateUseType ) {
+        handleAggregateType( aggregateUseType );
+}
+
+void TypeSubstitution::Substituter::premutate( UnionInstType *aggregateUseType ) {
+        handleAggregateType( aggregateUseType );
 }
 

src/SynTree/TypeSubstitution.h

@@ -27 +27 @@
 #include "SynTree/Declaration.h"   // for TypeDecl, Declaration (ptr only)
 #include "SynTree/Expression.h"    // for Expression (ptr only), NameExpr (p...
-#include "SynTree/Mutator.h"       // for Mutator
 #include "SynTree/Type.h"          // for Type, ArrayType (ptr only), BasicT...
 
-class TypeSubstitution : public Mutator {
-        typedef Mutator Parent;
+class TypeSubstitution {
   public:
         TypeSubstitution();
@@ -64 +62 @@
         TypeSubstitution *clone() const { return new TypeSubstitution( *this ); }
   private:
-        virtual Type* mutate(TypeInstType *aggregateUseType);
-        virtual Expression* mutate(NameExpr *nameExpr);
 
-        /// Records type variable bindings from forall-statements
-        template< typename TypeClass > Type *handleType( TypeClass *type );
-        /// Records type variable bindings from forall-statements and instantiations of generic types
-        template< typename TypeClass > Type *handleAggregateType( TypeClass *type );
-
-        virtual Type* mutate(VoidType *basicType);
-        virtual Type* mutate(BasicType *basicType);
-        virtual Type* mutate(PointerType *pointerType);
-        virtual Type* mutate(ArrayType *arrayType);
-        virtual Type* mutate(FunctionType *functionType);
-        virtual Type* mutate(StructInstType *aggregateUseType);
-        virtual Type* mutate(UnionInstType *aggregateUseType);
-        virtual Type* mutate(EnumInstType *aggregateUseType);
-        virtual Type* mutate(TraitInstType *aggregateUseType);
-        virtual Type* mutate(TupleType *tupleType);
-        virtual Type* mutate(VarArgsType *varArgsType);
-        virtual Type* mutate(ZeroType *zeroType);
-        virtual Type* mutate(OneType *oneType);
+        // Mutator that performs the substitution
+        struct Substituter;
 
         // TODO: worry about traversing into a forall-qualified function type or type decl with assertions
@@ -97 +77 @@
         typedef std::map< std::string, Type* > TypeEnvType;
         typedef std::map< std::string, Expression* > VarEnvType;
-        typedef std::set< std::string > BoundVarsType;
         TypeEnvType typeEnv;
         VarEnvType varEnv;
-        BoundVarsType boundVars;
-        int subCount;
-        bool freeOnly;
 };
 
@@ -134 +110 @@
 
 template< typename FormalIterator, typename ActualIterator >
-TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin )
-{
+TypeSubstitution::TypeSubstitution( FormalIterator formalBegin, FormalIterator formalEnd, ActualIterator actualBegin ) {
         add( formalBegin, formalEnd, actualBegin );
 }
+
+// include needs to happen after TypeSubstitution is defined so that both TypeSubstitution and
+// PassVisitor are defined before PassVisitor implementation accesses TypeSubstitution internals.
+#include "Common/PassVisitor.h"
+
+// definitition must happen after PassVisitor is included so that WithGuards can be used
+struct TypeSubstitution::Substituter : public WithGuards {
+                Substituter( TypeSubstitution & sub, bool freeOnly ) : sub( sub ), freeOnly( freeOnly ) {}
+
+                Type * postmutate( TypeInstType * aggregateUseType );
+                Expression * postmutate( NameExpr * nameExpr );
+
+                /// Records type variable bindings from forall-statements
+                void premutate( Type * type );
+                /// Records type variable bindings from forall-statements and instantiations of generic types
+                template< typename TypeClass > void handleAggregateType( TypeClass * type );
+
+                void premutate( StructInstType * aggregateUseType );
+                void premutate( UnionInstType * aggregateUseType );
+
+                TypeSubstitution & sub;
+                int subCount = 0;
+                bool freeOnly;
+                typedef std::set< std::string > BoundVarsType;
+                BoundVarsType boundVars;
+};
 
 template< typename SynTreeClass >
 int TypeSubstitution::apply( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = false;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+        PassVisitor<Substituter> sub( *this, false );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
         assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 
@@ -155 +155 @@
 int TypeSubstitution::applyFree( SynTreeClass *&input ) {
         assert( input );
-        subCount = 0;
-        freeOnly = true;
-        input = dynamic_cast< SynTreeClass *>( input->acceptMutator( *this ) );
+        PassVisitor<Substituter> sub( *this, true );
+        input = dynamic_cast< SynTreeClass * >( input->acceptMutator( sub ) );
         assert( input );
-///     std::cout << "substitution result is: ";
-///     newType->print( std::cout );
-///     std::cout << std::endl;
-        return subCount;
+///     std::cerr << "substitution result is: ";
+///     newType->print( std::cerr );
+///     std::cerr << std::endl;
+        return sub.pass.subCount;
 }
 

src/Tuples/TupleExpansion.cc

@@ -36 +36 @@
 namespace Tuples {
         namespace {
-                struct MemberTupleExpander final : public Mutator {
-                        typedef Mutator Parent;
-                        using Parent::mutate;
-
-                        virtual Expression * mutate( UntypedMemberExpr * memberExpr ) override;
+                struct MemberTupleExpander final : public WithShortCircuiting, public WithVisitorRef<MemberTupleExpander> {
+                        void premutate( UntypedMemberExpr * ) { visit_children = false; }
+                        Expression * postmutate( UntypedMemberExpr * memberExpr );
                 };
 
@@ -79 +77 @@
 
         void expandMemberTuples( std::list< Declaration * > & translationUnit ) {
-                MemberTupleExpander expander;
+                PassVisitor<MemberTupleExpander> expander;
                 mutateAll( translationUnit, expander );
         }
@@ -109 +107 @@
                                 // construct a new UntypedMemberExpr with the correct structure , and recursively
                                 // expand that member expression.
-                                MemberTupleExpander expander;
-                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->get_aggregate(), aggr->clone() );
-                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member(), inner );
+                                PassVisitor<MemberTupleExpander> expander;
+                                UntypedMemberExpr * inner = new UntypedMemberExpr( memberExpr->aggregate, aggr->clone() );
+                                UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member, inner );
                                 inner->location = newMemberExpr->location = loc;
-                                memberExpr->set_member(nullptr);
-                                memberExpr->set_aggregate(nullptr);
+                                memberExpr->member = nullptr;
+                                memberExpr->aggregate = nullptr;
                                 delete memberExpr;
                                 return newMemberExpr->acceptMutator( expander );
@@ -126 +124 @@
         }
 
-        Expression * MemberTupleExpander::mutate( UntypedMemberExpr * memberExpr ) {
-                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->get_member() ) ) {
-                        Expression * aggr = memberExpr->get_aggregate()->clone()->acceptMutator( *this );
+        Expression * MemberTupleExpander::postmutate( UntypedMemberExpr * memberExpr ) {
+                if ( UntypedTupleExpr * tupleExpr = dynamic_cast< UntypedTupleExpr * > ( memberExpr->member ) ) {
+                        Expression * aggr = memberExpr->aggregate->clone()->acceptMutator( *visitor );
                         // aggregate expressions which might be impure must be wrapped in unique expressions
                         // xxx - if there's a member-tuple expression nested in the aggregate, this currently generates the wrong code if a UniqueExpr is not used, and it's purely an optimization to remove the UniqueExpr
                         // if ( Tuples::maybeImpureIgnoreUnique( memberExpr->get_aggregate() ) ) aggr = new UniqueExpr( aggr );
                         aggr = new UniqueExpr( aggr );
-                        for ( Expression *& expr : tupleExpr->get_exprs() ) {
+                        for ( Expression *& expr : tupleExpr->exprs ) {
                                 expr = reconstructMemberExpr( expr, aggr, memberExpr->location );
                                 expr->location = memberExpr->location;
@@ -143 +141 @@
                         // there may be a tuple expr buried in the aggregate
                         // xxx - this is a memory leak
-                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->get_member()->clone(), memberExpr->get_aggregate()->acceptMutator( *this ) );
+                        UntypedMemberExpr * newMemberExpr = new UntypedMemberExpr( memberExpr->member->clone(), memberExpr->aggregate->acceptMutator( *visitor ) );
                         newMemberExpr->location = memberExpr->location;
                         return newMemberExpr;

src/tests/Makefile.am

@@ -77 +77 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
 
-dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
-dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
-
 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
@@ -110 +104 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
 
-memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
-ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
@@ -124 +112 @@
 alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+# Constructor/destructor tests
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
+
+raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+

src/tests/Makefile.in

@@ -827 +827 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} ${<} -o ${@}
 
-dtor-early-exit-ERR1: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
-dtor-early-exit-ERR2: dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
-
 declarationSpecifier: declarationSpecifier.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -CFA -XCFA -p ${<} -o ${@}
@@ -860 +854 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -lgmp ${<} -o ${@}
 
-memberCtors-ERR1: memberCtors.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
-ctor-autogen-ERR1: ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
-        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
-
 completeTypeError : completeTypeError.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
@@ -873 +861 @@
 
 alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+# Constructor/destructor tests
+raii/dtor-early-exit-ERR1: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+raii/dtor-early-exit-ERR2: raii/dtor-early-exit.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR2 ${<} -o ${@}
+
+raii/memberCtors-ERR1: raii/memberCtors.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+raii/ctor-autogen-ERR1: raii/ctor-autogen.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}