Changeset d0c91a6 for src

Timestamp:

Jan 15, 2019, 4:16:15 PM (7 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

c802eb88

Parents:

5e49e47 (diff), c9aba81 (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 jenkins-sandbox

Location:

src

Files:

• CodeTools/ResolvProtoDump.cc (modified) (18 diffs)
• Common/FilterCombos.h (added)
• Common/utility.h (modified) (2 diffs)
• GenPoly/Box.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (3 diffs)
• Makefile.am (modified) (2 diffs)
• Makefile.in (modified) (33 diffs)
• Parser/TypeData.cc (modified) (6 diffs)
• ResolvExpr/Alternative.cc (modified) (7 diffs)
• ResolvExpr/Alternative.h (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (48 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (3 diffs)
• ResolvExpr/ConversionCost.cc (modified) (1 diff)
• ResolvExpr/Cost.h (modified) (13 diffs)
• ResolvExpr/ResolvMode.h (added)
• ResolvExpr/ResolveAssertions.cc (added)
• ResolvExpr/ResolveAssertions.h (added)
• ResolvExpr/Resolver.cc (modified) (14 diffs)
• ResolvExpr/SpecCost.cc (added)
• ResolvExpr/TypeEnvironment.cc (modified) (4 diffs)
• ResolvExpr/TypeEnvironment.h (modified) (5 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (2 diffs)
• SynTree/ApplicationExpr.cc (modified) (4 diffs)
• SynTree/Expression.cc (modified) (6 diffs)
• SynTree/Expression.h (modified) (5 diffs)
• SynTree/FunctionDecl.cc (modified) (1 diff)
• SynTree/FunctionType.cc (modified) (1 diff)
• SynTree/ObjectDecl.cc (modified) (1 diff)
• SynTree/ReferenceToType.cc (modified) (4 diffs)
• SynTree/Type.cc (modified) (1 diff)
• Tuples/Explode.h (modified) (3 diffs)
• Tuples/TupleAssignment.cc (modified) (4 diffs)
• cfa.make (modified) (1 diff)
• config.h.in (modified) (3 diffs)
• main.cc (modified) (1 diff)

src/CodeTools/ResolvProtoDump.cc

@@ -51 +51 @@
 
                 /// Child constructor
-                ProtoDump(const ProtoDump* p, Type* r) 
+                ProtoDump(const ProtoDump* p, Type* r)
                         : decls(), exprs(), subs(), closed(p->closed), parent(p), rtnType(r) {}
 
                 // Fix copy issues
-                ProtoDump(const ProtoDump& o) 
-                        : decls(o.decls), exprs(o.exprs), subs(o.subs), closed(o.closed), parent(o.parent), 
+                ProtoDump(const ProtoDump& o)
+                        : decls(o.decls), exprs(o.exprs), subs(o.subs), closed(o.closed), parent(o.parent),
                           rtnType(maybeClone(o.rtnType.get())) {}
                 ProtoDump( ProtoDump&& ) = default;
@@ -69 +69 @@
                         parent = o.parent;
                         rtnType.reset( maybeClone(o.rtnType.get()) );
-                        
+
                         return *this;
                 }
-                ProtoDump& operator= (ProtoDump&&) = default;
+                ProtoDump& operator= (ProtoDump&&) = delete;
 
         private:
@@ -96 +96 @@
                         subs.emplace_back( std::move(sub.pass) );
                 }
-        
+
                 /// Whether lists should be separated, terminated, or preceded by their separator
                 enum septype { separated, terminated, preceded };
@@ -102 +102 @@
                 /// builds space-separated list of types
                 template<typename V>
-                static void build( V& visitor, const std::list< Type* >& tys, std::stringstream& ss, 
+                static void build( V& visitor, const std::list< Type* >& tys, std::stringstream& ss,
                                 septype mode = separated ) {
                         if ( tys.empty() ) return;
@@ -121 +121 @@
                 /// builds list of types wrapped as tuple type
                 template<typename V>
-                static void buildAsTuple( V& visitor, const std::list< Type* >& tys, 
+                static void buildAsTuple( V& visitor, const std::list< Type* >& tys,
                                 std::stringstream& ss ) {
                         switch ( tys.size() ) {
@@ -162 +162 @@
                         if ( name.compare( 0, 10, "_operator_" ) == 0 ) {
                                 ss << name.substr(10);
-                        } else if ( name.compare( "_constructor" ) == 0 
+                        } else if ( name.compare( "_constructor" ) == 0
                                         || name.compare( "_destructor" ) == 0 ) {
                                 ss << name.substr(1);
@@ -173 +173 @@
 
                 /// replaces operators with resolv-proto names
-                static void rp_name( const std::string& name, std::stringstream& ss, 
+                static void rp_name( const std::string& name, std::stringstream& ss,
                                 std::string&& pre = "" ) {
                         // safety check for anonymous names
@@ -187 +187 @@
                                 op_name( info.outputName, ss );
                                 return;
-                        } 
-                        
+                        }
+
                         // replace retval names
                         if ( name.compare( 0, 8, "_retval_" ) == 0 ) {
@@ -195 +195 @@
                                 return;
                         }
-                        
+
                         // default to just name, with first character in lowercase
-                        ss << pre 
+                        ss << pre
                            << (char)std::tolower( static_cast<unsigned char>(name[0]) )
                            << (name.c_str() + 1);
@@ -221 +221 @@
                         // strip trailing "_generic_" from autogen names (avoids some user-generation issues)
                         char generic[] = "_generic_"; size_t n_generic = sizeof(generic) - 1;
-                        if ( stripped.size() >= n_generic 
+                        if ( stripped.size() >= n_generic
                                         && stripped.substr( stripped.size() - n_generic ) == generic ) {
                                 stripped.resize( stripped.size() - n_generic );
@@ -237 +237 @@
                         unsigned depth;                                 ///< Depth of nesting from root type
 
-                        TypePrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss ) 
+                        TypePrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss )
                                 : ss(ss), closed(closed), depth(0) {}
 
@@ -337 +337 @@
                         }
                 };
-        
+
                 /// builds description of function
                 void build( const std::string& name, FunctionType* fnTy, std::stringstream& ss ) {
@@ -350 +350 @@
                         for ( TypeDecl* tyvar : fnTy->forall ) {
                                 for ( DeclarationWithType* assn : tyvar->assertions ) {
-                                        ss << " | "; 
+                                        ss << " | ";
                                         build( assn->name, assn->get_type(), ss );
                                 }
@@ -360 +360 @@
                         // ignore top-level references
                         Type *norefs = ty->stripReferences();
-                        
+
                         // fall back to function declaration if function type
                         if ( PointerType* pTy = dynamic_cast< PointerType* >(norefs) ) {
@@ -409 +409 @@
                         std::stringstream& ss;                          ///< Output to print to
 
-                        ExprPrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss ) 
+                        ExprPrinter( const std::unordered_set<std::string>& closed, std::stringstream& ss )
                                 : closed(closed), ss(ss) {}
 
@@ -476 +476 @@
                                 visit_children = false;
                         }
-                        
+
                         /// Member access handled as function from aggregate to member
                         void previsit( UntypedMemberExpr* expr ) {
@@ -662 +662 @@
                                         }
                                 }
-                                
+
                                 // add named parameters and returns to local scope
                                 body.pass.addAll( decl->type->returnVals );
@@ -679 +679 @@
                 void previsit( StructDecl* sd ) { addAggregateFields(sd); }
                 void previsit( UnionDecl* ud ) { addAggregateFields(ud); }
-                
+
                 void previsit( EnumDecl* ed ) {
-                        std::unique_ptr<Type> eType = 
+                        std::unique_ptr<Type> eType =
                                 std::make_unique<BasicType>( Type::Qualifiers{}, BasicType::SignedInt );
-                        
+
                         // add field names directly to enclosing scope
                         for ( Declaration* member : ed->members ) {

src/Common/utility.h

@@ -26 +26 @@
 #include <string>
 #include <type_traits>
+#include <utility>
 
 #include <cassert>
@@ -462 +463 @@
 std::pair<long long int, bool> eval(Expression * expr);
 
+// -----------------------------------------------------------------------------
+/// Reorders the input range in-place so that the minimal-value elements according to the 
+/// comparator are in front; 
+/// returns the iterator after the last minimal-value element.
+template<typename Iter, typename Compare>
+Iter sort_mins( Iter begin, Iter end, Compare& lt ) {
+        if ( begin == end ) return end;
+        
+        Iter min_pos = begin;
+        for ( Iter i = begin + 1; i != end; ++i ) {
+                if ( lt( *i, *min_pos ) ) {
+                        // new minimum cost; swap into first position
+                        min_pos = begin;
+                        std::iter_swap( min_pos, i );
+                } else if ( ! lt( *min_pos, *i ) ) {
+                        // duplicate minimum cost; swap into next minimum position
+                        ++min_pos;
+                        std::iter_swap( min_pos, i );
+                }
+        }
+        return ++min_pos;
+}
+
+template<typename Iter, typename Compare>
+inline Iter sort_mins( Iter begin, Iter end, Compare&& lt ) {
+        return sort_mins( begin, end, lt );
+}
+
+/// sort_mins defaulted to use std::less
+template<typename Iter>
+inline Iter sort_mins( Iter begin, Iter end ) {
+        return sort_mins( begin, end, std::less<typename std::iterator_traits<Iter>::value_type>{} );
+}
+
 // Local Variables: //
 // tab-width: 4 //

src/GenPoly/Box.cc

@@ -798 +798 @@
                         for ( Type::ForallList::iterator tyVar = functionType->get_forall().begin(); tyVar != functionType->get_forall().end(); ++tyVar ) {
                                 for ( std::list< DeclarationWithType *>::iterator assert = (*tyVar)->assertions.begin(); assert != (*tyVar)->assertions.end(); ++assert ) {
-                                        InferredParams::const_iterator inferParam = appExpr->get_inferParams().find( (*assert)->get_uniqueId() );
-                                        assertf( inferParam != appExpr->get_inferParams().end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
+                                        InferredParams::const_iterator inferParam = appExpr->inferParams.find( (*assert)->get_uniqueId() );
+                                        assertf( inferParam != appExpr->inferParams.end(), "addInferredParams missing inferred parameter: %s in: %s", toString( *assert ).c_str(), toString( appExpr ).c_str() );
                                         Expression *newExpr = inferParam->second.expr->clone();
                                         addCast( newExpr, (*assert)->get_type(), tyVars );

src/GenPoly/Specialize.cc

@@ -245 +245 @@
                 appExpr->env = TypeSubstitution::newFromExpr( appExpr, env );
                 if ( inferParams ) {
-                        appExpr->get_inferParams() = *inferParams;
+                        appExpr->inferParams = *inferParams;
                 } // if
 
@@ -284 +284 @@
                 std::list< Expression* >::iterator actual;
                 for ( formal = function->get_parameters().begin(), actual = appExpr->get_args().begin(); formal != function->get_parameters().end() && actual != appExpr->get_args().end(); ++formal, ++actual ) {
-                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->get_inferParams() );
+                        *actual = doSpecialization( (*formal)->get_type(), *actual, &appExpr->inferParams );
                 }
         }
@@ -295 +295 @@
                         // alternatively, if order starts to matter then copy appExpr's inferParams and pass them to handleExplicitParams.
                         handleExplicitParams( appExpr );
-                        for ( InferredParams::iterator inferParam = appExpr->get_inferParams().begin(); inferParam != appExpr->get_inferParams().end(); ++inferParam ) {
-                                inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, inferParam->second.inferParams.get() );
+                        for ( InferredParams::iterator inferParam = appExpr->inferParams.begin(); inferParam != appExpr->inferParams.end(); ++inferParam ) {
+                                inferParam->second.expr = doSpecialization( inferParam->second.formalType, inferParam->second.expr, &inferParam->second.expr->inferParams );
                         }
                 }

src/Makefile.am

@@ -17 +17 @@
 # create object files in directory with source files
 AUTOMAKE_OPTIONS = foreign subdir-objects
+ACLOCAL_AMFLAGS  = -I automake
 
 SRC = main.cc \
@@ -126 +127 @@
   ResolvExpr/PtrsCastable.cc \
   ResolvExpr/RenameVars.cc \
+  ResolvExpr/ResolveAssertions.cc \
   ResolvExpr/Resolver.cc \
   ResolvExpr/ResolveTypeof.cc \
+  ResolvExpr/SpecCost.cc \
   ResolvExpr/TypeEnvironment.cc \
   ResolvExpr/Unify.cc \

src/Makefile.in

@@ -141 +141 @@
 subdir = src
 ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
-am__aclocal_m4_deps = $(top_srcdir)/automake/cfa.m4 \
-        $(top_srcdir)/configure.ac
+am__aclocal_m4_deps = $(top_srcdir)/automake/libtool.m4 \
+        $(top_srcdir)/automake/ltoptions.m4 \
+        $(top_srcdir)/automake/ltsugar.m4 \
+        $(top_srcdir)/automake/ltversion.m4 \
+        $(top_srcdir)/automake/lt~obsolete.m4 \
+        $(top_srcdir)/automake/cfa.m4 $(top_srcdir)/configure.ac
 am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
         $(ACLOCAL_M4)
@@ -151 +155 @@
 CONFIG_CLEAN_VPATH_FILES =
 LIBRARIES = $(noinst_LIBRARIES)
-AR = ar
 AM_V_AR = $(am__v_AR_@AM_V@)
 am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
@@ -203 +206 @@
         ResolvExpr/PtrsAssignable.$(OBJEXT) \
         ResolvExpr/PtrsCastable.$(OBJEXT) \
-        ResolvExpr/RenameVars.$(OBJEXT) ResolvExpr/Resolver.$(OBJEXT) \
+        ResolvExpr/RenameVars.$(OBJEXT) \
+        ResolvExpr/ResolveAssertions.$(OBJEXT) \
+        ResolvExpr/Resolver.$(OBJEXT) \
         ResolvExpr/ResolveTypeof.$(OBJEXT) \
+        ResolvExpr/SpecCost.$(OBJEXT) \
         ResolvExpr/TypeEnvironment.$(OBJEXT) \
         ResolvExpr/Unify.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
@@ -259 +265 @@
         ResolvExpr/TypeEnvironment.$(OBJEXT) \
         ResolvExpr/CurrentObject.$(OBJEXT) \
-        ResolvExpr/ExplodedActual.$(OBJEXT) SymTab/Indexer.$(OBJEXT) \
-        SymTab/Mangler.$(OBJEXT) SymTab/ManglerCommon.$(OBJEXT) \
-        SymTab/Validate.$(OBJEXT) SymTab/FixFunction.$(OBJEXT) \
-        SymTab/Autogen.$(OBJEXT) SynTree/Type.$(OBJEXT) \
-        SynTree/VoidType.$(OBJEXT) SynTree/BasicType.$(OBJEXT) \
-        SynTree/PointerType.$(OBJEXT) SynTree/ArrayType.$(OBJEXT) \
-        SynTree/ReferenceType.$(OBJEXT) SynTree/FunctionType.$(OBJEXT) \
+        ResolvExpr/ExplodedActual.$(OBJEXT) \
+        ResolvExpr/SpecCost.$(OBJEXT) \
+        ResolvExpr/ResolveAssertions.$(OBJEXT) \
+        SymTab/Indexer.$(OBJEXT) SymTab/Mangler.$(OBJEXT) \
+        SymTab/ManglerCommon.$(OBJEXT) SymTab/Validate.$(OBJEXT) \
+        SymTab/FixFunction.$(OBJEXT) SymTab/Autogen.$(OBJEXT) \
+        SynTree/Type.$(OBJEXT) SynTree/VoidType.$(OBJEXT) \
+        SynTree/BasicType.$(OBJEXT) SynTree/PointerType.$(OBJEXT) \
+        SynTree/ArrayType.$(OBJEXT) SynTree/ReferenceType.$(OBJEXT) \
+        SynTree/FunctionType.$(OBJEXT) \
         SynTree/ReferenceToType.$(OBJEXT) SynTree/TupleType.$(OBJEXT) \
         SynTree/TypeofType.$(OBJEXT) SynTree/AttrType.$(OBJEXT) \
@@ -289 +298 @@
 ___driver_cfa_cpp_OBJECTS = $(am____driver_cfa_cpp_OBJECTS)
 ___driver_cfa_cpp_DEPENDENCIES =
+AM_V_lt = $(am__v_lt_@AM_V@)
+am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@)
+am__v_lt_0 = --silent
+am__v_lt_1 = 
 am_demangler_OBJECTS = SymTab/demangler.$(OBJEXT)
 demangler_OBJECTS = $(am_demangler_OBJECTS)
@@ -310 +323 @@
 CXXCOMPILE = $(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
         $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS)
+LTCXXCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CXX) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+        $(AM_CXXFLAGS) $(CXXFLAGS)
 AM_V_CXX = $(am__v_CXX_@AM_V@)
 am__v_CXX_ = $(am__v_CXX_@AM_DEFAULT_V@)
@@ -315 +332 @@
 am__v_CXX_1 = 
 CXXLD = $(CXX)
-CXXLINK = $(CXXLD) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) \
-        -o $@
+CXXLINK = $(LIBTOOL) $(AM_V_lt) --tag=CXX $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CXXLD) $(AM_CXXFLAGS) \
+        $(CXXFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CXXLD = $(am__v_CXXLD_@AM_V@)
 am__v_CXXLD_ = $(am__v_CXXLD_@AM_DEFAULT_V@)
@@ -322 +340 @@
 am__v_CXXLD_1 = 
 LEXCOMPILE = $(LEX) $(AM_LFLAGS) $(LFLAGS)
+LTLEXCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(LEX) $(AM_LFLAGS) $(LFLAGS)
 AM_V_LEX = $(am__v_LEX_@AM_V@)
 am__v_LEX_ = $(am__v_LEX_@AM_DEFAULT_V@)
@@ -330 +350 @@
                    -e s/c++$$/h++/ -e s/c$$/h/
 YACCCOMPILE = $(YACC) $(AM_YFLAGS) $(YFLAGS)
+LTYACCCOMPILE = $(LIBTOOL) $(AM_V_lt) $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(YACC) $(AM_YFLAGS) $(YFLAGS)
 AM_V_YACC = $(am__v_YACC_@AM_V@)
 am__v_YACC_ = $(am__v_YACC_@AM_DEFAULT_V@)
@@ -336 +358 @@
 COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
         $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 AM_V_CC = $(am__v_CC_@AM_V@)
 am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@)
@@ -341 +367 @@
 am__v_CC_1 = 
 CCLD = $(CC)
-LINK = $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) $(LDFLAGS) -o $@
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+        $(AM_LDFLAGS) $(LDFLAGS) -o $@
 AM_V_CCLD = $(am__v_CCLD_@AM_V@)
 am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@)
@@ -391 +419 @@
 AMTAR = @AMTAR@
 AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
 AUTOCONF = @AUTOCONF@
 AUTOHEADER = @AUTOHEADER@
 AUTOMAKE = @AUTOMAKE@
 AWK = @AWK@
-BACKEND_CC = @BACKEND_CC@
 BUILD_IN_TREE_FLAGS = @BUILD_IN_TREE_FLAGS@
 CC = @CC@
@@ -415 +443 @@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
+CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
@@ -420 +449 @@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
 DRIVER_DIR = @DRIVER_DIR@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
@@ -426 +458 @@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
+FGREP = @FGREP@
 GREP = @GREP@
 HOST_FLAGS = @HOST_FLAGS@
@@ -433 +466 @@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
 LDFLAGS = @LDFLAGS@
 LEX = @LEX@
@@ -441 +475 @@
 LIBOBJS = @LIBOBJS@
 LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
 LTLIBOBJS = @LTLIBOBJS@
+LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@
 MAKEINFO = @MAKEINFO@
+MANIFEST_TOOL = @MANIFEST_TOOL@
 MKDIR_P = @MKDIR_P@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJDUMP = @OBJDUMP@
 OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
 PACKAGE = @PACKAGE@
 PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
@@ -454 +498 @@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -465 +510 @@
 abs_top_builddir = @abs_top_builddir@
 abs_top_srcdir = @abs_top_srcdir@
+ac_ct_AR = @ac_ct_AR@
 ac_ct_CC = @ac_ct_CC@
 ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
 am__include = @am__include@
 am__leading_dot = @am__leading_dot@
@@ -516 +563 @@
 # create object files in directory with source files
 AUTOMAKE_OPTIONS = foreign subdir-objects
+ACLOCAL_AMFLAGS = -I automake
 SRC = main.cc MakeLibCfa.cc CompilationState.cc CodeGen/Generate.cc \
         CodeGen/CodeGenerator.cc CodeGen/GenType.cc \
@@ -547 +595 @@
         ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
         ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
+        ResolvExpr/SpecCost.cc ResolvExpr/ResolveAssertions.cc \
         SymTab/Indexer.cc SymTab/Mangler.cc SymTab/ManglerCommon.cc \
         SymTab/Validate.cc SymTab/FixFunction.cc SymTab/Autogen.cc \
@@ -654 +703 @@
   ResolvExpr/PtrsCastable.cc \
   ResolvExpr/RenameVars.cc \
+  ResolvExpr/ResolveAssertions.cc \
   ResolvExpr/Resolver.cc \
   ResolvExpr/ResolveTypeof.cc \
+  ResolvExpr/SpecCost.cc \
   ResolvExpr/TypeEnvironment.cc \
   ResolvExpr/Unify.cc \
@@ -672 +723 @@
 
 .SUFFIXES:
-.SUFFIXES: .cc .ll .o .obj .yy
+.SUFFIXES: .cc .ll .lo .o .obj .yy
 $(srcdir)/Makefile.in:  $(srcdir)/Makefile.am $(srcdir)/CodeGen/module.mk $(srcdir)/CodeTools/module.mk $(srcdir)/Concurrency/module.mk $(srcdir)/Common/module.mk $(srcdir)/ControlStruct/module.mk $(srcdir)/GenPoly/module.mk $(srcdir)/InitTweak/module.mk $(srcdir)/Parser/module.mk $(srcdir)/ResolvExpr/module.mk $(srcdir)/SymTab/module.mk $(srcdir)/SynTree/module.mk $(srcdir)/Tuples/module.mk $(srcdir)/Validate/module.mk $(srcdir)/Virtual/module.mk $(am__configure_deps)
         @for dep in $?; do \
@@ -904 +955 @@
 ResolvExpr/RenameVars.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/ResolveAssertions.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/Resolver.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/ResolveTypeof.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/SpecCost.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 ResolvExpr/TypeEnvironment.$(OBJEXT): ResolvExpr/$(am__dirstamp) \
@@ -957 +1012 @@
         sed 's/$(EXEEXT)$$//' | \
         while read p p1; do if test -f $$p \
+         || test -f $$p1 \
           ; then echo "$$p"; echo "$$p"; else :; fi; \
         done | \
@@ -971 +1027 @@
             if test "$$dir" = .; then dir=; else dir=/$$dir; fi; \
             test -z "$$files" || { \
-              echo " $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(cfa_cpplibdir)$$dir'"; \
-              $(INSTALL_PROGRAM_ENV) $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(cfa_cpplibdir)$$dir" || exit $$?; \
+            echo " $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files '$(DESTDIR)$(cfa_cpplibdir)$$dir'"; \
+            $(INSTALL_PROGRAM_ENV) $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL_PROGRAM) $$files "$(DESTDIR)$(cfa_cpplibdir)$$dir" || exit $$?; \
             } \
         ; done
@@ -988 +1044 @@
 
 clean-cfa_cpplibPROGRAMS:
-        -test -z "$(cfa_cpplib_PROGRAMS)" || rm -f $(cfa_cpplib_PROGRAMS)
+        @list='$(cfa_cpplib_PROGRAMS)'; test -n "$$list" || exit 0; \
+        echo " rm -f" $$list; \
+        rm -f $$list || exit $$?; \
+        test -n "$(EXEEXT)" || exit 0; \
+        list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \
+        echo " rm -f" $$list; \
+        rm -f $$list
 CodeGen/Generate.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
@@ -1158 +1220 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/PtrsCastable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/RenameVars.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/ResolveAssertions.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/ResolveTypeof.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/Resolver.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/SpecCost.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/TypeEnvironment.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/Unify.Po@am__quote@
@@ -1226 +1290 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXXCOMPILE) -c -o $@ `$(CYGPATH_W) '$<'`
 
+.cc.lo:
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+@am__fastdepCXX_TRUE@   $(LTCXXCOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
+@am__fastdepCXX_TRUE@   $(am__mv) $$depbase.Tpo $$depbase.Plo
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(LTCXXCOMPILE) -c -o $@ $<
+
 .ll.cc:
         $(AM_V_LEX)$(am__skiplex) $(SHELL) $(YLWRAP) $< $(LEX_OUTPUT_ROOT).c $@ -- $(LEXCOMPILE)
@@ -1231 +1303 @@
 .yy.cc:
         $(AM_V_YACC)$(am__skipyacc) $(SHELL) $(YLWRAP) $< y.tab.c $@ y.tab.h `echo $@ | $(am__yacc_c2h)` y.output $*.output -- $(YACCCOMPILE)
+
+mostlyclean-libtool:
+        -rm -f *.lo
+
+clean-libtool:
+        -rm -rf .libs _libs
+        -rm -rf ../driver/.libs ../driver/_libs
 
 ID: $(am__tagged_files)
@@ -1390 +1469 @@
 clean: clean-am
 
-clean-am: clean-cfa_cpplibPROGRAMS clean-generic clean-noinstLIBRARIES \
-        mostlyclean-am
+clean-am: clean-cfa_cpplibPROGRAMS clean-generic clean-libtool \
+        clean-noinstLIBRARIES mostlyclean-am
 
 distclean: distclean-am
@@ -1446 +1525 @@
 mostlyclean: mostlyclean-am
 
-mostlyclean-am: mostlyclean-compile mostlyclean-generic
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+        mostlyclean-libtool
 
 pdf: pdf-am
@@ -1461 +1541 @@
 
 .PHONY: CTAGS GTAGS TAGS all all-am check check-am clean \
-        clean-cfa_cpplibPROGRAMS clean-generic clean-noinstLIBRARIES \
-        cscopelist-am ctags ctags-am distclean distclean-compile \
-        distclean-generic distclean-tags distdir dvi dvi-am html \
-        html-am info info-am install install-am \
-        install-cfa_cpplibPROGRAMS install-data install-data-am \
-        install-dvi install-dvi-am install-exec install-exec-am \
-        install-html install-html-am install-info install-info-am \
-        install-man install-pdf install-pdf-am install-ps \
-        install-ps-am install-strip installcheck installcheck-am \
-        installdirs maintainer-clean maintainer-clean-generic \
-        mostlyclean mostlyclean-compile mostlyclean-generic pdf pdf-am \
-        ps ps-am tags tags-am uninstall uninstall-am \
+        clean-cfa_cpplibPROGRAMS clean-generic clean-libtool \
+        clean-noinstLIBRARIES cscopelist-am ctags ctags-am distclean \
+        distclean-compile distclean-generic distclean-libtool \
+        distclean-tags distdir dvi dvi-am html html-am info info-am \
+        install install-am install-cfa_cpplibPROGRAMS install-data \
+        install-data-am install-dvi install-dvi-am install-exec \
+        install-exec-am install-html install-html-am install-info \
+        install-info-am install-man install-pdf install-pdf-am \
+        install-ps install-ps-am install-strip installcheck \
+        installcheck-am installdirs maintainer-clean \
+        maintainer-clean-generic mostlyclean mostlyclean-compile \
+        mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+        tags tags-am uninstall uninstall-am \
         uninstall-cfa_cpplibPROGRAMS
 

src/Parser/TypeData.cc

@@ -322 +322 @@
                         function.params->printList( os, indent + 4 );
                 } else {
-                        os << string( indent + 2, ' ' ) << "with no parameters " << endl;
+                        os << string( indent + 2, ' ' ) << "with no parameters" << endl;
                 } // if
                 if ( function.idList ) {
@@ -347 +347 @@
                 os << DeclarationNode::aggregateNames[ aggregate.kind ] << ' ' << *aggregate.name << endl;
                 if ( aggregate.params ) {
-                        os << string( indent + 2, ' ' ) << "with type parameters " << endl;
+                        os << string( indent + 2, ' ' ) << "with type parameters" << endl;
                         aggregate.params->printList( os, indent + 4 );
                 } // if
                 if ( aggregate.actuals ) {
-                        os << string( indent + 2, ' ' ) << "instantiated with actual parameters " << endl;
+                        os << string( indent + 2, ' ' ) << "instantiated with actual parameters" << endl;
                         aggregate.actuals->printList( os, indent + 4 );
                 } // if
                 if ( aggregate.fields ) {
-                        os << string( indent + 2, ' ' ) << "with members " << endl;
+                        os << string( indent + 2, ' ' ) << "with members" << endl;
                         aggregate.fields->printList( os, indent + 4 );
                 } // if
                 if ( aggregate.body ) {
-                        os << string( indent + 2, ' ' ) << " with body " << endl;
+                        os << string( indent + 2, ' ' ) << " with body" << endl;
                 } // if
                 break;
@@ -370 +370 @@
                 } // if
                 if ( aggInst.params ) {
-                        os << string( indent + 2, ' ' ) << "with parameters " << endl;
+                        os << string( indent + 2, ' ' ) << "with parameters" << endl;
                         aggInst.params->printList( os, indent + 2 );
                 } // if
@@ -381 +381 @@
                 } // if
                 if ( enumeration.body ) {
-                        os << string( indent + 2, ' ' ) << " with body " << endl;
+                        os << string( indent + 2, ' ' ) << " with body" << endl;
                 } // if
                 break;
@@ -418 +418 @@
                 os << "tuple ";
                 if ( tuple ) {
-                        os << "with members " << endl;
+                        os << "with members" << endl;
                         tuple->printList( os, indent + 2 );
                 } // if
@@ -942 +942 @@
         assert( td->typeexpr );
         // assert( td->typeexpr->expr );
-        return new TypeofType{ 
+        return new TypeofType{
                 buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
 } // buildTypeof

src/ResolvExpr/Alternative.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:44:23 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat May 16 23:54:23 2015
-// Update Count     : 2
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Oct 11 10:55:00 2018
+// Update Count     : 3
 //
 
@@ -20 +20 @@
 #include <utility>                       // for move
 
-#include "Common/utility.h"              // for maybeClone
+#include "Common/utility.h"              // for cloneAll
 #include "ResolvExpr/Cost.h"             // for Cost, Cost::zero, operator<<
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
@@ -27 +27 @@
 
 namespace ResolvExpr {
-        Alternative::Alternative() : cost( Cost::zero ), cvtCost( Cost::zero ), expr( nullptr ) {}
+        Alternative::Alternative() 
+        : cost( Cost::zero ), cvtCost( Cost::zero ), expr( nullptr ), env(), openVars(), need() {}
 
-        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost )
-                : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( env ) {}
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env )
+        : cost( Cost::zero ), cvtCost( Cost::zero ), expr( expr ), env( env ), openVars(), need() {}
+        
+        Alternative::Alternative( const Alternative &o, Expression *expr, const Cost &cost ) 
+        : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( o.env ), openVars( o.openVars ), 
+          need() { cloneAll( o.need, need ); }
 
-        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, const Cost& cost, const Cost &cvtCost )
-                : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ) {}
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, 
+                const OpenVarSet& openVars, const AssertionList& oneed, const Cost& cost )
+        : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( env ), openVars( openVars ), 
+          need() { cloneAll( oneed, need ); }
 
-        Alternative::Alternative( const Alternative &other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), env( other.env ) {
-        }
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, 
+                const OpenVarSet& openVars, const AssertionList& oneed, const Cost& cost, 
+                const Cost &cvtCost )
+        : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ), openVars( openVars ), 
+          need() { cloneAll( oneed, need ); }
+        
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, 
+                const OpenVarSet &openVars, const AssertionSet &oneed, const Cost &cost)
+        : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( env ), openVars( openVars ), 
+          need() { cloneAll( oneed, need ); }
+        
+        Alternative::Alternative( Expression *expr, const TypeEnvironment &env, 
+                const OpenVarSet &openVars, const AssertionSet &oneed, const Cost &cost, 
+                const Cost& cvtCost )
+        : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( env ), openVars( openVars ), 
+          need() { cloneAll( oneed, need ); }
+        
+        Alternative::Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                AssertionSet &&needSet, const Cost &cost )
+        : cost( cost ), cvtCost( Cost::zero ), expr( expr ), env( std::move(env) ), 
+          openVars( std::move(openVars) ), need( needSet.begin(), needSet.end() ) {}
+        
+        Alternative::Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                AssertionSet &&needSet, const Cost &cost, const Cost &cvtCost )
+        : cost( cost ), cvtCost( cvtCost ), expr( expr ), env( std::move(env) ), 
+          openVars( std::move(openVars) ), need( needSet.begin(), needSet.end() ) {}
+
+        Alternative::Alternative( const Alternative &other ) 
+        : cost( other.cost ), cvtCost( other.cvtCost ), expr( maybeClone( other.expr ) ), 
+          env( other.env ), openVars( other.openVars ), need() { cloneAll( other.need, need ); }
 
         Alternative &Alternative::operator=( const Alternative &other ) {
@@ -45 +80 @@
                 expr = maybeClone( other.expr );
                 env = other.env;
+                openVars = other.openVars;
+                need.clear();
+                cloneAll( other.need, need );
                 return *this;
         }
 
-        Alternative::Alternative( Alternative && other ) : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), env( std::move( other.env ) ) {
-                other.expr = nullptr;
-        }
+        Alternative::Alternative( Alternative && other ) 
+        : cost( other.cost ), cvtCost( other.cvtCost ), expr( other.expr ), 
+          env( std::move( other.env ) ), openVars( std::move( other.openVars ) ), 
+          need( std::move( other.need ) ) { other.expr = nullptr; }
 
         Alternative & Alternative::operator=( Alternative && other ) {
@@ -59 +98 @@
                 expr = other.expr;
                 env = std::move( other.env );
+                openVars = std::move( other.openVars );
+                need = std::move( other.need );
                 other.expr = nullptr;
                 return *this;
@@ -64 +105 @@
 
         Alternative::~Alternative() {
+                for ( AssertionItem& n : need ) { delete n.decl; }
                 delete expr;
         }
@@ -78 +120 @@
                         os << "Null expression!" << std::endl;
                 } // if
-                os << indent << "Environment: ";
+                os << indent << "Environment:";
                 env.print( os, indent+1 );
                 os << std::endl;

src/ResolvExpr/Alternative.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:45:43 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:36:36 2017
-// Update Count     : 3
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Thu Oct 11 10:55:00 2018
+// Update Count     : 4
 //
 
@@ -20 +20 @@
 
 #include "Cost.h"             // for Cost
-#include "TypeEnvironment.h"  // for TypeEnvironment
+#include "TypeEnvironment.h"  // for TypeEnvironment, AssertionSetValue
+
+#include "Common/utility.h"   // for maybeClone
 
 class Expression;
 
 namespace ResolvExpr {
+        /// One assertion to resolve
+        struct AssertionItem {
+                DeclarationWithType* decl;
+                AssertionSetValue info;
+                
+                AssertionItem() = default;
+                AssertionItem( DeclarationWithType* decl, const AssertionSetValue& info ) 
+                : decl(decl), info(info) {}
+                AssertionItem( const AssertionSet::value_type& e ) : decl(e.first), info(e.second) {}
+                operator AssertionSet::value_type () const { return { decl, info }; }
+
+                // to support cloneAll
+                AssertionItem clone() const { return { maybeClone(decl), info }; }
+        };
+        /// A list of unresolved assertions
+        using AssertionList = std::vector<AssertionItem>;
+
+        /// Clones an assertion list into an assertion set
+        static inline void cloneAll( const AssertionList& src, AssertionSet& dst ) {
+                for ( const AssertionItem& item : src ) {
+                        dst.emplace( maybeClone(item.decl), item.info );
+                }
+        }
+
+        /// Clones an assertion set into an assertion list
+        static inline void cloneAll( const AssertionSet& src, AssertionList& dst ) {
+                dst.reserve( dst.size() + src.size() );
+                for ( const auto& entry : src ) {
+                        dst.emplace_back( maybeClone(entry.first), entry.second );
+                }
+        }
+
+        /// Clones an assertion list into an assertion list
+        static inline void cloneAll( const AssertionList& src, AssertionList& dst ) {
+                dst.reserve( dst.size() + src.size() );
+                for ( const AssertionItem& item : src ) {
+                        dst.emplace_back( maybeClone(item.decl), item.info );
+                }
+        }
+
+        /// One option for resolution of an expression
         struct Alternative {
                 Alternative();
-                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost );
-                Alternative( Expression *expr, const TypeEnvironment &env, const Cost &cost, const Cost &cvtCost );
+                Alternative( Expression *expr, const TypeEnvironment &env );
+                Alternative( const Alternative &o, Expression *expr, const Cost &cost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet& openVars, 
+                        const AssertionList& need, const Cost &cost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet& openVars, 
+                        const AssertionList& need, const Cost &cost, const Cost &cvtCost );
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet &openVars, 
+                        const AssertionSet &need, const Cost &cost);
+                Alternative( Expression *expr, const TypeEnvironment &env, const OpenVarSet &openVars, 
+                        const AssertionSet &need, const Cost &cost, const Cost& cvtCost );
+                Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                        AssertionSet &&need, const Cost &cost );
+                Alternative( Expression *expr, TypeEnvironment &&env, OpenVarSet &&openVars, 
+                        AssertionSet &&need, const Cost &cost, const Cost &cvtCost );
                 Alternative( const Alternative &other );
                 Alternative &operator=( const Alternative &other );
@@ -44 +99 @@
                 }
 
-                Cost cost;
-                Cost cvtCost;
-                Expression *expr;
-                TypeEnvironment env;
+                /// Sorts by cost
+                bool operator< ( const Alternative& o ) const { return cost < o.cost; }
+
+                Cost cost;            ///< Cost of the whole expression
+                Cost cvtCost;         ///< Cost of conversions to the satisfying expression
+                Expression *expr;     ///< Satisfying expression
+                TypeEnvironment env;  ///< Containing type environment
+                OpenVarSet openVars;  ///< Open variables for environment
+                AssertionList need;   ///< Assertions which need to be resolved
         };
 

src/ResolvExpr/AlternativeFinder.cc

@@ -11 +11 @@
 // Last Modified By : Peter A. Buhr
 // Last Modified On : Thu Nov  1 21:00:56 2018
-// Update Count     : 34
+// Update Count     : 35
 //
 
@@ -34 +34 @@
 #include "InitTweak/InitTweak.h"   // for getFunctionName
 #include "RenameVars.h"            // for RenameVars, global_renamer
+#include "ResolveAssertions.h"     // for resolveAssertions
 #include "ResolveTypeof.h"         // for resolveTypeof
 #include "Resolver.h"              // for resolveStmtExpr
@@ -102 +103 @@
                 void addAnonConversions( const Alternative & alt );
                 /// Adds alternatives for member expressions, given the aggregate, conversion cost for that aggregate, and name of the member
-                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name );
+                template< typename StructOrUnionType > void addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Alternative &alt, const Cost &newCost, const std::string & name );
                 /// Adds alternatives for member expressions where the left side has tuple type
-                void addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member );
+                void addTupleMembers( TupleType *tupleType, Expression *expr, const Alternative &alt, const Cost &newCost, Expression *member );
                 /// Adds alternatives for offsetof expressions, given the base type and name of the member
                 template< typename StructOrUnionType > void addOffsetof( StructOrUnionType *aggInst, const std::string &name );
@@ -113 +114 @@
                 template<typename OutputIterator>
                 void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
-                /// Checks if assertion parameters match for a new alternative
+                /// Sets up parameter inference for an output alternative
                 template< typename OutputIterator >
-                void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );
+                void inferParameters( Alternative &newAlt, OutputIterator out );
         private:
                 AlternativeFinder & altFinder;
@@ -244 +245 @@
         }
 
-        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune, bool failFast ) {
+        void AlternativeFinder::find( Expression *expr, ResolvMode mode ) {
                 PassVisitor<Finder> finder( *this );
                 expr->accept( finder );
-                if ( failFast && alternatives.empty() ) {
+                if ( mode.failFast && alternatives.empty() ) {
                         PRINT(
                                 std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
@@ -253 +254 @@
                         SemanticError( expr, "No reasonable alternatives for expression " );
                 }
-                if ( prune ) {
+                if ( mode.resolveAssns || mode.prune ) {
+                        // trim candidates just to those where the assertions resolve
+                        // - necessary pre-requisite to pruning
+                        AltList candidates;
+                        for ( unsigned i = 0; i < alternatives.size(); ++i ) {
+                                resolveAssertions( alternatives[i], indexer, candidates );
+                        }
+                        // fail early if none such
+                        if ( mode.failFast && candidates.empty() ) {
+                                std::ostringstream stream;
+                                stream << "No resolvable alternatives for expression " << expr << "\n"
+                                       << "Alternatives with failing assertions are:\n";
+                                printAlts( alternatives, stream, 1 );
+                                SemanticError( expr->location, stream.str() );
+                        }
+                        // reset alternatives
+                        alternatives = std::move( candidates );
+                }
+                if ( mode.prune ) {
                         auto oldsize = alternatives.size();
                         PRINT(
@@ -261 +280 @@
                         AltList pruned;
                         pruneAlternatives( alternatives.begin(), alternatives.end(), back_inserter( pruned ) );
-                        if ( failFast && pruned.empty() ) {
+                        if ( mode.failFast && pruned.empty() ) {
                                 std::ostringstream stream;
                                 AltList winners;
@@ -280 +299 @@
                 }
                 // adjust types after pruning so that types substituted by pruneAlternatives are correctly adjusted
-                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
-                        if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                if ( mode.adjust ) {
+                        for ( Alternative& i : alternatives ) {
+                                adjustExprType( i.expr->get_result(), i.env, indexer );
                         }
                 }
@@ -294 +313 @@
 
         void AlternativeFinder::findWithAdjustment( Expression *expr ) {
-                find( expr, true );
+                find( expr, ResolvMode::withAdjustment() );
         }
 
         void AlternativeFinder::findWithoutPrune( Expression * expr ) {
-                find( expr, true, false );
+                find( expr, ResolvMode::withoutPrune() );
         }
 
         void AlternativeFinder::maybeFind( Expression * expr ) {
-                find( expr, true, true, false );
+                find( expr, ResolvMode::withoutFailFast() );
         }
 
@@ -317 +336 @@
 
                 if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->result ) ) {
-                        addAggMembers( structInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
+                        addAggMembers( structInst, aggrExpr.get(), alt, alt.cost+Cost::safe, "" );
                 } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->result ) ) {
-                        addAggMembers( unionInst, aggrExpr.get(), alt.cost+Cost::safe, alt.env, "" );
+                        addAggMembers( unionInst, aggrExpr.get(), alt, alt.cost+Cost::safe, "" );
                 } // if
         }
 
         template< typename StructOrUnionType >
-        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string & name ) {
+        void AlternativeFinder::Finder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Alternative& alt, const Cost &newCost, const std::string & name ) {
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -332 +351 @@
                                 // addAnonAlternatives uses vector::push_back, which invalidates references to existing elements, so
                                 // can't construct in place and use vector::back
-                                Alternative newAlt( new MemberExpr( dwt, expr->clone() ), env, newCost );
+                                Alternative newAlt{ alt, new MemberExpr{ dwt, expr->clone() }, newCost };
                                 renameTypes( newAlt.expr );
                                 addAnonConversions( newAlt ); // add anonymous member interpretations whenever an aggregate value type is seen as a member expression.
@@ -342 +361 @@
         }
 
-        void AlternativeFinder::Finder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+        void AlternativeFinder::Finder::addTupleMembers( TupleType *tupleType, Expression *expr,                        const Alternative &alt, const Cost &newCost, Expression *member ) {
                 if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
                         // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
@@ -348 +367 @@
                         std::string tmp;
                         if ( val >= 0 && (unsigned long long)val < tupleType->size() ) {
-                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                                alternatives.push_back( Alternative{ 
+                                        alt, new TupleIndexExpr( expr->clone(), val ), newCost } );
                         } // if
                 } // if
@@ -354 +374 @@
 
         void AlternativeFinder::Finder::postvisit( ApplicationExpr *applicationExpr ) {
-                alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ applicationExpr->clone(), env } );
         }
 
@@ -410 +430 @@
         Cost computeApplicationConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
                 ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( alt.expr );
-                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
-                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
+                PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->function->result );
+                FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->base );
 
                 Cost convCost = Cost::zero;
-                std::list< DeclarationWithType* >& formals = function->get_parameters();
+                std::list< DeclarationWithType* >& formals = function->parameters;
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
-                std::list< Expression* >& actuals = appExpr->get_args();
-
-                for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-                        Type * actualType = (*actualExpr)->get_result();
+                std::list< Expression* >& actuals = appExpr->args;
+
+                for ( Expression*& actualExpr : actuals ) {
+                        Type * actualType = actualExpr->result;
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
-                                (*actualExpr)->print( std::cerr, 8 );
+                                actualExpr->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
                                 actualType->print( std::cerr, 8 );
                         )
                         if ( formal == formals.end() ) {
-                                if ( function->get_isVarArgs() ) {
+                                if ( function->isVarArgs ) {
                                         convCost.incUnsafe();
                                         PRINT( std::cerr << "end of formals with varargs function: inc unsafe: " << convCost << std::endl; ; )
                                         // convert reference-typed expressions to value-typed expressions
-                                        referenceToRvalueConversion( *actualExpr, convCost );
+                                        referenceToRvalueConversion( actualExpr, convCost );
                                         continue;
                                 } else {
@@ -437 +457 @@
                                 }
                         }
-                        if ( DefaultArgExpr * def = dynamic_cast< DefaultArgExpr * >( *actualExpr ) ) {
+                        if ( DefaultArgExpr * def = dynamic_cast< DefaultArgExpr * >( actualExpr ) ) {
                                 // default arguments should be free - don't include conversion cost.
                                 // Unwrap them here because they are not relevant to the rest of the system.
-                                *actualExpr = def->expr;
+                                actualExpr = def->expr;
                                 ++formal;
                                 continue;
                         }
+                        // mark conversion cost to formal and also specialization cost of formal type
                         Type * formalType = (*formal)->get_type();
-                        convCost += computeExpressionConversionCost( *actualExpr, formalType, indexer, alt.env );
+                        convCost += computeExpressionConversionCost( actualExpr, formalType, indexer, alt.env );
+                        convCost.decSpec( specCost( formalType ) );
                         ++formal; // can't be in for-loop update because of the continue
                 }
@@ -452 +474 @@
                 }
 
-                for ( InferredParams::const_iterator assert = appExpr->get_inferParams().begin(); assert != appExpr->get_inferParams().end(); ++assert ) {
+                // mark specialization cost of return types
+                for ( DeclarationWithType* returnVal : function->returnVals ) {
+                        convCost.decSpec( specCost( returnVal->get_type() ) );
+                }
+
+                // mark type variable and specialization cost of forall clause
+                convCost.incVar( function->forall.size() );
+                for ( TypeDecl* td : function->forall ) {
+                        convCost.decSpec( td->assertions.size() );
+                }
+
+                // xxx -- replace with new costs in resolver
+                for ( InferredParams::const_iterator assert = appExpr->inferParams.begin(); assert != appExpr->inferParams.end(); ++assert ) {
                         convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
                 }
@@ -466 +500 @@
                                 needAssertions[ *assert ].isUsed = true;
                         }
-///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
-                }
-        }
-
-        static const int recursionLimit = /*10*/ 4;  ///< Limit to depth of recursion satisfaction
-
-        void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
-                for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
-                        if ( i->second.isUsed ) {
-                                indexer.addId( i->first );
-                        }
-                }
-        }
-
-        template< typename ForwardIterator, typename OutputIterator >
-        void inferRecursive( ForwardIterator begin, ForwardIterator end, const Alternative &newAlt, OpenVarSet &openVars, const SymTab::Indexer &decls, const AssertionSet &newNeed, int level, const SymTab::Indexer &indexer, OutputIterator out ) {
-                if ( newAlt.cost == Cost::infinity ) return; // don't proceed down this dead end
-                if ( begin == end ) {
-                        if ( newNeed.empty() ) {
-                                PRINT(
-                                        std::cerr << "all assertions satisfied, output alternative: ";
-                                        newAlt.print( std::cerr );
-                                        std::cerr << std::endl;
-                                );
-                                *out++ = newAlt;
-                                return;
-                        } else if ( level >= recursionLimit ) {
-                                SemanticError( newAlt.expr->location, "Too many recursive assertions" );
-                        } else {
-                                AssertionSet newerNeed;
-                                PRINT(
-                                        std::cerr << "recursing with new set:" << std::endl;
-                                        printAssertionSet( newNeed, std::cerr, 8 );
-                                )
-                                inferRecursive( newNeed.begin(), newNeed.end(), newAlt, openVars, decls, newerNeed, level+1, indexer, out );
-                                return;
-                        }
-                }
-
-                ForwardIterator cur = begin++;
-                if ( ! cur->second.isUsed ) {
-                        inferRecursive( begin, end, newAlt, openVars, decls, newNeed, level, indexer, out );
-                        return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
-                }
-                DeclarationWithType *curDecl = cur->first;
-
-                PRINT(
-                        std::cerr << "inferRecursive: assertion is ";
-                        curDecl->print( std::cerr );
-                        std::cerr << std::endl;
-                )
-                std::list< SymTab::Indexer::IdData > candidates;
-                decls.lookupId( curDecl->get_name(), candidates );
-///   if ( candidates.empty() ) { std::cerr << "no candidates!" << std::endl; }
-                for ( const auto & data : candidates ) {
-                        DeclarationWithType * candidate = data.id;
-                        PRINT(
-                                std::cerr << "inferRecursive: candidate is ";
-                                candidate->print( std::cerr );
-                                std::cerr << std::endl;
-                        )
-
-                        AssertionSet newHave, newerNeed( newNeed );
-                        TypeEnvironment newEnv( newAlt.env );
-                        OpenVarSet newOpenVars( openVars );
-                        Type *adjType = candidate->get_type()->clone();
-                        adjustExprType( adjType, newEnv, indexer );
-                        renameTyVars( adjType );
-                        PRINT(
-                                std::cerr << "unifying ";
-                                curDecl->get_type()->print( std::cerr );
-                                std::cerr << " with ";
-                                adjType->print( std::cerr );
-                                std::cerr << std::endl;
-                        )
-                        if ( unify( curDecl->get_type(), adjType, newEnv, newerNeed, newHave, newOpenVars, indexer ) ) {
-                                PRINT(
-                                        std::cerr << "success!" << std::endl;
-                                )
-                                SymTab::Indexer newDecls( decls );
-                                addToIndexer( newHave, newDecls );
-                                Alternative newerAlt( newAlt );
-                                newerAlt.env = newEnv;
-                                assertf( candidate->get_uniqueId(), "Assertion candidate does not have a unique ID: %s", toString( candidate ).c_str() );
-
-                                // everything with an empty idChain was pulled in by the current assertion.
-                                // add current assertion's idChain + current assertion's ID so that the correct inferParameters can be found.
-                                for ( auto & a : newerNeed ) {
-                                        if ( a.second.idChain.empty() ) {
-                                                a.second.idChain = cur->second.idChain;
-                                                a.second.idChain.push_back( curDecl->get_uniqueId() );
-                                        }
-                                }
-
-                                Expression *varExpr = data.combine( newerAlt.cvtCost );
-                                delete varExpr->get_result();
-                                varExpr->set_result( adjType->clone() );
-                                PRINT(
-                                        std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
-                                        curDecl->print( std::cerr );
-                                        std::cerr << " with declaration " << candidate->get_uniqueId() << " ";
-                                        candidate->print( std::cerr );
-                                        std::cerr << std::endl;
-                                )
-                                // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
-                                InferredParams * inferParameters = &newerAlt.expr->get_inferParams();
-                                for ( UniqueId id : cur->second.idChain ) {
-                                        inferParameters = (*inferParameters)[ id ].inferParams.get();
-                                }
-                                // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( candidate->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
-                                inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, level, indexer, out );
-                        } else {
-                                delete adjType;
-                        }
-                }
-        }
+                }
+        }
+
+        /// Unique identifier for matching expression resolutions to their requesting expression
+        UniqueId globalResnSlot = 0;
 
         template< typename OutputIterator >
-        void AlternativeFinder::Finder::inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out ) {
-//      PRINT(
-//          std::cerr << "inferParameters: assertions needed are" << std::endl;
-//          printAll( need, std::cerr, 8 );
-//          )
-                SymTab::Indexer decls( indexer );
-                // PRINT(
-                //      std::cerr << "============= original indexer" << std::endl;
-                //      indexer.print( std::cerr );
-                //      std::cerr << "============= new indexer" << std::endl;
-                //      decls.print( std::cerr );
-                // )
-                addToIndexer( have, decls );
-                AssertionSet newNeed;
-                PRINT(
-                        std::cerr << "env is: " << std::endl;
-                        newAlt.env.print( std::cerr, 0 );
-                        std::cerr << std::endl;
-                )
-
-                inferRecursive( need.begin(), need.end(), newAlt, openVars, decls, newNeed, 0, indexer, out );
-//      PRINT(
-//          std::cerr << "declaration 14 is ";
-//          Declaration::declFromId
-//          *out++ = newAlt;
-//          )
+        void AlternativeFinder::Finder::inferParameters( Alternative &newAlt, OutputIterator out ) {
+                // Set need bindings for any unbound assertions
+                UniqueId crntResnSlot = 0;  // matching ID for this expression's assertions
+                for ( auto& assn : newAlt.need ) {
+                        // skip already-matched assertions
+                        if ( assn.info.resnSlot != 0 ) continue;
+                        // assign slot for expression if needed
+                        if ( crntResnSlot == 0 ) { crntResnSlot = ++globalResnSlot; }
+                        // fix slot to assertion
+                        assn.info.resnSlot = crntResnSlot;
+                }
+                // pair slot to expression
+                if ( crntResnSlot != 0 ) { newAlt.expr->resnSlots.push_back( crntResnSlot ); }
+
+                // add to output list, assertion resolution is deferred
+                *out++ = newAlt;
         }
 
@@ -951 +863 @@
                 }
                 // build and validate new alternative
-                Alternative newAlt( appExpr, result.env, cost );
+                Alternative newAlt{ appExpr, result.env, result.openVars, result.need, cost };
                 PRINT(
                         std::cerr << "instantiate function success: " << appExpr << std::endl;
@@ -957 +869 @@
                         printAssertionSet( result.need, std::cerr, 8 );
                 )
-                inferParameters( result.need, result.have, newAlt, result.openVars, out );
+                inferParameters( newAlt, out );
         }
 
@@ -1202 +1114 @@
 
                 // function may return struct or union value, in which case we need to add alternatives
-                // for implicitconversions to each of the anonymous members, must happen after findMinCost
+                // for implicit conversions to each of the anonymous members, must happen after findMinCost
                 // since anon conversions are never the cheapest expression
                 for ( const Alternative & alt : winners ) {
@@ -1234 +1146 @@
                         if ( isLvalue( alt.expr ) ) {
                                 alternatives.push_back(
-                                        Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
+                                        Alternative{ alt, new AddressExpr( alt.expr->clone() ), alt.cost } );
                         } // if
                 } // for
@@ -1240 +1152 @@
 
         void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
-                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
+                alternatives.push_back( Alternative{ expr->clone(), env } );
         }
 
@@ -1285 +1197 @@
                 AltList candidates;
                 for ( Alternative & alt : finder.alternatives ) {
-                        AssertionSet needAssertions, haveAssertions;
-                        OpenVarSet openVars;
+                        AssertionSet needAssertions( alt.need.begin(), alt.need.end() );
+                        AssertionSet haveAssertions;
+                        OpenVarSet openVars{ alt.openVars };
 
                         alt.env.extractOpenVars( openVars );
@@ -1314 +1227 @@
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-                                Alternative newAlt( restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), alt.env,
-                                        alt.cost, thisCost );
-                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
-                                        back_inserter( candidates ) );
+                                Alternative newAlt{ 
+                                        restructureCast( alt.expr->clone(), toType, castExpr->isGenerated ), 
+                                        alt.env, openVars, needAssertions, alt.cost + thisCost, thisCost };
+                                inferParameters( newAlt, back_inserter( candidates ) );
                         } // if
                 } // for
@@ -1330 +1243 @@
 
         void AlternativeFinder::Finder::postvisit( VirtualCastExpr * castExpr ) {
-                assertf( castExpr->get_result(), "Implicate virtual cast targets not yet supported." );
+                assertf( castExpr->get_result(), "Implicit virtual cast targets not yet supported." );
                 AlternativeFinder finder( indexer, env );
                 // don't prune here, since it's guaranteed all alternatives will have the same type
                 finder.findWithoutPrune( castExpr->get_arg() );
                 for ( Alternative & alt : finder.alternatives ) {
-                        alternatives.push_back( Alternative(
-                                new VirtualCastExpr( alt.expr->clone(), castExpr->get_result()->clone() ),
-                                alt.env, alt.cost ) );
+                        alternatives.push_back( Alternative{
+                                alt, new VirtualCastExpr{ alt.expr->clone(), castExpr->get_result()->clone() },
+                                alt.cost } );
                 }
         }
@@ -1365 +1278 @@
                         // find member of the given type
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( structInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
+                                addAggMembers( structInst, aggrExpr, *agg, cost, get_member_name(memberExpr) );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( aggrExpr->get_result() ) ) {
-                                addAggMembers( unionInst, aggrExpr, cost, agg->env, get_member_name(memberExpr) );
+                                addAggMembers( unionInst, aggrExpr, *agg, cost, get_member_name(memberExpr) );
                         } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( aggrExpr->get_result() ) ) {
-                                addTupleMembers( tupleType, aggrExpr, cost, agg->env, memberExpr->get_member() );
+                                addTupleMembers( tupleType, aggrExpr, *agg, cost, memberExpr->get_member() );
                         } // if
                 } // for
@@ -1375 +1288 @@
 
         void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
-                alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ memberExpr->clone(), env } );
         }
 
@@ -1388 +1301 @@
                         // addAnonAlternatives uses vector::push_back, which invalidates references to existing elements, so
                         // can't construct in place and use vector::back
-                        Alternative newAlt( newExpr, env, Cost::zero, cost );
+                        Alternative newAlt{ newExpr, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost };
                         PRINT(
                                 std::cerr << "decl is ";
@@ -1406 +1319 @@
                 // not sufficient to clone here, because variable's type may have changed
                 // since the VariableExpr was originally created.
-                alternatives.push_back( Alternative( new VariableExpr( variableExpr->var ), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ new VariableExpr{ variableExpr->var }, env } );
         }
 
         void AlternativeFinder::Finder::postvisit( ConstantExpr *constantExpr ) {
-                alternatives.push_back( Alternative( constantExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ constantExpr->clone(), env } );
         }
 
@@ -1416 +1329 @@
                 if ( sizeofExpr->get_isType() ) {
                         Type * newType = sizeofExpr->get_type()->clone();
-                        alternatives.push_back( Alternative( new SizeofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
+                        alternatives.push_back( Alternative{ 
+                                new SizeofExpr{ resolveTypeof( newType, indexer ) }, env } );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -1430 +1344 @@
                         Alternative &choice = winners.front();
                         referenceToRvalueConversion( choice.expr, choice.cost );
-                        alternatives.push_back( Alternative( new SizeofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+                        alternatives.push_back( Alternative{ 
+                                choice, new SizeofExpr( choice.expr->clone() ), Cost::zero } );
                 } // if
         }
@@ -1437 +1352 @@
                 if ( alignofExpr->get_isType() ) {
                         Type * newType = alignofExpr->get_type()->clone();
-                        alternatives.push_back( Alternative( new AlignofExpr( resolveTypeof( newType, indexer ) ), env, Cost::zero ) );
+                        alternatives.push_back( Alternative{ 
+                                new AlignofExpr{ resolveTypeof( newType, indexer ) }, env } );
                 } else {
                         // find all alternatives for the argument to sizeof
@@ -1451 +1367 @@
                         Alternative &choice = winners.front();
                         referenceToRvalueConversion( choice.expr, choice.cost );
-                        alternatives.push_back( Alternative( new AlignofExpr( choice.expr->clone() ), choice.env, Cost::zero ) );
+                        alternatives.push_back( Alternative{ 
+                                choice, new AlignofExpr{ choice.expr->clone() }, Cost::zero } );
                 } // if
         }
@@ -1461 +1378 @@
                 for ( std::list< Declaration* >::const_iterator i = members.begin(); i != members.end(); ++i ) {
                         if ( DeclarationWithType *dwt = dynamic_cast< DeclarationWithType* >( *i ) ) {
-                                alternatives.push_back( Alternative( new OffsetofExpr( aggInst->clone(), dwt ), env, Cost::zero ) );
+                                alternatives.push_back( Alternative{ 
+                                        new OffsetofExpr{ aggInst->clone(), dwt }, env } );
                                 renameTypes( alternatives.back().expr );
                         } else {
@@ -1480 +1398 @@
 
         void AlternativeFinder::Finder::postvisit( OffsetofExpr *offsetofExpr ) {
-                alternatives.push_back( Alternative( offsetofExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ offsetofExpr->clone(), env } );
         }
 
         void AlternativeFinder::Finder::postvisit( OffsetPackExpr *offsetPackExpr ) {
-                alternatives.push_back( Alternative( offsetPackExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ offsetPackExpr->clone(), env } );
         }
 
@@ -1504 +1422 @@
                                 Cost cost = Cost::zero;
                                 Expression * newExpr = data.combine( cost );
-                                alternatives.push_back( Alternative( new AttrExpr( newExpr, argType->clone() ), env, Cost::zero, cost ) );
+                                alternatives.push_back( Alternative{ 
+                                        new AttrExpr{ newExpr, argType->clone() }, env, OpenVarSet{}, 
+                                        AssertionList{}, Cost::zero, cost } );
                                 for ( DeclarationWithType * retVal : function->returnVals ) {
                                         alternatives.back().expr->result = retVal->get_type()->clone();
@@ -1543 +1463 @@
                                 Cost cost = Cost::zero;
                                 Expression * newExpr = data.combine( cost );
-                                alternatives.push_back( Alternative( newExpr, env, Cost::zero, cost ) );
+                                alternatives.push_back( Alternative{ 
+                                        newExpr, env, OpenVarSet{}, AssertionList{}, Cost::zero, cost } );
                                 renameTypes( alternatives.back().expr );
                         } // for
@@ -1558 +1479 @@
                 for ( const Alternative & first : firstFinder.alternatives ) {
                         for ( const Alternative & second : secondFinder.alternatives ) {
-                                TypeEnvironment compositeEnv;
-                                compositeEnv.simpleCombine( first.env );
+                                TypeEnvironment compositeEnv{ first.env };
                                 compositeEnv.simpleCombine( second.env );
-
-                                LogicalExpr *newExpr = new LogicalExpr( first.expr->clone(), second.expr->clone(), logicalExpr->get_isAnd() );
-                                alternatives.push_back( Alternative( newExpr, compositeEnv, first.cost + second.cost ) );
+                                OpenVarSet openVars{ first.openVars };
+                                mergeOpenVars( openVars, second.openVars );
+                                AssertionSet need;
+                                cloneAll( first.need, need );
+                                cloneAll( second.need, need );
+
+                                LogicalExpr *newExpr = new LogicalExpr{ 
+                                        first.expr->clone(), second.expr->clone(), logicalExpr->get_isAnd() };
+                                alternatives.push_back( Alternative{ 
+                                        newExpr, std::move(compositeEnv), std::move(openVars), 
+                                        AssertionList( need.begin(), need.end() ), first.cost + second.cost } );
                         }
                 }
@@ -1584 +1512 @@
                         for ( const Alternative & second : secondFinder.alternatives ) {
                                 for ( const Alternative & third : thirdFinder.alternatives ) {
-                                        TypeEnvironment compositeEnv;
-                                        compositeEnv.simpleCombine( first.env );
+                                        TypeEnvironment compositeEnv{ first.env };
                                         compositeEnv.simpleCombine( second.env );
                                         compositeEnv.simpleCombine( third.env );
-
+                                        OpenVarSet openVars{ first.openVars };
+                                        mergeOpenVars( openVars, second.openVars );
+                                        mergeOpenVars( openVars, third.openVars );
+                                        AssertionSet need;
+                                        cloneAll( first.need, need );
+                                        cloneAll( second.need, need );
+                                        cloneAll( third.need, need );
+                                        AssertionSet have;
+                                        
                                         // unify true and false types, then infer parameters to produce new alternatives
-                                        OpenVarSet openVars;
-                                        AssertionSet needAssertions, haveAssertions;
-                                        Alternative newAlt( 0, compositeEnv, first.cost + second.cost + third.cost );
                                         Type* commonType = nullptr;
-                                        if ( unify( second.expr->result, third.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                                                ConditionalExpr *newExpr = new ConditionalExpr( first.expr->clone(), second.expr->clone(), third.expr->clone() );
+                                        if ( unify( second.expr->result, third.expr->result, compositeEnv, 
+                                                        need, have, openVars, indexer, commonType ) ) {
+                                                ConditionalExpr *newExpr = new ConditionalExpr{ 
+                                                        first.expr->clone(), second.expr->clone(), third.expr->clone() };
                                                 newExpr->result = commonType ? commonType : second.expr->result->clone();
                                                 // convert both options to the conditional result type
-                                                newAlt.cost += computeExpressionConversionCost( newExpr->arg2, newExpr->result, indexer, newAlt.env );
-                                                newAlt.cost += computeExpressionConversionCost( newExpr->arg3, newExpr->result, indexer, newAlt.env );
-                                                newAlt.expr = newExpr;
-                                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
+                                                Cost cost = first.cost + second.cost + third.cost;
+                                                cost += computeExpressionConversionCost( 
+                                                        newExpr->arg2, newExpr->result, indexer, compositeEnv );
+                                                cost += computeExpressionConversionCost( 
+                                                        newExpr->arg3, newExpr->result, indexer, compositeEnv );
+                                                // output alternative
+                                                Alternative newAlt{ 
+                                                        newExpr, std::move(compositeEnv), std::move(openVars), 
+                                                        AssertionList( need.begin(), need.end() ), cost };
+                                                inferParameters( newAlt, back_inserter( alternatives ) );
                                         } // if
                                 } // for
@@ -1614 +1554 @@
                 secondFinder.findWithAdjustment( commaExpr->get_arg2() );
                 for ( const Alternative & alt : secondFinder.alternatives ) {
-                        alternatives.push_back( Alternative( new CommaExpr( newFirstArg->clone(), alt.expr->clone() ), alt.env, alt.cost ) );
+                        alternatives.push_back( Alternative{ 
+                                alt, new CommaExpr{ newFirstArg->clone(), alt.expr->clone() }, alt.cost } );
                 } // for
                 delete newFirstArg;
@@ -1629 +1570 @@
                 for ( const Alternative & first : firstFinder.alternatives ) {
                         for ( const Alternative & second : secondFinder.alternatives ) {
-                                TypeEnvironment compositeEnv;
-                                compositeEnv.simpleCombine( first.env );
+                                TypeEnvironment compositeEnv{ first.env };
                                 compositeEnv.simpleCombine( second.env );
-                                OpenVarSet openVars;
-                                AssertionSet needAssertions, haveAssertions;
-                                Alternative newAlt( 0, compositeEnv, first.cost + second.cost );
+                                OpenVarSet openVars{ first.openVars };
+                                mergeOpenVars( openVars, second.openVars );
+                                AssertionSet need;
+                                cloneAll( first.need, need );
+                                cloneAll( second.need, need );
+                                AssertionSet have;
+
                                 Type* commonType = nullptr;
-                                if ( unify( first.expr->result, second.expr->result, newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
-                                        RangeExpr * newExpr = new RangeExpr( first.expr->clone(), second.expr->clone() );
+                                if ( unify( first.expr->result, second.expr->result, compositeEnv, need, have, 
+                                                openVars, indexer, commonType ) ) {
+                                        RangeExpr * newExpr = 
+                                                new RangeExpr{ first.expr->clone(), second.expr->clone() };
                                         newExpr->result = commonType ? commonType : first.expr->result->clone();
-                                        newAlt.expr = newExpr;
-                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
+                                        Alternative newAlt{ 
+                                                newExpr, std::move(compositeEnv), std::move(openVars), 
+                                                AssertionList( need.begin(), need.end() ), first.cost + second.cost };
+                                        inferParameters( newAlt, back_inserter( alternatives ) );
                                 } // if
                         } // for
@@ -1658 +1606 @@
 
                         TypeEnvironment compositeEnv;
-                        simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
-                        alternatives.push_back(
-                                Alternative{ new TupleExpr( exprs ), compositeEnv, sumCost( alts ) } );
+                        OpenVarSet openVars;
+                        AssertionSet need;
+                        for ( const Alternative& alt : alts ) {
+                                compositeEnv.simpleCombine( alt.env );
+                                mergeOpenVars( openVars, alt.openVars );
+                                cloneAll( alt.need, need );
+                        }
+                        
+                        alternatives.push_back( Alternative{ 
+                                new TupleExpr{ exprs }, std::move(compositeEnv), std::move(openVars), 
+                                AssertionList( need.begin(), need.end() ), sumCost( alts ) } );
                 } // for
         }
 
         void AlternativeFinder::Finder::postvisit( TupleExpr *tupleExpr ) {
-                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ tupleExpr->clone(), env } );
         }
 
         void AlternativeFinder::Finder::postvisit( ImplicitCopyCtorExpr * impCpCtorExpr ) {
-                alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ impCpCtorExpr->clone(), env } );
         }
 
@@ -1678 +1634 @@
                 finder.findWithoutPrune( ctorExpr->get_callExpr() );
                 for ( Alternative & alt : finder.alternatives ) {
-                        alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
+                        alternatives.push_back( Alternative{ 
+                                alt, new ConstructorExpr( alt.expr->clone() ), alt.cost } );
                 }
         }
 
         void AlternativeFinder::Finder::postvisit( TupleIndexExpr *tupleExpr ) {
-                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ tupleExpr->clone(), env } );
         }
 
         void AlternativeFinder::Finder::postvisit( TupleAssignExpr *tupleAssignExpr ) {
-                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ tupleAssignExpr->clone(), env } );
         }
 
@@ -1696 +1653 @@
                         // ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
                         UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
-                        alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
+                        alternatives.push_back( Alternative{ alt, newUnqExpr, alt.cost } );
                 }
         }
@@ -1704 +1661 @@
                 ResolvExpr::resolveStmtExpr( newStmtExpr, indexer );
                 // xxx - this env is almost certainly wrong, and needs to somehow contain the combined environments from all of the statements in the stmtExpr...
-                alternatives.push_back( Alternative( newStmtExpr, env, Cost::zero ) );
+                alternatives.push_back( Alternative{ newStmtExpr, env } );
         }
 
@@ -1726 +1683 @@
                         for ( Alternative & alt : finder.get_alternatives() ) {
                                 TypeEnvironment newEnv( alt.env );
-                                AssertionSet needAssertions, haveAssertions;
-                                OpenVarSet openVars;  // find things in env that don't have a "representative type" and claim those are open vars?
+                                AssertionSet need;
+                                cloneAll( alt.need, need );
+                                AssertionSet have;
+                                OpenVarSet openVars( alt.openVars );  
+                                // xxx - find things in env that don't have a "representative type" and claim 
+                                // those are open vars?
                                 PRINT(
                                         std::cerr << "  @ " << toType << " " << initAlt.designation << std::endl;
                                 )
-                                // It's possible that a cast can throw away some values in a multiply-valued expression.  (An example is a
-                                // cast-to-void, which casts from one value to zero.)  Figure out the prefix of the subexpression results
-                                // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
-                                // to.
+                                // It's possible that a cast can throw away some values in a multiply-valued 
+                                // expression. (An example is a cast-to-void, which casts from one value to 
+                                // zero.)  Figure out the prefix of the subexpression results that are cast 
+                                // directly.  The candidate is invalid if it has fewer results than there are 
+                                // types to cast to.
                                 int discardedValues = alt.expr->result->size() - toType->size();
                                 if ( discardedValues < 0 ) continue;
-                                // xxx - may need to go into tuple types and extract relevant types and use unifyList. Note that currently, this does not
-                                // allow casting a tuple to an atomic type (e.g. (int)([1, 2, 3]))
+                                // xxx - may need to go into tuple types and extract relevant types and use 
+                                // unifyList. Note that currently, this does not allow casting a tuple to an 
+                                // atomic type (e.g. (int)([1, 2, 3]))
+                                
                                 // unification run for side-effects
-                                unify( toType, alt.expr->result, newEnv, needAssertions, haveAssertions, openVars, indexer ); // xxx - do some inspecting on this line... why isn't result bound to initAlt.type??
+                                unify( toType, alt.expr->result, newEnv, need, have, openVars, indexer );
+                                // xxx - do some inspecting on this line... why isn't result bound to initAlt.type?
 
                                 Cost thisCost = castCost( alt.expr->result, toType, indexer, newEnv );
@@ -1746 +1711 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
-                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                        Alternative newAlt{ 
+                                                new InitExpr{ 
+                                                        restructureCast( alt.expr->clone(), toType, true ), initAlt.designation->clone() }, 
+                                                std::move(newEnv), std::move(openVars), 
+                                                AssertionList( need.begin(), need.end() ), alt.cost, thisCost };
+                                        inferParameters( newAlt, back_inserter( candidates ) );
                                 }
                         }

src/ResolvExpr/AlternativeFinder.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sat May 16 23:56:12 2015
-// Last Modified By : Andrew Beach
-// Last Modified On : Wed Jul 26 11:24:00 2017
-// Update Count     : 4
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct -5 10:01:00 2018
+// Update Count     : 5
 //
 
@@ -24 +24 @@
 #include "ResolvExpr/Cost.h"             // for Cost, Cost::infinity
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
+#include "ResolvMode.h"                  // for ResolvMode
 #include "SynTree/Visitor.h"             // for Visitor
 #include "SynTree/SynTree.h"             // for Visitor Nodes
@@ -68 +69 @@
                 }
 
-                void find( Expression *expr, bool adjust = false, bool prune = true, bool failFast = true );
+                void find( Expression *expr, ResolvMode mode = ResolvMode{} );
                 /// Calls find with the adjust flag set; adjustment turns array and function types into equivalent pointer types
                 void findWithAdjustment( Expression *expr );

src/ResolvExpr/ConversionCost.cc

@@ -28 +28 @@
 
 namespace ResolvExpr {
-        const Cost Cost::zero =      Cost(  0,  0,  0,  0 );
-        const Cost Cost::infinity =  Cost( -1, -1, -1, -1 );
-        const Cost Cost::unsafe =    Cost(  1,  0,  0,  0 );
-        const Cost Cost::poly =      Cost(  0,  1,  0,  0 );
-        const Cost Cost::safe =      Cost(  0,  0,  1,  0 );
-        const Cost Cost::reference = Cost(  0,  0,  0,  1 );
+        const Cost Cost::zero =      Cost{  0,  0,  0,  0,  0,  0 };
+        const Cost Cost::infinity =  Cost{ -1, -1, -1, -1,  1, -1 };
+        const Cost Cost::unsafe =    Cost{  1,  0,  0,  0,  0,  0 };
+        const Cost Cost::poly =      Cost{  0,  1,  0,  0,  0,  0 };
+        const Cost Cost::safe =      Cost{  0,  0,  1,  0,  0,  0 };
+        const Cost Cost::var =       Cost{  0,  0,  0,  1,  0,  0 };
+        const Cost Cost::spec =      Cost{  0,  0,  0,  0, -1,  0 };
+        const Cost Cost::reference = Cost{  0,  0,  0,  0,  0,  1 };
 
 #if 0

src/ResolvExpr/Cost.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 09:39:50 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:35:55 2017
-// Update Count     : 5
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct 05 14:32:00 2018
+// Update Count     : 7
 //
 
@@ -21 +21 @@
         class Cost {
           private:
-                Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost );
+                Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost,
+                        int referenceCost );
 
           public:
@@ -27 +28 @@
                 Cost & incPoly( int inc = 1 );
                 Cost & incSafe( int inc = 1 );
+                Cost & incVar( int inc = 1 );
+                Cost & decSpec( int inc = 1 );
                 Cost & incReference( int inc = 1 );
 
@@ -32 +35 @@
                 int get_polyCost() const { return polyCost; }
                 int get_safeCost() const { return safeCost; }
+                int get_varCost() const { return varCost; }
+                int get_specCost() const { return specCost; }
                 int get_referenceCost() const { return referenceCost; }
 
@@ -41 +46 @@
                 bool operator!=( const Cost &other ) const;
                 friend std::ostream &operator<<( std::ostream &os, const Cost &cost );
+                // returns negative for *this < other, 0 for *this == other, positive for *this > other
+                int compare( const Cost &other ) const;
 
                 static const Cost zero;
@@ -48 +55 @@
                 static const Cost poly;
                 static const Cost safe;
+                static const Cost var;
+                static const Cost spec;
                 static const Cost reference;
+
           private:
-                int compare( const Cost &other ) const;
-
-                int unsafeCost;
-                int polyCost;
-                int safeCost;
-                int referenceCost;
+                int unsafeCost;     ///< Unsafe (narrowing) conversions
+                int polyCost;       ///< Count of parameters and return values bound to some poly type
+                int safeCost;       ///< Safe (widening) conversions
+                int varCost;        ///< Count of polymorphic type variables
+                int specCost;       ///< Polymorphic type specializations (type assertions), negative cost
+                int referenceCost;  ///< reference conversions
         };
 
-        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int referenceCost ) : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), referenceCost( referenceCost ) {}
+        inline Cost::Cost( int unsafeCost, int polyCost, int safeCost, int varCost, int specCost, 
+                        int referenceCost ) 
+                : unsafeCost( unsafeCost ), polyCost( polyCost ), safeCost( safeCost ), varCost( varCost ), 
+                  specCost( specCost ), referenceCost( referenceCost ) {}
 
         inline Cost & Cost::incUnsafe( int inc ) {
@@ -75 +88 @@
                 if ( *this == infinity ) return *this;
                 safeCost += inc;
+                return *this;
+        }
+
+        inline Cost & Cost::incVar( int inc ) {
+                if ( *this == infinity ) return *this;
+                varCost += inc;
+                return *this;
+        }
+
+        inline Cost& Cost::decSpec( int dec ) {
+                if ( *this == infinity ) return *this;
+                specCost -= dec;
                 return *this;
         }
@@ -86 +111 @@
         inline Cost Cost::operator+( const Cost &other ) const {
                 if ( *this == infinity || other == infinity ) return infinity;
-                return Cost( unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, referenceCost + other.referenceCost );
+                return Cost{ 
+                        unsafeCost + other.unsafeCost, polyCost + other.polyCost, safeCost + other.safeCost, 
+                        varCost + other.varCost, specCost + other.specCost, 
+                        referenceCost + other.referenceCost };
         }
 
         inline Cost Cost::operator-( const Cost &other ) const {
                 if ( *this == infinity || other == infinity ) return infinity;
-                return Cost( unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, referenceCost - other.referenceCost );
+                return Cost{ 
+                        unsafeCost - other.unsafeCost, polyCost - other.polyCost, safeCost - other.safeCost, 
+                        varCost - other.varCost, specCost - other.specCost, 
+                        referenceCost - other.referenceCost };
         }
 
@@ -103 +134 @@
                 polyCost += other.polyCost;
                 safeCost += other.safeCost;
+                varCost += other.varCost;
+                specCost += other.specCost;
                 referenceCost += other.referenceCost;
                 return *this;
@@ -123 +156 @@
                 } else if ( safeCost < other.safeCost ) {
                         return true;
+                } else if ( varCost > other.varCost ) {
+                        return false;
+                } else if ( varCost < other.varCost ) {
+                        return true;
+                } else if ( specCost > other.specCost ) {
+                        return false;
+                } else if ( specCost > other.specCost ) {
+                        return true;
                 } else if ( referenceCost > other.referenceCost ) {
                         return false;
@@ -130 +171 @@
                         return false;
                 } // if
+        }
+
+        inline int Cost::compare( const Cost &other ) const {
+                if ( *this == infinity ) return +1;
+                if ( other == infinity ) return -1;
+
+                int c = unsafeCost - other.unsafeCost; if ( c ) return c;
+                c = polyCost - other.polyCost; if ( c ) return c;
+                c = safeCost - other.safeCost; if ( c ) return c;
+                c = varCost - other.varCost; if ( c ) return c;
+                c = specCost - other.specCost; if ( c ) return c;
+                return referenceCost - other.referenceCost;
         }
 
@@ -136 +189 @@
                         && polyCost == other.polyCost
                         && safeCost == other.safeCost
+                        && varCost == other.varCost
+                        && specCost == other.specCost
                         && referenceCost == other.referenceCost;
         }
@@ -144 +199 @@
 
         inline std::ostream &operator<<( std::ostream &os, const Cost &cost ) {
-                os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " << cost.safeCost << ", " << cost.referenceCost << " )";
-                return os;
+                return os << "( " << cost.unsafeCost << ", " << cost.polyCost << ", " 
+                          << cost.safeCost << ", " << cost.varCost << ", " << cost.specCost << ", "
+                          << cost.referenceCost << " )";
         }
 } // namespace ResolvExpr

src/ResolvExpr/Resolver.cc

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Sun May 17 12:17:01 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 17 11:19:40 2018
-// Update Count     : 213
+// Last Modified By : Aaron B. Moss
+// Last Modified On : Fri Oct 05 09:43:00 2018
+// Update Count     : 214
 //
 
-#include <stddef.h>                      // for NULL
 #include <cassert>                       // for strict_dynamic_cast, assert
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
-#include <vector>
+#include <vector>                        // for vector
 
 #include "Alternative.h"                 // for Alternative, AltList
@@ -31 +30 @@
 #include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
 #include "Resolver.h"
+#include "ResolvMode.h"                  // for ResolvMode
 #include "SymTab/Autogen.h"              // for SizeType
 #include "SymTab/Indexer.h"              // for Indexer
@@ -168 +168 @@
 
         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) {
+                void findUnfinishedKindExpression(Expression * untyped, Alternative & alt, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{} ) {
                         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, adjust, prune, failFast );
+                        finder.find( untyped, recursion_level == 1 ? mode.atTopLevel() : mode );
+                        --recursion_level;
 
                         #if 0
@@ -185 +191 @@
                         #endif
 
+                        // produce filtered list of alternatives
                         AltList candidates;
                         for ( Alternative & alt : finder.get_alternatives() ) {
@@ -192 +199 @@
                         }
 
-                        // xxx - if > 1 alternative with same cost, ignore deleted and pick from remaining
-                        // choose the lowest cost expression among the candidates
+                        // produce invalid error if no candidates
+                        if ( candidates.empty() ) {
+                                SemanticError( untyped, toString( "No reasonable alternatives for ", kindStr, (kindStr != "" ? " " : ""), "expression: ") );
+                        }
+
+                        // search for cheapest candidate
                         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 ) {
+                        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 ) {
                                 std::ostringstream stream;
                                 stream << "Cannot choose between " << winners.size() << " alternatives for " << kindStr << (kindStr != "" ? " " : "") << "expression\n";
@@ -207 +246 @@
                         }
 
-                        // there is one unambiguous interpretation - move the expression into the with statement
-                        Alternative & choice = winners.front();
-                        if ( findDeletedExpr( choice.expr ) ) {
+                        // single selected choice
+                        Alternative& choice = winners.front();
+
+                        // fail on only expression deleted
+                        if ( ! seen_undeleted ) {
                                 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, bool adjust = false, bool prune = true, bool failFast = true) {
+                void findKindExpression(Expression *& untyped, const SymTab::Indexer & indexer, const std::string & kindStr, std::function<bool(const Alternative &)> pred, ResolvMode mode = ResolvMode{}) {
                         if ( ! untyped ) return;
                         Alternative choice;
-                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, adjust, prune, failFast );
+                        findUnfinishedKindExpression( untyped, choice, indexer, kindStr, pred, mode );
                         finishExpr( choice.expr, choice.env, untyped->env );
                         delete untyped;
@@ -250 +295 @@
                 untyped.arg = expr;
                 Alternative choice;
-                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, true );
+                findUnfinishedKindExpression( &untyped, choice, indexer, "", standardAlternativeFilter, ResolvMode::withAdjustment() );
                 CastExpr * castExpr = strict_dynamic_cast< CastExpr * >( choice.expr );
                 env = std::move( choice.env );
@@ -357 +402 @@
 
         void Resolver::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.
+                // 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() );
@@ -397 +442 @@
 
         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.
+                // 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 ) ) {
@@ -749 +795 @@
                 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();
 
@@ -766 +814 @@
                                         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";
+                                                        // strip cast if we're initializing a char[] with a char *, 
+                                                        // e.g.  char x[] = "hello";
                                                         newExpr = ce->get_arg();
                                                         ce->set_arg( nullptr );
@@ -788 +837 @@
                 // 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);
@@ -822 +872 @@
                 // fall back on C-style initializer
                 delete ctorInit->get_ctor();
-                ctorInit->set_ctor( NULL );
+                ctorInit->set_ctor( nullptr );
                 delete ctorInit->get_dtor();
-                ctorInit->set_dtor( NULL );
+                ctorInit->set_dtor( nullptr );
                 maybeAccept( ctorInit->get_init(), *visitor );
         }
@@ -867 +917 @@
 
                 // xxx - todo -- what about arrays?
-                // if ( dtor == NULL && InitTweak::isIntrinsicCallStmt( ctorInit->get_ctor() ) ) {
+                // if ( dtor == nullptr && 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( NULL );
+                //      ctorInit->set_ctor( nullptr );
 
                 //      Expression * arg =

src/ResolvExpr/TypeEnvironment.cc

@@ -120 +120 @@
 
         const EqvClass* TypeEnvironment::lookup( const std::string &var ) const {
-                for ( std::list< EqvClass >::const_iterator i = env.begin(); i != env.end(); ++i ) {
+                for ( ClassList::const_iterator i = env.begin(); i != env.end(); ++i ) {
                         if ( i->vars.find( var ) != i->vars.end() ) return &*i;
                 } // for
@@ -168 +168 @@
 
         void TypeEnvironment::makeSubstitution( TypeSubstitution &sub ) const {
-                for ( std::list< EqvClass >::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
+                for ( ClassList::const_iterator theClass = env.begin(); theClass != env.end(); ++theClass ) {
                         for ( std::set< std::string >::const_iterator theVar = theClass->vars.begin(); theVar != theClass->vars.end(); ++theVar ) {
                                 if ( theClass->type ) {
@@ -188 +188 @@
         }
 
-        std::list< EqvClass >::iterator TypeEnvironment::internal_lookup( const std::string &var ) {
-                for ( std::list< EqvClass >::iterator i = env.begin(); i != env.end(); ++i ) {
+        TypeEnvironment::ClassList::iterator TypeEnvironment::internal_lookup( const std::string &var ) {
+                for ( ClassList::iterator i = env.begin(); i != env.end(); ++i ) {
                         if ( i->vars.count( var ) ) return i;
                 } // for
@@ -199 +199 @@
         }
 
+        // xxx -- this should maybe be worrying about iterator invalidation (see resolv-proto)
+        bool TypeEnvironment::mergeBound( EqvClass& to, const EqvClass& from, OpenVarSet& openVars, const SymTab::Indexer& indexer ) {
+                if ( from.type ) {
+                        if ( to.type ) {
+                                // attempt to unify bound types
+                                std::unique_ptr<Type> toType{ to.type->clone() }, fromType{ from.type->clone() };
+                                WidenMode widenMode{ to.allowWidening, from.allowWidening };
+                                Type* common = nullptr;
+                                AssertionSet need, have;
+                                if ( unifyInexact( toType.get(), fromType.get(), *this, need, have, openVars, widenMode, indexer, common ) ) {
+                                        // unifies, set common type if necessary
+                                        if ( common ) {
+                                                common->get_qualifiers() = Type::Qualifiers{};
+                                                to.set_type( common );
+                                        }
+                                } else return false; // cannot unify
+                        } else {
+                                to.type = from.type->clone();
+                        }
+                }
+
+                // unify widening if matches
+                to.allowWidening &= from.allowWidening;
+                return true;
+        }
+
+        // xxx -- this should maybe be worrying about iterator invalidation (see resolv-proto)
+        bool TypeEnvironment::mergeClasses( TypeEnvironment::ClassList::iterator to, TypeEnvironment::ClassList::iterator from, OpenVarSet& openVars, const SymTab::Indexer& indexer ) {
+                EqvClass& r = *to;
+                EqvClass& s = *from;
+
+                // ensure bounds match
+                if ( ! mergeBound( r, s, openVars, indexer ) ) return false;
+
+                // check safely bindable
+                if ( r.type && occursIn( r.type, s.vars.begin(), s.vars.end(), *this ) ) return false;
+                
+                // merge classes in
+                r.vars.insert( s.vars.begin(), s.vars.end() );
+                r.allowWidening &= s.allowWidening;
+                env.erase( from );
+
+                return true;
+        }
+
+        bool TypeEnvironment::combine( const TypeEnvironment& o, OpenVarSet& openVars, const SymTab::Indexer& indexer ) {
+                // short-circuit easy cases
+                if ( o.isEmpty() ) return true;
+                if ( isEmpty() ) {
+                        simpleCombine( o );
+                        return true;
+                }
+
+                // merge classes
+                for ( auto ct = o.env.begin(); ct != o.env.end(); ++ct ) {
+                        const EqvClass& c = *ct;
+
+                        // typeclass in local environment bound to c
+                        auto rt = env.end();
+
+                        // look for first existing bound variable
+                        auto vt = c.vars.begin();
+                        for ( ; vt != c.vars.end(); ++vt ) {
+                                rt = internal_lookup( *vt );
+                                if ( rt != env.end() ) break;
+                        }
+
+                        if ( rt != env.end() ) {  // c needs to be merged into *rt
+                                EqvClass& r = *rt;
+                                // merge bindings
+                                if ( ! mergeBound( r, c, openVars, indexer ) ) return false;
+                                // merge previous unbound variables into this class, checking occurs if needed
+                                if ( r.type ) for ( auto ut = c.vars.begin(); ut != vt; ++ut ) {
+                                        if ( occurs( r.type, *ut, *this ) ) return false;
+                                        r.vars.insert( *ut );
+                                } else { r.vars.insert( c.vars.begin(), vt ); }
+                                // merge subsequent variables into this class (skipping *vt, already there)
+                                while ( ++vt != c.vars.end() ) {
+                                        auto st = internal_lookup( *vt );
+                                        if ( st == env.end() ) {
+                                                // unbound, safe to add if passes occurs
+                                                if ( r.type && occurs( r.type, *vt, *this ) ) return false;
+                                                r.vars.insert( *vt );
+                                        } else if ( st != rt ) {
+                                                // bound, but not to the same class
+                                                if ( ! mergeClasses( rt, st, openVars, indexer ) ) return false;
+                                        }   // ignore bound into the same class
+                                }
+                        } else {  // no variables in c bound; just copy up
+                                env.push_back( c );
+                        }
+                }
+
+                // merged all classes
+                return true;
+        }
+
         void TypeEnvironment::extractOpenVars( OpenVarSet &openVars ) const {
-                for ( std::list< EqvClass >::const_iterator eqvClass = env.begin(); eqvClass != env.end(); ++eqvClass ) {
+                for ( ClassList::const_iterator eqvClass = env.begin(); eqvClass != env.end(); ++eqvClass ) {
                         for ( std::set< std::string >::const_iterator var = eqvClass->vars.begin(); var != eqvClass->vars.end(); ++var ) {
                                 openVars[ *var ] = eqvClass->data;

src/ResolvExpr/TypeEnvironment.h

@@ -39 +39 @@
         // declarations.
         //
-        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this comparator.
+        // I've seen a TU go from 54 minutes to 1 minute 34 seconds with the addition of this 
+        // comparator.
         //
         // Note: since this compares pointers for position, minor changes in the source file that affect
         // memory layout can alter compilation time in unpredictable ways. For example, the placement
         // of a line directive can reorder type pointers with respect to each other so that assertions
-        // are seen in different orders, causing a potentially different number of unification calls when
-        // resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering line directives
-        // alone, so it would be nice to fix this comparison so that assertions compare more consistently.
-        // I've tried to modify this to compare on mangle name instead of type as the second comparator, but
-        // this causes some assertions to never be recorded. More investigation is needed.
+        // are seen in different orders, causing a potentially different number of unification calls 
+        // when resolving assertions. I've seen a TU go from 36 seconds to 27 seconds by reordering 
+        // line directives alone, so it would be nice to fix this comparison so that assertions compare 
+        // more consistently. I've tried to modify this to compare on mangle name instead of type as 
+        // the second comparator, but this causes some assertions to never be recorded. More 
+        // investigation is needed.
         struct AssertCompare {
                 bool operator()( DeclarationWithType * d1, DeclarationWithType * d2 ) const {
@@ -57 +59 @@
         };
         struct AssertionSetValue {
-                bool isUsed;
-                // chain of Unique IDs of the assertion declarations. The first ID in the chain is the ID of an assertion on the current type,
-                // with each successive ID being the ID of an assertion pulled in by the previous ID. The last ID in the chain is
-                // the ID of the assertion that pulled in the current assertion.
-                std::list< UniqueId > idChain;
+                bool isUsed;        ///< True if assertion needs to be resolved
+                UniqueId resnSlot;  ///< ID of slot assertion belongs to
+
+                AssertionSetValue() : isUsed(false), resnSlot(0) {}
         };
         typedef std::map< DeclarationWithType*, AssertionSetValue, AssertCompare > AssertionSet;
         typedef std::map< std::string, TypeDecl::Data > OpenVarSet;
+
+        /// merges one set of open vars into another
+        static inline void mergeOpenVars( OpenVarSet& dst, const OpenVarSet& src ) {
+                for ( const auto& entry : src ) { dst[ entry.first ] = entry.second; }
+        }
 
         void printAssertionSet( const AssertionSet &, std::ostream &, int indent = 0 );
@@ -91 +97 @@
 
         class TypeEnvironment {
+                using ClassList = std::list< EqvClass >;
           public:
                 const EqvClass* lookup( const std::string &var ) const;
@@ -103 +110 @@
                 bool isEmpty() const { return env.empty(); }
                 void print( std::ostream &os, Indenter indent = {} ) const;
-                // void combine( const TypeEnvironment &second, Type *(*combineFunc)( Type*, Type* ) );
+                
+                /// Simply concatenate the second environment onto this one; no safety checks performed
                 void simpleCombine( const TypeEnvironment &second );
+
+          private:
+                /// Unifies the type bound of to with the type bound of from, returning false if fails
+                bool mergeBound( EqvClass& to, const EqvClass& from, OpenVarSet& openVars, const SymTab::Indexer& indexer );
+
+                /// Merges two type classes from local environment, returning false if fails
+                bool mergeClasses( ClassList::iterator to, ClassList::iterator from, OpenVarSet& openVars, const SymTab::Indexer& indexer );
+
+          public:
+                /// Merges the second environment with this one, checking compatibility.
+                /// Returns false if fails, but does NOT roll back partial changes.
+                bool combine( const TypeEnvironment& second, OpenVarSet& openVars, const SymTab::Indexer& indexer );
+                
                 void extractOpenVars( OpenVarSet &openVars ) const;
                 TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
@@ -123 +144 @@
                 void forbidWidening();
 
-                using iterator = std::list< EqvClass >::const_iterator;
+                using iterator = ClassList::const_iterator;
                 iterator begin() const { return env.begin(); }
                 iterator end() const { return env.end(); }
 
           private:
-                std::list< EqvClass > env;
+                ClassList env;
                 
-                std::list< EqvClass >::iterator internal_lookup( const std::string &var );
+                ClassList::iterator internal_lookup( const std::string &var );
         };
 

src/ResolvExpr/module.mk

@@ -33 +33 @@
        ResolvExpr/TypeEnvironment.cc \
        ResolvExpr/CurrentObject.cc \
-       ResolvExpr/ExplodedActual.cc
+       ResolvExpr/ExplodedActual.cc \
+       ResolvExpr/SpecCost.cc \
+       ResolvExpr/ResolveAssertions.cc

src/ResolvExpr/typeops.h

@@ -72 +72 @@
         Cost conversionCost( Type *src, Type *dest, const SymTab::Indexer &indexer, const TypeEnvironment &env );
 
+        // in AlternativeFinder.cc
+        Cost computeConversionCost( Type *actualType, Type *formalType, 
+                const SymTab::Indexer &indexer, const TypeEnvironment &env );
+
         // in PtrsAssignable.cc
         int ptrsAssignable( Type *src, Type *dest, const TypeEnvironment &env );
@@ -102 +106 @@
         int polyCost( Type *type, const TypeEnvironment &env, const SymTab::Indexer &indexer );
 
+        // in SpecCost.cc
+        int specCost( Type *type );
+
         // in Occurs.cc
         bool occurs( Type *type, std::string varName, const TypeEnvironment &env );
+
+        template<typename Iter> 
+        bool occursIn( Type* ty, Iter begin, Iter end, const TypeEnvironment &env ) {
+                while ( begin != end ) {
+                        if ( occurs( ty, *begin, env ) ) return true;
+                        ++begin;
+                }
+                return false;
+        }
 
         // in AlternativeFinder.cc

src/SynTree/ApplicationExpr.cc

@@ -29 +29 @@
 
 ParamEntry::ParamEntry( const ParamEntry &other ) :
-                decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) ), inferParams( new InferredParams( *other.inferParams ) ) {
+                decl( other.decl ), actualType( maybeClone( other.actualType ) ), formalType( maybeClone( other.formalType ) ), expr( maybeClone( other.expr ) )/*, inferParams( new InferredParams( *other.inferParams ) )*/ {
 }
 
@@ -39 +39 @@
         formalType = maybeClone( other.formalType );
         expr = maybeClone( other.expr );
-        *inferParams = *other.inferParams;
+        // *inferParams = *other.inferParams;
         return *this;
 }
@@ -50 +50 @@
 
 ParamEntry::ParamEntry( ParamEntry && other ) :
-                decl( other.decl ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr ), inferParams( std::move( other.inferParams ) ) {
+                decl( other.decl ), actualType( other.actualType ), formalType( other.formalType ), expr( other.expr )/*, inferParams( std::move( other.inferParams ) )*/ {
         other.actualType = nullptr;
         other.formalType = nullptr;
@@ -68 +68 @@
         other.formalType = nullptr;
         other.expr = nullptr;
-        inferParams = std::move( other.inferParams );
+        // inferParams = std::move( other.inferParams );
         return *this;
 }

src/SynTree/Expression.cc

@@ -40 +40 @@
                         Declaration::declFromId( i->second.decl )->printShort( os, indent+1 );
                         os << std::endl;
-                        printInferParams( *i->second.inferParams, os, indent+1, level+1 );
+                        printInferParams( i->second.expr->inferParams, os, indent+1, level+1 );
                 } // for
         } // if
@@ -47 +47 @@
 Expression::Expression() : result( 0 ), env( 0 ) {}
 
-Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ) {
-}
+Expression::Expression( const Expression &other ) : BaseSyntaxNode( other ), result( maybeClone( other.result ) ), env( maybeClone( other.env ) ), extension( other.extension ), inferParams( other.inferParams ), resnSlots( other.resnSlots ) {}
 
 void Expression::spliceInferParams( Expression * other ) {
@@ -55 +54 @@
                 inferParams[p.first] = std::move( p.second );
         }
+        resnSlots.insert( resnSlots.end(), other->resnSlots.begin(), other->resnSlots.end() );
 }
 
@@ -376 +376 @@
         os << "Untyped Member Expression, with field: " << std::endl << indent+1;
         member->print(os, indent+1 );
-        os << indent << "... from aggregate: " << std::endl << indent+1;
+        os << indent << "... from aggregate:" << std::endl << indent+1;
         aggregate->print(os, indent+1);
         Expression::print( os, indent );
@@ -405 +405 @@
 
 void MemberExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Member Expression, with field: " << std::endl;
+        os << "Member Expression, with field:" << std::endl;
         os << indent+1;
         member->print( os, indent+1 );
-        os << std::endl << indent << "... from aggregate: " << std::endl << indent+1;
+        os << std::endl << indent << "... from aggregate:" << std::endl << indent+1;
         aggregate->print(os, indent + 1);
         Expression::print( os, indent );
@@ -456 +456 @@
 
 void UntypedExpr::print( std::ostream &os, Indenter indent ) const {
-        os << "Applying untyped: " << std::endl;
+        os << "Applying untyped:" << std::endl;
         os << indent+1;
         function->print(os, indent+1);
-        os << std::endl << indent << "...to: " << std::endl;
+        os << std::endl << indent << "...to:" << std::endl;
         printAll(args, os, indent+1);
         Expression::print( os, indent );

src/SynTree/Expression.h

@@ -21 +21 @@
 #include <memory>                 // for allocator, unique_ptr
 #include <string>                 // for string
+#include <vector>                 // for vector
 
 #include "BaseSyntaxNode.h"       // for BaseSyntaxNode
@@ -38 +39 @@
 /// but subject to decay-to-pointer and type parameter renaming
 struct ParamEntry {
-        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 ), inferParams( new InferredParams ) {}
-        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr ), inferParams( new InferredParams ) {}
+        ParamEntry(): decl( 0 ), actualType( 0 ), formalType( 0 ), expr( 0 )/*, inferParams( new InferredParams )*/ {}
+        ParamEntry( UniqueId decl, Type * actualType, Type * formalType, Expression* expr ): decl( decl ), actualType( actualType ), formalType( formalType ), expr( expr )/*, inferParams( new InferredParams )*/ {}
         ParamEntry( const ParamEntry & other );
         ParamEntry( ParamEntry && other );
@@ -50 +51 @@
         Type * formalType;
         Expression * expr;
-        std::unique_ptr< InferredParams > inferParams;
+        // std::unique_ptr< InferredParams > inferParams;
 };
 
@@ -59 +60 @@
         TypeSubstitution * env;
         bool extension = false;
-        InferredParams inferParams;
+        InferredParams inferParams;       ///< Post-resolution inferred parameter slots
+        std::vector<UniqueId> resnSlots;  ///< Pre-resolution inferred parameter slots
+        
+        // xxx - should turn inferParams+resnSlots into a union to save some memory
 
         Expression();
@@ -73 +77 @@
         bool get_extension() const { return extension; }
         Expression * set_extension( bool exten ) { extension = exten; return this; }
-
-        InferredParams & get_inferParams() { return inferParams; }
 
         // move other's inferParams to this

src/SynTree/FunctionDecl.cc

@@ -87 +87 @@
 
         if ( statements ) {
-                os << indent << "... with body " << endl << indent+1;
+                os << indent << "... with body" << endl << indent+1;
                 statements->print( os, indent+1 );
         } // if

src/SynTree/FunctionType.cc

@@ -66 +66 @@
                 os << indent+1 << "accepting unspecified arguments" << endl;
         } // if
-        os << indent << "... returning ";
+        os << indent << "... returning";
         if ( returnVals.empty() ) {
-                os << "nothing " << endl;
+                os << " nothing" << endl;
         } else {
                 os << endl;

src/SynTree/ObjectDecl.cc

@@ -66 +66 @@
 
         if ( ! attributes.empty() ) {
-                os << std::endl << indent << "... with attributes: " << std::endl;
+                os << std::endl << indent << "... with attributes:" << std::endl;
                 printAll( attributes, os, indent+1 );
         }

src/SynTree/ReferenceToType.cc

@@ -93 +93 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseStruct->has_body();
                 if ( ! parameters.empty() ) {
                         os << endl << indent << "... with parameters" << endl;
@@ -136 +136 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseUnion->has_body();
                 if ( ! parameters.empty() ) {
                         os << endl << indent << "... with parameters" << endl;
@@ -160 +160 @@
         else {
                 Type::print( os, indent );
-                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body() << " ";
+                os << "instance of " << typeString() << " " << name << " with body " << baseEnum->has_body();
         } // if
 }
@@ -205 +205 @@
 
         Type::print( os, indent );
-        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type) ";
+        os << "instance of " << typeString() << " " << get_name() << " (" << ( isFtype ? "" : "not" ) << " function type)";
         if ( ! parameters.empty() ) {
                 os << endl << indent << "... with parameters" << endl;

src/SynTree/Type.cc

@@ -118 +118 @@
 
 void QualifiedType::print( std::ostream & os, Indenter indent ) const {
-        os << "Qualified Type: " << endl;
+        os << "Qualified Type:" << endl;
         os << indent+1;
         parent->print( os, indent+1 );

src/Tuples/Explode.h

@@ -44 +44 @@
         template<typename OutputIterator>
         void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env,
+                        const ResolvExpr::OpenVarSet& openVars, const ResolvExpr::AssertionList& need, 
                         const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
-                *out++ = ResolvExpr::Alternative{ expr, env, cost, cvtCost };
+                *out++ = ResolvExpr::Alternative{ expr, env, openVars, need, cost, cvtCost };
         }
 
         /// Append alternative to an ExplodedActual
         static inline void append( ResolvExpr::ExplodedActual& ea, Expression* expr,
-                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
+                        const ResolvExpr::TypeEnvironment&, const ResolvExpr::OpenVarSet&, 
+                        const ResolvExpr::AssertionList&, const ResolvExpr::Cost&, const ResolvExpr::Cost& ) {
                 ea.exprs.emplace_back( expr );
-                /// xxx -- merge environment, cost?
+                /// xxx -- merge environment, openVars, need, cost?
         }
 
@@ -68 +70 @@
                                         // distribute reference cast over all components
                                         append( std::forward<Output>(out), distributeReference( alt.release_expr() ),
-                                                alt.env, alt.cost, alt.cvtCost );
+                                                alt.env, alt.openVars, alt.need, alt.cost, alt.cvtCost );
                                 }
                                 // in tuple assignment, still need to handle the other cases, but only if not already handled here (don't want to output too many alternatives)
@@ -102 +104 @@
                 } else {
                         // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.cost, alt.cvtCost );
+                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.openVars, alt.need,  
+                                alt.cost, alt.cvtCost );
                 }
         }

src/Tuples/TupleAssignment.cc

@@ -62 +62 @@
                 struct Matcher {
                   public:
-                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, const
-                                ResolvExpr::AltList& rhs );
+                        Matcher( TupleAssignSpotter &spotter, const ResolvExpr::AltList& lhs, 
+                                const ResolvExpr::AltList& rhs );
                         virtual ~Matcher() {}
+                        
                         virtual void match( std::list< Expression * > &out ) = 0;
                         ObjectDecl * newObject( UniqueName & namer, Expression * expr );
+
+                        void combineState( const ResolvExpr::Alternative& alt ) {
+                                compositeEnv.simpleCombine( alt.env );
+                                ResolvExpr::mergeOpenVars( openVars, alt.openVars );
+                                cloneAll( alt.need, need );
+                        }
+
+                        void combineState( const ResolvExpr::AltList& alts ) {
+                                for ( const ResolvExpr::Alternative& alt : alts ) { combineState( alt ); }
+                        }
+                        
                         ResolvExpr::AltList lhs, rhs;
                         TupleAssignSpotter &spotter;
@@ -72 +84 @@
                         std::list< ObjectDecl * > tmpDecls;
                         ResolvExpr::TypeEnvironment compositeEnv;
+                        ResolvExpr::OpenVarSet openVars;
+                        ResolvExpr::AssertionSet need;
                 };
 
@@ -245 +259 @@
                 }
 
-                // extract expressions from the assignment alternatives to produce a list of assignments that
-                // together form a single alternative
+                // extract expressions from the assignment alternatives to produce a list of assignments 
+                // that together form a single alternative
                 std::list< Expression *> solved_assigns;
                 for ( ResolvExpr::Alternative & alt : current ) {
                         solved_assigns.push_back( alt.expr->clone() );
-                }
-                // combine assignment environments into combined expression environment
-                simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
+                        matcher->combineState( alt );
+                }
+                
                 // xxx -- was push_front
-                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
-                        new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv,
-                        ResolvExpr::sumCost( current ) + matcher->baseCost ) );
+                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative{
+                        new TupleAssignExpr{ solved_assigns, matcher->tmpDecls }, matcher->compositeEnv, 
+                        matcher->openVars, 
+                        ResolvExpr::AssertionList( matcher->need.begin(), matcher->need.end() ), 
+                        ResolvExpr::sumCost( current ) + matcher->baseCost } );
         }
 
@@ -263 +279 @@
         : lhs(lhs), rhs(rhs), spotter(spotter),
           baseCost( ResolvExpr::sumCost( lhs ) + ResolvExpr::sumCost( rhs ) ) {
-                simpleCombineEnvironments( lhs.begin(), lhs.end(), compositeEnv );
-                simpleCombineEnvironments( rhs.begin(), rhs.end(), compositeEnv );
+                combineState( lhs ); 
+                combineState( rhs );
         }
 

src/cfa.make

@@ -21 +21 @@
         $(LTCFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
         $(am__mv) $$depbase.Tpo $$depbase.Plo
+
+AM_V_JAVAC = $(am__v_JAVAC_@AM_V@)
+am__v_JAVAC_ = $(am__v_JAVAC_@AM_DEFAULT_V@)
+am__v_JAVAC_0 = @echo "  JAVAC   " $@;
+am__v_JAVAC_1 =
+
+AM_V_GOC = $(am__v_GOC_@AM_V@)
+am__v_GOC_ = $(am__v_GOC_@AM_DEFAULT_V@)
+am__v_GOC_0 = @echo "  GOC     " $@;
+am__v_GOC_1 =
+
+UPPCC = u++
+UPPCOMPILE = $(UPPCC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_UPPFLAGS) $(UPPFLAGS) $(AM_CXXFLAGS) $(CXXFLAGS) $(AM_CFLAGS) $(CFLAGS)
+
+AM_V_UPP = $(am__v_UPP_@AM_V@)
+am__v_UPP_ = $(am__v_UPP_@AM_DEFAULT_V@)
+am__v_UPP_0 = @echo "  UPP     " $@;
+am__v_UPP_1 =

src/config.h.in

@@ -7 +7 @@
 #undef CFA_64_CPU
 
-/* Location of include files. */
+/* Backend compiler to use. */
 #undef CFA_BACKEND_CC
 
@@ -67 +67 @@
 #undef HAVE_ALLOCA_H
 
+/* Define to 1 if you have the <dlfcn.h> header file. */
+#undef HAVE_DLFCN_H
+
 /* Define to 1 if you have the <fenv.h> header file. */
 #undef HAVE_FENV_H
@@ -129 +132 @@
 /* Define to 1 if the system has the type `_Bool'. */
 #undef HAVE__BOOL
+
+/* Define to the sub-directory where libtool stores uninstalled libraries. */
+#undef LT_OBJDIR
 
 /* Name of package */

src/main.cc

@@ -487 +487 @@
                         resolvep = true;
                         break;
-                        case 'R':                                                                               // dump resolv-proto instance
+                  case 'R':                                                                             // dump resolv-proto instance
                         resolvprotop = true;
                         break;