Index: src/ResolvExpr/AdjustExprType.cc
===================================================================
--- src/ResolvExpr/AdjustExprType.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/AdjustExprType.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -23,10 +23,10 @@
 
 namespace {
-	class AdjustExprType_new final : public ast::WithShortCircuiting {
+	class AdjustExprType final : public ast::WithShortCircuiting {
 		const ast::SymbolTable & symtab;
 	public:
 		const ast::TypeEnvironment & tenv;
 
-		AdjustExprType_new( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
+		AdjustExprType( const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
 		: symtab( syms ), tenv( e ) {}
 
@@ -75,5 +75,5 @@
 	const ast::Type * type, const ast::TypeEnvironment & env, const ast::SymbolTable & symtab
 ) {
-	ast::Pass<AdjustExprType_new> adjuster{ env, symtab };
+	ast::Pass<AdjustExprType> adjuster{ env, symtab };
 	return type->accept( adjuster );
 }
Index: src/ResolvExpr/AdjustExprType.hpp
===================================================================
--- src/ResolvExpr/AdjustExprType.hpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/AdjustExprType.hpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,8 +16,4 @@
 #pragma once
 
-class Type;
-namespace SymTab {
-	class Indexer;
-}
 namespace ast {
 	class SymbolTable;
@@ -27,19 +23,4 @@
 
 namespace ResolvExpr {
-
-class TypeEnvironment;
-
-/// Replaces array types with the equivalent pointer, and function types with a pointer-to-function
-void adjustExprType( Type *& type, const TypeEnvironment & env, const SymTab::Indexer & indexer );
-
-/// Replaces array types with the equivalent pointer, and function types with a pointer-to-function using empty TypeEnvironment and Indexer.
-void adjustExprType( Type *& type );
-
-template< typename ForwardIterator >
-void adjustExprTypeList( ForwardIterator begin, ForwardIterator end, const TypeEnvironment & env, const SymTab::Indexer & indexer ) {
-	while ( begin != end ) {
-		adjustExprType( *begin++, env, indexer );
-	} // while
-}
 
 /// Replaces array types with equivalent pointer,
Index: src/ResolvExpr/CandidateFinder.cpp
===================================================================
--- src/ResolvExpr/CandidateFinder.cpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/CandidateFinder.cpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -61,5 +61,5 @@
 namespace {
 	/// First index is which argument, second is which alternative, third is which exploded element
-	using ExplodedArgs_new = std::deque< std::vector< ExplodedArg > >;
+	using ExplodedArgs = std::deque< std::vector< ExplodedArg > >;
 
 	/// Returns a list of alternatives with the minimum cost in the given list
@@ -255,5 +255,5 @@
 
 		/// Gets the list of exploded candidates for this pack
-		const ExplodedArg & getExpl( const ExplodedArgs_new & args ) const {
+		const ExplodedArg & getExpl( const ExplodedArgs & args ) const {
 			return args[ nextArg-1 ][ explAlt ];
 		}
@@ -281,5 +281,5 @@
 	bool instantiateArgument(
 		const CodeLocation & location,
-		const ast::Type * paramType, const ast::Init * init, const ExplodedArgs_new & args,
+		const ast::Type * paramType, const ast::Init * init, const ExplodedArgs & args,
 		std::vector< ArgPack > & results, std::size_t & genStart, const ast::SymbolTable & symtab,
 		unsigned nTuples = 0
@@ -618,5 +618,5 @@
 			const CodeLocation & location,
 			const CandidateRef & func, const ast::FunctionType * funcType,
-			const ExplodedArgs_new & args, CandidateList & out );
+			const ExplodedArgs & args, CandidateList & out );
 
 		/// Adds implicit struct-conversions to the alternative list
@@ -737,5 +737,5 @@
 		const CodeLocation & location,
 		const CandidateRef & func, const ast::FunctionType * funcType,
-		const ExplodedArgs_new & args, CandidateList & out
+		const ExplodedArgs & args, CandidateList & out
 	) {
 		ast::OpenVarSet funcOpen;
@@ -997,5 +997,5 @@
 
 		// pre-explode arguments
-		ExplodedArgs_new argExpansions;
+		ExplodedArgs argExpansions;
 		for ( const CandidateFinder & args : argCandidates ) {
 			argExpansions.emplace_back();
Index: src/ResolvExpr/CastCost.cc
===================================================================
--- src/ResolvExpr/CastCost.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/CastCost.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -26,5 +26,4 @@
 #include "ResolvExpr/ConversionCost.h"   // for conversionCost
 #include "ResolvExpr/PtrsCastable.hpp"   // for ptrsCastable
-#include "ResolvExpr/typeops.h"          // for ptrsCastable
 #include "ResolvExpr/Unify.h"            // for typesCompatibleIgnoreQualifiers
 
@@ -38,12 +37,12 @@
 
 namespace {
-	struct CastCost_new : public ConversionCost_new {
-		using ConversionCost_new::previsit;
-		using ConversionCost_new::postvisit;
+	struct CastCost : public ConversionCost {
+		using ConversionCost::previsit;
+		using ConversionCost::postvisit;
 
-		CastCost_new(
+		CastCost(
 			const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
 			const ast::TypeEnvironment & env, CostCalculation costFunc )
-		: ConversionCost_new( dst, srcIsLvalue, symtab, env, costFunc ) {}
+		: ConversionCost( dst, srcIsLvalue, symtab, env, costFunc ) {}
 
 		void postvisit( const ast::BasicType * basicType ) {
@@ -85,13 +84,4 @@
 	};
 
-	#warning For overload resolution between the two versions.
-	int localPtrsCastable(const ast::Type * t1, const ast::Type * t2,
-			const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) {
-		return ptrsCastable( t1, t2, symtab, env );
-	}
-	Cost localCastCost(
-		const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-		const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-	) { return castCost( src, dst, srcIsLvalue, symtab, env ); }
 } // anonymous namespace
 
@@ -136,11 +126,9 @@
 	} else if ( auto refType = dynamic_cast< const ast::ReferenceType * >( dst ) ) {
 		PRINT( std::cerr << "conversionCost: dest is reference" << std::endl; )
-		#warning cast on ptrsCastable artifact of having two functions, remove when port done
 		return convertToReferenceCost(
-			src, refType, srcIsLvalue, symtab, env, localPtrsCastable );
+			src, refType, srcIsLvalue, symtab, env, ptrsCastable );
 	} else {
-		#warning cast on castCost artifact of having two functions, remove when port done
-		ast::Pass< CastCost_new > converter(
-			dst, srcIsLvalue, symtab, env, localCastCost );
+		ast::Pass< CastCost > converter(
+			dst, srcIsLvalue, symtab, env, castCost );
 		src->accept( converter );
 		return converter.core.cost;
Index: src/ResolvExpr/CastCost.hpp
===================================================================
--- src/ResolvExpr/CastCost.hpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/CastCost.hpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -18,8 +18,4 @@
 #include "ResolvExpr/Cost.h"     // for Cost
 
-class Type;
-namespace SymTab {
-	class Indexer;
-}
 namespace ast {
 	class SymbolTable;
@@ -30,9 +26,4 @@
 namespace ResolvExpr {
 
-class TypeEnvironment;
-
-Cost castCost(
-	const Type * src, const Type * dest, bool srcIsLvalue,
-	const SymTab::Indexer & indexer, const TypeEnvironment & env );
 Cost castCost(
 	const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
Index: src/ResolvExpr/CommonType.cc
===================================================================
--- src/ResolvExpr/CommonType.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/CommonType.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -343,5 +343,5 @@
 	);
 
-	class CommonType_new final : public ast::WithShortCircuiting {
+	class CommonType final : public ast::WithShortCircuiting {
 		const ast::Type * type2;
 		WidenMode widen;
@@ -354,5 +354,5 @@
 		ast::ptr< ast::Type > result;
 
-		CommonType_new(
+		CommonType(
 			const ast::Type * t2, WidenMode w,
 			ast::TypeEnvironment & env, const ast::OpenVarSet & o,
@@ -388,5 +388,4 @@
 					result = enumDecl->base.get();
 				} else {
-					#warning remove casts when `commonTypes` moved to new AST
 					ast::BasicType::Kind kind = commonTypes[ basic->kind ][ ast::BasicType::SignedInt ];
 					if (
@@ -739,5 +738,5 @@
 	};
 
-	// size_t CommonType_new::traceId = Stats::Heap::new_stacktrace_id("CommonType_new");
+	// size_t CommonType::traceId = Stats::Heap::new_stacktrace_id("CommonType");
 	namespace {
 		ast::ptr< ast::Type > handleReference(
@@ -811,5 +810,5 @@
 		}
 		// otherwise both are reference types of the same depth and this is handled by the visitor
-		ast::Pass<CommonType_new> visitor{ type2, widen, env, open, need, have };
+		ast::Pass<CommonType> visitor{ type2, widen, env, open, need, have };
 		type1->accept( visitor );
 		// ast::ptr< ast::Type > result = visitor.core.result;
Index: src/ResolvExpr/ConversionCost.cc
===================================================================
--- src/ResolvExpr/ConversionCost.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/ConversionCost.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -153,13 +153,8 @@
 
 namespace {
-	# warning For overload resolution between the two versions.
 	int localPtrsAssignable(const ast::Type * t1, const ast::Type * t2,
 			const ast::SymbolTable &, const ast::TypeEnvironment & env ) {
 		return ptrsAssignable( t1, t2, env );
 	}
-	Cost localConversionCost(
-		const ast::Type * src, const ast::Type * dst, bool srcIsLvalue,
-		const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
-	) { return conversionCost( src, dst, srcIsLvalue, symtab, env ); }
 }
 
@@ -191,5 +186,5 @@
 		return convertToReferenceCost( src, refType, srcIsLvalue, symtab, env, localPtrsAssignable );
 	} else {
-		return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
+		return ast::Pass<ConversionCost>::read( src, dst, srcIsLvalue, symtab, env, conversionCost );
 	}
 }
@@ -232,5 +227,5 @@
 			}
 		} else {
-			return ast::Pass<ConversionCost_new>::read( src, dst, srcIsLvalue, symtab, env, localConversionCost );
+			return ast::Pass<ConversionCost>::read( src, dst, srcIsLvalue, symtab, env, conversionCost );
 		}
 	} else {
@@ -264,10 +259,10 @@
 }
 
-void ConversionCost_new::postvisit( const ast::VoidType * voidType ) {
+void ConversionCost::postvisit( const ast::VoidType * voidType ) {
 	(void)voidType;
 	cost = Cost::infinity;
 }
 
-void ConversionCost_new::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) {
+void ConversionCost::conversionCostFromBasicToBasic( const ast::BasicType * src, const ast::BasicType* dest ) {
 	int tableResult = costMatrix[ src->kind ][ dest->kind ];
 	if ( tableResult == -1 ) {
@@ -280,5 +275,5 @@
 }
 
-void ConversionCost_new::postvisit( const ast::BasicType * basicType ) {
+void ConversionCost::postvisit( const ast::BasicType * basicType ) {
 	if ( const ast::BasicType * dstAsBasic = dynamic_cast< const ast::BasicType * >( dst ) ) {
 		conversionCostFromBasicToBasic( basicType, dstAsBasic );
@@ -286,5 +281,5 @@
 		const ast::EnumDecl * enumDecl = enumInst->base.get();
 		if ( enumDecl->isTyped && !enumDecl->base.get() ) {
-			cost = Cost::infinity; 
+			cost = Cost::infinity;
 		} else if ( const ast::Type * enumType = enumDecl->base.get() ) {
 			if ( const ast::BasicType * enumTypeAsBasic = dynamic_cast<const ast::BasicType *>(enumType) ) {
@@ -299,5 +294,5 @@
 }
 
-void ConversionCost_new::postvisit( const ast::PointerType * pointerType ) {
+void ConversionCost::postvisit( const ast::PointerType * pointerType ) {
 	if ( const ast::PointerType * dstAsPtr = dynamic_cast< const ast::PointerType * >( dst ) ) {
 		ast::CV::Qualifiers tq1 = pointerType->base->qualifiers;
@@ -345,9 +340,9 @@
 }
 
-void ConversionCost_new::postvisit( const ast::ArrayType * arrayType ) {
+void ConversionCost::postvisit( const ast::ArrayType * arrayType ) {
 	(void)arrayType;
 }
 
-void ConversionCost_new::postvisit( const ast::ReferenceType * refType ) {
+void ConversionCost::postvisit( const ast::ReferenceType * refType ) {
 	assert( nullptr == dynamic_cast< const ast::ReferenceType * >( dst ) );
 
@@ -367,9 +362,9 @@
 }
 
-void ConversionCost_new::postvisit( const ast::FunctionType * functionType ) {
+void ConversionCost::postvisit( const ast::FunctionType * functionType ) {
 	(void)functionType;
 }
 
-void ConversionCost_new::postvisit( const ast::EnumInstType * enumInstType ) {
+void ConversionCost::postvisit( const ast::EnumInstType * enumInstType ) {
 	const ast::EnumDecl * baseEnum = enumInstType->base;
 	if ( const ast::Type * baseType = baseEnum->base ) {
@@ -384,9 +379,9 @@
 }
 
-void ConversionCost_new::postvisit( const ast::TraitInstType * traitInstType ) {
+void ConversionCost::postvisit( const ast::TraitInstType * traitInstType ) {
 	(void)traitInstType;
 }
 
-void ConversionCost_new::postvisit( const ast::TypeInstType * typeInstType ) {
+void ConversionCost::postvisit( const ast::TypeInstType * typeInstType ) {
 	if ( const ast::EqvClass * eqv = env.lookup( *typeInstType ) ) {
 		cost = costCalc( eqv->bound, dst, srcIsLvalue, symtab, env );
@@ -405,5 +400,5 @@
 }
 
-void ConversionCost_new::postvisit( const ast::TupleType * tupleType ) {
+void ConversionCost::postvisit( const ast::TupleType * tupleType ) {
 	Cost c = Cost::zero;
 	if ( const ast::TupleType * dstAsTuple = dynamic_cast< const ast::TupleType * >( dst ) ) {
@@ -427,5 +422,5 @@
 }
 
-void ConversionCost_new::postvisit( const ast::VarArgsType * varArgsType ) {
+void ConversionCost::postvisit( const ast::VarArgsType * varArgsType ) {
 	(void)varArgsType;
 	if ( dynamic_cast< const ast::VarArgsType * >( dst ) ) {
@@ -434,5 +429,5 @@
 }
 
-void ConversionCost_new::postvisit( const ast::ZeroType * zeroType ) {
+void ConversionCost::postvisit( const ast::ZeroType * zeroType ) {
 	(void)zeroType;
 	if ( dynamic_cast< const ast::ZeroType * >( dst ) ) {
@@ -461,10 +456,10 @@
 }
 
-void ConversionCost_new::postvisit( const ast::OneType * oneType ) {
+void ConversionCost::postvisit( const ast::OneType * oneType ) {
 	(void)oneType;
 	if ( dynamic_cast< const ast::OneType * >( dst ) ) {
 		cost = Cost::zero;
 	} else if ( const ast::BasicType * dstAsBasic =
-			dynamic_cast< const ast::BasicType * >( dst ) ) {		
+			dynamic_cast< const ast::BasicType * >( dst ) ) {
 		int tableResult = costMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ];
 		if ( -1 == tableResult ) {
@@ -475,9 +470,8 @@
 			cost.incSign( signMatrix[ ast::BasicType::SignedInt ][ dstAsBasic->kind ] );
 		}
-		
-		// cost = Cost::zero;
-	}
-}
-// size_t ConversionCost_new::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
+	}
+}
+
+// size_t ConversionCost::traceId = Stats::Heap::new_stacktrace_id("ConversionCost");
 
 } // namespace ResolvExpr
Index: src/ResolvExpr/ConversionCost.h
===================================================================
--- src/ResolvExpr/ConversionCost.h	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/ConversionCost.h	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -23,10 +23,5 @@
 #include "AST/Pass.hpp"       // for WithShortCircuiting
 
-namespace SymTab {
-	class Indexer;
-}  // namespace SymTab
-
 namespace ResolvExpr {
-	class TypeEnvironment;
 
 // Some function pointer types, differ in return type.
@@ -44,6 +39,5 @@
 	PtrsCalculation func );
 
-#warning when the old ConversionCost is removed, get ride of the _new suffix.
-class ConversionCost_new : public ast::WithShortCircuiting {
+class ConversionCost : public ast::WithShortCircuiting {
 protected:
 	const ast::Type * dst;
@@ -57,5 +51,5 @@
 	Cost result() { return cost; }
 
-	ConversionCost_new( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
+	ConversionCost( const ast::Type * dst, bool srcIsLvalue, const ast::SymbolTable & symtab,
 			const ast::TypeEnvironment & env, CostCalculation costCalc ) :
 		dst( dst ), srcIsLvalue( srcIsLvalue ), symtab( symtab ), env( env ),
Index: src/ResolvExpr/FindOpenVars.cc
===================================================================
--- src/ResolvExpr/FindOpenVars.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/FindOpenVars.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -25,5 +25,5 @@
 
 	namespace {
-		struct FindOpenVars_new final : public ast::WithGuards {
+		struct FindOpenVars final : public ast::WithGuards {
 			ast::OpenVarSet & open;
 			ast::OpenVarSet & closed;
@@ -33,5 +33,5 @@
 			bool nextIsOpen;
 
-			FindOpenVars_new(
+			FindOpenVars(
 				ast::OpenVarSet & o, ast::OpenVarSet & c, ast::AssertionSet & n,
 				ast::AssertionSet & h, ast::TypeEnvironment & env, FirstMode firstIsOpen )
@@ -73,5 +73,5 @@
 			const ast::Type * type, ast::OpenVarSet & open, ast::OpenVarSet & closed,
 			ast::AssertionSet & need, ast::AssertionSet & have, ast::TypeEnvironment & env, FirstMode firstIsOpen ) {
-		ast::Pass< FindOpenVars_new > finder{ open, closed, need, have, env, firstIsOpen };
+		ast::Pass< FindOpenVars > finder{ open, closed, need, have, env, firstIsOpen };
 		type->accept( finder );
 
Index: src/ResolvExpr/PolyCost.cc
===================================================================
--- src/ResolvExpr/PolyCost.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PolyCost.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -21,6 +21,5 @@
 namespace ResolvExpr {
 
-// TODO: When the old PolyCost is torn out get rid of the _new suffix.
-class PolyCost_new {
+class PolyCost {
 	const ast::SymbolTable &symtab;
 public:
@@ -28,5 +27,5 @@
 	const ast::TypeEnvironment &env_;
 
-	PolyCost_new( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
+	PolyCost( const ast::SymbolTable & symtab, const ast::TypeEnvironment & env ) 
 	: symtab( symtab ), result( 0 ), env_( env ) {}
 
@@ -49,5 +48,5 @@
 	const ast::Type * type, const ast::SymbolTable & symtab, const ast::TypeEnvironment & env
 ) {
-	ast::Pass<PolyCost_new> costing( symtab, env );
+	ast::Pass<PolyCost> costing( symtab, env );
 	type->accept( costing );
 	return (costing.core.result > 0) ? 1 : 0;
Index: src/ResolvExpr/PolyCost.hpp
===================================================================
--- src/ResolvExpr/PolyCost.hpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PolyCost.hpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,8 +16,4 @@
 #pragma once
 
-class Type;
-namespace SymTab {
-    class Indexer;
-}
 namespace ast {
     class SymbolTable;
@@ -28,8 +24,4 @@
 namespace ResolvExpr {
 
-class TypeEnvironment;
-
-int polyCost( Type * type,
-	const TypeEnvironment & env, const SymTab::Indexer & indexer );
 int polyCost( const ast::Type * type,
 	const ast::SymbolTable & symtab, const ast::TypeEnvironment & env );
Index: src/ResolvExpr/PtrsAssignable.cc
===================================================================
--- src/ResolvExpr/PtrsAssignable.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PtrsAssignable.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -22,14 +22,13 @@
 namespace ResolvExpr {
 
-// TODO: Get rid of the `_new` suffix when the old version is removed.
-struct PtrsAssignable_new : public ast::WithShortCircuiting {
+struct PtrsAssignable : public ast::WithShortCircuiting {
 	const ast::Type * dst;
 	const ast::TypeEnvironment & typeEnv;
 	int result;
 
-	PtrsAssignable_new( const ast::Type * dst, const ast::TypeEnvironment & env ) :
+	PtrsAssignable( const ast::Type * dst, const ast::TypeEnvironment & env ) :
 		dst( dst ), typeEnv( env ), result( 0 ) {}
 
-	void previsit( Type * ) { visit_children = false; }
+	void previsit( ast::Type * ) { visit_children = false; }
 
 	void postvisit( const ast::EnumInstType * ) {
@@ -63,5 +62,5 @@
 		return -1;
 	} else {
-		ast::Pass<PtrsAssignable_new> visitor( dst, env );
+		ast::Pass<PtrsAssignable> visitor( dst, env );
 		src->accept( visitor );
 		return visitor.core.result;
Index: src/ResolvExpr/PtrsAssignable.hpp
===================================================================
--- src/ResolvExpr/PtrsAssignable.hpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PtrsAssignable.hpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,5 +16,4 @@
 #pragma once
 
-class Type;
 namespace ast {
 	class Type;
@@ -24,8 +23,4 @@
 namespace ResolvExpr {
 
-class TypeEnvironment;
-
-int ptrsAssignable( const Type * src, const Type * dest,
-	const TypeEnvironment & env );
 int ptrsAssignable( const ast::Type * src, const ast::Type * dst,
 	const ast::TypeEnvironment & env );
Index: src/ResolvExpr/PtrsCastable.cc
===================================================================
--- src/ResolvExpr/PtrsCastable.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PtrsCastable.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -55,5 +55,5 @@
 	}
 
-	class PtrsCastable_new : public ast::WithShortCircuiting {
+	class PtrsCastable : public ast::WithShortCircuiting {
 		const ast::Type * dst;
 		const ast::TypeEnvironment & env;
@@ -62,5 +62,5 @@
 		int result;
 
-		PtrsCastable_new(
+		PtrsCastable(
 			const ast::Type * d, const ast::TypeEnvironment & e, const ast::SymbolTable & syms )
 		: dst( d ), env( e ), symtab( syms ), result( 0 ) {}
@@ -149,5 +149,5 @@
 		return objectCast( src, env, symtab );
 	} else {
-		return ast::Pass<PtrsCastable_new>::read( src, dst, env, symtab );
+		return ast::Pass<PtrsCastable>::read( src, dst, env, symtab );
 	}
 }
Index: src/ResolvExpr/PtrsCastable.hpp
===================================================================
--- src/ResolvExpr/PtrsCastable.hpp	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/PtrsCastable.hpp	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,8 +16,4 @@
 #pragma once
 
-class Type;
-namespace SymTab {
-    class Indexer;
-}
 namespace ast {
     class SymbolTable;
@@ -28,9 +24,4 @@
 namespace ResolvExpr {
 
-class TypeEnvironment;
-
-int ptrsCastable(
-	const Type * src, const Type * dst,
-	const TypeEnvironment & env, const SymTab::Indexer & indexer );
 int ptrsCastable(
 	const ast::Type * src, const ast::Type * dst,
Index: src/ResolvExpr/RenameVars.cc
===================================================================
--- src/ResolvExpr/RenameVars.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/RenameVars.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -101,5 +101,5 @@
 	RenamingData renaming;
 
-	struct RenameVars_new : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
+	struct RenameVars final : public ast::PureVisitor /*: public ast::WithForallSubstitutor*/ {
 		RenameMode mode;
 
@@ -132,5 +132,5 @@
 
 const ast::Type * renameTyVars( const ast::Type * t, RenameMode mode, bool reset ) {
-	ast::Pass<RenameVars_new> renamer;
+	ast::Pass<RenameVars> renamer;
 	renamer.core.mode = mode;
 	if (mode == GEN_USAGE && reset) {
Index: src/ResolvExpr/ResolveTypeof.cc
===================================================================
--- src/ResolvExpr/ResolveTypeof.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/ResolveTypeof.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -33,8 +33,8 @@
 
 namespace {
-struct ResolveTypeof_new : public ast::WithShortCircuiting {
+struct ResolveTypeof : public ast::WithShortCircuiting {
     const ResolveContext & context;
 
-		ResolveTypeof_new( const ResolveContext & context ) :
+		ResolveTypeof( const ResolveContext & context ) :
 			context( context ) {}
 
@@ -78,5 +78,5 @@
 
 const ast::Type * resolveTypeof( const ast::Type * type , const ResolveContext & context ) {
-	ast::Pass< ResolveTypeof_new > mutator( context );
+	ast::Pass< ResolveTypeof > mutator( context );
 	return type->accept( mutator );
 }
Index: src/ResolvExpr/ResolveTypeof.h
===================================================================
--- src/ResolvExpr/ResolveTypeof.h	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/ResolveTypeof.h	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,8 +16,4 @@
 #pragma once
 
-class Type;
-namespace SymTab {
-class Indexer;
-}  // namespace SymTab
 namespace ast {
 	class Type;
@@ -28,9 +24,8 @@
 	struct ResolveContext;
 
-	Type *resolveTypeof( Type*, const SymTab::Indexer &indexer );
 	const ast::Type * resolveTypeof( const ast::Type *, const ResolveContext & );
 	const ast::Type * fixArrayType( const ast::Type *, const ResolveContext & );
 	const ast::ObjectDecl * fixObjectType( const ast::ObjectDecl * decl , const ResolveContext & );
-	const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext &);
+	const ast::ObjectDecl * fixObjectInit( const ast::ObjectDecl * decl , const ResolveContext & );
 } // namespace ResolvExpr
 
Index: src/ResolvExpr/Resolver.cc
===================================================================
--- src/ResolvExpr/Resolver.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/Resolver.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -62,5 +62,5 @@
 	namespace {
 		/// Finds deleted expressions in an expression tree
-		struct DeleteFinder_new final : public ast::WithShortCircuiting, public ast::WithVisitorRef<DeleteFinder_new> {
+		struct DeleteFinder final : public ast::WithShortCircuiting, public ast::WithVisitorRef<DeleteFinder> {
 			const ast::DeletedExpr * result = nullptr;
 
@@ -80,9 +80,9 @@
 		};
 
-		struct ResolveDesignators_new final : public ast::WithShortCircuiting {
+		struct ResolveDesignators final : public ast::WithShortCircuiting {
 			ResolveContext& context;
 			bool result = false;
 
-			ResolveDesignators_new( ResolveContext& _context ): context{_context} {};
+			ResolveDesignators( ResolveContext& _context ): context{_context} {};
 
 			void previsit( const ast::Node * ) {
@@ -113,5 +113,5 @@
 	/// Check if this expression is or includes a deleted expression
 	const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
-		return ast::Pass<DeleteFinder_new>::read( expr );
+		return ast::Pass<DeleteFinder>::read( expr );
 	}
 
@@ -203,5 +203,5 @@
 
 		/// Strips extraneous casts out of an expression
-		struct StripCasts_new final {
+		struct StripCasts final {
 			const ast::Expr * postvisit( const ast::CastExpr * castExpr ) {
 				if (
@@ -217,5 +217,5 @@
 
 			static void strip( ast::ptr< ast::Expr > & expr ) {
-				ast::Pass< StripCasts_new > stripper;
+				ast::Pass< StripCasts > stripper;
 				expr = expr->accept( stripper );
 			}
@@ -251,5 +251,5 @@
 			expr.get_and_mutate()->env = std::move( newenv );
 			// remove unncecessary casts
-			StripCasts_new::strip( expr );
+			StripCasts::strip( expr );
 		}
 
@@ -368,7 +368,7 @@
 	}
 
-	class Resolver_new final
+	class Resolver final
 	: public ast::WithSymbolTable, public ast::WithGuards,
-	  public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
+	  public ast::WithVisitorRef<Resolver>, public ast::WithShortCircuiting,
 	  public ast::WithStmtsToAdd<> {
 
@@ -376,5 +376,5 @@
 		ast::CurrentObject currentObject;
 		// for work previously in GenInit
-		static InitTweak::ManagedTypes_new managedTypes;
+		static InitTweak::ManagedTypes managedTypes;
 		ResolveContext context;
 
@@ -383,8 +383,8 @@
 	public:
 		static size_t traceId;
-		Resolver_new( const ast::TranslationGlobal & global ) :
+		Resolver( const ast::TranslationGlobal & global ) :
 			ast::WithSymbolTable(ast::SymbolTable::ErrorDetection::ValidateOnAdd),
 			context{ symtab, global } {}
-		Resolver_new( const ResolveContext & context ) :
+		Resolver( const ResolveContext & context ) :
 			ast::WithSymbolTable{ context.symtab },
 			context{ symtab, context.global } {}
@@ -427,10 +427,10 @@
 		bool on_error(ast::ptr<ast::Decl> & decl);
 	};
-	// size_t Resolver_new::traceId = Stats::Heap::new_stacktrace_id("Resolver");
-
-	InitTweak::ManagedTypes_new Resolver_new::managedTypes;
+	// size_t Resolver::traceId = Stats::Heap::new_stacktrace_id("Resolver");
+
+	InitTweak::ManagedTypes Resolver::managedTypes;
 
 	void resolve( ast::TranslationUnit& translationUnit ) {
-		ast::Pass< Resolver_new >::run( translationUnit, translationUnit.global );
+		ast::Pass< Resolver >::run( translationUnit, translationUnit.global );
 	}
 
@@ -439,5 +439,5 @@
 	) {
 		assert( ctorInit );
-		ast::Pass< Resolver_new > resolver( context );
+		ast::Pass< Resolver > resolver( context );
 		return ctorInit->accept( resolver );
 	}
@@ -447,5 +447,5 @@
 	) {
 		assert( stmtExpr );
-		ast::Pass< Resolver_new > resolver( context );
+		ast::Pass< Resolver > resolver( context );
 		auto ret = mutate(stmtExpr->accept(resolver));
 		strict_dynamic_cast< ast::StmtExpr * >( ret )->computeResult();
@@ -489,5 +489,5 @@
 	}
 
-	const ast::FunctionDecl * Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
+	const ast::FunctionDecl * Resolver::previsit( const ast::FunctionDecl * functionDecl ) {
 		GuardValue( functionReturn );
 
@@ -563,5 +563,5 @@
 	}
 
-	const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
+	const ast::FunctionDecl * Resolver::postvisit( const ast::FunctionDecl * functionDecl ) {
 		// default value expressions have an environment which shouldn't be there and trips up
 		// later passes.
@@ -591,5 +591,5 @@
 	}
 
-	const ast::ObjectDecl * Resolver_new::previsit( const ast::ObjectDecl * objectDecl ) {
+	const ast::ObjectDecl * Resolver::previsit( const ast::ObjectDecl * objectDecl ) {
 		// To handle initialization of routine pointers [e.g. int (*fp)(int) = foo()],
 		// class-variable `initContext` is changed multiple times because the LHS is analyzed
@@ -630,5 +630,5 @@
 					// constructed objects cannot be designated
 					if ( InitTweak::isDesignated( mutDecl->init ) ) {
-						ast::Pass<ResolveDesignators_new> res( context );
+						ast::Pass<ResolveDesignators> res( context );
 						maybe_accept( mutDecl->init.get(), res );
 						if ( !res.core.result ) {
@@ -650,5 +650,5 @@
 	}
 
-	void Resolver_new::previsit( const ast::AggregateDecl * _aggDecl ) {
+	void Resolver::previsit( const ast::AggregateDecl * _aggDecl ) {
 		auto aggDecl = mutate(_aggDecl);
 		assertf(aggDecl == _aggDecl, "type declarations must be unique");
@@ -662,10 +662,10 @@
 	}
 
-	void Resolver_new::previsit( const ast::StructDecl * structDecl ) {
+	void Resolver::previsit( const ast::StructDecl * structDecl ) {
 		previsit(static_cast<const ast::AggregateDecl *>(structDecl));
 		managedTypes.handleStruct(structDecl);
 	}
 
-	void Resolver_new::previsit( const ast::EnumDecl * ) {
+	void Resolver::previsit( const ast::EnumDecl * ) {
 		// in case we decide to allow nested enums
 		GuardValue( inEnumDecl );
@@ -674,5 +674,5 @@
 	}
 
-	const ast::StaticAssertDecl * Resolver_new::previsit(
+	const ast::StaticAssertDecl * Resolver::previsit(
 		const ast::StaticAssertDecl * assertDecl
 	) {
@@ -694,13 +694,13 @@
 	}
 
-	const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
+	const ast::ArrayType * Resolver::previsit( const ast::ArrayType * at ) {
 		return handlePtrType( at, context );
 	}
 
-	const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
+	const ast::PointerType * Resolver::previsit( const ast::PointerType * pt ) {
 		return handlePtrType( pt, context );
 	}
 
-	const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
+	const ast::ExprStmt * Resolver::previsit( const ast::ExprStmt * exprStmt ) {
 		visit_children = false;
 		assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
@@ -710,5 +710,5 @@
 	}
 
-	const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
+	const ast::AsmExpr * Resolver::previsit( const ast::AsmExpr * asmExpr ) {
 		visit_children = false;
 
@@ -719,5 +719,5 @@
 	}
 
-	const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
+	const ast::AsmStmt * Resolver::previsit( const ast::AsmStmt * asmStmt ) {
 		visitor->maybe_accept( asmStmt, &ast::AsmStmt::input );
 		visitor->maybe_accept( asmStmt, &ast::AsmStmt::output );
@@ -726,15 +726,15 @@
 	}
 
-	const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
+	const ast::IfStmt * Resolver::previsit( const ast::IfStmt * ifStmt ) {
 		return ast::mutate_field(
 			ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, context ) );
 	}
 
-	const ast::WhileDoStmt * Resolver_new::previsit( const ast::WhileDoStmt * whileDoStmt ) {
+	const ast::WhileDoStmt * Resolver::previsit( const ast::WhileDoStmt * whileDoStmt ) {
 		return ast::mutate_field(
 			whileDoStmt, &ast::WhileDoStmt::cond, findIntegralExpression( whileDoStmt->cond, context ) );
 	}
 
-	const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) {
+	const ast::ForStmt * Resolver::previsit( const ast::ForStmt * forStmt ) {
 		if ( forStmt->cond ) {
 			forStmt = ast::mutate_field(
@@ -750,5 +750,5 @@
 	}
 
-	const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
+	const ast::SwitchStmt * Resolver::previsit( const ast::SwitchStmt * switchStmt ) {
 		GuardValue( currentObject );
 		switchStmt = ast::mutate_field(
@@ -759,5 +759,5 @@
 	}
 
-	const ast::CaseClause * Resolver_new::previsit( const ast::CaseClause * caseStmt ) {
+	const ast::CaseClause * Resolver::previsit( const ast::CaseClause * caseStmt ) {
 		if ( caseStmt->cond ) {
 			std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
@@ -780,5 +780,5 @@
 	}
 
-	const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
+	const ast::BranchStmt * Resolver::previsit( const ast::BranchStmt * branchStmt ) {
 		visit_children = false;
 		// must resolve the argument of a computed goto
@@ -793,5 +793,5 @@
 	}
 
-	const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
+	const ast::ReturnStmt * Resolver::previsit( const ast::ReturnStmt * returnStmt ) {
 		visit_children = false;
 		if ( returnStmt->expr ) {
@@ -803,5 +803,5 @@
 	}
 
-	const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
+	const ast::ThrowStmt * Resolver::previsit( const ast::ThrowStmt * throwStmt ) {
 		visit_children = false;
 		if ( throwStmt->expr ) {
@@ -818,5 +818,5 @@
 	}
 
-	const ast::CatchClause * Resolver_new::previsit( const ast::CatchClause * catchClause ) {
+	const ast::CatchClause * Resolver::previsit( const ast::CatchClause * catchClause ) {
 		// Until we are very sure this invarent (ifs that move between passes have then)
 		// holds, check it. This allows a check for when to decode the mangling.
@@ -834,5 +834,5 @@
 	}
 
-	const ast::CatchClause * Resolver_new::postvisit( const ast::CatchClause * catchClause ) {
+	const ast::CatchClause * Resolver::postvisit( const ast::CatchClause * catchClause ) {
 		// Decode the catchStmt so everything is stored properly.
 		const ast::IfStmt * ifStmt = catchClause->body.as<ast::IfStmt>();
@@ -849,5 +849,5 @@
 	}
 
-	const ast::WaitForStmt * Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
+	const ast::WaitForStmt * Resolver::previsit( const ast::WaitForStmt * stmt ) {
 		visit_children = false;
 
@@ -1114,5 +1114,5 @@
 	}
 
-	const ast::WithStmt * Resolver_new::previsit( const ast::WithStmt * withStmt ) {
+	const ast::WithStmt * Resolver::previsit( const ast::WithStmt * withStmt ) {
 		auto mutStmt = mutate(withStmt);
 		resolveWithExprs(mutStmt->exprs, stmtsToAddBefore);
@@ -1120,5 +1120,5 @@
 	}
 
-	void Resolver_new::resolveWithExprs(std::vector<ast::ptr<ast::Expr>> & exprs, std::list<ast::ptr<ast::Stmt>> & stmtsToAdd) {
+	void Resolver::resolveWithExprs(std::vector<ast::ptr<ast::Expr>> & exprs, std::list<ast::ptr<ast::Stmt>> & stmtsToAdd) {
 		for (auto & expr : exprs) {
 			// only struct- and union-typed expressions are viable candidates
@@ -1146,5 +1146,5 @@
 
 
-	const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
+	const ast::SingleInit * Resolver::previsit( const ast::SingleInit * singleInit ) {
 		visit_children = false;
 		// resolve initialization using the possibilities as determined by the `currentObject`
@@ -1195,5 +1195,5 @@
 	}
 
-	const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
+	const ast::ListInit * Resolver::previsit( const ast::ListInit * listInit ) {
 		// move cursor into brace-enclosed initializer-list
 		currentObject.enterListInit( listInit->location );
@@ -1218,5 +1218,5 @@
 	}
 
-	const ast::ConstructorInit * Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
+	const ast::ConstructorInit * Resolver::previsit( const ast::ConstructorInit * ctorInit ) {
 		visitor->maybe_accept( ctorInit, &ast::ConstructorInit::ctor );
 		visitor->maybe_accept( ctorInit, &ast::ConstructorInit::dtor );
@@ -1240,5 +1240,5 @@
 
 	// suppress error on autogen functions and mark invalid autogen as deleted.
-	bool Resolver_new::on_error(ast::ptr<ast::Decl> & decl) {
+	bool Resolver::on_error(ast::ptr<ast::Decl> & decl) {
 		if (auto functionDecl = decl.as<ast::FunctionDecl>()) {
 			// xxx - can intrinsic gen ever fail?
Index: src/ResolvExpr/Resolver.h
===================================================================
--- src/ResolvExpr/Resolver.h	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/Resolver.h	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -16,17 +16,5 @@
 #pragma once
 
-#include <list>          // for list
-
 #include "AST/Node.hpp"  // for ptr
-
-class ConstructorInit;
-class Declaration;
-class Expression;
-class DeletedExpr;
-class StmtExpr;
-class Type;
-namespace SymTab {
-	class Indexer;
-} // namespace SymTab
 
 namespace ast {
@@ -45,17 +33,4 @@
 
 namespace ResolvExpr {
-	/// Checks types and binds syntactic constructs to typed representations
-	void resolve( std::list< Declaration * > translationUnit );
-	void resolveDecl( Declaration *, const SymTab::Indexer & indexer );
-	Expression *resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer );
-	void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer );
-	void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer );
-	void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer );
-	void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer );
-	void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer );
-	/// Searches expr and returns the first DeletedExpr found, otherwise nullptr
-	DeletedExpr * findDeletedExpr( Expression * expr );
-	/// Resolves with-stmts and with-clauses on functions
-	void resolveWithExprs( std::list< Declaration * > & translationUnit );
 
 	/// Helper Type: Passes around information between various sub-calls.
Index: src/ResolvExpr/SpecCost.cc
===================================================================
--- src/ResolvExpr/SpecCost.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/SpecCost.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -76,5 +76,5 @@
 
 	public:
-		int get_count() const { return 0 <= count ? count : 0; }
+		int result() const { return 0 <= count ? count : 0; }
 
 		// Mark specialization of base type.
@@ -125,7 +125,5 @@
 		return 0;
 	}
-	ast::Pass<SpecCounter> counter;
-	type->accept( counter );
-	return counter.core.get_count();
+	return ast::Pass<SpecCounter>::read( type );
 }
 
Index: src/ResolvExpr/Unify.cc
===================================================================
--- src/ResolvExpr/Unify.cc	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/Unify.cc	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -105,8 +105,8 @@
 		/// If this isn't done when satifying ttype assertions, then argument lists can have
 		/// different size and structure when they should be compatible.
-		struct TtypeExpander_new : public ast::WithShortCircuiting, public ast::PureVisitor {
+		struct TtypeExpander : public ast::WithShortCircuiting, public ast::PureVisitor {
 			ast::TypeEnvironment & tenv;
 
-			TtypeExpander_new( ast::TypeEnvironment & env ) : tenv( env ) {}
+			TtypeExpander( ast::TypeEnvironment & env ) : tenv( env ) {}
 
 			const ast::Type * postvisit( const ast::TypeInstType * typeInst ) {
@@ -128,5 +128,5 @@
 		dst.reserve( src.size() );
 		for ( const auto & d : src ) {
-			ast::Pass<TtypeExpander_new> expander{ env };
+			ast::Pass<TtypeExpander> expander{ env };
 			// TtypeExpander pass is impure (may mutate nodes in place)
 			// need to make nodes shared to prevent accidental mutation
@@ -268,5 +268,5 @@
 	}
 
-	class Unify_new final : public ast::WithShortCircuiting {
+	class Unify final : public ast::WithShortCircuiting {
 		const ast::Type * type2;
 		ast::TypeEnvironment & tenv;
@@ -279,5 +279,5 @@
 		bool result;
 
-		Unify_new(
+		Unify(
 			const ast::Type * type2, ast::TypeEnvironment & env, ast::AssertionSet & need,
 			ast::AssertionSet & have, const ast::OpenVarSet & open, WidenMode widen )
@@ -606,5 +606,5 @@
 			if ( ! tuple2 ) return;
 
-			ast::Pass<TtypeExpander_new> expander{ tenv };
+			ast::Pass<TtypeExpander> expander{ tenv };
 
 			const ast::Type * flat = tuple->accept( expander );
@@ -634,5 +634,6 @@
 	};
 
-	// size_t Unify_new::traceId = Stats::Heap::new_stacktrace_id("Unify_new");
+	// size_t Unify::traceId = Stats::Heap::new_stacktrace_id("Unify");
+
 	bool unify(
 			const ast::ptr<ast::Type> & type1, const ast::ptr<ast::Type> & type2,
@@ -678,5 +679,5 @@
 			return env.bindVar( var2, type1, ast::TypeData{var2->base}, need, have, open, widen );
 		} else {
-			return ast::Pass<Unify_new>::read(
+			return ast::Pass<Unify>::read(
 				type1, type2, env, need, have, open, widen );
 		}
Index: src/ResolvExpr/typeops.h
===================================================================
--- src/ResolvExpr/typeops.h	(revision c6b4432f5c6c6679b981f5a6bded51ad30ac00d9)
+++ src/ResolvExpr/typeops.h	(revision 0bd3faf870391e5ed803287ec0b3c696cfde22b2)
@@ -19,8 +19,4 @@
 
 #include "AST/Type.hpp"
-
-namespace SymTab {
-	class Indexer;
-}
 
 namespace ResolvExpr {