Index: src/ResolvExpr/AdjustExprType.cc
===================================================================
--- src/ResolvExpr/AdjustExprType.cc	(revision d29fa5fd0f3ac4c642952b5485abba72c11fb998)
+++ src/ResolvExpr/AdjustExprType.cc	(revision 93fe71415c43a87afa87a0b68520b22c26540814)
@@ -14,4 +14,5 @@
 //
 
+#include "Common/PassVisitor.h"
 #include "SymTab/Indexer.h"       // for Indexer
 #include "SynTree/Declaration.h"  // for TypeDecl, TypeDecl::Kind::Ftype
@@ -21,25 +22,26 @@
 
 namespace ResolvExpr {
-	class AdjustExprType : public Mutator {
-		typedef Mutator Parent;
-		using Parent::mutate;
+	class AdjustExprType : public WithShortCircuiting {
 	  public:
 		AdjustExprType( const TypeEnvironment &env, const SymTab::Indexer &indexer );
+		void premutate( VoidType * ) { visit_children = false; }
+		void premutate( BasicType * ) { visit_children = false; }
+		void premutate( PointerType * ) { visit_children = false; }
+		void premutate( FunctionType * ) { visit_children = false; }
+		void premutate( StructInstType * ) { visit_children = false; }
+		void premutate( UnionInstType * ) { visit_children = false; }
+		void premutate( EnumInstType * ) { visit_children = false; }
+		void premutate( TraitInstType * ) { visit_children = false; }
+		void premutate( TypeInstType * ) { visit_children = false; }
+		void premutate( TupleType * ) { visit_children = false; }
+		void premutate( VarArgsType * ) { visit_children = false; }
+		void premutate( ZeroType * ) { visit_children = false; }
+		void premutate( OneType * ) { visit_children = false; }
+
+		Type * postmutate( ArrayType *arrayType );
+		Type * postmutate( FunctionType *functionType );
+		Type * postmutate( TypeInstType *aggregateUseType );
+
 	  private:
-		virtual Type* mutate( VoidType *voidType );
-		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( TypeInstType *aggregateUseType );
-		virtual Type* mutate( TupleType *tupleType );
-		virtual Type* mutate( VarArgsType *varArgsType );
-		virtual Type* mutate( ZeroType *zeroType );
-		virtual Type* mutate( OneType *oneType );
-
 		const TypeEnvironment &env;
 		const SymTab::Indexer &indexer;
@@ -47,5 +49,5 @@
 
 	void adjustExprType( Type *&type, const TypeEnvironment &env, const SymTab::Indexer &indexer ) {
-		AdjustExprType adjuster( env, indexer );
+		PassVisitor<AdjustExprType> adjuster( env, indexer );
 		Type *newType = type->acceptMutator( adjuster );
 		type = newType;
@@ -56,45 +58,17 @@
 	}
 
-	Type *AdjustExprType::mutate( VoidType *voidType ) {
-		return voidType;
-	}
-
-	Type *AdjustExprType::mutate( BasicType *basicType ) {
-		return basicType;
-	}
-
-	Type *AdjustExprType::mutate( PointerType *pointerType ) {
-		return pointerType;
-	}
-
-	Type *AdjustExprType::mutate( ArrayType *arrayType ) {
+	Type * AdjustExprType::postmutate( ArrayType * arrayType ) {
 		// need to recursively mutate the base type in order for multi-dimensional arrays to work.
-		PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->get_base()->clone()->acceptMutator( *this ) );
+		PointerType *pointerType = new PointerType( arrayType->get_qualifiers(), arrayType->base );
+		arrayType->base = nullptr;
 		delete arrayType;
 		return pointerType;
 	}
 
-	Type *AdjustExprType::mutate( FunctionType *functionType ) {
-		PointerType *pointerType = new PointerType( Type::Qualifiers(), functionType );
-		return pointerType;
+	Type * AdjustExprType::postmutate( FunctionType * functionType ) {
+		return new PointerType( Type::Qualifiers(), functionType );
 	}
 
-	Type *AdjustExprType::mutate( StructInstType *aggregateUseType ) {
-		return aggregateUseType;
-	}
-
-	Type *AdjustExprType::mutate( UnionInstType *aggregateUseType ) {
-		return aggregateUseType;
-	}
-
-	Type *AdjustExprType::mutate( EnumInstType *aggregateUseType ) {
-		return aggregateUseType;
-	}
-
-	Type *AdjustExprType::mutate( TraitInstType *aggregateUseType ) {
-		return aggregateUseType;
-	}
-
-	Type *AdjustExprType::mutate( TypeInstType *typeInst ) {
+	Type * AdjustExprType::postmutate( TypeInstType * typeInst ) {
 		EqvClass eqvClass;
 		if ( env.lookup( typeInst->get_name(), eqvClass ) ) {
@@ -113,20 +87,4 @@
 		return typeInst;
 	}
-
-	Type *AdjustExprType::mutate( TupleType *tupleType ) {
-		return tupleType;
-	}
-
-	Type *AdjustExprType::mutate( VarArgsType *varArgsType ) {
-		return varArgsType;
-	}
-
-	Type *AdjustExprType::mutate( ZeroType *zeroType ) {
-		return zeroType;
-	}
-
-	Type *AdjustExprType::mutate( OneType *oneType ) {
-		return oneType;
-	}
 } // namespace ResolvExpr
 
