Changes in src/ResolvExpr/Resolver.cc [8fd52e90:2a08c25]

File:

• src/ResolvExpr/Resolver.cc (modified) (45 diffs)

src/ResolvExpr/Resolver.cc

@@ -7 +7 @@
 // Resolver.cc --
 //
-// Author           : Aaron B. Moss
+// Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Aaron B. Moss
-// Last Modified On : Wed May 29 11:00:00 2019
-// Update Count     : 241
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Feb 17 11:19:40 2018
+// Update Count     : 213
 //
 
+#include <stddef.h>                      // for NULL
 #include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
-#include <vector>                        // for vector
+#include <vector>
 
 #include "Alternative.h"                 // for Alternative, AltList
 #include "AlternativeFinder.h"           // for AlternativeFinder, resolveIn...
-#include "Candidate.hpp"
-#include "CandidateFinder.hpp"
-#include "CurrentObject.h"               // for CurrentObject
-#include "RenameVars.h"                  // for RenameVars, global_renamer
-#include "Resolver.h"
-#include "ResolvMode.h"                  // for ResolvMode
-#include "typeops.h"                     // for extractResultType
-#include "Unify.h"                       // for unify
-#include "AST/Chain.hpp"
-#include "AST/Decl.hpp"
-#include "AST/Init.hpp"
-#include "AST/Pass.hpp"
-#include "AST/Print.hpp"
-#include "AST/SymbolTable.hpp"
-#include "AST/Type.hpp"
 #include "Common/PassVisitor.h"          // for PassVisitor
 #include "Common/SemanticError.h"        // for SemanticError
 #include "Common/utility.h"              // for ValueGuard, group_iterate
+#include "CurrentObject.h"               // for CurrentObject
 #include "InitTweak/GenInit.h"
 #include "InitTweak/InitTweak.h"         // for isIntrinsicSingleArgCallStmt
+#include "RenameVars.h"                  // for RenameVars, global_renamer
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "ResolveTypeof.h"               // for resolveTypeof
+#include "Resolver.h"
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -52 +42 @@
 #include "SynTree/Visitor.h"             // for acceptAll, maybeAccept
 #include "Tuples/Tuples.h"
-#include "Validate/FindSpecialDecls.h"   // for SizeType
+#include "typeops.h"                     // for extractResultType
+#include "Unify.h"                       // for unify
 
 using namespace std;
 
 namespace ResolvExpr {
-        struct Resolver_old final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver_old>, public WithShortCircuiting, public WithStmtsToAdd {
-                Resolver_old() {}
-                Resolver_old( const SymTab::Indexer & other ) {
+        struct Resolver final : public WithIndexer, public WithGuards, public WithVisitorRef<Resolver>, public WithShortCircuiting, public WithStmtsToAdd {
+                Resolver() {}
+                Resolver( const SymTab::Indexer & other ) {
                         indexer = other;
                 }
 
-                void previsit( FunctionDecl * functionDecl );
-                void postvisit( FunctionDecl * functionDecl );
-                void previsit( ObjectDecl * objectDecll );
+                void previsit( FunctionDecl *functionDecl );
+                void postvisit( FunctionDecl *functionDecl );
+                void previsit( ObjectDecl *objectDecll );
+                void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
                 void previsit( StaticAssertDecl * assertDecl );
@@ -72 +64 @@
                 void previsit( PointerType * at );
 
-                void previsit( ExprStmt * exprStmt );
-                void previsit( AsmExpr * asmExpr );
-                void previsit( AsmStmt * asmStmt );
-                void previsit( IfStmt * ifStmt );
-                void previsit( WhileStmt * whileStmt );
-                void previsit( ForStmt * forStmt );
-                void previsit( SwitchStmt * switchStmt );
-                void previsit( CaseStmt * caseStmt );
-                void previsit( BranchStmt * branchStmt );
-                void previsit( ReturnStmt * returnStmt );
-                void previsit( ThrowStmt * throwStmt );
-                void previsit( CatchStmt * catchStmt );
+                void previsit( ExprStmt *exprStmt );
+                void previsit( AsmExpr *asmExpr );
+                void previsit( AsmStmt *asmStmt );
+                void previsit( IfStmt *ifStmt );
+                void previsit( WhileStmt *whileStmt );
+                void previsit( ForStmt *forStmt );
+                void previsit( SwitchStmt *switchStmt );
+                void previsit( CaseStmt *caseStmt );
+                void previsit( BranchStmt *branchStmt );
+                void previsit( ReturnStmt *returnStmt );
+                void previsit( ThrowStmt *throwStmt );
+                void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
-
-                void previsit( SingleInit * singleInit );
-                void previsit( ListInit * listInit );
-                void previsit( ConstructorInit * ctorInit );
+                void previsit( WithStmt * withStmt );
+
+                void previsit( SingleInit *singleInit );
+                void previsit( ListInit *listInit );
+                void previsit( ConstructorInit *ctorInit );
           private:
                 typedef std::list< Initializer * >::iterator InitIterator;
@@ -95 +88 @@
                 void handlePtrType( PtrType * type );
 
+                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
                 void fallbackInit( ConstructorInit * ctorInit );
 
@@ -102 +96 @@
         };
 
-        struct ResolveWithExprs : public WithIndexer, public WithGuards, public WithVisitorRef<ResolveWithExprs>, public WithShortCircuiting, public WithStmtsToAdd {
-                void previsit( FunctionDecl * );
-                void previsit( WithStmt * );
-
-                void resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts );
-        };
-
         void resolve( std::list< Declaration * > translationUnit ) {
-                PassVisitor<Resolver_old> resolver;
+                PassVisitor<Resolver> resolver;
                 acceptAll( translationUnit, resolver );
         }
 
-        void resolveDecl( Declaration * decl, const SymTab::Indexer & indexer ) {
-                PassVisitor<Resolver_old> resolver( indexer );
+        void resolveDecl( Declaration * decl, const SymTab::Indexer &indexer ) {
+                PassVisitor<Resolver> resolver( indexer );
                 maybeAccept( decl, resolver );
         }
 
         namespace {
-                struct DeleteFinder_old : public WithShortCircuiting    {
+                struct DeleteFinder : public WithShortCircuiting        {
                         DeletedExpr * delExpr = nullptr;
                         void previsit( DeletedExpr * expr ) {
@@ -134 +121 @@
 
         DeletedExpr * findDeletedExpr( Expression * expr ) {
-                PassVisitor<DeleteFinder_old> finder;
+                PassVisitor<DeleteFinder> finder;
                 expr->accept( finder );
                 return finder.pass.delExpr;
@@ -140 +127 @@
 
         namespace {
-                struct StripCasts_old {
+                struct StripCasts {
                         Expression * postmutate( CastExpr * castExpr ) {
                                 if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
@@ -153 +140 @@
 
                         static void strip( Expression *& expr ) {
-                                PassVisitor<StripCasts_old> stripper;
+                                PassVisitor<StripCasts> stripper;
                                 expr = expr->acceptMutator( stripper );
                         }
                 };
 
-                void finishExpr( Expression *& expr, const TypeEnvironment & env, TypeSubstitution * oldenv = nullptr ) {
+                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
                         env.makeSubstitution( *expr->env );
-                        StripCasts_old::strip( expr ); // remove unnecessary casts that may be buried in an expression
+                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
                 }
 
                 void removeExtraneousCast( Expression *& expr, const SymTab::Indexer & indexer ) {
                         if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( expr ) ) {
-                                if ( typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
+                                if ( ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, indexer ) ) {
                                         // cast is to the same type as its argument, so it's unnecessary -- remove it
                                         expr = castExpr->arg;
@@ -178 +165 @@
 
         namespace {
-                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
+                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
                         assertf( untyped, "expected a non-null expression." );
-
-                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
-                        static unsigned recursion_level = 0;
-
-                        ++recursion_level;
                         TypeEnvironment env;
                         AlternativeFinder finder( indexer, env );
-                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
-                        --recursion_level;
+                        finder.find( untyped, adjust, prune, failFast );
 
                         #if 0
@@ -201 +182 @@
                         #endif
 
-                        // produce filtered list of alternatives
                         AltList candidates;
                         for ( Alternative & alt : finder.get_alternatives() ) {
@@ -209 +189 @@
                         }
 
-                        // produce invalid error if no candidates
-                        if ( candidates.empty() ) {
+                        // xxx - if > 1 alternative with same cost, ignore deleted and pick from remaining
+                        // choose the lowest cost expression among the candidates
+                        AltList winners;
+                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
+                        if ( winners.size() == 0 ) {
                                 SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
-                        }
-
-                        // search for cheapest candidate
-                        AltList winners;
-                        bool seen_undeleted = false;
-                        for ( unsigned i = 0; i < candidates.size(); ++i ) {
-                                int c = winners.empty() ? -1 : candidates[i].cost.compare( winners.front().cost );
-
-                                if ( c > 0 ) continue; // skip more expensive than winner
-
-                                if ( c < 0 ) {
-                                        // reset on new cheapest
-                                        seen_undeleted = ! findDeletedExpr( candidates[i].expr );
-                                        winners.clear();
-                                } else /* if ( c == 0 ) */ {
-                                        if ( findDeletedExpr( candidates[i].expr ) ) {
-                                                // skip deleted expression if already seen one equivalent-cost not
-                                                if ( seen_undeleted ) continue;
-                                        } else if ( ! seen_undeleted ) {
-                                                // replace list of equivalent-cost deleted expressions with one non-deleted
-                                                winners.clear();
-                                                seen_undeleted = true;
-                                        }
-                                }
-
-                                winners.emplace_back( std::move( candidates[i] ) );
-                        }
-
-                        // promote alternative.cvtCost to .cost
-                        // xxx - I don't know why this is done, but I'm keeping the behaviour from findMinCost
-                        for ( Alternative& winner : winners ) {
-                                winner.cost = winner.cvtCost;
-                        }
-
-                        // produce ambiguous errors, if applicable
-                        if ( winners.size() != 1 ) {
+                        } else if ( winners.size() != 1 ) {
                                 std::ostringstream stream;
                                 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
@@ -256 +204 @@
                         }
 
-                        // single selected choice
-                        Alternative& choice = winners.front();
-
-                        // fail on only expression deleted
-                        if ( ! seen_undeleted ) {
+                        // there is one unambiguous interpretation - move the expression into the with statement
+                        Alternative & choice = winners.front();
+                        if ( findDeletedExpr( choice.expr ) ) {
                                 SemanticError( untyped->location, choice.expr, "Unique best alternative includes deleted identifier in " );
                         }
-
-                        // xxx - check for ambiguous expressions
-
-                        // output selected choice
                         alt = std::move( choice );
                 }
 
                 /// resolve `untyped` to the expression whose alternative satisfies `pred` with the lowest cost; kindStr is used for providing better error messages
-                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, bool adjust = false, bool prune = true, bool failFast = true) {
                         if ( ! untyped ) return;
                         Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
                         finishExpr( choice.expr, choice.env, untyped->env );
                         delete untyped;
@@ -289 +231 @@
 
         // used in resolveTypeof
-        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer ) {
+        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
                 TypeEnvironment env;
                 return resolveInVoidContext( expr, indexer, env );
         }
 
-        Expression * resolveInVoidContext( Expression * expr, const SymTab::Indexer & indexer, TypeEnvironment & env ) {
+        Expression * resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
                 // it's a property of the language that a cast expression has either 1 or 0 interpretations; if it has 0
                 // interpretations, an exception has already been thrown.
                 assertf( expr, "expected a non-null expression." );
 
-                CastExpr * untyped = new CastExpr( expr ); // cast to void
-                untyped->location = expr->location;
+                static CastExpr untyped( nullptr ); // cast to void
+                untyped.location = expr->location;
 
                 // set up and resolve expression cast to void
+                untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
+                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
-                assert( castExpr );
                 env = std::move( choice.env );
 
@@ -314 +256 @@
 
                 // unlink the arg so that it isn't deleted twice at the end of the program
-                untyped->arg = nullptr;
+                untyped.arg = nullptr;
                 return ret;
         }
 
-        void findVoidExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+        void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                 resetTyVarRenaming();
                 TypeEnvironment env;
@@ -327 +269 @@
         }
 
-        void findSingleExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+        void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
                 findKindExpression( untyped, indexer, "", standardAlternativeFilter );
         }
@@ -346 +288 @@
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
-                        } else if ( BasicType * bt = dynamic_cast< BasicType * >( type ) ) {
+                        } else if ( BasicType *bt = dynamic_cast< BasicType * >( type ) ) {
                                 return bt->isInteger();
                         } else if ( dynamic_cast< ZeroType* >( type ) != nullptr || dynamic_cast< OneType* >( type ) != nullptr ) {
@@ -355 +297 @@
                 }
 
-                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer & indexer ) {
+                void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
                         findKindExpression( untyped, indexer, "condition", isIntegralType );
                 }
         }
 
-
-        bool isStructOrUnion( const Alternative & alt ) {
-                Type * t = alt.expr->result->stripReferences();
-                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
-        }
-
-        void resolveWithExprs( std::list< Declaration * > & translationUnit ) {
-                PassVisitor<ResolveWithExprs> resolver;
-                acceptAll( translationUnit, resolver );
-        }
-
-        void ResolveWithExprs::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
-                for ( Expression *& expr : withExprs )  {
-                        // only struct- and union-typed expressions are viable candidates
-                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
-
-                        // if with expression might be impure, create a temporary so that it is evaluated once
-                        if ( Tuples::maybeImpure( expr ) ) {
-                                static UniqueName tmpNamer( "_with_tmp_" );
-                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
-                                expr = new VariableExpr( tmp );
-                                newStmts.push_back( new DeclStmt( tmp ) );
-                                if ( InitTweak::isConstructable( tmp->type ) ) {
-                                        // generate ctor/dtor and resolve them
-                                        tmp->init = InitTweak::genCtorInit( tmp );
-                                        tmp->accept( *visitor );
-                                }
-                        }
-                }
-        }
-
-        void ResolveWithExprs::previsit( WithStmt * withStmt ) {
-                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
-        }
-
-        void ResolveWithExprs::previsit( FunctionDecl * functionDecl ) {
+        void Resolver::previsit( ObjectDecl *objectDecl ) {
+                Type *new_type = resolveTypeof( objectDecl->get_type(), indexer );
+                objectDecl->set_type( new_type );
+                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that class-variable
+                // initContext is changed multiple time because the LHS is analysed twice. The second analysis changes
+                // initContext because of a function type can contain object declarations in the return and parameter types. So
+                // each value of initContext is retained, so the type on the first analysis is preserved and used for selecting
+                // the RHS.
+                GuardValue( currentObject );
+                currentObject = CurrentObject( objectDecl->get_type() );
+                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
+                        // enumerator initializers should not use the enum type to initialize, since
+                        // the enum type is still incomplete at this point. Use signed int instead.
+                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
+                }
+        }
+
+        template< typename PtrType >
+        void Resolver::handlePtrType( PtrType * type ) {
+                if ( type->get_dimension() ) {
+                        findSingleExpression( type->dimension, SymTab::SizeType->clone(), indexer );
+                }
+        }
+
+        void Resolver::previsit( ArrayType * at ) {
+                handlePtrType( at );
+        }
+
+        void Resolver::previsit( PointerType * pt ) {
+                handlePtrType( pt );
+        }
+
+        void Resolver::previsit( TypeDecl *typeDecl ) {
+                if ( typeDecl->get_base() ) {
+                        Type *new_type = resolveTypeof( typeDecl->get_base(), indexer );
+                        typeDecl->set_base( new_type );
+                } // if
+        }
+
+        void Resolver::previsit( FunctionDecl *functionDecl ) {
+#if 0
+                std::cerr << "resolver visiting functiondecl ";
+                functionDecl->print( std::cerr );
+                std::cerr << std::endl;
+#endif
+                Type *new_type = resolveTypeof( functionDecl->type, indexer );
+                functionDecl->set_type( new_type );
+                GuardValue( functionReturn );
+                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
+
                 {
                         // resolve with-exprs with parameters in scope and add any newly generated declarations to the
@@ -411 +367 @@
         }
 
-        void Resolver_old::previsit( ObjectDecl * objectDecl ) {
-                // To handle initialization of routine pointers, e.g., int (*fp)(int) = foo(), means that
-                // class-variable initContext is changed multiple time because the LHS is analysed twice.
-                // The second analysis changes initContext because of a function type can contain object
-                // declarations in the return and parameter types. So each value of initContext is
-                // retained, so the type on the first analysis is preserved and used for selecting the RHS.
-                GuardValue( currentObject );
-                currentObject = CurrentObject( objectDecl->get_type() );
-                if ( inEnumDecl && dynamic_cast< EnumInstType * >( objectDecl->get_type() ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since
-                        // the enum type is still incomplete at this point. Use signed int instead.
-                        currentObject = CurrentObject( new BasicType( Type::Qualifiers(), BasicType::SignedInt ) );
-                }
-        }
-
-        template< typename PtrType >
-        void Resolver_old::handlePtrType( PtrType * type ) {
-                if ( type->get_dimension() ) {
-                        findSingleExpression( type->dimension, Validate::SizeType->clone(), indexer );
-                }
-        }
-
-        void Resolver_old::previsit( ArrayType * at ) {
-                handlePtrType( at );
-        }
-
-        void Resolver_old::previsit( PointerType * pt ) {
-                handlePtrType( pt );
-        }
-
-        void Resolver_old::previsit( FunctionDecl * functionDecl ) {
-#if 0
-                std::cerr << "resolver visiting functiondecl ";
-                functionDecl->print( std::cerr );
-                std::cerr << std::endl;
-#endif
-                GuardValue( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
-        }
-
-        void Resolver_old::postvisit( FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up
-                // later passes.
-                // xxx - it might be necessary to somehow keep the information from this environment, but I
-                // can't currently see how it's useful.
+        void Resolver::postvisit( FunctionDecl *functionDecl ) {
+                // default value expressions have an environment which shouldn't be there and trips up later passes.
+                // xxx - it might be necessary to somehow keep the information from this environment, but I can't currently
+                // see how it's useful.
                 for ( Declaration * d : functionDecl->type->parameters ) {
                         if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
@@ -466 +381 @@
         }
 
-        void Resolver_old::previsit( EnumDecl * ) {
+        void Resolver::previsit( EnumDecl * ) {
                 // in case we decide to allow nested enums
                 GuardValue( inEnumDecl );
@@ -472 +387 @@
         }
 
-        void Resolver_old::previsit( StaticAssertDecl * assertDecl ) {
+        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
                 findIntegralExpression( assertDecl->condition, indexer );
         }
 
-        void Resolver_old::previsit( ExprStmt * exprStmt ) {
+        void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
                 assertf( exprStmt->expr, "ExprStmt has null Expression in resolver" );
@@ -482 +397 @@
         }
 
-        void Resolver_old::previsit( AsmExpr * asmExpr ) {
+        void Resolver::previsit( AsmExpr *asmExpr ) {
                 visit_children = false;
                 findVoidExpression( asmExpr->operand, indexer );
@@ -490 +405 @@
         }
 
-        void Resolver_old::previsit( AsmStmt * asmStmt ) {
+        void Resolver::previsit( AsmStmt *asmStmt ) {
                 visit_children = false;
                 acceptAll( asmStmt->get_input(), *visitor );
@@ -496 +411 @@
         }
 
-        void Resolver_old::previsit( IfStmt * ifStmt ) {
+        void Resolver::previsit( IfStmt *ifStmt ) {
                 findIntegralExpression( ifStmt->condition, indexer );
         }
 
-        void Resolver_old::previsit( WhileStmt * whileStmt ) {
+        void Resolver::previsit( WhileStmt *whileStmt ) {
                 findIntegralExpression( whileStmt->condition, indexer );
         }
 
-        void Resolver_old::previsit( ForStmt * forStmt ) {
+        void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->condition ) {
                         findIntegralExpression( forStmt->condition, indexer );
@@ -514 +429 @@
         }
 
-        void Resolver_old::previsit( SwitchStmt * switchStmt ) {
+        void Resolver::previsit( SwitchStmt *switchStmt ) {
                 GuardValue( currentObject );
                 findIntegralExpression( switchStmt->condition, indexer );
@@ -521 +436 @@
         }
 
-        void Resolver_old::previsit( CaseStmt * caseStmt ) {
+        void Resolver::previsit( CaseStmt *caseStmt ) {
                 if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
@@ -540 +455 @@
         }
 
-        void Resolver_old::previsit( BranchStmt * branchStmt ) {
+        void Resolver::previsit( BranchStmt *branchStmt ) {
                 visit_children = false;
                 // must resolve the argument for a computed goto
@@ -551 +466 @@
         }
 
-        void Resolver_old::previsit( ReturnStmt * returnStmt ) {
+        void Resolver::previsit( ReturnStmt *returnStmt ) {
                 visit_children = false;
                 if ( returnStmt->expr ) {
@@ -558 +473 @@
         }
 
-        void Resolver_old::previsit( ThrowStmt * throwStmt ) {
+        void Resolver::previsit( ThrowStmt *throwStmt ) {
                 visit_children = false;
                 // TODO: Replace *exception type with &exception type.
                 if ( throwStmt->get_expr() ) {
-                        const StructDecl * exception_decl = indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
+                        StructDecl * exception_decl =
+                                indexer.lookupStruct( "__cfaabi_ehm__base_exception_t" );
                         assert( exception_decl );
-                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, const_cast<StructDecl *>(exception_decl) ) );
+                        Type * exceptType = new PointerType( noQualifiers, new StructInstType( noQualifiers, exception_decl ) );
                         findSingleExpression( throwStmt->expr, exceptType, indexer );
                 }
         }
 
-        void Resolver_old::previsit( CatchStmt * catchStmt ) {
+        void Resolver::previsit( CatchStmt *catchStmt ) {
                 if ( catchStmt->cond ) {
                         findSingleExpression( catchStmt->cond, new BasicType( noQualifiers, BasicType::Bool ), indexer );
@@ -584 +500 @@
         }
 
-        void Resolver_old::previsit( WaitForStmt * stmt ) {
+        void Resolver::previsit( WaitForStmt * stmt ) {
                 visit_children = false;
 
@@ -666 +582 @@
 
                                                         // Make sure we don't widen any existing bindings
-                                                        resultEnv.forbidWidening();
+                                                        for ( auto & i : resultEnv ) {
+                                                                i.allowWidening = false;
+                                                        }
 
                                                         // Find any unbound type variables
@@ -674 +592 @@
                                                         auto param_end = function->parameters.end();
 
-                                                        int n_mutex_param = 0;
+                                                        int n_mutex_arg = 0;
 
                                                         // For every arguments of its set, check if it matches one of the parameter
@@ -684 +602 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_param, "\n" ));
+                                                                        SemanticError( function, toString("candidate function not viable: too many mutex arguments, expected ", n_mutex_arg, "\n" ));
                                                                 }
 
-                                                                n_mutex_param++;
+                                                                n_mutex_arg++;
 
                                                                 // Check if the argument matches the parameter type in the current scope
@@ -710 +628 @@
                                                         // Check if parameters are missing
                                                         if( advance_to_mutex( param, param_end ) ) {
-                                                                do {
-                                                                        n_mutex_param++;
-                                                                        param++;
-                                                                } while( advance_to_mutex( param, param_end ) );
-
                                                                 // We ran out of arguments but still have parameters left
                                                                 // this function doesn't match
-                                                                SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_param, "\n" ));
+                                                                SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_arg, "\n" ));
                                                         }
 
@@ -733 +646 @@
 
                                                 }
-                                                catch( SemanticErrorException & e ) {
+                                                catch( SemanticErrorException &e ) {
                                                         errors.append( e );
                                                 }
                                         }
                                 }
-                                catch( SemanticErrorException & e ) {
+                                catch( SemanticErrorException &e ) {
                                         errors.append( e );
                                 }
@@ -781 +694 @@
         }
 
-        bool isCharType( Type * t ) {
+        bool isStructOrUnion( const Alternative & alt ) {
+                Type * t = alt.expr->result->stripReferences();
+                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
+        }
+
+        void Resolver::resolveWithExprs( std::list< Expression * > & withExprs, std::list< Statement * > & newStmts ) {
+                for ( Expression *& expr : withExprs )  {
+                        // only struct- and union-typed expressions are viable candidates
+                        findKindExpression( expr, indexer, "with statement", isStructOrUnion );
+
+                        // if with expression might be impure, create a temporary so that it is evaluated once
+                        if ( Tuples::maybeImpure( expr ) ) {
+                                static UniqueName tmpNamer( "_with_tmp_" );
+                                ObjectDecl * tmp = ObjectDecl::newObject( tmpNamer.newName(), expr->result->clone(), new SingleInit( expr ) );
+                                expr = new VariableExpr( tmp );
+                                newStmts.push_back( new DeclStmt( tmp ) );
+                                if ( InitTweak::isConstructable( tmp->type ) ) {
+                                        // generate ctor/dtor and resolve them
+                                        tmp->init = InitTweak::genCtorInit( tmp );
+                                        tmp->accept( *visitor );
+                                }
+                        }
+                }
+        }
+
+        void Resolver::previsit( WithStmt * withStmt ) {
+                resolveWithExprs( withStmt->exprs, stmtsToAddBefore );
+        }
+
+        template< typename T >
+        bool isCharType( T t ) {
                 if ( BasicType * bt = dynamic_cast< BasicType * >( t ) ) {
                         return bt->get_kind() == BasicType::Char || bt->get_kind() == BasicType::SignedChar ||
@@ -789 +732 @@
         }
 
-        void Resolver_old::previsit( SingleInit * singleInit ) {
+        void Resolver::previsit( SingleInit *singleInit ) {
                 visit_children = false;
                 // resolve initialization using the possibilities as determined by the currentObject cursor
@@ -803 +746 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
-                // InitExpr may have inferParams in the case where the expression specializes a function
-                // pointer, and newExpr may already have inferParams of its own, so a simple swap is not
-                // sufficient.
+                // InitExpr may have inferParams in the case where the expression specializes a function pointer,
+                // and newExpr may already have inferParams of its own, so a simple swap is not sufficient.
                 newExpr->spliceInferParams( initExpr );
                 delete initExpr;
 
-                // get the actual object's type (may not exactly match what comes back from the resolver
-                // due to conversions)
+                // get the actual object's type (may not exactly match what comes back from the resolver due to conversions)
                 Type * initContext = currentObject.getCurrentType();
 
@@ -821 +762 @@
                                 if ( PointerType * pt = dynamic_cast< PointerType *>( newExpr->get_result() ) ) {
                                         if ( isCharType( pt->get_base() ) ) {
-                                                if ( CastExpr * ce = dynamic_cast< CastExpr * >( newExpr ) ) {
-                                                        // strip cast if we're initializing a char[] with a char *,
-                                                        // e.g.  char x[] = "hello";
+                                                if ( CastExpr *ce = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                                        // strip cast if we're initializing a char[] with a char *, e.g.  char x[] = "hello";
                                                         newExpr = ce->get_arg();
                                                         ce->set_arg( nullptr );
@@ -841 +781 @@
         }
 
-        void Resolver_old::previsit( ListInit * listInit ) {
+        void Resolver::previsit( ListInit * listInit ) {
                 visit_children = false;
                 // move cursor into brace-enclosed initializer-list
                 currentObject.enterListInit();
-                // xxx - fix this so that the list isn't copied, iterator should be used to change current
-                // element
+                // xxx - fix this so that the list isn't copied, iterator should be used to change current element
                 std::list<Designation *> newDesignations;
                 for ( auto p : group_iterate(listInit->get_designations(), listInit->get_initializers()) ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current
-                        // designated object and resolving the initializer against that object.
+                        // iterate designations and initializers in pairs, moving the cursor to the current designated object and resolving
+                        // the initializer against that object.
                         Designation * des = std::get<0>(p);
                         Initializer * init = std::get<1>(p);
@@ -876 +815 @@
 
         // ConstructorInit - fall back on C-style initializer
-        void Resolver_old::fallbackInit( ConstructorInit * ctorInit ) {
+        void Resolver::fallbackInit( ConstructorInit * ctorInit ) {
                 // could not find valid constructor, or found an intrinsic constructor
                 // fall back on C-style initializer
                 delete ctorInit->get_ctor();
-                ctorInit->set_ctor( nullptr );
+                ctorInit->set_ctor( NULL );
                 delete ctorInit->get_dtor();
-                ctorInit->set_dtor( nullptr );
+                ctorInit->set_dtor( NULL );
                 maybeAccept( ctorInit->get_init(), *visitor );
         }
@@ -889 +828 @@
         void resolveCtorInit( ConstructorInit * ctorInit, const SymTab::Indexer & indexer ) {
                 assert( ctorInit );
-                PassVisitor<Resolver_old> resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 ctorInit->accept( resolver );
         }
@@ -895 +834 @@
         void resolveStmtExpr( StmtExpr * stmtExpr, const SymTab::Indexer & indexer ) {
                 assert( stmtExpr );
-                PassVisitor<Resolver_old> resolver( indexer );
+                PassVisitor<Resolver> resolver( indexer );
                 stmtExpr->accept( resolver );
                 stmtExpr->computeResult();
@@ -901 +840 @@
         }
 
-        void Resolver_old::previsit( ConstructorInit * ctorInit ) {
+        void Resolver::previsit( ConstructorInit *ctorInit ) {
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
@@ -925 +864 @@
 
                 // xxx - todo -- what about arrays?
-                // if ( dtor == nullptr && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                // if ( dtor == NULL && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
                 //      // can reduce the constructor down to a SingleInit using the
                 //      // second argument from the ctor call, since
                 //      delete ctorInit->get_ctor();
-                //      ctorInit->set_ctor( nullptr );
+                //      ctorInit->set_ctor( NULL );
 
                 //      Expression * arg =
@@ -935 +874 @@
                 // }
         }
-
-        ///////////////////////////////////////////////////////////////////////////
-        //
-        // *** NEW RESOLVER ***
-        //
-        ///////////////////////////////////////////////////////////////////////////
-
-        namespace {
-                /// Finds deleted expressions in an expression tree
-                struct DeleteFinder_new final : public ast::WithShortCircuiting {
-                        const ast::DeletedExpr * delExpr = nullptr;
-
-                        void previsit( const ast::DeletedExpr * expr ) {
-                                if ( delExpr ) { visit_children = false; }
-                                else { delExpr = expr; }
-                        }
-
-                        void previsit( const ast::Expr * ) {
-                                if ( delExpr ) { visit_children = false; }
-                        }
-                };
-        } // anonymous namespace
-
-        /// Check if this expression is or includes a deleted expression
-        const ast::DeletedExpr * findDeletedExpr( const ast::Expr * expr ) {
-                ast::Pass<DeleteFinder_new> finder;
-                expr->accept( finder );
-                return finder.pass.delExpr;
-        }
-
-        namespace {
-                /// always-accept candidate filter
-                bool anyCandidate( const Candidate & ) { return true; }
-
-                /// Calls the CandidateFinder and finds the single best candidate
-                CandidateRef findUnfinishedKindExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab, const std::string & kind,
-                        std::function<bool(const Candidate &)> pred = anyCandidate, ResolvMode mode = {}
-                ) {
-                        if ( ! untyped ) return nullptr;
-
-                        // xxx - this isn't thread-safe, but should work until we parallelize the resolver
-                        static unsigned recursion_level = 0;
-
-                        ++recursion_level;
-                        ast::TypeEnvironment env;
-                        CandidateFinder finder{ symtab, env };
-                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
-                        --recursion_level;
-
-                        // produce a filtered list of candidates
-                        CandidateList candidates;
-                        for ( auto & cand : finder.candidates ) {
-                                if ( pred( *cand ) ) { candidates.emplace_back( cand ); }
-                        }
-
-                        // produce invalid error if no candidates
-                        if ( candidates.empty() ) {
-                                SemanticError( untyped,
-                                        toString( "No reasonable alternatives for ", kind, (kind != "" ? " " : ""),
-                                        "expression: ") );
-                        }
-
-                        // search for cheapest candidate
-                        CandidateList winners;
-                        bool seen_undeleted = false;
-                        for ( CandidateRef & cand : candidates ) {
-                                int c = winners.empty() ? -1 : cand->cost.compare( winners.front()->cost );
-
-                                if ( c > 0 ) continue;  // skip more expensive than winner
-
-                                if ( c < 0 ) {
-                                        // reset on new cheapest
-                                        seen_undeleted = ! findDeletedExpr( cand->expr );
-                                        winners.clear();
-                                } else /* if ( c == 0 ) */ {
-                                        if ( findDeletedExpr( cand->expr ) ) {
-                                                // skip deleted expression if already seen one equivalent-cost not
-                                                if ( seen_undeleted ) continue;
-                                        } else if ( ! seen_undeleted ) {
-                                                // replace list of equivalent-cost deleted expressions with one non-deleted
-                                                winners.clear();
-                                                seen_undeleted = true;
-                                        }
-                                }
-
-                                winners.emplace_back( std::move( cand ) );
-                        }
-
-                        // promote candidate.cvtCost to .cost
-                        promoteCvtCost( winners );
-
-                        // produce ambiguous errors, if applicable
-                        if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for "
-                                        << kind << (kind != "" ? " " : "") << "expression\n";
-                                ast::print( stream, untyped );
-                                stream << " Alternatives are:\n";
-                                print( stream, winners, 1 );
-                                SemanticError( untyped->location, stream.str() );
-                        }
-
-                        // single selected choice
-                        CandidateRef & choice = winners.front();
-
-                        // fail on only expression deleted
-                        if ( ! seen_undeleted ) {
-                                SemanticError( untyped->location, choice->expr.get(), "Unique best alternative "
-                                "includes deleted identifier in " );
-                        }
-
-                        return std::move( choice );
-                }
-
-                /// Strips extraneous casts out of an expression
-                struct StripCasts_new final {
-                        const ast::Expr * postmutate( const ast::CastExpr * castExpr ) {
-                                if (
-                                        castExpr->isGenerated
-                                        && typesCompatible( castExpr->arg->result, castExpr->result )
-                                ) {
-                                        // generated cast is the same type as its argument, remove it after keeping env
-                                        return ast::mutate_field(
-                                                castExpr->arg.get(), &ast::Expr::env, castExpr->env );
-                                }
-                                return castExpr;
-                        }
-
-                        static void strip( ast::ptr< ast::Expr > & expr ) {
-                                ast::Pass< StripCasts_new > stripper;
-                                expr = expr->accept( stripper );
-                        }
-                };
-
-                /// Swaps argument into expression pointer, saving original environment
-                void swap_and_save_env( ast::ptr< ast::Expr > & expr, const ast::Expr * newExpr ) {
-                        ast::ptr< ast::TypeSubstitution > env = expr->env;
-                        expr.set_and_mutate( newExpr )->env = env;
-                }
-
-                /// Removes cast to type of argument (unlike StripCasts, also handles non-generated casts)
-                void removeExtraneousCast( ast::ptr<ast::Expr> & expr, const ast::SymbolTable & symtab ) {
-                        if ( const ast::CastExpr * castExpr = expr.as< ast::CastExpr >() ) {
-                                if ( typesCompatible( castExpr->arg->result, castExpr->result, symtab ) ) {
-                                        // cast is to the same type as its argument, remove it
-                                        swap_and_save_env( expr, castExpr->arg );
-                                }
-                        }
-                }
-
-                /// Establish post-resolver invariants for expressions
-                void finishExpr(
-                        ast::ptr< ast::Expr > & expr, const ast::TypeEnvironment & env,
-                        const ast::TypeSubstitution * oldenv = nullptr
-                ) {
-                        // set up new type substitution for expression
-                        ast::ptr< ast::TypeSubstitution > newenv =
-                                 oldenv ? oldenv : new ast::TypeSubstitution{};
-                        env.writeToSubstitution( *newenv.get_and_mutate() );
-                        expr.get_and_mutate()->env = std::move( newenv );
-                        // remove unncecessary casts
-                        StripCasts_new::strip( expr );
-                }
-        } // anonymous namespace
-
-
-        ast::ptr< ast::Expr > resolveInVoidContext(
-                const ast::Expr * expr, const ast::SymbolTable & symtab, ast::TypeEnvironment & env
-        ) {
-                assertf( expr, "expected a non-null expression" );
-
-                // set up and resolve expression cast to void
-                ast::CastExpr * untyped = new ast::CastExpr{ expr };
-                CandidateRef choice = findUnfinishedKindExpression(
-                        untyped, symtab, "", anyCandidate, ResolvMode::withAdjustment() );
-
-                // a cast expression has either 0 or 1 interpretations (by language rules);
-                // if 0, an exception has already been thrown, and this code will not run
-                const ast::CastExpr * castExpr = choice->expr.strict_as< ast::CastExpr >();
-                env = std::move( choice->env );
-
-                return castExpr->arg;
-        }
-
-        namespace {
-                /// Resolve `untyped` to the expression whose candidate is the best match for a `void`
-                /// context.
-                ast::ptr< ast::Expr > findVoidExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab
-                ) {
-                        resetTyVarRenaming();
-                        ast::TypeEnvironment env;
-                        ast::ptr< ast::Expr > newExpr = resolveInVoidContext( untyped, symtab, env );
-                        finishExpr( newExpr, env, untyped->env );
-                        return newExpr;
-                }
-
-                /// resolve `untyped` to the expression whose candidate satisfies `pred` with the
-                /// lowest cost, returning the resolved version
-                ast::ptr< ast::Expr > findKindExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab,
-                        std::function<bool(const Candidate &)> pred = anyCandidate,
-                        const std::string & kind = "", ResolvMode mode = {}
-                ) {
-                        if ( ! untyped ) return {};
-                        CandidateRef choice =
-                                findUnfinishedKindExpression( untyped, symtab, kind, pred, mode );
-                        finishExpr( choice->expr, choice->env, untyped->env );
-                        return std::move( choice->expr );
-                }
-
-                /// Resolve `untyped` to the single expression whose candidate is the best match
-                ast::ptr< ast::Expr > findSingleExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab
-                ) {
-                        return findKindExpression( untyped, symtab );
-                }
-        } // anonymous namespace
-
-                ast::ptr< ast::Expr > findSingleExpression(
-                        const ast::Expr * untyped, const ast::Type * type, const ast::SymbolTable & symtab
-                ) {
-                        assert( untyped && type );
-                        ast::ptr< ast::Expr > castExpr = new ast::CastExpr{ untyped, type };
-                        ast::ptr< ast::Expr > newExpr = findSingleExpression( castExpr, symtab );
-                        removeExtraneousCast( newExpr, symtab );
-                        return newExpr;
-                }
-
-        namespace {
-                /// Predicate for "Candidate has integral type"
-                bool hasIntegralType( const Candidate & i ) {
-                        const ast::Type * type = i.expr->result;
-
-                        if ( auto bt = dynamic_cast< const ast::BasicType * >( type ) ) {
-                                return bt->isInteger();
-                        } else if (
-                                dynamic_cast< const ast::EnumInstType * >( type )
-                                || dynamic_cast< const ast::ZeroType * >( type )
-                                || dynamic_cast< const ast::OneType * >( type )
-                        ) {
-                                return true;
-                        } else return false;
-                }
-
-                /// Resolve `untyped` as an integral expression, returning the resolved version
-                ast::ptr< ast::Expr > findIntegralExpression(
-                        const ast::Expr * untyped, const ast::SymbolTable & symtab
-                ) {
-                        return findKindExpression( untyped, symtab, hasIntegralType, "condition" );
-                }
-
-                /// check if a type is a character type
-                bool isCharType( const ast::Type * t ) {
-                        if ( auto bt = dynamic_cast< const ast::BasicType * >( t ) ) {
-                                return bt->kind == ast::BasicType::Char
-                                        || bt->kind == ast::BasicType::SignedChar
-                                        || bt->kind == ast::BasicType::UnsignedChar;
-                        }
-                        return false;
-                }
-
-                /// Advance a type itertor to the next mutex parameter
-                template<typename Iter>
-                inline bool nextMutex( Iter & it, const Iter & end ) {
-                        while ( it != end && ! (*it)->get_type()->is_mutex() ) { ++it; }
-                        return it != end;
-                }
-        }
-
-        class Resolver_new final
-        : public ast::WithSymbolTable, public ast::WithGuards,
-          public ast::WithVisitorRef<Resolver_new>, public ast::WithShortCircuiting,
-          public ast::WithStmtsToAdd<> {
-
-                ast::ptr< ast::Type > functionReturn = nullptr;
-                ast::CurrentObject currentObject;
-                bool inEnumDecl = false;
-
-        public:
-                Resolver_new() = default;
-                Resolver_new( const ast::SymbolTable & syms ) { symtab = syms; }
-
-                void previsit( const ast::FunctionDecl * );
-                const ast::FunctionDecl * postvisit( const ast::FunctionDecl * );
-                void previsit( const ast::ObjectDecl * );
-                void previsit( const ast::EnumDecl * );
-                const ast::StaticAssertDecl * previsit( const ast::StaticAssertDecl * );
-
-                const ast::ArrayType * previsit( const ast::ArrayType * );
-                const ast::PointerType * previsit( const ast::PointerType * );
-
-                const ast::ExprStmt *        previsit( const ast::ExprStmt * );
-                const ast::AsmExpr *         previsit( const ast::AsmExpr * );
-                const ast::AsmStmt *         previsit( const ast::AsmStmt * );
-                const ast::IfStmt *          previsit( const ast::IfStmt * );
-                const ast::WhileStmt *       previsit( const ast::WhileStmt * );
-                const ast::ForStmt *         previsit( const ast::ForStmt * );
-                const ast::SwitchStmt *      previsit( const ast::SwitchStmt * );
-                const ast::CaseStmt *        previsit( const ast::CaseStmt * );
-                const ast::BranchStmt *      previsit( const ast::BranchStmt * );
-                const ast::ReturnStmt *      previsit( const ast::ReturnStmt * );
-                const ast::ThrowStmt *       previsit( const ast::ThrowStmt * );
-                const ast::CatchStmt *       previsit( const ast::CatchStmt * );
-                const ast::WaitForStmt *     previsit( const ast::WaitForStmt * );
-
-                const ast::SingleInit *      previsit( const ast::SingleInit * );
-                const ast::ListInit *        previsit( const ast::ListInit * );
-                const ast::ConstructorInit * previsit( const ast::ConstructorInit * );
-        };
-
-        void resolve( std::list< ast::ptr<ast::Decl> >& translationUnit ) {
-                ast::Pass< Resolver_new > resolver;
-                accept_all( translationUnit, resolver );
-        }
-
-        ast::ptr< ast::Init > resolveCtorInit(
-                const ast::ConstructorInit * ctorInit, const ast::SymbolTable & symtab
-        ) {
-                assert( ctorInit );
-                ast::Pass< Resolver_new > resolver{ symtab };
-                return ctorInit->accept( resolver );
-        }
-
-        ast::ptr< ast::Expr > resolveStmtExpr(
-                const ast::StmtExpr * stmtExpr, const ast::SymbolTable & symtab
-        ) {
-                assert( stmtExpr );
-                ast::Pass< Resolver_new > resolver{ symtab };
-                ast::ptr< ast::Expr > ret = stmtExpr;
-                ret = ret->accept( resolver );
-                strict_dynamic_cast< ast::StmtExpr * >( ret.get_and_mutate() )->computeResult();
-                return ret;
-        }
-
-        void Resolver_new::previsit( const ast::FunctionDecl * functionDecl ) {
-                GuardValue( functionReturn );
-                functionReturn = extractResultType( functionDecl->type );
-        }
-
-        const ast::FunctionDecl * Resolver_new::postvisit( const ast::FunctionDecl * functionDecl ) {
-                // default value expressions have an environment which shouldn't be there and trips up
-                // later passes.
-                ast::ptr< ast::FunctionDecl > ret = functionDecl;
-                for ( unsigned i = 0; i < functionDecl->type->params.size(); ++i ) {
-                        const ast::ptr<ast::DeclWithType> & d = functionDecl->type->params[i];
-
-                        if ( const ast::ObjectDecl * obj = d.as< ast::ObjectDecl >() ) {
-                                if ( const ast::SingleInit * init = obj->init.as< ast::SingleInit >() ) {
-                                        if ( init->value->env == nullptr ) continue;
-                                        // clone initializer minus the initializer environment
-                                        ast::chain_mutate( ret )
-                                                ( &ast::FunctionDecl::type )
-                                                        ( &ast::FunctionType::params )[i]
-                                                                ( &ast::ObjectDecl::init )
-                                                                        ( &ast::SingleInit::value )->env = nullptr;
-
-                                        assert( functionDecl != ret.get() || functionDecl->unique() );
-                                        assert( ! ret->type->params[i].strict_as< ast::ObjectDecl >()->init.strict_as< ast::SingleInit >()->value->env );
-                                }
-                        }
-                }
-                return ret.get();
-        }
-
-        void Resolver_new::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
-                // twice. The second analysis changes `initContext` because a function type can contain
-                // object declarations in the return and parameter types. Therefore each value of
-                // `initContext` is retained so the type on the first analysis is preserved and used for
-                // selecting the RHS.
-                GuardValue( currentObject );
-                currentObject = ast::CurrentObject{ objectDecl->location, objectDecl->get_type() };
-                if ( inEnumDecl && dynamic_cast< const ast::EnumInstType * >( objectDecl->get_type() ) ) {
-                        // enumerator initializers should not use the enum type to initialize, since the
-                        // enum type is still incomplete at this point. Use `int` instead.
-                        currentObject = ast::CurrentObject{
-                                objectDecl->location, new ast::BasicType{ ast::BasicType::SignedInt } };
-                }
-        }
-
-        void Resolver_new::previsit( const ast::EnumDecl * ) {
-                // in case we decide to allow nested enums
-                GuardValue( inEnumDecl );
-                inEnumDecl = false;
-        }
-
-        const ast::StaticAssertDecl * Resolver_new::previsit(
-                const ast::StaticAssertDecl * assertDecl
-        ) {
-                return ast::mutate_field(
-                        assertDecl, &ast::StaticAssertDecl::cond,
-                        findIntegralExpression( assertDecl->cond, symtab ) );
-        }
-
-        template< typename PtrType >
-        const PtrType * handlePtrType( const PtrType * type, const ast::SymbolTable & symtab ) {
-                if ( type->dimension ) {
-                        #warning should use new equivalent to Validate::SizeType rather than sizeType here
-                        ast::ptr< ast::Type > sizeType = new ast::BasicType{ ast::BasicType::LongUnsignedInt };
-                        ast::mutate_field(
-                                type, &PtrType::dimension,
-                                findSingleExpression( type->dimension, sizeType, symtab ) );
-                }
-                return type;
-        }
-
-        const ast::ArrayType * Resolver_new::previsit( const ast::ArrayType * at ) {
-                return handlePtrType( at, symtab );
-        }
-
-        const ast::PointerType * Resolver_new::previsit( const ast::PointerType * pt ) {
-                return handlePtrType( pt, symtab );
-        }
-
-        const ast::ExprStmt * Resolver_new::previsit( const ast::ExprStmt * exprStmt ) {
-                visit_children = false;
-                assertf( exprStmt->expr, "ExprStmt has null expression in resolver" );
-
-                return ast::mutate_field(
-                        exprStmt, &ast::ExprStmt::expr, findVoidExpression( exprStmt->expr, symtab ) );
-        }
-
-        const ast::AsmExpr * Resolver_new::previsit( const ast::AsmExpr * asmExpr ) {
-                visit_children = false;
-
-                asmExpr = ast::mutate_field(
-                        asmExpr, &ast::AsmExpr::operand, findVoidExpression( asmExpr->operand, symtab ) );
-
-                if ( asmExpr->inout ) {
-                        asmExpr = ast::mutate_field(
-                                asmExpr, &ast::AsmExpr::inout, findVoidExpression( asmExpr->inout, symtab ) );
-                }
-
-                return asmExpr;
-        }
-
-        const ast::AsmStmt * Resolver_new::previsit( const ast::AsmStmt * asmStmt ) {
-                visitor->maybe_accept( asmStmt, &ast::AsmStmt::input );
-                visitor->maybe_accept( asmStmt, &ast::AsmStmt::output );
-                visit_children = false;
-                return asmStmt;
-        }
-
-        const ast::IfStmt * Resolver_new::previsit( const ast::IfStmt * ifStmt ) {
-                return ast::mutate_field(
-                        ifStmt, &ast::IfStmt::cond, findIntegralExpression( ifStmt->cond, symtab ) );
-        }
-
-        const ast::WhileStmt * Resolver_new::previsit( const ast::WhileStmt * whileStmt ) {
-                return ast::mutate_field(
-                        whileStmt, &ast::WhileStmt::cond, findIntegralExpression( whileStmt->cond, symtab ) );
-        }
-
-        const ast::ForStmt * Resolver_new::previsit( const ast::ForStmt * forStmt ) {
-                if ( forStmt->cond ) {
-                        forStmt = ast::mutate_field(
-                                forStmt, &ast::ForStmt::cond, findIntegralExpression( forStmt->cond, symtab ) );
-                }
-
-                if ( forStmt->inc ) {
-                        forStmt = ast::mutate_field(
-                                forStmt, &ast::ForStmt::inc, findVoidExpression( forStmt->inc, symtab ) );
-                }
-
-                return forStmt;
-        }
-
-        const ast::SwitchStmt * Resolver_new::previsit( const ast::SwitchStmt * switchStmt ) {
-                GuardValue( currentObject );
-                switchStmt = ast::mutate_field(
-                        switchStmt, &ast::SwitchStmt::cond,
-                        findIntegralExpression( switchStmt->cond, symtab ) );
-                currentObject = ast::CurrentObject{ switchStmt->location, switchStmt->cond->result };
-                return switchStmt;
-        }
-
-        const ast::CaseStmt * Resolver_new::previsit( const ast::CaseStmt * caseStmt ) {
-                if ( caseStmt->cond ) {
-                        std::deque< ast::InitAlternative > initAlts = currentObject.getOptions();
-                        assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral "
-                                "expression." );
-
-                        ast::ptr< ast::Expr > untyped =
-                                new ast::CastExpr{ caseStmt->location, caseStmt->cond, initAlts.front().type };
-                        ast::ptr< ast::Expr > newExpr = findSingleExpression( untyped, symtab );
-
-                        // case condition cannot have a cast in C, so it must be removed here, regardless of
-                        // whether it would perform a conversion.
-                        if ( const ast::CastExpr * castExpr = newExpr.as< ast::CastExpr >() ) {
-                                swap_and_save_env( newExpr, castExpr->arg );
-                        }
-
-                        caseStmt = ast::mutate_field( caseStmt, &ast::CaseStmt::cond, newExpr );
-                }
-                return caseStmt;
-        }
-
-        const ast::BranchStmt * Resolver_new::previsit( const ast::BranchStmt * branchStmt ) {
-                visit_children = false;
-                // must resolve the argument of a computed goto
-                if ( branchStmt->kind == ast::BranchStmt::Goto && branchStmt->computedTarget ) {
-                        // computed goto argument is void*
-                        ast::ptr< ast::Type > target = new ast::PointerType{ new ast::VoidType{} };
-                        branchStmt = ast::mutate_field(
-                                branchStmt, &ast::BranchStmt::computedTarget,
-                                findSingleExpression( branchStmt->computedTarget, target, symtab ) );
-                }
-                return branchStmt;
-        }
-
-        const ast::ReturnStmt * Resolver_new::previsit( const ast::ReturnStmt * returnStmt ) {
-                visit_children = false;
-                if ( returnStmt->expr ) {
-                        returnStmt = ast::mutate_field(
-                                returnStmt, &ast::ReturnStmt::expr,
-                                findSingleExpression( returnStmt->expr, functionReturn, symtab ) );
-                }
-                return returnStmt;
-        }
-
-        const ast::ThrowStmt * Resolver_new::previsit( const ast::ThrowStmt * throwStmt ) {
-                visit_children = false;
-                if ( throwStmt->expr ) {
-                        const ast::StructDecl * exceptionDecl =
-                                symtab.lookupStruct( "__cfaabi_ehm__base_exception_t" );
-                        assert( exceptionDecl );
-                        ast::ptr< ast::Type > exceptType =
-                                new ast::PointerType{ new ast::StructInstType{ exceptionDecl } };
-                        throwStmt = ast::mutate_field(
-                                throwStmt, &ast::ThrowStmt::expr,
-                                findSingleExpression( throwStmt->expr, exceptType, symtab ) );
-                }
-                return throwStmt;
-        }
-
-        const ast::CatchStmt * Resolver_new::previsit( const ast::CatchStmt * catchStmt ) {
-                if ( catchStmt->cond ) {
-                        ast::ptr< ast::Type > boolType = new ast::BasicType{ ast::BasicType::Bool };
-                        catchStmt = ast::mutate_field(
-                                catchStmt, &ast::CatchStmt::cond,
-                                findSingleExpression( catchStmt->cond, boolType, symtab ) );
-                }
-                return catchStmt;
-        }
-
-        const ast::WaitForStmt * Resolver_new::previsit( const ast::WaitForStmt * stmt ) {
-                visit_children = false;
-
-                // Resolve all clauses first
-                for ( unsigned i = 0; i < stmt->clauses.size(); ++i ) {
-                        const ast::WaitForStmt::Clause & clause = stmt->clauses[i];
-
-                        ast::TypeEnvironment env;
-                        CandidateFinder funcFinder{ symtab, env };
-
-                        // Find all candidates for a function in canonical form
-                        funcFinder.find( clause.target.func, ResolvMode::withAdjustment() );
-
-                        if ( funcFinder.candidates.empty() ) {
-                                stringstream ss;
-                                ss << "Use of undeclared indentifier '";
-                                ss << clause.target.func.strict_as< ast::NameExpr >()->name;
-                                ss << "' in call to waitfor";
-                                SemanticError( stmt->location, ss.str() );
-                        }
-
-                        if ( clause.target.args.empty() ) {
-                                SemanticError( stmt->location,
-                                        "Waitfor clause must have at least one mutex parameter");
-                        }
-
-                        // Find all alternatives for all arguments in canonical form
-                        std::vector< CandidateFinder > argFinders =
-                                funcFinder.findSubExprs( clause.target.args );
-
-                        // List all combinations of arguments
-                        std::vector< CandidateList > possibilities;
-                        combos( argFinders.begin(), argFinders.end(), back_inserter( possibilities ) );
-
-                        // For every possible function:
-                        // * try matching the arguments to the parameters, not the other way around because
-                        //   more arguments than parameters
-                        CandidateList funcCandidates;
-                        std::vector< CandidateList > argsCandidates;
-                        SemanticErrorException errors;
-                        for ( CandidateRef & func : funcFinder.candidates ) {
-                                try {
-                                        auto pointerType = dynamic_cast< const ast::PointerType * >(
-                                                func->expr->result->stripReferences() );
-                                        if ( ! pointerType ) {
-                                                SemanticError( stmt->location, func->expr->result.get(),
-                                                        "candidate not viable: not a pointer type\n" );
-                                        }
-
-                                        auto funcType = pointerType->base.as< ast::FunctionType >();
-                                        if ( ! funcType ) {
-                                                SemanticError( stmt->location, func->expr->result.get(),
-                                                        "candidate not viable: not a function type\n" );
-                                        }
-
-                                        {
-                                                auto param    = funcType->params.begin();
-                                                auto paramEnd = funcType->params.end();
-
-                                                if( ! nextMutex( param, paramEnd ) ) {
-                                                        SemanticError( stmt->location, funcType,
-                                                                "candidate function not viable: no mutex parameters\n");
-                                                }
-                                        }
-
-                                        CandidateRef func2{ new Candidate{ *func } };
-                                        // strip reference from function
-                                        func2->expr = referenceToRvalueConversion( func->expr, func2->cost );
-
-                                        // Each argument must be matched with a parameter of the current candidate
-                                        for ( auto & argsList : possibilities ) {
-                                                try {
-                                                        // Declare data structures needed for resolution
-                                                        ast::OpenVarSet open;
-                                                        ast::AssertionSet need, have;
-                                                        ast::TypeEnvironment resultEnv{ func->env };
-                                                        // Add all type variables as open so that those not used in the
-                                                        // parameter list are still considered open
-                                                        resultEnv.add( funcType->forall );
-
-                                                        // load type variables from arguments into one shared space
-                                                        for ( auto & arg : argsList ) {
-                                                                resultEnv.simpleCombine( arg->env );
-                                                        }
-
-                                                        // Make sure we don't widen any existing bindings
-                                                        resultEnv.forbidWidening();
-
-                                                        // Find any unbound type variables
-                                                        resultEnv.extractOpenVars( open );
-
-                                                        auto param = funcType->params.begin();
-                                                        auto paramEnd = funcType->params.end();
-
-                                                        unsigned n_mutex_param = 0;
-
-                                                        // For every argument of its set, check if it matches one of the
-                                                        // parameters. The order is important
-                                                        for ( auto & arg : argsList ) {
-                                                                // Ignore non-mutex arguments
-                                                                if ( ! nextMutex( param, paramEnd ) ) {
-                                                                        // We ran out of parameters but still have arguments.
-                                                                        // This function doesn't match
-                                                                        SemanticError( stmt->location, funcType,
-                                                                                toString("candidate function not viable: too many mutex "
-                                                                                "arguments, expected ", n_mutex_param, "\n" ) );
-                                                                }
-
-                                                                ++n_mutex_param;
-
-                                                                // Check if the argument matches the parameter type in the current
-                                                                // scope
-                                                                ast::ptr< ast::Type > paramType = (*param)->get_type();
-                                                                if (
-                                                                        ! unify(
-                                                                                arg->expr->result, paramType, resultEnv, need, have, open,
-                                                                                symtab )
-                                                                ) {
-                                                                        // Type doesn't match
-                                                                        stringstream ss;
-                                                                        ss << "candidate function not viable: no known conversion "
-                                                                                "from '";
-                                                                        ast::print( ss, (*param)->get_type() );
-                                                                        ss << "' to '";
-                                                                        ast::print( ss, arg->expr->result );
-                                                                        ss << "' with env '";
-                                                                        ast::print( ss, resultEnv );
-                                                                        ss << "'\n";
-                                                                        SemanticError( stmt->location, funcType, ss.str() );
-                                                                }
-
-                                                                ++param;
-                                                        }
-
-                                                        // All arguments match!
-
-                                                        // Check if parameters are missing
-                                                        if ( nextMutex( param, paramEnd ) ) {
-                                                                do {
-                                                                        ++n_mutex_param;
-                                                                        ++param;
-                                                                } while ( nextMutex( param, paramEnd ) );
-
-                                                                // We ran out of arguments but still have parameters left; this
-                                                                // function doesn't match
-                                                                SemanticError( stmt->location, funcType,
-                                                                        toString( "candidate function not viable: too few mutex "
-                                                                        "arguments, expected ", n_mutex_param, "\n" ) );
-                                                        }
-
-                                                        // All parameters match!
-
-                                                        // Finish the expressions to tie in proper environments
-                                                        finishExpr( func2->expr, resultEnv );
-                                                        for ( CandidateRef & arg : argsList ) {
-                                                                finishExpr( arg->expr, resultEnv );
-                                                        }
-
-                                                        // This is a match, store it and save it for later
-                                                        funcCandidates.emplace_back( std::move( func2 ) );
-                                                        argsCandidates.emplace_back( std::move( argsList ) );
-
-                                                } catch ( SemanticErrorException & e ) {
-                                                        errors.append( e );
-                                                }
-                                        }
-                                } catch ( SemanticErrorException & e ) {
-                                        errors.append( e );
-                                }
-                        }
-
-                        // Make sure correct number of arguments
-                        if( funcCandidates.empty() ) {
-                                SemanticErrorException top( stmt->location,
-                                        "No alternatives for function in call to waitfor" );
-                                top.append( errors );
-                                throw top;
-                        }
-
-                        if( argsCandidates.empty() ) {
-                                SemanticErrorException top( stmt->location,
-                                        "No alternatives for arguments in call to waitfor" );
-                                top.append( errors );
-                                throw top;
-                        }
-
-                        if( funcCandidates.size() > 1 ) {
-                                SemanticErrorException top( stmt->location,
-                                        "Ambiguous function in call to waitfor" );
-                                top.append( errors );
-                                throw top;
-                        }
-                        if( argsCandidates.size() > 1 ) {
-                                SemanticErrorException top( stmt->location,
-                                        "Ambiguous arguments in call to waitfor" );
-                                top.append( errors );
-                                throw top;
-                        }
-                        // TODO: need to use findDeletedExpr to ensure no deleted identifiers are used.
-
-                        // build new clause
-                        ast::WaitForStmt::Clause clause2;
-
-                        clause2.target.func = funcCandidates.front()->expr;
-
-                        clause2.target.args.reserve( clause.target.args.size() );
-                        for ( auto arg : argsCandidates.front() ) {
-                                clause2.target.args.emplace_back( std::move( arg->expr ) );
-                        }
-
-                        // Resolve the conditions as if it were an IfStmt, statements normally
-                        clause2.cond = findSingleExpression( clause.cond, symtab );
-                        clause2.stmt = clause.stmt->accept( *visitor );
-
-                        // set results into stmt
-                        auto n = mutate( stmt );
-                        n->clauses[i] = std::move( clause2 );
-                        stmt = n;
-                }
-
-                if ( stmt->timeout.stmt ) {
-                        // resolve the timeout as a size_t, the conditions like IfStmt, and stmts normally
-                        ast::WaitForStmt::Timeout timeout2;
-
-                        ast::ptr< ast::Type > target =
-                                new ast::BasicType{ ast::BasicType::LongLongUnsignedInt };
-                        timeout2.time = findSingleExpression( stmt->timeout.time, target, symtab );
-                        timeout2.cond = findSingleExpression( stmt->timeout.cond, symtab );
-                        timeout2.stmt = stmt->timeout.stmt->accept( *visitor );
-
-                        // set results into stmt
-                        auto n = mutate( stmt );
-                        n->timeout = std::move( timeout2 );
-                        stmt = n;
-                }
-
-                if ( stmt->orElse.stmt ) {
-                        // resolve the condition like IfStmt, stmts normally
-                        ast::WaitForStmt::OrElse orElse2;
-
-                        orElse2.cond = findSingleExpression( stmt->orElse.cond, symtab );
-                        orElse2.stmt = stmt->orElse.stmt->accept( *visitor );
-
-                        // set results into stmt
-                        auto n = mutate( stmt );
-                        n->orElse = std::move( orElse2 );
-                        stmt = n;
-                }
-
-                return stmt;
-        }
-
-
-
-        const ast::SingleInit * Resolver_new::previsit( const ast::SingleInit * singleInit ) {
-                visit_children = false;
-                // resolve initialization using the possibilities as determined by the `currentObject`
-                // cursor.
-                ast::ptr< ast::Expr > untyped = new ast::UntypedInitExpr{
-                        singleInit->location, singleInit->value, currentObject.getOptions() };
-                ast::ptr<ast::Expr> newExpr = findSingleExpression( untyped, symtab );
-                const ast::InitExpr * initExpr = newExpr.strict_as< ast::InitExpr >();
-
-                // move cursor to the object that is actually initialized
-                currentObject.setNext( initExpr->designation );
-
-                // discard InitExpr wrapper and retain relevant pieces.
-                // `initExpr` may have inferred params in the case where the expression specialized a
-                // function pointer, and newExpr may already have inferParams of its own, so a simple
-                // swap is not sufficient
-                ast::Expr::InferUnion inferred = initExpr->inferred;
-                swap_and_save_env( newExpr, initExpr->expr );
-                newExpr.get_and_mutate()->inferred.splice( std::move(inferred) );
-
-                // get the actual object's type (may not exactly match what comes back from the resolver
-                // due to conversions)
-                const ast::Type * initContext = currentObject.getCurrentType();
-
-                removeExtraneousCast( newExpr, symtab );
-
-                // check if actual object's type is char[]
-                if ( auto at = dynamic_cast< const ast::ArrayType * >( initContext ) ) {
-                        if ( isCharType( at->base ) ) {
-                                // check if the resolved type is char*
-                                if ( auto pt = newExpr->result.as< ast::PointerType >() ) {
-                                        if ( isCharType( pt->base ) ) {
-                                                // strip cast if we're initializing a char[] with a char*
-                                                // e.g. char x[] = "hello"
-                                                if ( auto ce = newExpr.as< ast::CastExpr >() ) {
-                                                        swap_and_save_env( newExpr, ce->arg );
-                                                }
-                                        }
-                                }
-                        }
-                }
-
-                // move cursor to next object in preparation for next initializer
-                currentObject.increment();
-
-                // set initializer expression to resolved expression
-                return ast::mutate_field( singleInit, &ast::SingleInit::value, std::move(newExpr) );
-        }
-
-        const ast::ListInit * Resolver_new::previsit( const ast::ListInit * listInit ) {
-                // move cursor into brace-enclosed initializer-list
-                currentObject.enterListInit( listInit->location );
-
-                assert( listInit->designations.size() == listInit->initializers.size() );
-                for ( unsigned i = 0; i < listInit->designations.size(); ++i ) {
-                        // iterate designations and initializers in pairs, moving the cursor to the current
-                        // designated object and resolving the initializer against that object
-                        listInit = ast::mutate_field_index(
-                                listInit, &ast::ListInit::designations, i,
-                                currentObject.findNext( listInit->designations[i] ) );
-                        listInit = ast::mutate_field_index(
-                                listInit, &ast::ListInit::initializers, i,
-                                listInit->initializers[i]->accept( *visitor ) );
-                }
-
-                // move cursor out of brace-enclosed initializer-list
-                currentObject.exitListInit();
-
-                visit_children = false;
-                return listInit;
-        }
-
-        const ast::ConstructorInit * Resolver_new::previsit( const ast::ConstructorInit * ctorInit ) {
-                visitor->maybe_accept( ctorInit, &ast::ConstructorInit::ctor );
-                visitor->maybe_accept( ctorInit, &ast::ConstructorInit::dtor );
-
-                // found a constructor - can get rid of C-style initializer
-                // xxx - Rob suggests this field is dead code
-                ctorInit = ast::mutate_field( ctorInit, &ast::ConstructorInit::init, nullptr );
-
-                // intrinsic single-parameter constructors and destructors do nothing. Since this was
-                // implicitly generated, there's no way for it to have side effects, so get rid of it to
-                // clean up generated code
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
-                        ctorInit = ast::mutate_field( ctorInit, &ast::ConstructorInit::ctor, nullptr );
-                }
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
-                        ctorInit = ast::mutate_field( ctorInit, &ast::ConstructorInit::dtor, nullptr );
-                }
-
-                return ctorInit;
-        }
-
 } // namespace ResolvExpr