Changeset cde3891 for src

Timestamp:

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

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

a200795

Parents:

9b086ca (diff), 1d832f4 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' into cleanup-dtors

Location:

src

Files:

• CodeTools/ResolvProtoDump.cc (added)
• CodeTools/ResolvProtoDump.h (added)
• CodeTools/module.mk (modified) (1 diff)
• Common/FilterCombos.h (added)
• Common/utility.h (modified) (2 diffs)
• CompilationState.cc (modified) (1 diff)
• CompilationState.h (modified) (1 diff)
• Concurrency/Keywords.cc (modified) (2 diffs)
• Concurrency/Waitfor.cc (modified) (4 diffs)
• GenPoly/Box.cc (modified) (1 diff)
• GenPoly/Specialize.cc (modified) (3 diffs)
• Makefile.am (modified) (3 diffs)
• Makefile.in (modified) (37 diffs)
• Parser/DeclarationNode.cc (modified) (2 diffs)
• Parser/LinkageSpec.cc (modified) (2 diffs)
• Parser/LinkageSpec.h (modified) (2 diffs)
• Parser/ParseNode.h (modified) (2 diffs)
• Parser/TypeData.cc (modified) (12 diffs)
• Parser/TypeData.h (modified) (2 diffs)
• Parser/lex.ll (modified) (3 diffs)
• Parser/parser.yy (modified) (9 diffs)
• ResolvExpr/Alternative.cc (modified) (7 diffs)
• ResolvExpr/Alternative.h (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (49 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/ResolveTypeof.cc (modified) (1 diff)
• 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)
• SymTab/Demangle.cc (modified) (1 diff)
• SymTab/Mangler.cc (modified) (6 diffs)
• SymTab/Mangler.h (modified) (2 diffs)
• SymTab/Validate.cc (modified) (2 diffs)
• SynTree/ApplicationExpr.cc (modified) (4 diffs)
• SynTree/Constant.cc (modified) (3 diffs)
• SynTree/Constant.h (modified) (2 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)
• SynTree/Type.h (modified) (1 diff)
• SynTree/TypeofType.cc (modified) (2 diffs)
• Tuples/Explode.h (modified) (3 diffs)
• Tuples/TupleAssignment.cc (modified) (4 diffs)
• cfa.make (modified) (2 diffs)
• config.h.in (modified) (3 diffs)
• main.cc (modified) (10 diffs)

src/CodeTools/module.mk

@@ -16 +16 @@
 
 SRC += CodeTools/DeclStats.cc \
+        CodeTools/ResolvProtoDump.cc \
         CodeTools/TrackLoc.cc

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/CompilationState.cc

@@ -30 +30 @@
         parsep = false,
         resolvep = false,
+        resolvprotop = false,
         symtabp = false,
         treep = false,

src/CompilationState.h

@@ -31 +31 @@
         parsep,
         resolvep,
+        resolvprotop,
         symtabp,
         treep,

src/Concurrency/Keywords.cc

@@ -575 +575 @@
 
                 //in reverse order :
-                // monitor_guard_t __guard = { __monitors, #, func };
+                // monitor_dtor_guard_t __guard = { __monitors, func };
                 body->push_front(
                         new DeclStmt( new ObjectDecl(
@@ -634 +634 @@
                 assert(generic_func);
 
-                //in reverse order :
+                // in reverse order :
                 // monitor_guard_t __guard = { __monitors, #, func };
                 body->push_front(

src/Concurrency/Waitfor.cc

@@ -66 +66 @@
 void foo() {
         while( true ) {
-
-                acceptable_t acceptables[3];
-                if( a < 1 ) {
-                        acceptables[0].func = f;
-                        acceptables[0].mon = a;
-                }
-                acceptables[1].func = g;
-                acceptables[1].mon = a;
-
-                acceptables[2].func = f;
-                acceptables[2].mon = a;
-                acceptables[2].is_dtor = true;
-
-                int ret = waitfor_internal( acceptables, swagl() );
-
-                switch( ret ) {
-                        case 0:
-                        {
-                                bar();
+                {
+                        acceptable_t acceptables[3];
+                        if( a < 1 ) {
+                                acceptables[0].func = f;
+                                acceptables[0].mon = a;
                         }
-                        case 1:
-                        {
-                                baz();
+                        acceptables[1].func = g;
+                        acceptables[1].mon = a;
+
+                        acceptables[2].func = f;
+                        acceptables[2].mon = a;
+                        acceptables[2].is_dtor = true;
+
+                        int ret = waitfor_internal( acceptables, swagl() );
+
+                        switch( ret ) {
+                                case 0:
+                                {
+                                        bar();
+                                }
+                                case 1:
+                                {
+                                        baz();
+                                }
+                                case 2:
+                                        signal(a);
+                                        {
+                                                break;
+                                        }
                         }
-                        case 2:
-                                signal(a);
-                                {
-                                        break;
-                                }
                 }
         }
@@ -555 +556 @@
                                         new ConstantExpr( Constant::from_ulong( i++ ) ),
                                         {
-                                                clause.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        clause.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )
@@ -570 +573 @@
                                         new ConstantExpr( Constant::from_int( -2 ) ),
                                         {
-                                                waitfor->timeout.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        waitfor->timeout.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )
@@ -585 +590 @@
                                         new ConstantExpr( Constant::from_int( -1 ) ),
                                         {
-                                                waitfor->orelse.statement,
-                                                new BranchStmt(
-                                                        "",
-                                                        BranchStmt::Break
-                                                )
+                                                new CompoundStmt({
+                                                        waitfor->orelse.statement,
+                                                        new BranchStmt(
+                                                                "",
+                                                                BranchStmt::Break
+                                                        )
+                                                })
                                         }
                                 )

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 \
@@ -50 +51 @@
 AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
 AM_LDFLAGS  = @HOST_FLAGS@ -Xlinker -export-dynamic
+ARFLAGS     = cr
 
 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
@@ -126 +128 @@
   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
-ARFLAGS = cru
 AM_V_AR = $(am__v_AR_@AM_V@)
 am__v_AR_ = $(am__v_AR_@AM_DEFAULT_V@)
@@ -204 +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) \
@@ -222 +227 @@
         CodeGen/FixNames.$(OBJEXT) CodeGen/FixMain.$(OBJEXT) \
         CodeGen/OperatorTable.$(OBJEXT) CodeTools/DeclStats.$(OBJEXT) \
+        CodeTools/ResolvProtoDump.$(OBJEXT) \
         CodeTools/TrackLoc.$(OBJEXT) Concurrency/Keywords.$(OBJEXT) \
         Concurrency/Waitfor.$(OBJEXT) Common/SemanticError.$(OBJEXT) \
@@ -260 +266 @@
         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) \
@@ -291 +300 @@
 ___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)
@@ -312 +325 @@
 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@)
@@ -317 +334 @@
 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@)
@@ -324 +342 @@
 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@)
@@ -332 +352 @@
                    -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@)
@@ -338 +360 @@
 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@)
@@ -343 +369 @@
 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@)
@@ -393 +421 @@
 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@
@@ -417 +445 @@
 CPPFLAGS = @CPPFLAGS@
 CXX = @CXX@
+CXXCPP = @CXXCPP@
 CXXDEPMODE = @CXXDEPMODE@
 CXXFLAGS = @CXXFLAGS@
@@ -422 +451 @@
 DEFS = @DEFS@
 DEPDIR = @DEPDIR@
+DLLTOOL = @DLLTOOL@
 DRIVER_DIR = @DRIVER_DIR@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
 ECHO_C = @ECHO_C@
 ECHO_N = @ECHO_N@
@@ -428 +460 @@
 EGREP = @EGREP@
 EXEEXT = @EXEEXT@
+FGREP = @FGREP@
 GREP = @GREP@
 HOST_FLAGS = @HOST_FLAGS@
@@ -435 +468 @@
 INSTALL_SCRIPT = @INSTALL_SCRIPT@
 INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+LD = @LD@
 LDFLAGS = @LDFLAGS@
 LEX = @LEX@
@@ -443 +477 @@
 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@
@@ -456 +500 @@
 PATH_SEPARATOR = @PATH_SEPARATOR@
 RANLIB = @RANLIB@
+SED = @SED@
 SET_MAKE = @SET_MAKE@
 SHELL = @SHELL@
@@ -467 +512 @@
 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@
@@ -518 +565 @@
 # 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 \
         CodeGen/FixNames.cc CodeGen/FixMain.cc \
         CodeGen/OperatorTable.cc CodeTools/DeclStats.cc \
-        CodeTools/TrackLoc.cc Concurrency/Keywords.cc \
-        Concurrency/Waitfor.cc Common/SemanticError.cc \
-        Common/UniqueName.cc Common/DebugMalloc.cc Common/Assert.cc \
-        Common/Heap.cc Common/Eval.cc ControlStruct/LabelGenerator.cc \
+        CodeTools/ResolvProtoDump.cc CodeTools/TrackLoc.cc \
+        Concurrency/Keywords.cc Concurrency/Waitfor.cc \
+        Common/SemanticError.cc Common/UniqueName.cc \
+        Common/DebugMalloc.cc Common/Assert.cc Common/Heap.cc \
+        Common/Eval.cc ControlStruct/LabelGenerator.cc \
         ControlStruct/LabelFixer.cc ControlStruct/MLEMutator.cc \
         ControlStruct/Mutate.cc ControlStruct/ForExprMutator.cc \
@@ -548 +597 @@
         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 \
@@ -582 +632 @@
 AM_CXXFLAGS = @HOST_FLAGS@ -Wno-deprecated -Wall -Wextra -DDEBUG_ALL -I./Parser -I$(srcdir)/Parser -I$(srcdir)/include -DYY_NO_INPUT -O2 -g -std=c++14
 AM_LDFLAGS = @HOST_FLAGS@ -Xlinker -export-dynamic
+ARFLAGS = cr
 demangler_SOURCES = SymTab/demangler.cc # test driver for the demangler, also useful as a sanity check that libdemangle.a is complete
 demangler_LDADD = libdemangle.a     # yywrap
@@ -655 +706 @@
   ResolvExpr/PtrsCastable.cc \
   ResolvExpr/RenameVars.cc \
+  ResolvExpr/ResolveAssertions.cc \
   ResolvExpr/Resolver.cc \
   ResolvExpr/ResolveTypeof.cc \
+  ResolvExpr/SpecCost.cc \
   ResolvExpr/TypeEnvironment.cc \
   ResolvExpr/Unify.cc \
@@ -674 +727 @@
 
 .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 \
@@ -908 +961 @@
 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) \
@@ -963 +1020 @@
         sed 's/$(EXEEXT)$$//' | \
         while read p p1; do if test -f $$p \
+         || test -f $$p1 \
           ; then echo "$$p"; echo "$$p"; else :; fi; \
         done | \
@@ -977 +1035 @@
             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
@@ -994 +1052 @@
 
 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/FixNames.$(OBJEXT): CodeGen/$(am__dirstamp) \
         CodeGen/$(DEPDIR)/$(am__dirstamp)
@@ -1004 +1068 @@
         @: > CodeTools/$(DEPDIR)/$(am__dirstamp)
 CodeTools/DeclStats.$(OBJEXT): CodeTools/$(am__dirstamp) \
+        CodeTools/$(DEPDIR)/$(am__dirstamp)
+CodeTools/ResolvProtoDump.$(OBJEXT): CodeTools/$(am__dirstamp) \
         CodeTools/$(DEPDIR)/$(am__dirstamp)
 CodeTools/TrackLoc.$(OBJEXT): CodeTools/$(am__dirstamp) \
@@ -1107 +1173 @@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeGen/$(DEPDIR)/OperatorTable.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/DeclStats.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/ResolvProtoDump.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@CodeTools/$(DEPDIR)/TrackLoc.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@Common/$(DEPDIR)/Assert.Po@am__quote@
@@ -1159 +1226 @@
 @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@
@@ -1228 +1297 @@
 @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)
@@ -1233 +1310 @@
 .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)
@@ -1392 +1476 @@
 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
@@ -1448 +1532 @@
 mostlyclean: mostlyclean-am
 
-mostlyclean-am: mostlyclean-compile mostlyclean-generic
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+        mostlyclean-libtool
 
 pdf: pdf-am
@@ -1463 +1548 @@
 
 .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/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 20 14:56:54 2018
-// Update Count     : 1107
+// Last Modified On : Thu Nov  1 20:54:26 2018
+// Update Count     : 1108
 //
 
@@ -402 +402 @@
 }
 
-DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr ) {
-        DeclarationNode * newnode = new DeclarationNode;
-        newnode->type = new TypeData( TypeData::Typeof );
+DeclarationNode * DeclarationNode::newTypeof( ExpressionNode * expr, bool basetypeof ) {
+        DeclarationNode * newnode = new DeclarationNode;
+        newnode->type = new TypeData( basetypeof ? TypeData::Basetypeof : TypeData::Typeof );
         newnode->type->typeexpr = expr;
         return newnode;

src/Parser/LinkageSpec.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 13:22:09 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul  7 11:11:00 2017
-// Update Count     : 25
+// Last Modified On : Thr Spt 12 15:59:00 2018
+// Update Count     : 26
 //
 
@@ -23 +23 @@
 
 namespace LinkageSpec {
-
-Spec linkageCheck( CodeLocation location, const string * spec ) {
-        assert( spec );
-        unique_ptr<const string> guard( spec ); // allocated by lexer
-        if ( *spec == "\"Cforall\"" ) {
-                return Cforall;
-        } else if ( *spec == "\"C\"" ) {
-                return C;
-        } else if ( *spec == "\"BuiltinC\"" ) {
-                return BuiltinC;
-        } else {
-                SemanticError( location, "Invalid linkage specifier " + *spec );
-        } // if
-}
 
 Spec linkageUpdate( CodeLocation location, Spec old_spec, const string * cmd ) {

src/Parser/LinkageSpec.h

@@ -9 +9 @@
 // Author           : Rodolfo G. Esteves
 // Created On       : Sat May 16 13:24:28 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Jul  2 07:46:49 2018
-// Update Count     : 16
+// Last Modified By : Andrew Beach
+// Last Modified On : Thr Spt 13 15:59:00 2018
+// Update Count     : 17
 //
 
@@ -41 +41 @@
 
 
-        Spec linkageCheck( CodeLocation location, const std::string * );
-        // Returns the Spec with the given name (limited to C, Cforall & BuiltinC)
         Spec linkageUpdate( CodeLocation location, Spec old_spec, const std::string * cmd );
         /* If cmd = "C" returns a Spec that is old_spec with is_mangled = false

src/Parser/ParseNode.h

@@ -10 +10 @@
 // Created On       : Sat May 16 13:28:16 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Aug  4 09:39:40 2018
-// Update Count     : 853
+// Last Modified On : Thu Nov  1 20:54:53 2018
+// Update Count     : 854
 //
 
@@ -249 +249 @@
         static DeclarationNode * newBitfield( ExpressionNode * size );
         static DeclarationNode * newTuple( DeclarationNode * members );
-        static DeclarationNode * newTypeof( ExpressionNode * expr );
+        static DeclarationNode * newTypeof( ExpressionNode * expr, bool basetypeof = false );
         static DeclarationNode * newAttr( const std::string *, ExpressionNode * expr ); // @ attributes
         static DeclarationNode * newAttr( const std::string *, DeclarationNode * type ); // @ attributes

src/Parser/TypeData.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 15:12:51 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 20 14:39:31 2018
-// Update Count     : 622
+// Last Modified On : Fri Nov  2 07:54:26 2018
+// Update Count     : 624
 //
 
@@ -96 +96 @@
                 break;
           case Typeof:
+          case Basetypeof:
                 // typeexpr = new Typeof_t;
                 typeexpr = nullptr;
@@ -166 +167 @@
                 break;
           case Typeof:
+          case Basetypeof:
                 // delete typeexpr->expr;
                 delete typeexpr;
@@ -245 +247 @@
                 break;
           case Typeof:
+          case Basetypeof:
                 newtype->typeexpr = maybeClone( typeexpr );
                 break;
@@ -319 +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 ) {
@@ -344 +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;
@@ -367 +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
@@ -378 +381 @@
                 } // if
                 if ( enumeration.body ) {
-                        os << string( indent + 2, ' ' ) << " with body " << endl;
+                        os << string( indent + 2, ' ' ) << " with body" << endl;
                 } // if
                 break;
@@ -415 +418 @@
                 os << "tuple ";
                 if ( tuple ) {
-                        os << "with members " << endl;
+                        os << "with members" << endl;
                         tuple->printList( os, indent + 2 );
                 } // if
                 break;
+          case Basetypeof:
+                os << "base-";
+                #if defined(__GNUC__) && __GNUC__ >= 7
+                        __attribute__((fallthrough));
+                #endif
           case Typeof:
                 os << "type-of expression ";
@@ -457 +465 @@
           case Tuple:
           case Typeof:
+          case Basetypeof:
           case Builtin:
                 assertf(false, "Tried to get leaf name from kind without a name: %d", kind);
@@ -513 +522 @@
         switch ( td->kind ) {
           case TypeData::Unknown:
-                // fill in implicit int
-                return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
+                        // fill in implicit int
+                        return new BasicType( buildQualifiers( td ), BasicType::SignedInt );
           case TypeData::Basic:
-                return buildBasicType( td );
+                        return buildBasicType( td );
           case TypeData::Pointer:
-                return buildPointer( td );
+                        return buildPointer( td );
           case TypeData::Array:
-                return buildArray( td );
+                        return buildArray( td );
           case TypeData::Reference:
-                return buildReference( td );
+                        return buildReference( td );
           case TypeData::Function:
-                return buildFunction( td );
+                        return buildFunction( td );
           case TypeData::AggregateInst:
-                return buildAggInst( td );
+                        return buildAggInst( td );
           case TypeData::EnumConstant:
-                // the name gets filled in later -- by SymTab::Validate
-                return new EnumInstType( buildQualifiers( td ), "" );
+                        // the name gets filled in later -- by SymTab::Validate
+                        return new EnumInstType( buildQualifiers( td ), "" );
           case TypeData::SymbolicInst:
-                return buildSymbolicInst( td );
+                        return buildSymbolicInst( td );
           case TypeData::Tuple:
-                return buildTuple( td );
+                        return buildTuple( td );
           case TypeData::Typeof:
-                return buildTypeof( td );
+          case TypeData::Basetypeof:
+                        return buildTypeof( td );
           case TypeData::Builtin:
-                if(td->builtintype == DeclarationNode::Zero) {
-                        return new ZeroType( noQualifiers );
-                }
-                else if(td->builtintype == DeclarationNode::One) {
-                        return new OneType( noQualifiers );
-                }
-                else {
-                        return new VarArgsType( buildQualifiers( td ) );
-                }
+                        if (td->builtintype == DeclarationNode::Zero) {
+                                return new ZeroType( noQualifiers );
+                        }
+                        else if (td->builtintype == DeclarationNode::One) {
+                                return new OneType( noQualifiers );
+                        }
+                        else {
+                                return new VarArgsType( buildQualifiers( td ) );
+                        }
           case TypeData::GlobalScope:
-                return new GlobalScopeType();
+                        return new GlobalScopeType();
                 case TypeData::Qualified:
-                return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
+                        return new QualifiedType( buildQualifiers( td ), typebuild( td->qualified.parent ), typebuild( td->qualified.child ) );
           case TypeData::Symbolic:
           case TypeData::Enum:
           case TypeData::Aggregate:
-                assert( false );
+                        assert( false );
         } // switch
 
@@ -929 +939 @@
 
 TypeofType * buildTypeof( const TypeData * td ) {
-        assert( td->kind == TypeData::Typeof );
+        assert( td->kind == TypeData::Typeof || td->kind == TypeData::Basetypeof );
         assert( td->typeexpr );
         // assert( td->typeexpr->expr );
-        return new TypeofType( buildQualifiers( td ), td->typeexpr->build() );
+        return new TypeofType{
+                buildQualifiers( td ), td->typeexpr->build(), td->kind == TypeData::Basetypeof };
 } // buildTypeof
 

src/Parser/TypeData.h

@@ -10 +10 @@
 // Created On       : Sat May 16 15:18:36 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Fri Jul 20 13:56:40 2018
-// Update Count     : 195
+// Last Modified On : Thu Nov  1 20:56:46 2018
+// Update Count     : 196
 //
 
@@ -27 +27 @@
 struct TypeData {
         enum Kind { Basic, Pointer, Reference, Array, Function, Aggregate, AggregateInst, Enum, EnumConstant, Symbolic,
-                                SymbolicInst, Tuple, Typeof, Builtin, GlobalScope, Qualified, Unknown };
+                                SymbolicInst, Tuple, Typeof, Basetypeof, Builtin, GlobalScope, Qualified, Unknown };
 
         struct Aggregate_t {

src/Parser/lex.ll

@@ -10 +10 @@
  * Created On       : Sat Sep 22 08:58:10 2001
  * Last Modified By : Peter A. Buhr
- * Last Modified On : Wed Aug  8 17:23:17 2018
- * Update Count     : 685
+ * Last Modified On : Thu Nov  1 20:57:35 2018
+ * Update Count     : 687
  */
 
@@ -209 +209 @@
 __attribute__   { KEYWORD_RETURN(ATTRIBUTE); }                  // GCC
 auto                    { KEYWORD_RETURN(AUTO); }
+basetypeof              { KEYWORD_RETURN(BASETYPEOF); }                 // CFA
 _Bool                   { KEYWORD_RETURN(BOOL); }                               // C99
 break                   { KEYWORD_RETURN(BREAK); }
@@ -410 +411 @@
 ">>="                   { NAMEDOP_RETURN(RSassign); }
 
-"~="                    { NAMEDOP_RETURN(Erange); }                             // CFA
 "@="                    { NAMEDOP_RETURN(ATassign); }                   // CFA
+"~="                    { NAMEDOP_RETURN(ErangeUpEq); }                 // CFA
+"-~"                    { NAMEDOP_RETURN(ErangeDown); }                 // CFA
+"-~="                   { NAMEDOP_RETURN(ErangeDownEq); }               // CFA
 
                                 /* CFA, operator identifier */

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Aug  8 17:50:07 2018
-// Update Count     : 3998
+// Last Modified On : Thu Nov  8 18:08:23 2018
+// Update Count     : 4052
 //
 
@@ -187 +187 @@
 
 ForCtrl * forCtrl( ExpressionNode * type, string * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        ConstantExpr * constant = dynamic_cast<ConstantExpr *>(type->get_expr());
+        if ( constant && (constant->get_constant()->get_value() == "0" || constant->get_constant()->get_value() == "1") ) {
+        type = new ExpressionNode( new CastExpr( maybeMoveBuild< Expression >(type), new BasicType( Type::Qualifiers(), BasicType::SignedInt ) ) );
+        } // if
         return new ForCtrl(
-                distAttr( DeclarationNode::newTypeof( type ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
+                distAttr( DeclarationNode::newTypeof( type, true ), DeclarationNode::newName( index )->addInitializer( new InitializerNode( start ) ) ),
                 new ExpressionNode( build_binary_val( compop, new ExpressionNode( build_varref( new string( *index ) ) ), comp ) ),
-                new ExpressionNode( build_binary_val( OperKinds::PlusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
+                new ExpressionNode( build_binary_val( compop == OperKinds::LThan || compop == OperKinds::LEThan ? // choose += or -= for upto/downto
+                                                                                          OperKinds::PlusAssn : OperKinds::MinusAssn, new ExpressionNode( build_varref( new string( *index ) ) ), inc ) ) );
+} // forCtrl
+
+ForCtrl * forCtrl( ExpressionNode * type, ExpressionNode * index, ExpressionNode * start, enum OperKinds compop, ExpressionNode * comp, ExpressionNode * inc ) {
+        if ( NameExpr * identifier = dynamic_cast<NameExpr *>(index->get_expr()) ) {
+                return forCtrl( type, new string( identifier->name ), start, compop, comp, inc );
+        } else {
+                SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); return nullptr;
+        } // if
 } // forCtrl
 
@@ -214 +227 @@
 
 // Types declaration for productions
-%union
-{
+%union {
         Token tok;
         ParseNode * pn;
@@ -254 +266 @@
 %token ZERO_T ONE_T                                                                             // CFA
 %token VALIST                                                                                   // GCC
-%token TYPEOF LABEL                                                                             // GCC
+%token TYPEOF BASETYPEOF LABEL                                                  // GCC
 %token ENUM STRUCT UNION
 %token EXCEPTION                                                                                // CFA
@@ -290 +302 @@
 %token ANDassign        ERassign        ORassign                                // &=   ^=      |=
 
-%token Erange                                                                                   // ~=
+%token ErangeUpEq       ErangeDown      ErangeDownEq                    // ~=   -~      -~=
 %token ATassign                                                                                 // @=
 
@@ -629 +641 @@
                 { $$ = new ExpressionNode( build_fieldSel( $1, build_tuple( $4 ) ) ); }
         | postfix_expression ARROW no_attr_identifier
-                {
-                        $$ = new ExpressionNode( build_pfieldSel( $1, *$3 == "0" || *$3 == "1" ? build_constantInteger( *$3 ) : build_varref( $3 ) ) );
-                }
+                { $$ = new ExpressionNode( build_pfieldSel( $1, build_varref( $3 ) ) ); }
         | postfix_expression ARROW INTEGERconstant                      // CFA, tuple index
                 { $$ = new ExpressionNode( build_pfieldSel( $1, build_constantInteger( *$3 ) ) ); }
@@ -1130 +1140 @@
         | FOR '(' push for_control_expression ')' statement pop
                 { $$ = new StatementNode( build_for( $4, $6 ) ); }
+        | FOR '(' ')' statement                                                         // CFA => for ( ;; )
+                { $$ = new StatementNode( build_for( new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr ), $4 ) ); }
         ;
 
 for_control_expression:
-        comma_expression_opt                                                            // CFA
-                {
-                        if ( ! $1 ) {                                                           // => for ( ;; )
-                                $$ = new ForCtrl( (ExpressionNode * )nullptr, (ExpressionNode * )nullptr, (ExpressionNode * )nullptr );
-                        } else {
-                                $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $1->clone(),
-                                                         new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
-                        } // if
-                }
+        comma_expression                                                                        // CFA
+                { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                OperKinds::LThan, $1->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | constant_expression inclexcl constant_expression      // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
         | constant_expression inclexcl constant_expression '~' constant_expression // CFA
                 { $$ = forCtrl( $1, new string( DeclarationNode::anonymous.newName() ), $1->clone(), $2, $3, $5 ); }
-        | comma_expression_opt ';' comma_expression                     // CFA
-                {
-                        if ( ! $1 ) {
-                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
-                        } else if ( ! $3 ) {
-                                SemanticError( yylloc, "Missing loop range." ); $$ = nullptr;
-                        } else {
-                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-                                        $$ = forCtrl( $3, new string( identifier->name ), new ExpressionNode( build_constantInteger( *new string( "0" ) ) ), OperKinds::LThan, $3->clone(),
-                                                                 new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
-                                } else {
-                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
-                                } // if
-                        } // if
-                }
-        | comma_expression_opt ';' constant_expression inclexcl constant_expression // CFA
-                {
-                        if ( ! $1 ) {
-                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
-                        } else {
-                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) );
-                                } else {
-                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
-                                } // if
-                        } // if
-                }
-        | comma_expression_opt ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
-                {
-                        if ( ! $1 ) {
-                                SemanticError( yylloc, "Missing loop index." ); $$ = nullptr;
-                        } else {
-                                if ( NameExpr *identifier = dynamic_cast<NameExpr *>($1->get_expr()) ) {
-                                        $$ = forCtrl( $3, new string( identifier->name ), $3->clone(), $4, $5, $7 );
-                                } else {
-                                        SemanticError( yylloc, "Expression disallowed. Only loop-index name allowed" ); $$ = nullptr;
-                                } // if
-                        } // if
-                }
-        | comma_expression_opt ';' comma_expression_opt ';' comma_expression_opt
+        | comma_expression ';' comma_expression                         // CFA
+                { $$ = forCtrl( $3, $1, new ExpressionNode( build_constantInteger( *new string( "0" ) ) ),
+                                                OperKinds::LThan, $3->clone(), new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' constant_expression inclexcl constant_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, new ExpressionNode( build_constantInteger( *new string( "1" ) ) ) ); }
+        | comma_expression ';' constant_expression inclexcl constant_expression '~' constant_expression // CFA
+                { $$ = forCtrl( $3, $1, $3->clone(), $4, $5, $7 ); }
+        | comma_expression ';' comma_expression_opt ';' comma_expression_opt
                 { $$ = new ForCtrl( $1, $3, $5 ); }
+        | ';' comma_expression_opt ';' comma_expression_opt
+                { $$ = new ForCtrl( (ExpressionNode * )nullptr, $2, $4 ); }
         | declaration comma_expression_opt ';' comma_expression_opt // C99, declaration has ';'
                 { $$ = new ForCtrl( $1, $2, $4 ); }
@@ -1194 +1170 @@
         '~'
                 { $$ = OperKinds::LThan; }
-        | Erange
+        | ErangeUpEq
                 { $$ = OperKinds::LEThan; }
+        | ErangeDown
+                { $$ = OperKinds::GThan; }
+        | ErangeDownEq
+                { $$ = OperKinds::GEThan; }
         ;
 
@@ -1844 +1824 @@
 
 indirect_type:
-        TYPEOF '(' type ')'                                                                     // GCC: typeof(x) y;
+        TYPEOF '(' type ')'                                                                     // GCC: typeof( x ) y;
                 { $$ = $3; }
-        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof(a+b) y;
+        | TYPEOF '(' comma_expression ')'                                       // GCC: typeof( a+b ) y;
                 { $$ = DeclarationNode::newTypeof( $3 ); }
-        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type(x) y;
+        | BASETYPEOF '(' type ')'                                                       // CFA: basetypeof( x ) y;
+                { $$ = DeclarationNode::newTypeof( new ExpressionNode( new TypeExpr( maybeMoveBuildType( $3 ) ) ), true ); }
+        | BASETYPEOF '(' comma_expression ')'                           // CFA: basetypeof( a+b ) y;
+                { $$ = DeclarationNode::newTypeof( $3, true ); }
+        | ATTR_TYPEGENname '(' type ')'                                         // CFA: e.g., @type( x ) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
-        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type(a+b) y;
+        | ATTR_TYPEGENname '(' comma_expression ')'                     // CFA: e.g., @type( a+b ) y;
                 { $$ = DeclarationNode::newAttr( $1, $3 ); }
         | ZERO_T                                                                                        // CFA

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

@@ -10 +10 @@
 // Created On       : Sat May 16 23:52:08 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Feb 17 11:19:39 2018
-// Update Count     : 33
+// Last Modified On : Thu Nov  1 21:00:56 2018
+// 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 ) {
-                        convCost += computeConversionCost( assert->second.actualType, assert->second.formalType, indexer, alt.env );
+                // specialization cost of return types can't be accounted for directly, it disables 
+                // otherwise-identical calls, like this example based on auto-newline in the I/O lib:
+                //
+                //   forall(otype OS) {
+                //     void ?|?(OS&, int);  // with newline
+                //     OS&  ?|?(OS&, int);  // no newline, always chosen due to more specialization
+                //   }
+
+                // mark type variable and specialization cost of forall clause
+                convCost.incVar( function->forall.size() );
+                for ( TypeDecl* td : function->forall ) {
+                        convCost.decSpec( td->assertions.size() );
                 }
 
@@ -466 +498 @@
                                 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 +861 @@
                 }
                 // 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 +867 @@
                         printAssertionSet( result.need, std::cerr, 8 );
                 )
-                inferParameters( result.need, result.have, newAlt, result.openVars, out );
+                inferParameters( newAlt, out );
         }
 
@@ -1202 +1112 @@
 
                 // 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 +1144 @@
                         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 +1150 @@
 
         void AlternativeFinder::Finder::postvisit( LabelAddressExpr * expr ) {
-                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
+                alternatives.push_back( Alternative{ expr->clone(), env } );
         }
 
@@ -1285 +1195 @@
                 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 +1225 @@
                                 // 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, alt.cost + thisCost };
+                                inferParameters( newAlt, back_inserter( candidates ) );
                         } // if
                 } // for
@@ -1330 +1241 @@
 
         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 } );
                 }
         }
@@ -1344 +1255 @@
                 /// Gets name from untyped member expression (member must be NameExpr)
                 const std::string& get_member_name( UntypedMemberExpr *memberExpr ) {
+                        if ( dynamic_cast< ConstantExpr * >( memberExpr->get_member() ) ) {
+                                SemanticError( memberExpr, "Indexed access to struct fields unsupported: " );
+                        } // if
                         NameExpr * nameExpr = dynamic_cast< NameExpr * >( memberExpr->get_member() );
                         assert( nameExpr );
@@ -1362 +1276 @@
                         // 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
@@ -1372 +1286 @@
 
         void AlternativeFinder::Finder::postvisit( MemberExpr *memberExpr ) {
-                alternatives.push_back( Alternative( memberExpr->clone(), env, Cost::zero ) );
+                alternatives.push_back( Alternative{ memberExpr->clone(), env } );
         }
 
@@ -1385 +1299 @@
                         // 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 ";
@@ -1403 +1317 @@
                 // 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 } );
         }
 
@@ -1413 +1327 @@
                 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
@@ -1427 +1342 @@
                         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
         }
@@ -1434 +1350 @@
                 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
@@ -1448 +1365 @@
                         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
         }
@@ -1458 +1376 @@
                 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 {
@@ -1477 +1396 @@
 
         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 } );
         }
 
@@ -1501 +1420 @@
                                 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();
@@ -1540 +1461 @@
                                 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
@@ -1555 +1477 @@
                 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 } );
                         }
                 }
@@ -1581 +1510 @@
                         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
@@ -1611 +1552 @@
                 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;
@@ -1626 +1568 @@
                 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
@@ -1655 +1604 @@
 
                         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 } );
         }
 
@@ -1675 +1632 @@
                 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 } );
         }
 
@@ -1693 +1651 @@
                         // 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 } );
                 }
         }
@@ -1701 +1659 @@
                 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 } );
         }
 
@@ -1723 +1681 @@
                         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 );
@@ -1743 +1709 @@
                                         // 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/ResolveTypeof.cc

@@ -67 +67 @@
                 std::cerr << std::endl;
 #endif
-                if ( typeofType->expr ) {
+                // pass on null expression
+                if ( ! typeofType->expr ) return typeofType;
+
+                bool isBasetypeof = typeofType->is_basetypeof;
+                auto oldQuals = typeofType->get_qualifiers().val;
+
+                Type* newType;
+                if ( TypeExpr* tyExpr = dynamic_cast<TypeExpr*>(typeofType->expr) ) {
+                        // typeof wrapping type
+                        newType = tyExpr->type;
+                        tyExpr->type = nullptr;
+                        delete tyExpr;
+                } else {
+                        // typeof wrapping expression
                         Expression * newExpr = resolveInVoidContext( typeofType->expr, indexer );
                         assert( newExpr->result && ! newExpr->result->isVoid() );
-                        Type * newType = newExpr->result;
+                        newType = newExpr->result;
                         newExpr->result = nullptr;
                         delete typeofType;
                         delete newExpr;
-                        return newType;
-                } // if
-                return typeofType;
+                }
+
+                // clear qualifiers for base, combine with typeoftype quals in any case
+                if ( isBasetypeof ) {
+                        // replace basetypeof(<enum>) by int
+                        if ( dynamic_cast<EnumInstType*>(newType) ) {
+                                Type* newerType = 
+                                        new BasicType{ newType->get_qualifiers(), BasicType::SignedInt, 
+                                        newType->attributes };
+                                delete newType;
+                                newType = newerType;
+                        }
+                        newType->get_qualifiers().val 
+                                = ( newType->get_qualifiers().val & ~Type::Qualifiers::Mask ) | oldQuals;
+                } else {
+                        newType->get_qualifiers().val |= oldQuals;
+                }
+                
+                return newType;
         }
 } // 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
 #include "SynTree/Declaration.h"         // for ObjectDecl, TypeDecl, Declar...
@@ -168 +169 @@
 
         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 +192 @@
                         #endif
 
+                        // produce filtered list of alternatives
                         AltList candidates;
                         for ( Alternative & alt : finder.get_alternatives() ) {
@@ -192 +200 @@
                         }
 
-                        // 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 +247 @@
                         }
 
-                        // 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 +296 @@
                 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 +403 @@
 
         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 +443 @@
 
         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 +796 @@
                 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 +815 @@
                                         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 +838 @@
                 // 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 +873 @@
                 // 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 +918 @@
 
                 // 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/SymTab/Demangle.cc

@@ -392 +392 @@
                                 parsers.emplace_back(Encoding::enum_t, [this](Type::Qualifiers tq) { return parseEnum(tq); });
                                 parsers.emplace_back(Encoding::type, [this](Type::Qualifiers tq) { return parseType(tq); });
-                                parsers.emplace_back(Encoding::zero, [this](Type::Qualifiers tq) { return new ZeroType(tq); });
-                                parsers.emplace_back(Encoding::one, [this](Type::Qualifiers tq) { return new OneType(tq); });
+                                parsers.emplace_back(Encoding::zero, [](Type::Qualifiers tq) { return new ZeroType(tq); });
+                                parsers.emplace_back(Encoding::one, [](Type::Qualifiers tq) { return new OneType(tq); });
                         }
 

src/SymTab/Mangler.cc

@@ -15 +15 @@
 #include "Mangler.h"
 
-#include <algorithm>                // for copy, transform
-#include <cassert>                  // for assert, assertf
-#include <functional>               // for const_mem_fun_t, mem_fun
-#include <iterator>                 // for ostream_iterator, back_insert_ite...
-#include <list>                     // for _List_iterator, list, _List_const...
-#include <string>                   // for string, char_traits, operator<<
-
-#include "CodeGen/OperatorTable.h"  // for OperatorInfo, operatorLookup
+#include <algorithm>                     // for copy, transform
+#include <cassert>                       // for assert, assertf
+#include <functional>                    // for const_mem_fun_t, mem_fun
+#include <iterator>                      // for ostream_iterator, back_insert_ite...
+#include <list>                          // for _List_iterator, list, _List_const...
+#include <string>                        // for string, char_traits, operator<<
+
+#include "CodeGen/OperatorTable.h"       // for OperatorInfo, operatorLookup
 #include "Common/PassVisitor.h"
-#include "Common/SemanticError.h"   // for SemanticError
-#include "Common/utility.h"         // for toString
-#include "Parser/LinkageSpec.h"     // for Spec, isOverridable, AutoGen, Int...
-#include "SynTree/Declaration.h"    // for TypeDecl, DeclarationWithType
-#include "SynTree/Expression.h"     // for TypeExpr, Expression, operator<<
-#include "SynTree/Type.h"           // for Type, ReferenceToType, Type::Fora...
+#include "Common/SemanticError.h"        // for SemanticError
+#include "Common/utility.h"              // for toString
+#include "Parser/LinkageSpec.h"          // for Spec, isOverridable, AutoGen, Int...
+#include "ResolvExpr/TypeEnvironment.h"  // for TypeEnvironment
+#include "SynTree/Declaration.h"         // for TypeDecl, DeclarationWithType
+#include "SynTree/Expression.h"          // for TypeExpr, Expression, operator<<
+#include "SynTree/Type.h"                // for Type, ReferenceToType, Type::Fora...
 
 namespace SymTab {
@@ -37 +38 @@
                         struct Mangler : public WithShortCircuiting, public WithVisitorRef<Mangler>, public WithGuards {
                                 Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams );
+                                Mangler( const ResolvExpr::TypeEnvironment& env );
                                 Mangler( const Mangler & ) = delete;
 
@@ -65 +67 @@
                           private:
                                 std::ostringstream mangleName;  ///< Mangled name being constructed
-                                typedef std::map< std::string, std::pair< int, int > > VarMapType;
+                                typedef std::map< std::string, std::pair< std::string, int > > VarMapType;
                                 VarMapType varNums;             ///< Map of type variables to indices
                                 int nextVarNum;                 ///< Next type variable index
+                                const ResolvExpr::TypeEnvironment* env;  ///< optional environment for substitutions
                                 bool isTopLevel;                ///< Is the Mangler at the top level
                                 bool mangleOverridable;         ///< Specially mangle overridable built-in methods
@@ -75 +78 @@
                                 bool inQualifiedType = false;   ///< Add start/end delimiters around qualified type
 
+                          public:
+                                Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
+                                        int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
+                                        const VarMapType& varNums );
+
+                          private:
                                 void mangleDecl( DeclarationWithType *declaration );
                                 void mangleRef( ReferenceToType *refType, std::string prefix );
@@ -100 +109 @@
                 }
 
+                std::string mangleAssnKey( DeclarationWithType* decl, 
+                                const ResolvExpr::TypeEnvironment& env ) {
+                        PassVisitor<Mangler> mangler( env );
+                        maybeAccept( decl, mangler );
+                        return mangler.pass.get_mangleName();
+                }
+
                 namespace {
                         Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams )
-                                : nextVarNum( 0 ), isTopLevel( true ), mangleOverridable( mangleOverridable ), typeMode( typeMode ), mangleGenericParams( mangleGenericParams ) {}
+                                : nextVarNum( 0 ), env(nullptr), isTopLevel( true ), 
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
+                                mangleGenericParams( mangleGenericParams ) {}
+                        
+                        Mangler::Mangler( const ResolvExpr::TypeEnvironment& env )
+                                : nextVarNum( 0 ), env( &env ), isTopLevel( true ), mangleOverridable( false ),
+                                typeMode( false ), mangleGenericParams( true ) {}
+                        
+                        Mangler::Mangler( bool mangleOverridable, bool typeMode, bool mangleGenericParams, 
+                                int nextVarNum, const ResolvExpr::TypeEnvironment* env, 
+                                const VarMapType& varNums )
+                                : varNums( varNums ), nextVarNum( nextVarNum ), env( env ), isTopLevel( false ), 
+                                mangleOverridable( mangleOverridable ), typeMode( typeMode ), 
+                                mangleGenericParams( mangleGenericParams ) {}
 
                         void Mangler::mangleDecl( DeclarationWithType * declaration ) {
@@ -329 +358 @@
                                                         assert( false );
                                                 } // switch
-                                                varNums[ (*i)->name ] = std::pair< int, int >( nextVarNum++, (int)(*i)->get_kind() );
+                                                std::string varName;
+                                                // replace type with substitution name if environment is available and bound
+                                                if ( env ) {
+                                                        const ResolvExpr::EqvClass* varClass = env->lookup( (*i)->name );
+                                                        if ( varClass && varClass->type ) {
+                                                                PassVisitor<Mangler> sub_mangler(
+                                                                        mangleOverridable, typeMode, mangleGenericParams, nextVarNum, 
+                                                                        env, varNums );
+                                                                varClass->type->accept( sub_mangler );
+                                                                varName = std::string{"%"} + sub_mangler.pass.get_mangleName();
+                                                        }
+                                                }
+                                                // otherwise just give type numeric name
+                                                if ( varName.empty() ) {
+                                                        varName = std::to_string( nextVarNum++ );
+                                                }
+                                                varNums[ (*i)->name ] = std::make_pair( varName, (int)(*i)->get_kind() );
                                                 for ( std::list< DeclarationWithType* >::iterator assert = (*i)->assertions.begin(); assert != (*i)->assertions.end(); ++assert ) {
-                                                        PassVisitor<Mangler> sub_mangler( mangleOverridable, typeMode, mangleGenericParams );
-                                                        sub_mangler.pass.nextVarNum = nextVarNum;
-                                                        sub_mangler.pass.isTopLevel = false;
-                                                        sub_mangler.pass.varNums = varNums;
+                                                        PassVisitor<Mangler> sub_mangler( 
+                                                                mangleOverridable, typeMode, mangleGenericParams, nextVarNum, env, 
+                                                                varNums );
                                                         (*assert)->accept( sub_mangler );
-                                                        assertionNames.push_back( sub_mangler.pass.mangleName.str() );
+                                                        assertionNames.push_back( sub_mangler.pass.get_mangleName() );
                                                         acount++;
                                                 } // for

src/SymTab/Mangler.h

@@ -31 +31 @@
 // * Currently name compression is not implemented.
 
+namespace ResolvExpr {
+        class TypeEnvironment;
+}
+
 namespace SymTab {
         namespace Mangler {
@@ -40 +44 @@
                 /// Mangle ignoring generic type parameters
                 std::string mangleConcrete( Type* ty );
+                /// Mangle for assertion key
+                std::string mangleAssnKey( DeclarationWithType* decl, 
+                        const ResolvExpr::TypeEnvironment& env );
 
                 namespace Encoding {

src/SymTab/Validate.cc

@@ -398 +398 @@
                         assert( aggr ); // TODO: need to handle forward declarations
                         for ( Declaration * member : aggr->members ) {
-                                if ( StructInstType * inst = dynamic_cast< StructInstType * >( child ) ) {
-                                        if ( StructDecl * aggr = dynamic_cast< StructDecl * >( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        // TODO: is this case, and other non-TypeInstType cases, necessary?
-                                                        return new StructInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( child ) ) {
-                                        if ( UnionDecl * aggr = dynamic_cast< UnionDecl * > ( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        return new UnionInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( child ) ) {
-                                        if ( EnumDecl * aggr = dynamic_cast< EnumDecl * > ( member ) ) {
-                                                if ( aggr->name == inst->name ) {
-                                                        return new EnumInstType( qualType->get_qualifiers(), aggr );
-                                                }
-                                        }
-                                } else if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
+                                if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( child ) ) {
                                         // name on the right is a typedef
                                         if ( NamedTypeDecl * aggr = dynamic_cast< NamedTypeDecl * > ( member ) ) {
@@ -424 +405 @@
                                                         Type * ret = aggr->base->clone();
                                                         ret->get_qualifiers() = qualType->get_qualifiers();
+                                                        TypeSubstitution sub = parent->genericSubstitution();
+                                                        sub.apply(ret);
                                                         return ret;
                                                 }

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/Constant.cc

@@ -10 +10 @@
 // Created On       : Mon May 18 07:44:20 2015
 // Last Modified By : Andrew Beach
-// Last Modified On : Fri Jul 14 14:50:00 2017
-// Update Count     : 29
+// Last Modified On : Fri Spt 28 14:49:00 2018
+// Update Count     : 30
 //
 
@@ -19 +19 @@
 
 #include "Constant.h"
+#include "Expression.h" // for ConstantExpr
 #include "Type.h"    // for BasicType, Type, Type::Qualifiers, PointerType
 
@@ -48 +49 @@
 Constant Constant::from_double( double d ) {
         return Constant( new BasicType( Type::Qualifiers(), BasicType::Double ), std::to_string( d ), d );
+}
+
+Constant Constant::from_string( std::string const & str ) {
+        return Constant(
+                new ArrayType(
+                        noQualifiers,
+                        new BasicType( Type::Qualifiers( Type::Const ), BasicType::Char ),
+                        new ConstantExpr( Constant::from_int( str.size() + 1 /* \0 */ )),
+                        false, false ),
+                std::string("\"") + str + "\"", (unsigned long long int)0 );
 }
 

src/SynTree/Constant.h

@@ -9 +9 @@
 // Author           : Richard C. Bilson
 // Created On       : Mon May 18 07:44:20 2015
-// Last Modified By : Peter A. Buhr
-// Last Modified On : Sat Jul 22 09:54:46 2017
-// Update Count     : 17
+// Last Modified By : Andrew Beach
+// Last Modified On : Fri Spt 28 14:48:00 2018
+// Update Count     : 18
 //
 
@@ -51 +51 @@
         /// generates a floating point constant of the given double
         static Constant from_double( double d );
+        /// generates an array of chars constant of the given string
+        static Constant from_string( std::string const & s );
 
         /// generates a null pointer value for the given type. void * if omitted.

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/SynTree/Type.h

@@ -598 +598 @@
 class TypeofType : public Type {
   public:
-        Expression *expr;
-
-        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >()  );
+        Expression *expr;    ///< expression to take the type of
+        bool is_basetypeof;  ///< true iff is basetypeof type
+
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, const std::list< Attribute * > & attributes = std::list< Attribute * >() );
+        TypeofType( const Type::Qualifiers & tq, Expression *expr, bool is_basetypeof, 
+                const std::list< Attribute * > & attributes = std::list< Attribute * >() );
         TypeofType( const TypeofType& );
         virtual ~TypeofType();

src/SynTree/TypeofType.cc

@@ -23 +23 @@
 class Attribute;
 
-TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, const std::list< Attribute * > & attributes ) : Type( tq, attributes ), expr( expr ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof(false) {}
 
-TypeofType::TypeofType( const TypeofType &other ) : Type( other ), expr( maybeClone( other.expr ) ) {
-}
+TypeofType::TypeofType( const Type::Qualifiers &tq, Expression *expr, bool is_basetypeof, 
+        const std::list< Attribute * > & attributes ) 
+: Type( tq, attributes ), expr( expr ), is_basetypeof( is_basetypeof ) {}
+
+TypeofType::TypeofType( const TypeofType &other )
+: Type( other ), expr( maybeClone( other.expr ) ), is_basetypeof( other.is_basetypeof ) {}
 
 TypeofType::~TypeofType() {
@@ -35 +40 @@
 void TypeofType::print( std::ostream &os, Indenter indent ) const {
         Type::print( os, indent );
+        if ( is_basetypeof ) { os << "base-"; }
         os << "type-of expression ";
         if ( expr ) {

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

@@ +1 @@
+
+
 CFACOMPILE = $(CFACC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCFACOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CFACC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CFAFLAGS) $(CFAFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
 
 AM_V_CFA = $(am__v_CFA_@AM_V@)
@@ -6 +12 @@
 am__v_CFA_1 =
 
-.cfa.o: $(CFACC) $(CFACPP)
+.cfa.o:
         $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.o$$||'`;\
         $(CFACOMPILE) -MT $@ -MD -MP -MF $$depbase.Tpo -c -o $@ $< &&\
         $(am__mv) $$depbase.Tpo $$depbase.Po
+
+.cfa.lo:
+        $(AM_V_CFA)depbase=`echo $@ | sed 's|[^/]*$$|$(DEPDIR)/&|;s|\.lo$$||'`;\
+        $(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

@@ -10 +10 @@
 // Created On       : Fri May 15 23:12:02 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Wed Jun  6 15:51:47 2018
-// Update Count     : 498
+// Last Modified On : Wed Dec 26 08:11:19 2018
+// Update Count     : 499
 //
 
@@ -34 +34 @@
 #include "CodeGen/Generate.h"               // for generate
 #include "CodeTools/DeclStats.h"            // for printDeclStats
+#include "CodeTools/ResolvProtoDump.h"      // for dumpAsResolvProto
 #include "CodeTools/TrackLoc.h"             // for fillLocations
 #include "Common/CompilerError.h"           // for CompilerError
@@ -171 +172 @@
                         if ( filename == nullptr ) filename = argv[ optind ];
                         // prelude filename comes in differently
-                        if ( libcfap ) filename = "prelude.cf";
+                        if ( libcfap ) filename = "prelude.cfa";
                         optind += 1;
                 } else {                                                                                // no input file name
@@ -198 +199 @@
                         if ( ! libcfap ) {
                                 // read the prelude in, if not generating the cfa library
-                                FILE * prelude = fopen( (PreludeDirector + "/prelude.cf").c_str(), "r" );
-                                assertf( prelude, "cannot open prelude.cf\n" );
+                                FILE * prelude = fopen( (PreludeDirector + "/prelude.cfa").c_str(), "r" );
+                                assertf( prelude, "cannot open prelude.cfa\n" );
                                 parse( prelude, LinkageSpec::Intrinsic );
 
@@ -270 +271 @@
 
                 CodeTools::fillLocations( translationUnit );
+
+                if ( resolvprotop ) {
+                        CodeTools::dumpAsResolvProto( translationUnit );
+                        return 0;
+                }
 
                 PASS( "resolve", ResolvExpr::resolve( translationUnit ) );
@@ -365 +371 @@
                         }
                 } catch(const std::exception& e) {
-                        std::cerr << "Unaught Exception \"" << e.what() << "\"\n";
+                        std::cerr << "Uncaught Exception \"" << e.what() << "\"\n";
                 }
                 return 1;
@@ -376 +382 @@
 
 void parse_cmdline( int argc, char * argv[], const char *& filename ) {
-        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, Symbol, Tree, TupleExpansion, Validate, };
+        enum { Ast, Bbox, Bresolver, CtorInitFix, DeclStats, Expr, ExprAlt, Grammar, LibCFA, Linemarks, Nolinemarks, Nopreamble, Parse, PreludeDir, Prototypes, Resolver, ResolvProto, Symbol, Tree, TupleExpansion, Validate, };
 
         static struct option long_opts[] = {
@@ -395 +401 @@
                 { "no-prototypes", no_argument, 0, Prototypes },
                 { "resolver", no_argument, 0, Resolver },
+                { "resolv-proto", no_argument, 0, ResolvProto },
                 { "symbol", no_argument, 0, Symbol },
                 { "tree", no_argument, 0, Tree },
@@ -407 +414 @@
         bool Wsuppress = false, Werror = false;
         int c;
-        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
+        while ( (c = getopt_long( argc, argv, "abBcCdefgGlLmnNpqrRstTvwW:yzZD:F:", long_opts, &long_index )) != -1 ) {
                 switch ( c ) {
                   case Ast:
@@ -479 +486 @@
                   case 'r':                                                                             // print resolver steps
                         resolvep = true;
+                        break;
+                  case 'R':                                                                             // dump resolv-proto instance
+                        resolvprotop = true;
                         break;
                   case Symbol: