Index: src/ResolvExpr/CandidateFinder.cpp
===================================================================
--- src/ResolvExpr/CandidateFinder.cpp	(revision 2908f08a0e243fe6bf1b61d204824745ab192f95)
+++ src/ResolvExpr/CandidateFinder.cpp	(revision 4a89b52c4fa1aae1dce7701bb4c97d75453681e5)
@@ -105,5 +105,5 @@
 
 			// CandidateFinder finder{ symtab, env };
-			// finder.find( arg, ResolvMode::withAdjustment() );
+			// finder.find( arg, ResolveMode::withAdjustment() );
 			// assertf( finder.candidates.size() > 0,
 			// 	"Somehow castable expression failed to find alternatives." );
@@ -974,5 +974,5 @@
 		// xxx - is it possible that handleTupleAssignment and main finder both produce candidates?
 		// this means there exists ctor/assign functions with a tuple as first parameter.
-		ResolvMode mode = {
+		ResolveMode mode = {
 			true, // adjust
 			!untypedExpr->func.as<ast::NameExpr>(), // prune if not calling by name
@@ -989,5 +989,5 @@
 		CandidateFinder opFinder( context, tenv );
 		// okay if there aren't any function operations
-		opFinder.find( opExpr, ResolvMode::withoutFailFast() );
+		opFinder.find( opExpr, ResolveMode::withoutFailFast() );
 		PRINT(
 			std::cerr << "known function ops:" << std::endl;
@@ -1175,10 +1175,10 @@
 		if ( castExpr->kind == ast::CastExpr::Return ) {
 			finder.strictMode = true;
-			finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+			finder.find( castExpr->arg, ResolveMode::withAdjustment() );
 
 			// return casts are eliminated (merely selecting an overload, no actual operation)
 			candidates = std::move(finder.candidates);
 		}
-		finder.find( castExpr->arg, ResolvMode::withAdjustment() );
+		finder.find( castExpr->arg, ResolveMode::withAdjustment() );
 
 		if ( !finder.candidates.empty() ) reason.code = NoMatch;
@@ -1251,5 +1251,5 @@
 		CandidateFinder finder( context, tenv );
 		// don't prune here, all alternatives guaranteed to have same type
-		finder.find( castExpr->arg, ResolvMode::withoutPrune() );
+		finder.find( castExpr->arg, ResolveMode::withoutPrune() );
 		for ( CandidateRef & r : finder.candidates ) {
 			addCandidate(
@@ -1298,5 +1298,5 @@
 
 			// don't prune here, since it's guaranteed all alternatives will have the same type
-			finder.find( tech1.get(), ResolvMode::withoutPrune() );
+			finder.find( tech1.get(), ResolveMode::withoutPrune() );
 			pick_alternatives(finder.candidates, false);
 
@@ -1307,5 +1307,5 @@
 		std::unique_ptr<const ast::Expr> fallback { ast::UntypedExpr::createDeref(loc,  new ast::UntypedExpr(loc, new ast::NameExpr(loc, castExpr->concrete_target.getter), { castExpr->arg })) };
 		// don't prune here, since it's guaranteed all alternatives will have the same type
-		finder.find( fallback.get(), ResolvMode::withoutPrune() );
+		finder.find( fallback.get(), ResolveMode::withoutPrune() );
 
 		pick_alternatives(finder.candidates, true);
@@ -1316,5 +1316,5 @@
 	void Finder::postvisit( const ast::UntypedMemberExpr * memberExpr ) {
 		CandidateFinder aggFinder( context, tenv );
-		aggFinder.find( memberExpr->aggregate, ResolvMode::withAdjustment() );
+		aggFinder.find( memberExpr->aggregate, ResolveMode::withAdjustment() );
 		for ( CandidateRef & agg : aggFinder.candidates ) {
 			// it's okay for the aggregate expression to have reference type -- cast it to the
@@ -1475,9 +1475,9 @@
 	void Finder::postvisit( const ast::LogicalExpr * logicalExpr ) {
 		CandidateFinder finder1( context, tenv );
-		finder1.find( logicalExpr->arg1, ResolvMode::withAdjustment() );
+		finder1.find( logicalExpr->arg1, ResolveMode::withAdjustment() );
 		if ( finder1.candidates.empty() ) return;
 
 		CandidateFinder finder2( context, tenv );
-		finder2.find( logicalExpr->arg2, ResolvMode::withAdjustment() );
+		finder2.find( logicalExpr->arg2, ResolveMode::withAdjustment() );
 		if ( finder2.candidates.empty() ) return;
 
@@ -1505,5 +1505,5 @@
 		// candidates for condition
 		CandidateFinder finder1( context, tenv );
-		finder1.find( conditionalExpr->arg1, ResolvMode::withAdjustment() );
+		finder1.find( conditionalExpr->arg1, ResolveMode::withAdjustment() );
 		if ( finder1.candidates.empty() ) return;
 
@@ -1511,5 +1511,5 @@
 		CandidateFinder finder2( context, tenv );
 		finder2.allowVoid = true;
-		finder2.find( conditionalExpr->arg2, ResolvMode::withAdjustment() );
+		finder2.find( conditionalExpr->arg2, ResolveMode::withAdjustment() );
 		if ( finder2.candidates.empty() ) return;
 
@@ -1517,5 +1517,5 @@
 		CandidateFinder finder3( context, tenv );
 		finder3.allowVoid = true;
-		finder3.find( conditionalExpr->arg3, ResolvMode::withAdjustment() );
+		finder3.find( conditionalExpr->arg3, ResolveMode::withAdjustment() );
 		if ( finder3.candidates.empty() ) return;
 
@@ -1570,5 +1570,5 @@
 
 		CandidateFinder finder2( context, env );
-		finder2.find( commaExpr->arg2, ResolvMode::withAdjustment() );
+		finder2.find( commaExpr->arg2, ResolveMode::withAdjustment() );
 
 		for ( const CandidateRef & r2 : finder2.candidates ) {
@@ -1584,5 +1584,5 @@
 		CandidateFinder finder( context, tenv );
 		finder.allowVoid = true;
-		finder.find( ctorExpr->callExpr, ResolvMode::withoutPrune() );
+		finder.find( ctorExpr->callExpr, ResolveMode::withoutPrune() );
 		for ( CandidateRef & r : finder.candidates ) {
 			addCandidate( *r, new ast::ConstructorExpr{ ctorExpr->location, r->expr } );
@@ -1593,9 +1593,9 @@
 		// resolve low and high, accept candidates where low and high types unify
 		CandidateFinder finder1( context, tenv );
-		finder1.find( rangeExpr->low, ResolvMode::withAdjustment() );
+		finder1.find( rangeExpr->low, ResolveMode::withAdjustment() );
 		if ( finder1.candidates.empty() ) return;
 
 		CandidateFinder finder2( context, tenv );
-		finder2.find( rangeExpr->high, ResolvMode::withAdjustment() );
+		finder2.find( rangeExpr->high, ResolveMode::withAdjustment() );
 		if ( finder2.candidates.empty() ) return;
 
@@ -1673,5 +1673,5 @@
 	void Finder::postvisit( const ast::UniqueExpr * unqExpr ) {
 		CandidateFinder finder( context, tenv );
-		finder.find( unqExpr->expr, ResolvMode::withAdjustment() );
+		finder.find( unqExpr->expr, ResolveMode::withAdjustment() );
 		for ( CandidateRef & r : finder.candidates ) {
 			// ensure that the the id is passed on so that the expressions are "linked"
@@ -1699,5 +1699,5 @@
 			// only open for the duration of resolving the UntypedExpr.
 			CandidateFinder finder( context, tenv, toType );
-			finder.find( initExpr->expr, ResolvMode::withAdjustment() );
+			finder.find( initExpr->expr, ResolveMode::withAdjustment() );
 
 			Cost minExprCost = Cost::infinity;
@@ -1889,5 +1889,5 @@
 }
 
-void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
+void CandidateFinder::find( const ast::Expr * expr, ResolveMode mode ) {
 	// Find alternatives for expression
 	ast::Pass<Finder> finder{ *this };
@@ -2004,5 +2004,5 @@
 	for ( const auto & x : xs ) {
 		out.emplace_back( context, env );
-		out.back().find( x, ResolvMode::withAdjustment() );
+		out.back().find( x, ResolveMode::withAdjustment() );
 
 		PRINT(
