Changeset 90152a4 for src/ResolvExpr/Resolver.cc

Timestamp:

Aug 27, 2018, 4:40:34 PM (7 years ago)

Author:

Rob Schluntz <rschlunt@…>

Branches:

ADT, arm-eh, ast-experimental, cleanup-dtors, enum, forall-pointer-decay, jacob/cs343-translation, jenkins-sandbox, master, new-ast, new-ast-unique-expr, pthread-emulation, qualifiedEnum

Children:

b7c89aa

Parents:

f9feab8 (diff), 305581d (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

File:

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

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Tus Aug  8 16:06:00 2017
-// Update Count     : 212
+// Last Modified By : Peter A. Buhr
+// Last Modified On : Sat Feb 17 11:19:40 2018
+// Update Count     : 213
 //
 
@@ -30 +30 @@
 #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
@@ -57 +56 @@
                 void postvisit( FunctionDecl *functionDecl );
                 void previsit( ObjectDecl *objectDecll );
-                void previsit( TypeDecl *typeDecl );
                 void previsit( EnumDecl * enumDecl );
+                void previsit( StaticAssertDecl * assertDecl );
 
                 void previsit( ArrayType * at );
@@ -76 +75 @@
                 void previsit( CatchStmt *catchStmt );
                 void previsit( WaitForStmt * stmt );
-                void previsit( WithStmt * withStmt );
 
                 void previsit( SingleInit *singleInit );
@@ -82 +80 @@
                 void previsit( ConstructorInit *ctorInit );
           private:
-        typedef std::list< Initializer * >::iterator InitIterator;
+                typedef std::list< Initializer * >::iterator InitIterator;
 
                 template< typename PtrType >
                 void handlePtrType( PtrType * type );
 
-          void resolveAggrInit( ReferenceToType *, InitIterator &, InitIterator & );
-          void resolveSingleAggrInit( Declaration *, InitIterator &, InitIterator &, TypeSubstitution sub );
-          void fallbackInit( ConstructorInit * ctorInit );
+                void fallbackInit( ConstructorInit * ctorInit );
 
                 Type * functionReturn = nullptr;
@@ -96 +92 @@
         };
 
+        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> resolver;
@@ -106 +109 @@
         }
 
-        // used in resolveTypeof
-        Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer ) {
-                TypeEnvironment env;
-                return resolveInVoidContext( expr, indexer, env );
-        }
-
         namespace {
-                void finishExpr( Expression *expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
+                struct DeleteFinder : public WithShortCircuiting        {
+                        DeletedExpr * delExpr = nullptr;
+                        void previsit( DeletedExpr * expr ) {
+                                if ( delExpr ) visit_children = false;
+                                else delExpr = expr;
+                        }
+
+                        void previsit( Expression * ) {
+                                if ( delExpr ) visit_children = false;
+                        }
+                };
+        }
+
+        DeletedExpr * findDeletedExpr( Expression * expr ) {
+                PassVisitor<DeleteFinder> finder;
+                expr->accept( finder );
+                return finder.pass.delExpr;
+        }
+
+        namespace {
+                struct StripCasts {
+                        Expression * postmutate( CastExpr * castExpr ) {
+                                if ( castExpr->isGenerated && ResolvExpr::typesCompatible( castExpr->arg->result, castExpr->result, SymTab::Indexer() ) ) {
+                                        // generated cast is to the same type as its argument, so it's unnecessary -- remove it
+                                        Expression * expr = castExpr->arg;
+                                        castExpr->arg = nullptr;
+                                        std::swap( expr->env, castExpr->env );
+                                        return expr;
+                                }
+                                return castExpr;
+                        }
+
+                        static void strip( Expression *& expr ) {
+                                PassVisitor<StripCasts> stripper;
+                                expr = expr->acceptMutator( stripper );
+                        }
+                };
+
+                void finishExpr( Expression *&expr, const TypeEnvironment &env, TypeSubstitution * oldenv = nullptr ) {
                         expr->env = oldenv ? oldenv->clone() : new TypeSubstitution;
-                        env.makeSubstitution( *expr->get_env() );
+                        env.makeSubstitution( *expr->env );
+                        StripCasts::strip( expr ); // remove unnecessary casts that may be buried in an expression
                 }
 
@@ -131 +167 @@
         } // namespace
 
+        namespace {
+                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." );
+                        TypeEnvironment env;
+                        AlternativeFinder finder( indexer, env );
+                        finder.find( untyped, adjust, prune, failFast );
+
+                        #if 0
+                        if ( finder.get_alternatives().size() != 1 ) {
+                                std::cerr << "untyped expr is ";
+                                untyped->print( std::cerr );
+                                std::cerr << std::endl << "alternatives are:";
+                                for ( const Alternative & alt : finder.get_alternatives() ) {
+                                        alt.print( std::cerr );
+                                } // for
+                        } // if
+                        #endif
+
+                        AltList candidates;
+                        for ( Alternative & alt : finder.get_alternatives() ) {
+                                if ( pred( alt ) ) {
+                                        candidates.push_back( std::move( alt ) );
+                                }
+                        }
+
+                        // 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: ") );
+                        } else if ( winners.size() != 1 ) {
+                                std::ostringstream stream;
+                                stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
+                                untyped->print( stream );
+                                stream << " Alternatives are:\n";
+                                printAlts( winners, stream, 1 );
+                                SemanticError( untyped->location, stream.str() );
+                        }
+
+                        // 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 " );
+                        }
+                        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, bool adjust = false, bool prune = true, bool failFast = true) {
+                        if ( ! untyped ) return;
+                        Alternative choice;
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
+                        finishExpr( choice.expr, choice.env, untyped->env );
+                        delete untyped;
+                        untyped = choice.expr;
+                        choice.expr = nullptr;
+                }
+
+                bool standardAlternativeFilter( const Alternative & ) {
+                        // currently don't need to filter, under normal circumstances.
+                        // in the future, this may be useful for removing deleted expressions
+                        return true;
+                }
+        } // namespace
+
+        // used in resolveTypeof
+        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 ) {
+                // 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." );
+
+                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, true );
+                CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
+                env = std::move( choice.env );
+
+                // clean up resolved expression
+                Expression * ret = castExpr->arg;
+                castExpr->arg = nullptr;
+
+                // unlink the arg so that it isn't deleted twice at the end of the program
+                untyped.arg = nullptr;
+                return ret;
+        }
+
         void findVoidExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                global_renamer.reset();
+                resetTyVarRenaming();
                 TypeEnvironment env;
-                Expression *newExpr = resolveInVoidContext( untyped, indexer, env );
+                Expression * newExpr = resolveInVoidContext( untyped, indexer, env );
                 finishExpr( newExpr, env, untyped->env );
                 delete untyped;
@@ -141 +273 @@
 
         void findSingleExpression( Expression *&untyped, const SymTab::Indexer &indexer ) {
-                if ( ! untyped ) return;
-                TypeEnvironment env;
-                AlternativeFinder finder( indexer, env );
-                finder.find( untyped );
-                #if 0
-                if ( finder.get_alternatives().size() != 1 ) {
-                        std::cerr << "untyped expr is ";
-                        untyped->print( std::cerr );
-                        std::cerr << std::endl << "alternatives are:";
-                        for ( const Alternative & alt : finder.get_alternatives() ) {
-                                alt.print( std::cerr );
-                        } // for
-                } // if
-                #endif
-                assertf( finder.get_alternatives().size() == 1, "findSingleExpression: must have exactly one alternative at the end." );
-                Alternative &choice = finder.get_alternatives().front();
-                Expression *newExpr = choice.expr->clone();
-                finishExpr( newExpr, choice.env, untyped->env );
-                delete untyped;
-                untyped = newExpr;
+                findKindExpression( untyped, indexer, "", standardAlternativeFilter );
         }
 
         void findSingleExpression( Expression *& untyped, Type * type, const SymTab::Indexer & indexer ) {
                 assert( untyped && type );
+                // transfer location to generated cast for error purposes
+                CodeLocation location = untyped->location;
                 untyped = new CastExpr( untyped, type );
+                untyped->location = location;
                 findSingleExpression( untyped, indexer );
                 removeExtraneousCast( untyped, indexer );
@@ -171 +287 @@
 
         namespace {
-                bool isIntegralType( Type *type ) {
+                bool isIntegralType( const Alternative & alt ) {
+                        Type * type = alt.expr->result;
                         if ( dynamic_cast< EnumInstType * >( type ) ) {
                                 return true;
@@ -184 +301 @@
 
                 void findIntegralExpression( Expression *& untyped, const SymTab::Indexer &indexer ) {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.find( untyped );
-#if 0
-                        if ( finder.get_alternatives().size() != 1 ) {
-                                std::cout << "untyped expr is ";
-                                untyped->print( std::cout );
-                                std::cout << std::endl << "alternatives are:";
-                                for ( std::list< Alternative >::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                        i->print( std::cout );
-                                } // for
-                        } // if
-#endif
-                        Expression *newExpr = 0;
-                        const TypeEnvironment *newEnv = 0;
-                        for ( AltList::const_iterator i = finder.get_alternatives().begin(); i != finder.get_alternatives().end(); ++i ) {
-                                if ( i->expr->get_result()->size() == 1 && isIntegralType( i->expr->get_result() ) ) {
-                                        if ( newExpr ) {
-                                                throw SemanticError( "Too many interpretations for case control expression", untyped );
-                                        } else {
-                                                newExpr = i->expr->clone();
-                                                newEnv = &i->env;
-                                        } // if
-                                } // if
-                        } // for
-                        if ( ! newExpr ) {
-                                throw SemanticError( "No interpretations for case control expression", untyped );
-                        } // if
-                        finishExpr( newExpr, *newEnv, untyped->env );
-                        delete untyped;
-                        untyped = newExpr;
-                }
-
+                        findKindExpression( untyped, indexer, "condition", isIntegralType );
+                }
+        }
+
+
+        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 ) {
+                {
+                        // resolve with-exprs with parameters in scope and add any newly generated declarations to the
+                        // front of the function body.
+                        auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this](){ indexer.leaveScope(); } );
+                        indexer.addFunctionType( functionDecl->type );
+                        std::list< Statement * > newStmts;
+                        resolveWithExprs( functionDecl->withExprs, newStmts );
+                        if ( functionDecl->statements ) {
+                                functionDecl->statements->kids.splice( functionDecl->statements->kids.begin(), newStmts );
+                        } else {
+                                assertf( functionDecl->withExprs.empty() && newStmts.empty(), "Function %s without a body has with-clause and/or generated with declarations.", functionDecl->name.c_str() );
+                        }
+                }
         }
 
         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
@@ -251 +386 @@
         }
 
-        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
@@ -264 +392 @@
                 std::cerr << std::endl;
 #endif
-                Type *new_type = resolveTypeof( functionDecl->get_type(), indexer );
-                functionDecl->set_type( new_type );
                 GuardValue( functionReturn );
-                functionReturn = ResolvExpr::extractResultType( functionDecl->get_functionType() );
+                functionReturn = ResolvExpr::extractResultType( functionDecl->type );
         }
 
@@ -274 +400 @@
                 // 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->get_functionType()->get_parameters() ) {
+                for ( Declaration * d : functionDecl->type->parameters ) {
                         if ( ObjectDecl * obj = dynamic_cast< ObjectDecl * >( d ) ) {
-                                if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->get_init() ) ) {
-                                        delete init->get_value()->get_env();
-                                        init->get_value()->set_env( nullptr );
+                                if ( SingleInit * init = dynamic_cast< SingleInit * >( obj->init ) ) {
+                                        delete init->value->env;
+                                        init->value->env = nullptr;
                                 }
                         }
@@ -290 +416 @@
         }
 
+        void Resolver::previsit( StaticAssertDecl * assertDecl ) {
+                findIntegralExpression( assertDecl->condition, indexer );
+        }
+
         void Resolver::previsit( ExprStmt *exprStmt ) {
                 visit_children = false;
@@ -311 +441 @@
 
         void Resolver::previsit( IfStmt *ifStmt ) {
-                findSingleExpression( ifStmt->condition, indexer );
+                findIntegralExpression( ifStmt->condition, indexer );
         }
 
         void Resolver::previsit( WhileStmt *whileStmt ) {
-                findSingleExpression( whileStmt->condition, indexer );
+                findIntegralExpression( whileStmt->condition, indexer );
         }
 
         void Resolver::previsit( ForStmt *forStmt ) {
                 if ( forStmt->condition ) {
-                        findSingleExpression( forStmt->condition, indexer );
+                        findIntegralExpression( forStmt->condition, indexer );
                 } // if
 
@@ -336 +466 @@
 
         void Resolver::previsit( CaseStmt *caseStmt ) {
-                if ( caseStmt->get_condition() ) {
+                if ( caseStmt->condition ) {
                         std::list< InitAlternative > initAlts = currentObject.getOptions();
                         assertf( initAlts.size() == 1, "SwitchStmt did not correctly resolve an integral expression." );
@@ -342 +472 @@
                         Expression * newExpr = new CastExpr( caseStmt->condition, initAlts.front().type->clone() );
                         findSingleExpression( newExpr, indexer );
-                        CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( newExpr );
-                        caseStmt->condition = castExpr->arg;
-                        castExpr->arg = nullptr;
-                        delete castExpr;
+                        // case condition cannot have a cast in C, so it must be removed, regardless of whether it performs a conversion.
+                        // Ideally we would perform the conversion internally here.
+                        if ( CastExpr * castExpr = dynamic_cast< CastExpr * >( newExpr ) ) {
+                                newExpr = castExpr->arg;
+                                castExpr->arg = nullptr;
+                                std::swap( newExpr->env, castExpr->env );
+                                delete castExpr;
+                        }
+                        caseStmt->condition = newExpr;
                 }
         }
@@ -411 +546 @@
                                 ss << strict_dynamic_cast<NameExpr*>( clause.target.function )->name;
                                 ss << "' in call to waitfor";
-                                throw SemanticError( ss.str() );
+                                SemanticError( stmt->location, ss.str() );
+                        }
+
+                        if(clause.target.arguments.empty()) {
+                                SemanticError( stmt->location, "Waitfor clause must have at least one mutex parameter");
                         }
 
@@ -428 +567 @@
                         //      try matching the arguments to the parameters
                         //      not the other way around because we have more arguments than parameters
-                        SemanticError errors;
+                        SemanticErrorException errors;
                         for ( Alternative & func : funcFinder.get_alternatives() ) {
                                 try {
                                         PointerType * pointer = dynamic_cast< PointerType* >( func.expr->get_result()->stripReferences() );
                                         if( !pointer ) {
-                                                throw SemanticError( "candidate not viable: not a pointer type\n", func.expr->get_result() );
+                                                SemanticError( func.expr->get_result(), "candidate not viable: not a pointer type\n" );
                                         }
 
                                         FunctionType * function = dynamic_cast< FunctionType* >( pointer->get_base() );
                                         if( !function ) {
-                                                throw SemanticError( "candidate not viable: not a function type\n", pointer->get_base() );
+                                                SemanticError( pointer->get_base(), "candidate not viable: not a function type\n" );
                                         }
 
@@ -447 +586 @@
 
                                                 if( !advance_to_mutex( param, param_end ) ) {
-                                                        throw SemanticError("candidate function not viable: no mutex parameters\n", function);
+                                                        SemanticError(function, "candidate function not viable: no mutex parameters\n");
                                                 }
                                         }
@@ -453 +592 @@
                                         Alternative newFunc( func );
                                         // Strip reference from function
-                                        referenceToRvalueConversion( newFunc.expr );
+                                        referenceToRvalueConversion( newFunc.expr, newFunc.cost );
 
                                         // For all the set of arguments we have try to match it with the parameter of the current function alternative
@@ -462 +601 @@
                                                         OpenVarSet openVars;
                                                         AssertionSet resultNeed, resultHave;
-                                                        TypeEnvironment resultEnv;
+                                                        TypeEnvironment resultEnv( func.env );
+                                                        makeUnifiableVars( function, openVars, resultNeed );
+                                                        // add all type variables as open variables now so that those not used in the parameter
+                                                        // list are still considered open.
+                                                        resultEnv.add( function->forall );
 
                                                         // Load type variables from arguemnts into one shared space
@@ -468 +611 @@
 
                                                         // Make sure we don't widen any existing bindings
-                                                        for ( auto & i : resultEnv ) {
-                                                                i.allowWidening = false;
-                                                        }
+                                                        resultEnv.forbidWidening();
 
                                                         // Find any unbound type variables
@@ -477 +618 @@
                                                         auto param     = function->parameters.begin();
                                                         auto param_end = function->parameters.end();
+
+                                                        int n_mutex_param = 0;
 
                                                         // For every arguments of its set, check if it matches one of the parameter
@@ -486 +629 @@
                                                                         // We ran out of parameters but still have arguments
                                                                         // this function doesn't match
-                                                                        throw SemanticError("candidate function not viable: too many mutex arguments\n", function);
+                                                                        SemanticError( function, 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
-                                                                if( ! unify( (*param)->get_type(), arg.expr->get_result(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
+                                                                if( ! unify( arg.expr->get_result(), (*param)->get_type(), resultEnv, resultNeed, resultHave, openVars, this->indexer ) ) {
                                                                         // Type doesn't match
                                                                         stringstream ss;
                                                                         ss << "candidate function not viable: no known convertion from '";
+                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "' to '";
                                                                         arg.expr->get_result()->print( ss );
-                                                                        ss << "' to '";
-                                                                        (*param)->get_type()->print( ss );
+                                                                        ss << "' with env '";
+                                                                        resultEnv.print(ss);
                                                                         ss << "'\n";
-                                                                        throw SemanticError(ss.str(), function);
+                                                                        SemanticError( function, ss.str() );
                                                                 }
 
@@ -508 +655 @@
                                                         // 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
-                                                                throw SemanticError("candidate function not viable: too few mutex arguments\n", function);
+                                                                SemanticError( function, toString("candidate function not viable: too few mutex arguments, expected ", n_mutex_param, "\n" ));
                                                         }
 
@@ -526 +678 @@
 
                                                 }
-                                                catch( SemanticError &e ) {
+                                                catch( SemanticErrorException &e ) {
                                                         errors.append( e );
                                                 }
                                         }
                                 }
-                                catch( SemanticError &e ) {
+                                catch( SemanticErrorException &e ) {
                                         errors.append( e );
                                 }
@@ -537 +689 @@
 
                         // Make sure we got the right number of arguments
-                        if( func_candidates.empty() )    { SemanticError top( "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
-                        if( args_candidates.empty() )    { SemanticError top( "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
-                        if( func_candidates.size() > 1 ) { SemanticError top( "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
-                        if( args_candidates.size() > 1 ) { SemanticError top( "Ambiguous arguments in call to waitfor"           ); top.append( errors ); throw top; }
-
+                        if( func_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for function in call to waitfor"  ); top.append( errors ); throw top; }
+                        if( args_candidates.empty() )    { SemanticErrorException top( stmt->location, "No alternatives for arguments in call to waitfor" ); top.append( errors ); throw top; }
+                        if( func_candidates.size() > 1 ) { SemanticErrorException top( stmt->location, "Ambiguous function in call to waitfor"            ); top.append( errors ); throw top; }
+                        if( args_candidates.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.
 
                         // Swap the results from the alternative with the unresolved values.
@@ -574 +726 @@
         }
 
-        bool isStructOrUnion( Type * t ) {
-                t = t->stripReferences();
-                return dynamic_cast< StructInstType * >( t ) || dynamic_cast< UnionInstType * >( t );
-        }
-
-        void Resolver::previsit( WithStmt * withStmt ) {
-                for ( Expression *& expr : withStmt->exprs )  {
-                        TypeEnvironment env;
-                        AlternativeFinder finder( indexer, env );
-                        finder.findWithAdjustment( expr );
-
-                        // only struct- and union-typed expressions are viable candidates
-                        AltList candidates;
-                        for ( Alternative & alt : finder.get_alternatives() ) {
-                                if ( isStructOrUnion( alt.expr->result ) ) {
-                                        candidates.push_back( std::move( alt ) );
-                                }
-                        }
-
-                        // choose the lowest cost expression among the candidates
-                        AltList winners;
-                        findMinCost( candidates.begin(), candidates.end(), back_inserter( winners ) );
-                        if ( winners.size() == 0 ) {
-                                throw SemanticError( "No reasonable alternatives for with statement expression: ", expr );
-                        } else if ( winners.size() != 1 ) {
-                                std::ostringstream stream;
-                                stream << "Cannot choose between " << winners.size() << " alternatives for with statement expression\n";
-                                expr->print( stream );
-                                stream << "Alternatives are:\n";
-                                printAlts( winners, stream, 1 );
-                                throw SemanticError( stream.str() );
-                        }
-
-                        // there is one unambiguous interpretation - move the expression into the with statement
-                        Alternative & alt = winners.front();
-                        finishExpr( alt.expr, alt.env, expr->env );
-                        delete expr;
-                        expr = alt.expr;
-                        alt.expr = nullptr;
-
-                        // 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 );
-                                stmtsToAddBefore.push_back( new DeclStmt( tmp ) );
-                                if ( InitTweak::isConstructable( tmp->type ) ) {
-                                        // generate ctor/dtor and resolve them
-                                        tmp->init = InitTweak::genCtorInit( tmp );
-                                        tmp->accept( *visitor );
-                                }
-                        }
-                }
-        }
-
         template< typename T >
         bool isCharType( T t ) {
@@ -652 +749 @@
                 initExpr->expr = nullptr;
                 std::swap( initExpr->env, newExpr->env );
-                std::swap( initExpr->inferParams, newExpr->inferParams ) ;
+                // 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;
 
@@ -740 +839 @@
                 PassVisitor<Resolver> resolver( indexer );
                 stmtExpr->accept( resolver );
+                stmtExpr->computeResult();
+                // xxx - aggregate the environments from all statements? Possibly in AlternativeFinder instead?
         }
 
@@ -745 +846 @@
                 visit_children = false;
                 // xxx - fallback init has been removed => remove fallbackInit function and remove complexity from FixInit and remove C-init from ConstructorInit
-                maybeAccept( ctorInit->get_ctor(), *visitor );
-                maybeAccept( ctorInit->get_dtor(), *visitor );
+                maybeAccept( ctorInit->ctor, *visitor );
+                maybeAccept( ctorInit->dtor, *visitor );
 
                 // found a constructor - can get rid of C-style initializer
-                delete ctorInit->get_init();
-                ctorInit->set_init( NULL );
+                delete ctorInit->init;
+                ctorInit->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->get_ctor() ) ) {
-                        delete ctorInit->get_ctor();
-                        ctorInit->set_ctor( NULL );
-                }
-
-                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->get_dtor() ) ) {
-                        delete ctorInit->get_dtor();
-                        ctorInit->set_dtor( NULL );
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->ctor ) ) {
+                        delete ctorInit->ctor;
+                        ctorInit->ctor = nullptr;
+                }
+
+                if ( InitTweak::isIntrinsicSingleArgCallStmt( ctorInit->dtor ) ) {
+                        delete ctorInit->dtor;
+                        ctorInit->dtor = nullptr;
                 }