Changeset f5478c8

Timestamp:

Nov 24, 2017, 8:57:00 PM (5 years ago)

Author:

Thierry Delisle <tdelisle@…>

Branches:

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

Children:

2b716ec

Parents:

50abab9 (diff), 3de176d (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' of plg.uwaterloo.ca:software/cfa/cfa-cc

Location:

src

Files:

• GenPoly/Box.cc (modified) (5 diffs)
• GenPoly/InstantiateGeneric.cc (modified) (4 diffs)
• InitTweak/FixInit.cc (modified) (7 diffs)
• InitTweak/InitTweak.cc (modified) (2 diffs)
• InitTweak/InitTweak.h (modified) (1 diff)
• Makefile.in (modified) (5 diffs)
• ResolvExpr/Alternative.cc (modified) (2 diffs)
• ResolvExpr/Alternative.h (modified) (4 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (25 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (5 diffs)
• ResolvExpr/ExplodedActual.cc (added)
• ResolvExpr/ExplodedActual.h (added)
• ResolvExpr/PtrsAssignable.cc (modified) (1 diff)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.h (modified) (2 diffs)
• ResolvExpr/module.mk (modified) (1 diff)
• ResolvExpr/typeops.h (modified) (3 diffs)
• SymTab/Autogen.cc (modified) (5 diffs)
• SymTab/Autogen.h (modified) (6 diffs)
• SymTab/Indexer.cc (modified) (1 diff)
• SymTab/Indexer.h (modified) (1 diff)
• SymTab/Validate.cc (modified) (5 diffs)
• SynTree/Expression.cc (modified) (2 diffs)
• Tuples/Explode.h (modified) (5 diffs)
• Tuples/TupleAssignment.cc (modified) (1 diff)
• libcfa/concurrency/kernel (modified) (1 diff)
• libcfa/concurrency/monitor.c (modified) (1 diff)
• libcfa/stdhdr/stddef.h (modified) (2 diffs)
• libcfa/stdlib (modified) (6 diffs)
• prelude/prelude.cf (modified) (4 diffs)
• tests/.expect/alloc-ERROR.txt (added)
• tests/.expect/castError.txt (modified) (2 diffs)
• tests/.expect/completeTypeError.txt (modified) (5 diffs)
• tests/Makefile.am (modified) (1 diff)
• tests/Makefile.in (modified) (1 diff)
• tests/alloc.c (modified) (4 diffs)
• tests/completeTypeError.c (modified) (2 diffs)
• tests/dtor-early-exit.c (modified) (1 diff)
• tests/init_once.c (modified) (1 diff)
• tests/multiDimension.c (modified) (3 diffs)
• tests/polymorphism.c (modified) (2 diffs)
• tests/tupleVariadic.c (modified) (1 diff)
• tests/vector/vector_int.c (modified) (4 diffs)

src/GenPoly/Box.cc

@@ -167 +167 @@
                         Expression *postmutate( OffsetofExpr *offsetofExpr );
                         Expression *postmutate( OffsetPackExpr *offsetPackExpr );
+                        void premutate( StructDecl * );
+                        void premutate( UnionDecl * );
 
                         void beginScope();
@@ -178 +180 @@
                         /// adds type parameters to the layout call; will generate the appropriate parameters if needed
                         void addOtypeParamsToLayoutCall( UntypedExpr *layoutCall, const std::list< Type* > &otypeParams );
+                        /// change the type of generic aggregate members to char[]
+                        void mutateMembers( AggregateDecl * aggrDecl );
 
                         /// Enters a new scope for type-variables, adding the type variables from ty
@@ -1414 +1418 @@
 
                 void PolyGenericCalculator::premutate( TypedefDecl *typedefDecl ) {
+                        assert(false);
                         beginTypeScope( typedefDecl->get_base() );
                 }
@@ -1460 +1465 @@
                 }
 
+                /// converts polymorphic type T into a suitable monomorphic representation, currently: __attribute__((aligned(8)) char[size_T]
+                Type * polyToMonoType( Type * declType ) {
+                        Type * charType = new BasicType( Type::Qualifiers(), BasicType::Kind::Char);
+                        Expression * size = new NameExpr( sizeofName( mangleType(declType) ) );
+                        Attribute * aligned = new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } );
+                        return new ArrayType( Type::Qualifiers(), charType, size,
+                                true, false, std::list<Attribute *>{ aligned } );
+                }
+
+                void PolyGenericCalculator::mutateMembers( AggregateDecl * aggrDecl ) {
+                        std::set< std::string > genericParams;
+                        for ( TypeDecl * td : aggrDecl->parameters ) {
+                                genericParams.insert( td->name );
+                        }
+                        for ( Declaration * decl : aggrDecl->members ) {
+                                if ( ObjectDecl * field = dynamic_cast< ObjectDecl * >( decl ) ) {
+                                        Type * ty = replaceTypeInst( field->type, env );
+                                        if ( TypeInstType *typeInst = dynamic_cast< TypeInstType* >( ty ) ) {
+                                                // do not try to monomorphize generic parameters
+                                                if ( scopeTyVars.find( typeInst->get_name() ) != scopeTyVars.end() && ! genericParams.count( typeInst->name ) ) {
+                                                        // polymorphic aggregate members should be converted into monomorphic members.
+                                                        // Using char[size_T] here respects the expected sizing rules of an aggregate type.
+                                                        Type * newType = polyToMonoType( field->type );
+                                                        delete field->type;
+                                                        field->type = newType;
+                                                }
+                                        }
+                                }
+                        }
+                }
+
+                void PolyGenericCalculator::premutate( StructDecl * structDecl ) {
+                        mutateMembers( structDecl );
+                }
+
+                void PolyGenericCalculator::premutate( UnionDecl * unionDecl ) {
+                        mutateMembers( unionDecl );
+                }
+
                 void PolyGenericCalculator::premutate( DeclStmt *declStmt ) {
                         if ( ObjectDecl *objectDecl = dynamic_cast< ObjectDecl *>( declStmt->get_decl() ) ) {
@@ -1465 +1509 @@
                                         // change initialization of a polymorphic value object to allocate via a VLA
                                         // (alloca was previously used, but can't be safely used in loops)
-                                        Type *declType = objectDecl->get_type();
-                                        ObjectDecl *newBuf = new ObjectDecl( bufNamer.newName(), Type::StorageClasses(), LinkageSpec::C, 0,
-                                                new ArrayType( Type::Qualifiers(), new BasicType( Type::Qualifiers(), BasicType::Kind::Char), new NameExpr( sizeofName( mangleType(declType) ) ),
-                                                true, false, std::list<Attribute*>{ new Attribute( "aligned", std::list<Expression*>{ new ConstantExpr( Constant::from_int(8) ) } ) } ), 0 );
+                                        ObjectDecl *newBuf = ObjectDecl::newObject( bufNamer.newName(), polyToMonoType( objectDecl->type ), nullptr );
                                         stmtsToAddBefore.push_back( new DeclStmt( noLabels, newBuf ) );
 

src/GenPoly/InstantiateGeneric.cc

@@ -27 +27 @@
 #include "Common/utility.h"            // for deleteAll, cloneAll
 #include "GenPoly.h"                   // for isPolyType, typesPolyCompatible
+#include "ResolvExpr/typeops.h"
 #include "ScopedSet.h"                 // for ScopedSet, ScopedSet<>::iterator
 #include "ScrubTyVars.h"               // for ScrubTyVars
@@ -151 +152 @@
                 return gt;
         }
+
+        /// Add cast to dtype-static member expressions so that type information is not lost in GenericInstantiator
+        struct FixDtypeStatic final {
+                Expression * postmutate( MemberExpr * memberExpr );
+
+                template<typename AggrInst>
+                Expression * fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr );
+        };
 
         /// Mutator pass that replaces concrete instantiations of generic types with actual struct declarations, scoped appropriately
@@ -198 +207 @@
 
         void instantiateGeneric( std::list< Declaration* > &translationUnit ) {
+                PassVisitor<FixDtypeStatic> fixer;
                 PassVisitor<GenericInstantiator> instantiator;
+
+                mutateAll( translationUnit, fixer );
                 mutateAll( translationUnit, instantiator );
+        }
+
+        bool isDtypeStatic( const std::list< TypeDecl* >& baseParams ) {
+                return std::all_of( baseParams.begin(), baseParams.end(), []( TypeDecl * td ) { return ! td->isComplete(); } );
         }
 
@@ -479 +495 @@
         }
 
+        template< typename AggrInst >
+        Expression * FixDtypeStatic::fixMemberExpr( AggrInst * inst, MemberExpr * memberExpr ) {
+                // need to cast dtype-static member expressions to their actual type before that type is erased.
+                auto & baseParams = *inst->get_baseParameters();
+                if ( isDtypeStatic( baseParams ) ) {
+                        if ( ! ResolvExpr::typesCompatible( memberExpr->result, memberExpr->member->get_type(), SymTab::Indexer() ) ) {
+                                // type of member and type of expression differ, so add cast to actual type
+                                return new CastExpr( memberExpr, memberExpr->result->clone() );
+                        }
+                }
+                return memberExpr;
+        }
+
+        Expression * FixDtypeStatic::postmutate( MemberExpr * memberExpr ) {
+                Type * aggrType = memberExpr->aggregate->result;
+                if ( isGenericType( aggrType ) ) {
+                        if ( StructInstType * inst = dynamic_cast< StructInstType * >( aggrType ) ) {
+                                return fixMemberExpr( inst, memberExpr );
+                        } else if ( UnionInstType * inst = dynamic_cast< UnionInstType * >( aggrType ) ) {
+                                return fixMemberExpr( inst, memberExpr );
+                        }
+                }
+                return memberExpr;
+        }
+
 } // namespace GenPoly
 

src/InitTweak/FixInit.cc

@@ -393 +393 @@
                         if ( skipCopyConstruct( result ) ) return; // skip certain non-copyable types
 
-                        // type may involve type variables, so apply type substitution to get temporary variable's actual type.
+                        // type may involve type variables, so apply type substitution to get temporary variable's actual type,
+                        // since result type may not be substituted (e.g., if the type does not appear in the parameter list)
                         // Use applyFree so that types bound in function pointers are not substituted, e.g. in forall(dtype T) void (*)(T).
-                        result = result->clone();
                         env->applyFree( result );
                         ObjectDecl * tmp = ObjectDecl::newObject( "__tmp", result, nullptr );
@@ -570 +570 @@
 
                         if ( returnDecl ) {
-                                UntypedExpr * assign = new UntypedExpr( new NameExpr( "?=?" ) );
-                                assign->get_args().push_back( new VariableExpr( returnDecl ) );
-                                assign->get_args().push_back( callExpr );
-                                // know the result type of the assignment is the type of the LHS (minus the pointer), so
-                                // add that onto the assignment expression so that later steps have the necessary information
-                                assign->set_result( returnDecl->get_type()->clone() );
-
+                                ApplicationExpr * assign = createBitwiseAssignment( new VariableExpr( returnDecl ), callExpr );
                                 Expression * retExpr = new CommaExpr( assign, new VariableExpr( returnDecl ) );
                                 // move env from callExpr to retExpr
@@ -943 +937 @@
                 }
 
-                void addIds( SymTab::Indexer & indexer, const std::list< DeclarationWithType * > & decls ) {
-                        for ( auto d : decls ) {
-                                indexer.addId( d );
-                        }
-                }
-
-                void addTypes( SymTab::Indexer & indexer, const std::list< TypeDecl * > & tds ) {
-                        for ( auto td : tds ) {
-                                indexer.addType( td );
-                                addIds( indexer, td->assertions );
-                        }
-                }
-
                 void GenStructMemberCalls::previsit( FunctionDecl * funcDecl ) {
                         GuardValue( function );
@@ -1012 +993 @@
                                 // need to explicitly re-add function parameters to the indexer in order to resolve copy constructors
                                 auto guard = makeFuncGuard( [this]() { indexer.enterScope(); }, [this]() { indexer.leaveScope(); } );
-                                addTypes( indexer, function->type->forall );
-                                addIds( indexer, function->type->returnVals );
-                                addIds( indexer, function->type->parameters );
+                                indexer.addFunctionType( function->type );
 
                                 // need to iterate through members in reverse in order for
@@ -1029 +1008 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        Expression * arg2 = 0;
+                                        Expression * arg2 = nullptr;
                                         if ( isCopyConstructor( function ) ) {
                                                 // if copy ctor, need to pass second-param-of-this-function.field
@@ -1161 +1140 @@
                         assert( ctorExpr->result && ctorExpr->get_result()->size() == 1 );
 
-                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
-                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), ctorExpr->get_result()->clone(), nullptr );
-                        declsToAddBefore.push_back( tmp );
-
                         // xxx - this can be TupleAssignExpr now. Need to properly handle this case.
                         ApplicationExpr * callExpr = strict_dynamic_cast< ApplicationExpr * > ( ctorExpr->get_callExpr() );
@@ -1170 +1145 @@
                         ctorExpr->set_callExpr( nullptr );
                         ctorExpr->set_env( nullptr );
+
+                        // xxx - ideally we would reuse the temporary generated from the copy constructor passes from within firstArg if it exists and not generate a temporary if it's unnecessary.
+                        ObjectDecl * tmp = ObjectDecl::newObject( tempNamer.newName(), callExpr->args.front()->result->clone(), nullptr );
+                        declsToAddBefore.push_back( tmp );
                         delete ctorExpr;
 

src/InitTweak/InitTweak.cc

@@ -12 +12 @@
 #include "Parser/LinkageSpec.h"    // for Spec, isBuiltin, Intrinsic
 #include "ResolvExpr/typeops.h"    // for typesCompatibleIgnoreQualifiers
+#include "SymTab/Autogen.h"
 #include "SymTab/Indexer.h"        // for Indexer
 #include "SynTree/Attribute.h"     // for Attribute
@@ -524 +525 @@
         }
 
+        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src ) {
+                static FunctionDecl * assign = nullptr;
+                if ( ! assign ) {
+                        // temporary? Generate a fake assignment operator to represent bitwise assignments.
+                        // This operator could easily exist as a real function, but it's tricky because nothing should resolve to this function.
+                        TypeDecl * td = new TypeDecl( "T", noStorageClasses, nullptr, TypeDecl::Dtype, true );
+                        assign = new FunctionDecl( "?=?", noStorageClasses, LinkageSpec::Intrinsic, SymTab::genAssignType( new TypeInstType( noQualifiers, td->name, td ) ), nullptr );
+                }
+                if ( dynamic_cast< ReferenceType * >( dst->result ) ) {
+                        dst = new AddressExpr( dst );
+                } else {
+                        dst = new CastExpr( dst, new ReferenceType( noQualifiers, dst->result->clone() ) );
+                }
+                if ( dynamic_cast< ReferenceType * >( src->result ) ) {
+                        src = new CastExpr( src, new ReferenceType( noQualifiers, src->result->stripReferences()->clone() ) );
+                }
+                return new ApplicationExpr( VariableExpr::functionPointer( assign ), { dst, src } );
+        }
+
         class ConstExprChecker : public Visitor {
         public:

src/InitTweak/InitTweak.h

@@ -35 +35 @@
         /// returns the first parameter of a constructor/destructor/assignment function
         ObjectDecl * getParamThis( FunctionType * ftype );
+
+        /// generate a bitwise assignment operation.
+        ApplicationExpr * createBitwiseAssignment( Expression * dst, Expression * src );
 
         /// transform Initializer into an argument list that can be passed to a call expression

src/Makefile.in

@@ -210 +210 @@
         ResolvExpr/driver_cfa_cpp-TypeEnvironment.$(OBJEXT) \
         ResolvExpr/driver_cfa_cpp-CurrentObject.$(OBJEXT) \
+        ResolvExpr/driver_cfa_cpp-ExplodedActual.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Indexer.$(OBJEXT) \
         SymTab/driver_cfa_cpp-Mangler.$(OBJEXT) \
@@ -511 +512 @@
         ResolvExpr/FindOpenVars.cc ResolvExpr/PolyCost.cc \
         ResolvExpr/Occurs.cc ResolvExpr/TypeEnvironment.cc \
-        ResolvExpr/CurrentObject.cc SymTab/Indexer.cc \
-        SymTab/Mangler.cc SymTab/Validate.cc SymTab/FixFunction.cc \
-        SymTab/ImplementationType.cc SymTab/TypeEquality.cc \
-        SymTab/Autogen.cc SynTree/Type.cc SynTree/VoidType.cc \
-        SynTree/BasicType.cc SynTree/PointerType.cc \
-        SynTree/ArrayType.cc SynTree/ReferenceType.cc \
-        SynTree/FunctionType.cc SynTree/ReferenceToType.cc \
-        SynTree/TupleType.cc SynTree/TypeofType.cc SynTree/AttrType.cc \
+        ResolvExpr/CurrentObject.cc ResolvExpr/ExplodedActual.cc \
+        SymTab/Indexer.cc SymTab/Mangler.cc SymTab/Validate.cc \
+        SymTab/FixFunction.cc SymTab/ImplementationType.cc \
+        SymTab/TypeEquality.cc SymTab/Autogen.cc SynTree/Type.cc \
+        SynTree/VoidType.cc SynTree/BasicType.cc \
+        SynTree/PointerType.cc SynTree/ArrayType.cc \
+        SynTree/ReferenceType.cc SynTree/FunctionType.cc \
+        SynTree/ReferenceToType.cc SynTree/TupleType.cc \
+        SynTree/TypeofType.cc SynTree/AttrType.cc \
         SynTree/VarArgsType.cc SynTree/ZeroOneType.cc \
         SynTree/Constant.cc SynTree/Expression.cc SynTree/TupleExpr.cc \
@@ -825 +827 @@
         ResolvExpr/$(am__dirstamp) \
         ResolvExpr/$(DEPDIR)/$(am__dirstamp)
+ResolvExpr/driver_cfa_cpp-ExplodedActual.$(OBJEXT):  \
+        ResolvExpr/$(am__dirstamp) \
+        ResolvExpr/$(DEPDIR)/$(am__dirstamp)
 SymTab/$(am__dirstamp):
         @$(MKDIR_P) SymTab
@@ -1022 +1027 @@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ConversionCost.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-CurrentObject.Po@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-FindOpenVars.Po@am__quote@
 @AMDEP_TRUE@@am__include@ @am__quote@ResolvExpr/$(DEPDIR)/driver_cfa_cpp-Occurs.Po@am__quote@
@@ -1964 +1970 @@
 @am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-CurrentObject.obj `if test -f 'ResolvExpr/CurrentObject.cc'; then $(CYGPATH_W) 'ResolvExpr/CurrentObject.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/CurrentObject.cc'; fi`
 
+ResolvExpr/driver_cfa_cpp-ExplodedActual.o: ResolvExpr/ExplodedActual.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-ExplodedActual.o -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.o `test -f 'ResolvExpr/ExplodedActual.cc' || echo '$(srcdir)/'`ResolvExpr/ExplodedActual.cc
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/ExplodedActual.cc' object='ResolvExpr/driver_cfa_cpp-ExplodedActual.o' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.o `test -f 'ResolvExpr/ExplodedActual.cc' || echo '$(srcdir)/'`ResolvExpr/ExplodedActual.cc
+
+ResolvExpr/driver_cfa_cpp-ExplodedActual.obj: ResolvExpr/ExplodedActual.cc
+@am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT ResolvExpr/driver_cfa_cpp-ExplodedActual.obj -MD -MP -MF ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.obj `if test -f 'ResolvExpr/ExplodedActual.cc'; then $(CYGPATH_W) 'ResolvExpr/ExplodedActual.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/ExplodedActual.cc'; fi`
+@am__fastdepCXX_TRUE@   $(AM_V_at)$(am__mv) ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Tpo ResolvExpr/$(DEPDIR)/driver_cfa_cpp-ExplodedActual.Po
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      $(AM_V_CXX)source='ResolvExpr/ExplodedActual.cc' object='ResolvExpr/driver_cfa_cpp-ExplodedActual.obj' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCXX_FALSE@      DEPDIR=$(DEPDIR) $(CXXDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCXX_FALSE@  $(AM_V_CXX@am__nodep@)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -c -o ResolvExpr/driver_cfa_cpp-ExplodedActual.obj `if test -f 'ResolvExpr/ExplodedActual.cc'; then $(CYGPATH_W) 'ResolvExpr/ExplodedActual.cc'; else $(CYGPATH_W) '$(srcdir)/ResolvExpr/ExplodedActual.cc'; fi`
+
 SymTab/driver_cfa_cpp-Indexer.o: SymTab/Indexer.cc
 @am__fastdepCXX_TRUE@   $(AM_V_CXX)$(CXX) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(driver_cfa_cpp_CXXFLAGS) $(CXXFLAGS) -MT SymTab/driver_cfa_cpp-Indexer.o -MD -MP -MF SymTab/$(DEPDIR)/driver_cfa_cpp-Indexer.Tpo -c -o SymTab/driver_cfa_cpp-Indexer.o `test -f 'SymTab/Indexer.cc' || echo '$(srcdir)/'`SymTab/Indexer.cc

src/ResolvExpr/Alternative.cc

@@ -18 +18 @@
 #include <ostream>                       // for operator<<, ostream, basic_o...
 #include <string>                        // for operator<<, char_traits, string
+#include <utility>                       // for move
 
 #include "Common/utility.h"              // for maybeClone
@@ -81 +82 @@
                 os << std::endl;
         }
+
+        void splice( AltList& dst, AltList& src ) {
+                dst.reserve( dst.size() + src.size() );
+                for ( Alternative& alt : src ) {
+                        dst.push_back( std::move(alt) );
+                }
+                src.clear();
+        }
+
+        void spliceBegin( AltList& dst, AltList& src ) {
+                splice( src, dst );
+                dst.swap( src );
+        }
+
 } // namespace ResolvExpr
 

src/ResolvExpr/Alternative.h

@@ -17 +17 @@
 
 #include <iosfwd>             // for ostream
-#include <list>               // for list
+#include <vector>             // for vector
 
 #include "Cost.h"             // for Cost
@@ -25 +25 @@
 
 namespace ResolvExpr {
-        struct Alternative;
-
-        typedef std::list< Alternative > AltList;
-
         struct Alternative {
                 Alternative();
@@ -41 +37 @@
                 void print( std::ostream &os, Indenter indent = {} ) const;
 
+                /// Returns the stored expression, but released from management of this Alternative
+                Expression* release_expr() {
+                        Expression* tmp = expr;
+                        expr = nullptr;
+                        return tmp;
+                }
+
                 Cost cost;
                 Cost cvtCost;
@@ -46 +49 @@
                 TypeEnvironment env;
         };
+
+        typedef std::vector< Alternative > AltList;
+
+        /// Moves all elements from src to the end of dst
+        void splice( AltList& dst, AltList& src );
+
+        /// Moves all elements from src to the beginning of dst
+        void spliceBegin( AltList& dst, AltList& src );
 } // namespace ResolvExpr
 

src/ResolvExpr/AlternativeFinder.cc

@@ -16 +16 @@
 #include <algorithm>               // for copy
 #include <cassert>                 // for strict_dynamic_cast, assert, assertf
+#include <cstddef>                 // for size_t
 #include <iostream>                // for operator<<, cerr, ostream, endl
 #include <iterator>                // for back_insert_iterator, back_inserter
 #include <list>                    // for _List_iterator, list, _List_const_...
 #include <map>                     // for _Rb_tree_iterator, map, _Rb_tree_c...
-#include <memory>                  // for allocator_traits<>::value_type
+#include <memory>                  // for allocator_traits<>::value_type, unique_ptr
 #include <utility>                 // for pair
 #include <vector>                  // for vector
@@ -29 +30 @@
 #include "Common/utility.h"        // for deleteAll, printAll, CodeLocation
 #include "Cost.h"                  // for Cost, Cost::zero, operator<<, Cost...
+#include "ExplodedActual.h"        // for ExplodedActual
 #include "InitTweak/InitTweak.h"   // for getFunctionName
 #include "RenameVars.h"            // for RenameVars, global_renamer
@@ -50 +52 @@
 #define PRINT( text ) if ( resolvep ) { text }
 //#define DEBUG_COST
+
+using std::move;
+
+/// copies any copyable type
+template<typename T>
+T copy(const T& x) { return x; }
 
 namespace ResolvExpr {
@@ -179 +187 @@
                 expr->accept( *this );
                 if ( failFast && alternatives.empty() ) {
+                        PRINT(
+                                std::cerr << "No reasonable alternatives for expression " << expr << std::endl;
+                        )
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
                 }
@@ -187 +198 @@
                                 printAlts( alternatives, std::cerr );
                         )
-                        AltList::iterator oldBegin = alternatives.begin();
-                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
-                        if ( failFast && alternatives.begin() == oldBegin ) {
+                        AltList pruned;
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), back_inserter( pruned ) );
+                        if ( failFast && pruned.empty() ) {
                                 std::ostringstream stream;
                                 AltList winners;
@@ -199 +210 @@
                                 throw SemanticError( stream.str() );
                         }
-                        alternatives.erase( oldBegin, alternatives.end() );
+                        alternatives = move(pruned);
                         PRINT(
                                 std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
@@ -571 +582 @@
         /// State to iteratively build a match of parameter expressions to arguments
         struct ArgPack {
-                AltList actuals;                 ///< Arguments included in this pack
-                TypeEnvironment env;             ///< Environment for this pack
-                AssertionSet need;               ///< Assertions outstanding for this pack
-                AssertionSet have;               ///< Assertions found for this pack
-                OpenVarSet openVars;             ///< Open variables for this pack
-                unsigned nextArg;                ///< Index of next argument in arguments list
-                std::vector<Alternative> expls;  ///< Exploded actuals left over from last match
-                unsigned nextExpl;               ///< Index of next exploded alternative to use
-                std::vector<unsigned> tupleEls;  /// Number of elements in current tuple element(s)
+                std::size_t parent;                ///< Index of parent pack
+                std::unique_ptr<Expression> expr;  ///< The argument stored here
+                Cost cost;                         ///< The cost of this argument
+                TypeEnvironment env;               ///< Environment for this pack
+                AssertionSet need;                 ///< Assertions outstanding for this pack
+                AssertionSet have;                 ///< Assertions found for this pack
+                OpenVarSet openVars;               ///< Open variables for this pack
+                unsigned nextArg;                  ///< Index of next argument in arguments list
+                unsigned tupleStart;               ///< Number of tuples that start at this index
+                unsigned nextExpl;                 ///< Index of next exploded element
+                unsigned explAlt;                  ///< Index of alternative for nextExpl > 0
+
+                ArgPack()
+                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
+
+                          tupleStart(0), nextExpl(0), explAlt(0) {}
 
                 ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
                                 const OpenVarSet& openVars)
-                        : actuals(), env(env), need(need), have(have), openVars(openVars), nextArg(0),
-                          expls(), nextExpl(0), tupleEls() {}
-
-                /// Starts a new tuple expression
-                void beginTuple() {
-                        if ( ! tupleEls.empty() ) ++tupleEls.back();
-                        tupleEls.push_back(0);
+                        : parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have),
+                          openVars(openVars), nextArg(0), tupleStart(0), nextExpl(0), explAlt(0) {}
+
+                ArgPack(std::size_t parent, Expression* expr, TypeEnvironment&& env, AssertionSet&& need,
+                                AssertionSet&& have, OpenVarSet&& openVars, unsigned nextArg,
+                                unsigned tupleStart = 0, Cost cost = Cost::zero, unsigned nextExpl = 0,
+                                unsigned explAlt = 0 )
+                        : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
+                          have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
+                          nextExpl(nextExpl), explAlt(explAlt) {}
+
+                ArgPack(const ArgPack& o, TypeEnvironment&& env, AssertionSet&& need, AssertionSet&& have,
+                                OpenVarSet&& openVars, unsigned nextArg, Cost added )
+                        : parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), cost(o.cost + added),
+                          env(move(env)), need(move(need)), have(move(have)), openVars(move(openVars)),
+                          nextArg(nextArg), tupleStart(o.tupleStart), nextExpl(0), explAlt(0) {}
+
+                /// true iff this pack is in the middle of an exploded argument
+                bool hasExpl() const { return nextExpl > 0; }
+
+                /// Gets the list of exploded alternatives for this pack
+                const ExplodedActual& getExpl( const ExplodedArgs& args ) const {
+                        return args[nextArg-1][explAlt];
                 }
 
                 /// Ends a tuple expression, consolidating the appropriate actuals
-                void endTuple() {
-                        // set up new Tuple alternative
+                void endTuple( const std::vector<ArgPack>& packs ) {
+                        // add all expressions in tuple to list, summing cost
                         std::list<Expression*> exprs;
-                        Cost cost = Cost::zero;
-
-                        // transfer elements into alternative
-                        for (unsigned i = 0; i < tupleEls.back(); ++i) {
-                                exprs.push_front( actuals.back().expr );
-                                actuals.back().expr = nullptr;
-                                cost += actuals.back().cost;
-                                actuals.pop_back();
-                        }
-                        tupleEls.pop_back();
-
-                        // build new alternative
-                        actuals.emplace_back( new TupleExpr( exprs ), this->env, cost );
-                }
-
-                /// Clones and adds an actual, returns this
-                ArgPack& withArg( Expression* expr, Cost cost = Cost::zero ) {
-                        actuals.emplace_back( expr->clone(), this->env, cost );
-                        if ( ! tupleEls.empty() ) ++tupleEls.back();
-                        return *this;
+                        const ArgPack* pack = this;
+                        if ( expr ) { exprs.push_front( expr.release() ); }
+                        while ( pack->tupleStart == 0 ) {
+                                pack = &packs[pack->parent];
+                                exprs.push_front( pack->expr->clone() );
+                                cost += pack->cost;
+                        }
+                        // reset pack to appropriate tuple
+                        expr.reset( new TupleExpr( exprs ) );
+                        tupleStart = pack->tupleStart - 1;
+                        parent = pack->parent;
                 }
         };
@@ -621 +646 @@
         /// Instantiates an argument to match a formal, returns false if no results left
         bool instantiateArgument( Type* formalType, Initializer* initializer,
-                        const std::vector< AlternativeFinder >& args,
-                        std::vector<ArgPack>& results, std::vector<ArgPack>& nextResults,
-                        const SymTab::Indexer& indexer ) {
+                        const ExplodedArgs& args, std::vector<ArgPack>& results, std::size_t& genStart,
+                        const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
                 if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr
-                        for ( ArgPack& result : results ) { result.beginTuple(); }
+                        ++nTuples;
                         for ( Type* type : *tupleType ) {
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
-                                if ( ! instantiateArgument( type, nullptr, args, results, nextResults, indexer ) )
+                                if ( ! instantiateArgument(
+                                                type, nullptr, args, results, genStart, indexer, nTuples ) )
                                         return false;
-                        }
-                        for ( ArgPack& result : results ) { result.endTuple(); }
+                                nTuples = 0;
+                        }
+                        // re-consititute tuples for final generation
+                        for ( auto i = genStart; i < results.size(); ++i ) {
+                                results[i].endTuple( results );
+                        }
                         return true;
                 } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
                         // formalType is a ttype, consumes all remaining arguments
                         // xxx - mixing default arguments with variadic??
-                        std::vector<ArgPack> finalResults{};  /// list of completed tuples
-                        // start tuples
-                        for ( ArgPack& result : results ) {
-                                result.beginTuple();
-
-                                // use rest of exploded tuple if present
-                                while ( result.nextExpl < result.expls.size() ) {
-                                        const Alternative& actual = result.expls[result.nextExpl];
-                                        result.env.addActual( actual.env, result.openVars );
-                                        result.withArg( actual.expr );
-                                        ++result.nextExpl;
-                                }
-                        }
+
+                        // completed tuples; will be spliced to end of results to finish
+                        std::vector<ArgPack> finalResults{};
+
                         // iterate until all results completed
-                        while ( ! results.empty() ) {
+                        std::size_t genEnd;
+                        ++nTuples;
+                        do {
+                                genEnd = results.size();
+
                                 // add another argument to results
-                                for ( ArgPack& result : results ) {
-                                        // finish result when out of arguments
-                                        if ( result.nextArg >= args.size() ) {
-                                                Type* argType = result.actuals.back().expr->get_result();
-                                                if ( result.tupleEls.back() == 1 && Tuples::isTtype( argType ) ) {
-                                                        // the case where a ttype value is passed directly is special, e.g. for
-                                                        // argument forwarding purposes
-                                                        // xxx - what if passing multiple arguments, last of which is ttype?
-                                                        // xxx - what would happen if unify was changed so that unifying tuple
-                                                        // types flattened both before unifying lists? then pass in TupleType
-                                                        // (ttype) below.
-                                                        result.tupleEls.pop_back();
-                                                } else {
-                                                        // collapse leftover arguments into tuple
-                                                        result.endTuple();
-                                                        argType = result.actuals.back().expr->get_result();
+                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                                        auto nextArg = results[i].nextArg;
+
+                                        // use next element of exploded tuple if present
+                                        if ( results[i].hasExpl() ) {
+                                                const ExplodedActual& expl = results[i].getExpl( args );
+
+                                                unsigned nextExpl = results[i].nextExpl + 1;
+                                                if ( nextExpl == expl.exprs.size() ) {
+                                                        nextExpl = 0;
                                                 }
-                                                // check unification for ttype before adding to final
-                                                if ( unify( ttype, argType, result.env, result.need, result.have,
-                                                                result.openVars, indexer ) ) {
-                                                        finalResults.push_back( std::move(result) );
-                                                }
+
+                                                results.emplace_back(
+                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+                                                        copy(results[i].need), copy(results[i].have),
+                                                        copy(results[i].openVars), nextArg, nTuples, Cost::zero, nextExpl,
+                                                        results[i].explAlt );
+
                                                 continue;
                                         }
 
+                                        // finish result when out of arguments
+                                        if ( nextArg >= args.size() ) {
+                                                ArgPack newResult{
+                                                        results[i].env, results[i].need, results[i].have,
+                                                        results[i].openVars };
+                                                newResult.nextArg = nextArg;
+                                                Type* argType;
+
+                                                if ( nTuples > 0 ) {
+                                                        // first iteration, push empty tuple expression
+                                                        newResult.parent = i;
+                                                        std::list<Expression*> emptyList;
+                                                        newResult.expr.reset( new TupleExpr( emptyList ) );
+                                                        argType = newResult.expr->get_result();
+                                                } else {
+                                                        // clone result to collect tuple
+                                                        newResult.parent = results[i].parent;
+                                                        newResult.cost = results[i].cost;
+                                                        newResult.tupleStart = results[i].tupleStart;
+                                                        newResult.expr.reset( results[i].expr->clone() );
+                                                        argType = newResult.expr->get_result();
+
+                                                        if ( results[i].tupleStart > 0 && Tuples::isTtype( argType ) ) {
+                                                                // the case where a ttype value is passed directly is special,
+                                                                // e.g. for argument forwarding purposes
+                                                                // xxx - what if passing multiple arguments, last of which is
+                                                                //       ttype?
+                                                                // xxx - what would happen if unify was changed so that unifying
+                                                                //       tuple
+                                                                // types flattened both before unifying lists? then pass in
+                                                                // TupleType (ttype) below.
+                                                                --newResult.tupleStart;
+                                                        } else {
+                                                                // collapse leftover arguments into tuple
+                                                                newResult.endTuple( results );
+                                                                argType = newResult.expr->get_result();
+                                                        }
+                                                }
+
+                                                // check unification for ttype before adding to final
+                                                if ( unify( ttype, argType, newResult.env, newResult.need, newResult.have,
+                                                                newResult.openVars, indexer ) ) {
+                                                        finalResults.push_back( move(newResult) );
+                                                }
+
+                                                continue;
+                                        }
+
                                         // add each possible next argument
-                                        for ( const Alternative& actual : args[result.nextArg] ) {
-                                                ArgPack aResult = result;  // copy to clone everything
-                                                // add details of actual to result
-                                                aResult.env.addActual( actual.env, aResult.openVars );
-                                                Cost cost = actual.cost;
-
-                                                // explode argument
-                                                std::vector<Alternative> exploded;
-                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
-
-                                                // add exploded argument to tuple
-                                                for ( Alternative& aActual : exploded ) {
-                                                        aResult.withArg( aActual.expr, cost );
-                                                        cost = Cost::zero;
+                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                                const ExplodedActual& expl = args[nextArg][j];
+
+                                                // fresh copies of parent parameters for this iteration
+                                                TypeEnvironment env = results[i].env;
+                                                OpenVarSet openVars = results[i].openVars;
+
+                                                env.addActual( expl.env, openVars );
+
+                                                // skip empty tuple arguments by (near-)cloning parent into next gen
+                                                if ( expl.exprs.empty() ) {
+                                                        results.emplace_back(
+                                                                results[i], move(env), copy(results[i].need),
+                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
+
+                                                        continue;
                                                 }
-                                                ++aResult.nextArg;
-                                                nextResults.push_back( std::move(aResult) );
+
+                                                // add new result
+                                                results.emplace_back(
+                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
+                                                        copy(results[i].have), move(openVars), nextArg + 1,
+                                                        nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                         }
                                 }
 
                                 // reset for next round
-                                results.swap( nextResults );
-                                nextResults.clear();
-                        }
-                        results.swap( finalResults );
-                        return ! results.empty();
+                                genStart = genEnd;
+                                nTuples = 0;
+                        } while ( genEnd != results.size() );
+
+                        // splice final results onto results
+                        for ( std::size_t i = 0; i < finalResults.size(); ++i ) {
+                                results.push_back( move(finalResults[i]) );
+                        }
+                        return ! finalResults.empty();
                 }
 
                 // iterate each current subresult
-                for ( unsigned iResult = 0; iResult < results.size(); ++iResult ) {
-                        ArgPack& result = results[iResult];
-
-                        if ( result.nextExpl < result.expls.size() ) {
-                                // use remainder of exploded tuple if present
-                                const Alternative& actual = result.expls[result.nextExpl];
-                                result.env.addActual( actual.env, result.openVars );
-                                Type* actualType = actual.expr->get_result();
+                std::size_t genEnd = results.size();
+                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                        auto nextArg = results[i].nextArg;
+
+                        // use remainder of exploded tuple if present
+                        if ( results[i].hasExpl() ) {
+                                const ExplodedActual& expl = results[i].getExpl( args );
+                                Expression* expr = expl.exprs[results[i].nextExpl].get();
+
+                                TypeEnvironment env = results[i].env;
+                                AssertionSet need = results[i].need, have = results[i].have;
+                                OpenVarSet openVars = results[i].openVars;
+
+                                Type* actualType = expr->get_result();
 
                                 PRINT(
@@ -725 +809 @@
                                 )
 
-                                if ( unify( formalType, actualType, result.env, result.need, result.have,
-                                                result.openVars, indexer ) ) {
-                                        ++result.nextExpl;
-                                        nextResults.push_back( std::move(result.withArg( actual.expr )) );
+                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
+                                        unsigned nextExpl = results[i].nextExpl + 1;
+                                        if ( nextExpl == expl.exprs.size() ) {
+                                                nextExpl = 0;
+                                        }
+
+                                        results.emplace_back(
+                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg,
+                                                nTuples, Cost::zero, nextExpl, results[i].explAlt );
                                 }
 
                                 continue;
-                        } else if ( result.nextArg >= args.size() ) {
-                                // use default initializers if out of arguments
+                        }
+
+                        // use default initializers if out of arguments
+                        if ( nextArg >= args.size() ) {
                                 if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
                                         if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
-                                                if ( unify( formalType, cnst->get_type(), result.env, result.need,
-                                                                result.have, result.openVars, indexer ) ) {
-                                                        nextResults.push_back( std::move(result.withArg( cnstExpr )) );
+                                                TypeEnvironment env = results[i].env;
+                                                AssertionSet need = results[i].need, have = results[i].have;
+                                                OpenVarSet openVars = results[i].openVars;
+
+                                                if ( unify( formalType, cnst->get_type(), env, need, have, openVars,
+                                                                indexer ) ) {
+                                                        results.emplace_back(
+                                                                i, cnstExpr, move(env), move(need), move(have),
+                                                                move(openVars), nextArg, nTuples );
                                                 }
                                         }
                                 }
+
                                 continue;
                         }
 
                         // Check each possible next argument
-                        for ( const Alternative& actual : args[result.nextArg] ) {
-                                ArgPack aResult = result;  // copy to clone everything
-                                // add details of actual to result
-                                aResult.env.addActual( actual.env, aResult.openVars );
-
-                                // explode argument
-                                std::vector<Alternative> exploded;
-                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
-                                if ( exploded.empty() ) {
-                                        // skip empty tuple arguments
-                                        ++aResult.nextArg;
-                                        results.push_back( std::move(aResult) );
+                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                const ExplodedActual& expl = args[nextArg][j];
+
+                                // fresh copies of parent parameters for this iteration
+                                TypeEnvironment env = results[i].env;
+                                AssertionSet need = results[i].need, have = results[i].have;
+                                OpenVarSet openVars = results[i].openVars;
+
+                                env.addActual( expl.env, openVars );
+
+                                // skip empty tuple arguments by (near-)cloning parent into next gen
+                                if ( expl.exprs.empty() ) {
+                                        results.emplace_back(
+                                                results[i], move(env), move(need), move(have), move(openVars),
+                                                nextArg + 1, expl.cost );
+
                                         continue;
                                 }
 
                                 // consider only first exploded actual
-                                const Alternative& aActual = exploded.front();
-                                Type* actualType = aActual.expr->get_result()->clone();
+                                Expression* expr = expl.exprs.front().get();
+                                Type* actualType = expr->get_result()->clone();
 
                                 PRINT(
@@ -774 +876 @@
 
                                 // attempt to unify types
-                                if ( unify( formalType, actualType, aResult.env, aResult.need, aResult.have, aResult.openVars, indexer ) ) {
-                                        // add argument
-                                        aResult.withArg( aActual.expr, actual.cost );
-                                        ++aResult.nextArg;
-                                        if ( exploded.size() > 1 ) {
-                                                // other parts of tuple left over
-                                                aResult.expls = std::move( exploded );
-                                                aResult.nextExpl = 1;
-                                        }
-                                        nextResults.push_back( std::move(aResult) );
+                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
+                                        // add new result
+                                        results.emplace_back(
+                                                i, expr, move(env), move(need), move(have), move(openVars), nextArg + 1,
+                                                nTuples, expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                 }
                         }
@@ -789 +886 @@
 
                 // reset for next parameter
-                results.swap( nextResults );
-                nextResults.clear();
-
-                return ! results.empty();
+                genStart = genEnd;
+
+                return genEnd != results.size();
+        }
+
+        template<typename OutputIterator>
+        void AlternativeFinder::validateFunctionAlternative( const Alternative &func, ArgPack& result,
+                        const std::vector<ArgPack>& results, OutputIterator out ) {
+                ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
+                // sum cost and accumulate actuals
+                std::list<Expression*>& args = appExpr->get_args();
+                Cost cost = Cost::zero;
+                const ArgPack* pack = &result;
+                while ( pack->expr ) {
+                        args.push_front( pack->expr->clone() );
+                        cost += pack->cost;
+                        pack = &results[pack->parent];
+                }
+                // build and validate new alternative
+                Alternative newAlt( appExpr, result.env, cost );
+                PRINT(
+                        std::cerr << "instantiate function success: " << appExpr << std::endl;
+                        std::cerr << "need assertions:" << std::endl;
+                        printAssertionSet( result.need, std::cerr, 8 );
+                )
+                inferParameters( result.need, result.have, newAlt, result.openVars, out );
         }
 
         template<typename OutputIterator>
         void AlternativeFinder::makeFunctionAlternatives( const Alternative &func,
-                        FunctionType *funcType, const std::vector< AlternativeFinder > &args,
-                        OutputIterator out ) {
+                        FunctionType *funcType, const ExplodedArgs &args, OutputIterator out ) {
                 OpenVarSet funcOpenVars;
                 AssertionSet funcNeed, funcHave;
@@ -818 +936 @@
 
                 // iteratively build matches, one parameter at a time
-                std::vector<ArgPack> results{ ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } };
-                std::vector<ArgPack> nextResults{};
+                std::vector<ArgPack> results;
+                results.push_back( ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } );
+                std::size_t genStart = 0;
+
                 for ( DeclarationWithType* formal : funcType->get_parameters() ) {
                         ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
                         if ( ! instantiateArgument(
-                                        obj->get_type(), obj->get_init(), args, results, nextResults, indexer ) )
+                                        obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
                                 return;
                 }
 
-                // filter out results that don't use all the arguments, and aren't variadic
-                std::vector<ArgPack> finalResults{};
                 if ( funcType->get_isVarArgs() ) {
-                        for ( ArgPack& result : results ) {
-                                // use rest of exploded tuple if present
-                                while ( result.nextExpl < result.expls.size() ) {
-                                        const Alternative& actual = result.expls[result.nextExpl];
-                                        result.env.addActual( actual.env, result.openVars );
-                                        result.withArg( actual.expr );
-                                        ++result.nextExpl;
-                                }
-                        }
-
-                        while ( ! results.empty() ) {
-                                // build combinations for all remaining arguments
-                                for ( ArgPack& result : results ) {
-                                        // keep if used all arguments
-                                        if ( result.nextArg >= args.size() ) {
-                                                finalResults.push_back( std::move(result) );
+                        // append any unused arguments to vararg pack
+                        std::size_t genEnd;
+                        do {
+                                genEnd = results.size();
+
+                                // iterate results
+                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
+                                        auto nextArg = results[i].nextArg;
+
+                                        // use remainder of exploded tuple if present
+                                        if ( results[i].hasExpl() ) {
+                                                const ExplodedActual& expl = results[i].getExpl( args );
+
+                                                unsigned nextExpl = results[i].nextExpl + 1;
+                                                if ( nextExpl == expl.exprs.size() ) {
+                                                        nextExpl = 0;
+                                                }
+
+                                                results.emplace_back(
+                                                        i, expl.exprs[results[i].nextExpl].get(), copy(results[i].env),
+                                                        copy(results[i].need), copy(results[i].have),
+                                                        copy(results[i].openVars), nextArg, 0, Cost::zero, nextExpl,
+                                                        results[i].explAlt );
+
                                                 continue;
                                         }
 
+                                        // finish result when out of arguments
+                                        if ( nextArg >= args.size() ) {
+                                                validateFunctionAlternative( func, results[i], results, out );
+
+                                                continue;
+                                        }
+
                                         // add each possible next argument
-                                        for ( const Alternative& actual : args[result.nextArg] ) {
-                                                ArgPack aResult = result; // copy to clone everything
-                                                // add details of actual to result
-                                                aResult.env.addActual( actual.env, aResult.openVars );
-                                                Cost cost = actual.cost;
-
-                                                // explode argument
-                                                std::vector<Alternative> exploded;
-                                                Tuples::explode( actual, indexer, back_inserter( exploded ) );
-
-                                                // add exploded argument to arg list
-                                                for ( Alternative& aActual : exploded ) {
-                                                        aResult.withArg( aActual.expr, cost );
-                                                        cost = Cost::zero;
+                                        for ( std::size_t j = 0; j < args[nextArg].size(); ++j ) {
+                                                const ExplodedActual& expl = args[nextArg][j];
+
+                                                // fresh copies of parent parameters for this iteration
+                                                TypeEnvironment env = results[i].env;
+                                                OpenVarSet openVars = results[i].openVars;
+
+                                                env.addActual( expl.env, openVars );
+
+                                                // skip empty tuple arguments by (near-)cloning parent into next gen
+                                                if ( expl.exprs.empty() ) {
+                                                        results.emplace_back(
+                                                                results[i], move(env), copy(results[i].need),
+                                                                copy(results[i].have), move(openVars), nextArg + 1, expl.cost );
+
+                                                        continue;
                                                 }
-                                                ++aResult.nextArg;
-                                                nextResults.push_back( std::move(aResult) );
+
+                                                // add new result
+                                                results.emplace_back(
+                                                        i, expl.exprs.front().get(), move(env), copy(results[i].need),
+                                                        copy(results[i].have), move(openVars), nextArg + 1, 0,
+                                                        expl.cost, expl.exprs.size() == 1 ? 0 : 1, j );
                                         }
                                 }
 
-                                // reset for next round
-                                results.swap( nextResults );
-                                nextResults.clear();
-                        }
+                                genStart = genEnd;
+                        } while ( genEnd != results.size() );
                 } else {
                         // filter out results that don't use all the arguments
-                        for ( ArgPack& result : results ) {
-                                if ( result.nextExpl >= result.expls.size() && result.nextArg >= args.size() ) {
-                                        finalResults.push_back( std::move(result) );
+                        for ( std::size_t i = genStart; i < results.size(); ++i ) {
+                                ArgPack& result = results[i];
+                                if ( ! result.hasExpl() && result.nextArg >= args.size() ) {
+                                        validateFunctionAlternative( func, result, results, out );
                                 }
                         }
-                }
-
-                // validate matching combos, add to final result list
-                for ( ArgPack& result : finalResults ) {
-                        ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
-                        Alternative newAlt( appExpr, result.env, sumCost( result.actuals ) );
-                        makeExprList( result.actuals, appExpr->get_args() );
-                        PRINT(
-                                std::cerr << "instantiate function success: " << appExpr << std::endl;
-                                std::cerr << "need assertions:" << std::endl;
-                                printAssertionSet( result.need, std::cerr, 8 );
-                        )
-                        inferParameters( result.need, result.have, newAlt, result.openVars, out );
                 }
         }
@@ -920 +1045 @@
                         printAlts( funcOpFinder.alternatives, std::cerr, 1 );
                 )
+
+                // pre-explode arguments
+                ExplodedArgs argExpansions;
+                argExpansions.reserve( argAlternatives.size() );
+
+                for ( const AlternativeFinder& arg : argAlternatives ) {
+                        argExpansions.emplace_back();
+                        auto& argE = argExpansions.back();
+                        argE.reserve( arg.alternatives.size() );
+
+                        for ( const Alternative& actual : arg ) {
+                                argE.emplace_back( actual, indexer );
+                        }
+                }
 
                 AltList candidates;
@@ -934 +1073 @@
                                                 Alternative newFunc( *func );
                                                 referenceToRvalueConversion( newFunc.expr );
-                                                makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                makeFunctionAlternatives( newFunc, function, argExpansions,
                                                         std::back_inserter( candidates ) );
                                         }
@@ -943 +1082 @@
                                                         Alternative newFunc( *func );
                                                         referenceToRvalueConversion( newFunc.expr );
-                                                        makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                        makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
                                                 } // if
@@ -955 +1094 @@
                 // try each function operator ?() with each function alternative
                 if ( ! funcOpFinder.alternatives.empty() ) {
-                        // add function alternatives to front of argument list
-                        argAlternatives.insert( argAlternatives.begin(), std::move(funcFinder) );
+                        // add exploded function alternatives to front of argument list
+                        std::vector<ExplodedActual> funcE;
+                        funcE.reserve( funcFinder.alternatives.size() );
+                        for ( const Alternative& actual : funcFinder ) {
+                                funcE.emplace_back( actual, indexer );
+                        }
+                        argExpansions.insert( argExpansions.begin(), move(funcE) );
 
                         for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
@@ -968 +1112 @@
                                                         Alternative newFunc( *funcOp );
                                                         referenceToRvalueConversion( newFunc.expr );
-                                                        makeFunctionAlternatives( newFunc, function, argAlternatives,
+                                                        makeFunctionAlternatives( newFunc, function, argExpansions,
                                                                 std::back_inserter( candidates ) );
                                                 }
@@ -982 +1126 @@
 
                 // compute conversionsion costs
-                for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
-                        Cost cvtCost = computeApplicationConversionCost( *withFunc, indexer );
+                for ( Alternative& withFunc : candidates ) {
+                        Cost cvtCost = computeApplicationConversionCost( withFunc, indexer );
 
                         PRINT(
-                                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                ApplicationExpr *appExpr = strict_dynamic_cast< ApplicationExpr* >( withFunc.expr );
                                 PointerType *pointer = strict_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
                                 FunctionType *function = strict_dynamic_cast< FunctionType* >( pointer->get_base() );
@@ -995 +1139 @@
                                 printAll( appExpr->get_args(), std::cerr, 8 );
                                 std::cerr << "bindings are:" << std::endl;
-                                withFunc->env.print( std::cerr, 8 );
+                                withFunc.env.print( std::cerr, 8 );
                                 std::cerr << "cost of conversion is:" << cvtCost << std::endl;
                         )
                         if ( cvtCost != Cost::infinity ) {
-                                withFunc->cvtCost = cvtCost;
-                                alternatives.push_back( *withFunc );
+                                withFunc.cvtCost = cvtCost;
+                                alternatives.push_back( withFunc );
                         } // if
                 } // for
 
-                candidates.clear();
-                candidates.splice( candidates.end(), alternatives );
+                candidates = move(alternatives);
 
                 // use a new list so that alternatives are not examined by addAnonConversions twice.
@@ -1011 +1154 @@
                 findMinCost( candidates.begin(), candidates.end(), std::back_inserter( winners ) );
 
-                // function may return struct or union value, in which case we need to add alternatives for implicit
-                // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
-                // are never the cheapest expression
+                // 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
+                // since anon conversions are never the cheapest expression
                 for ( const Alternative & alt : winners ) {
                         addAnonConversions( alt );
                 }
-                alternatives.splice( alternatives.begin(), winners );
+                spliceBegin( alternatives, winners );
 
                 if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {
@@ -1041 +1184 @@
                 AlternativeFinder finder( indexer, env );
                 finder.find( addressExpr->get_arg() );
-                for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
-                        if ( isLvalue( i->expr ) ) {
-                                alternatives.push_back( Alternative( new AddressExpr( i->expr->clone() ), i->env, i->cost ) );
+                for ( Alternative& alt : finder.alternatives ) {
+                        if ( isLvalue( alt.expr ) ) {
+                                alternatives.push_back(
+                                        Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
                         } // if
                 } // for
@@ -1049 +1193 @@
 
         void AlternativeFinder::visit( LabelAddressExpr * expr ) {
-                alternatives.push_back( Alternative( expr->clone(), env, Cost::zero) );
+                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
         }
 
@@ -1091 +1235 @@
 
                 AltList candidates;
-                for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
+                for ( Alternative & alt : finder.alternatives ) {
                         AssertionSet needAssertions, haveAssertions;
                         OpenVarSet openVars;
@@ -1099 +1243 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = i->expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->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]))
                         // unification run for side-effects
-                        unify( castExpr->get_result(), i->expr->get_result(), i->env, needAssertions, haveAssertions, openVars, indexer );
-                        Cost thisCost = castCost( i->expr->get_result(), castExpr->get_result(), indexer, i->env );
+                        unify( castExpr->get_result(), alt.expr->get_result(), alt.env, needAssertions,
+                                haveAssertions, openVars, indexer );
+                        Cost thisCost = castCost( alt.expr->get_result(), castExpr->get_result(), indexer,
+                                alt.env );
+                        PRINT(
+                                std::cerr << "working on cast with result: " << castExpr->result << std::endl;
+                                std::cerr << "and expr type: " << alt.expr->result << std::endl;
+                                std::cerr << "env: " << alt.env << std::endl;
+                        )
                         if ( thisCost != Cost::infinity ) {
+                                PRINT(
+                                        std::cerr << "has finite cost." << std::endl;
+                                )
                                 // count one safe conversion for each value that is thrown away
                                 thisCost.incSafe( discardedValues );
-                                Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
-                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                Alternative newAlt( restructureCast( alt.expr->clone(), toType ), alt.env,
+                                        alt.cost, thisCost );
+                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
+                                        back_inserter( candidates ) );
                         } // if
                 } // for
@@ -1397 +1553 @@
 
         void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
-                std::list< AlternativeFinder > subExprAlternatives;
-                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
-                std::list< AltList > possibilities;
-                combos( subExprAlternatives.begin(), subExprAlternatives.end(), back_inserter( possibilities ) );
-                for ( std::list< AltList >::const_iterator i = possibilities.begin(); i != possibilities.end(); ++i ) {
+                std::vector< AlternativeFinder > subExprAlternatives;
+                findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(),
+                        back_inserter( subExprAlternatives ) );
+                std::vector< AltList > possibilities;
+                combos( subExprAlternatives.begin(), subExprAlternatives.end(),
+                        back_inserter( possibilities ) );
+                for ( const AltList& alts : possibilities ) {
                         std::list< Expression * > exprs;
-                        makeExprList( *i, exprs );
+                        makeExprList( alts, exprs );
 
                         TypeEnvironment compositeEnv;
-                        simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
+                        simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
+                        alternatives.push_back(
+                                Alternative{ new TupleExpr( exprs ), compositeEnv, sumCost( alts ) } );
                 } // for
         }

src/ResolvExpr/AlternativeFinder.h

@@ -21 +21 @@
 
 #include "Alternative.h"                 // for AltList, Alternative
+#include "ExplodedActual.h"              // for ExplodedActual
 #include "ResolvExpr/Cost.h"             // for Cost, Cost::infinity
 #include "ResolvExpr/TypeEnvironment.h"  // for AssertionSet, OpenVarSet
@@ -31 +32 @@
 
 namespace ResolvExpr {
+        struct ArgPack;
+
+        /// First index is which argument, second index is which alternative for that argument,
+        /// third index is which exploded element of that alternative
+        using ExplodedArgs = std::vector< std::vector< ExplodedActual > >;
+
         class AlternativeFinder : public Visitor {
           public:
@@ -36 +43 @@
 
                 AlternativeFinder( const AlternativeFinder& o )
-                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env), 
+                        : indexer(o.indexer), alternatives(o.alternatives), env(o.env),
                           targetType(o.targetType) {}
-                
+
                 AlternativeFinder( AlternativeFinder&& o )
-                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env), 
+                        : indexer(o.indexer), alternatives(std::move(o.alternatives)), env(o.env),
                           targetType(o.targetType) {}
-                
+
                 AlternativeFinder& operator= ( const AlternativeFinder& o ) {
                         if (&o == this) return *this;
-                        
+
                         // horrific nasty hack to rebind references...
                         alternatives.~AltList();
@@ -54 +61 @@
                 AlternativeFinder& operator= ( AlternativeFinder&& o ) {
                         if (&o == this) return *this;
-                        
+
                         // horrific nasty hack to rebind references...
                         alternatives.~AltList();
@@ -126 +133 @@
                 /// 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 );
+                /// Takes a final result and checks if its assertions can be satisfied
                 template<typename OutputIterator>
-                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const std::vector< AlternativeFinder >& args, OutputIterator out );
+                void validateFunctionAlternative( const Alternative &func, ArgPack& result, const std::vector<ArgPack>& results, OutputIterator out );
+                /// Finds matching alternatives for a function, given a set of arguments
+                template<typename OutputIterator>
+                void makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const ExplodedArgs& args, OutputIterator out );
+                /// Checks if assertion parameters match for a new alternative
                 template< typename OutputIterator >
                 void inferParameters( const AssertionSet &need, AssertionSet &have, const Alternative &newAlt, OpenVarSet &openVars, OutputIterator out );

src/ResolvExpr/PtrsAssignable.cc

@@ -68 +68 @@
 
         void PtrsAssignable::visit( __attribute((unused)) VoidType *voidType ) {
-                if ( ! dynamic_cast< FunctionType* >( dest ) ) {
-                        // T * = void * is safe for any T that is not a function type.
-                        // xxx - this should be unsafe...
-                        result = 1;
-                } // if
+                // T * = void * is disallowed - this is a change from C, where any
+                // void * can be assigned or passed to a non-void pointer without a cast.
         }
 

src/ResolvExpr/Resolver.cc

@@ -18 +18 @@
 #include <memory>                        // for allocator, allocator_traits<...
 #include <tuple>                         // for get
+#include <vector>
 
 #include "Alternative.h"                 // for Alternative, AltList
@@ -411 +412 @@
 
                         // Find all alternatives for all arguments in canonical form
-                        std::list< AlternativeFinder > argAlternatives;
+                        std::vector< AlternativeFinder > argAlternatives;
                         funcFinder.findSubExprs( clause.target.arguments.begin(), clause.target.arguments.end(), back_inserter( argAlternatives ) );
 
                         // List all combinations of arguments
-                        std::list< AltList > possibilities;
+                        std::vector< AltList > possibilities;
                         combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
 

src/ResolvExpr/TypeEnvironment.cc

@@ -212 +212 @@
         }
 
+        std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env ) {
+                env.print( out );
+                return out;
+        }
 } // namespace ResolvExpr
 

src/ResolvExpr/TypeEnvironment.h

@@ -86 +86 @@
                 TypeEnvironment *clone() const { return new TypeEnvironment( *this ); }
 
-                /// Iteratively adds the environment of a new actual (with allowWidening = false), 
+                /// Iteratively adds the environment of a new actual (with allowWidening = false),
                 /// and extracts open variables.
                 void addActual( const TypeEnvironment& actualEnv, OpenVarSet& openVars );
@@ -114 +114 @@
                 return sub.applyFree( type );
         }
+
+        std::ostream & operator<<( std::ostream & out, const TypeEnvironment & env );
 } // namespace ResolvExpr
 

src/ResolvExpr/module.mk

@@ -32 +32 @@
        ResolvExpr/Occurs.cc \
        ResolvExpr/TypeEnvironment.cc \
-       ResolvExpr/CurrentObject.cc
+       ResolvExpr/CurrentObject.cc \
+       ResolvExpr/ExplodedActual.cc

src/ResolvExpr/typeops.h

@@ -16 +16 @@
 #pragma once
 
+#include <vector>
+
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
@@ -28 +30 @@
         void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
                 typedef typename InputIterator::value_type SetType;
-                typedef typename std::list< typename SetType::value_type > ListType;
+                typedef typename std::vector< typename SetType::value_type > ListType;
 
                 if ( begin == end )     {
@@ -38 +40 @@
                 begin++;
 
-                std::list< ListType > recursiveResult;
+                std::vector< ListType > recursiveResult;
                 combos( begin, end, back_inserter( recursiveResult ) );
 
-                for ( typename std::list< ListType >::const_iterator i = recursiveResult.begin(); i != recursiveResult.end(); ++i ) {
-                        for ( typename ListType::const_iterator j = current->begin(); j != current->end(); ++j ) {
-                                ListType result;
-                                std::back_insert_iterator< ListType > inserter = back_inserter( result );
-                                *inserter++ = *j;
-                                std::copy( i->begin(), i->end(), inserter );
-                                *out++ = result;
-                        } // for
-                } // for
+                for ( const auto& i : recursiveResult ) for ( const auto& j : *current ) {
+                        ListType result;
+                        std::back_insert_iterator< ListType > inserter = back_inserter( result );
+                        *inserter++ = j;
+                        std::copy( i.begin(), i.end(), inserter );
+                        *out++ = result;
+                }
         }
 

src/SymTab/Autogen.cc

@@ -62 +62 @@
                 void previsit( FunctionDecl * functionDecl );
 
-                void previsit( FunctionType * ftype );
-                void previsit( PointerType * ptype );
-
                 void previsit( CompoundStmt * compoundStmt );
 
@@ -72 +69 @@
                 unsigned int functionNesting = 0;     // current level of nested functions
 
-                InitTweak::ManagedTypes managedTypes;
                 std::vector< FuncData > data;
         };
@@ -622 +618 @@
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
         void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
-                visit_children = false;
                 if ( ! typeDecl->base ) return;
 
@@ -628 +623 @@
                 TypeFuncGenerator gen( typeDecl, &refType, data, functionNesting, indexer );
                 generateFunctions( gen, declsToAddAfter );
-        }
-
-        void AutogenerateRoutines::previsit( FunctionType *) {
-                // ensure that we don't add assignment ops for types defined as part of the function
-                visit_children = false;
-        }
-
-        void AutogenerateRoutines::previsit( PointerType *) {
-                // ensure that we don't add assignment ops for types defined as part of the pointer
-                visit_children = false;
+
         }
 
@@ -645 +631 @@
         }
 
-        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
-                visit_children = false;
-                // record the existence of this function as appropriate
-                managedTypes.handleDWT( functionDecl );
-
-                maybeAccept( functionDecl->type, *visitor );
+        void AutogenerateRoutines::previsit( FunctionDecl * ) {
+                // Track whether we're currently in a function.
+                // Can ignore function type idiosyncrasies, because function type can never
+                // declare a new type.
                 functionNesting += 1;
-                maybeAccept( functionDecl->statements, *visitor );
-                functionNesting -= 1;
+                GuardAction( [this]()  { functionNesting -= 1; } );
         }
 
         void AutogenerateRoutines::previsit( CompoundStmt * ) {
-                GuardScope( managedTypes );
                 GuardScope( structsDone );
         }

src/SymTab/Autogen.h

@@ -56 +56 @@
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Intended to be used with generated ?=?, ?{}, and ^?{} calls.
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast = nullptr, bool forward = true );
 
         /// inserts into out a generated call expression to function fname with arguments dstParam and srcParam. Should only be called with non-array types.
         /// optionally returns a statement which must be inserted prior to the containing loop, if there is one
         template< typename OutputIterator >
-        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, Type * addCast = nullptr ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -68 +68 @@
                         fname = "?=?";
                         dstParam = new AddressExpr( dstParam );
-                        addCast = false;
+                        addCast = nullptr;
                         isReferenceCtorDtor = true;
                 }
@@ -83 +83 @@
                         // remove lvalue as a qualifier, this can change to
                         //   type->get_qualifiers() = Type::Qualifiers();
-                        assert( type );
-                        Type * castType = type->clone();
+                        Type * castType = addCast->clone();
                         castType->get_qualifiers() -= Type::Qualifiers( Type::Lvalue | Type::Const | Type::Volatile | Type::Restrict | Type::Atomic );
                         // castType->set_lvalue( true ); // xxx - might not need this
@@ -115 +114 @@
         /// If forward is true, loop goes from 0 to N-1, else N-1 to 0
         template< typename OutputIterator >
-        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, Type * addCast = nullptr, bool forward = true ) {
                 static UniqueName indexName( "_index" );
 
                 // for a flexible array member nothing is done -- user must define own assignment
-                if ( ! array->get_dimension() ) return ;
+                if ( ! array->get_dimension() ) return;
+
+                if ( addCast ) {
+                        // peel off array layer from cast
+                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
+                        addCast = at->base;
+                }
 
                 Expression * begin, * end, * update, * cmp;
@@ -171 +176 @@
 
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -191 +196 @@
                 if ( isUnnamedBitfield( obj ) ) return;
 
-                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
+                Type * addCast = nullptr;
+                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
+                        assert( dstParam->result );
+                        addCast = dstParam->result;
+                }
                 std::list< Statement * > stmts;
                 genCall( srcParam, dstParam, fname, back_inserter( stmts ), obj->type, addCast, forward );

src/SymTab/Indexer.cc

@@ -567 +567 @@
         }
 
+        void Indexer::addIds( const std::list< DeclarationWithType * > & decls ) {
+                for ( auto d : decls ) {
+                        addId( d );
+                }
+        }
+
+        void Indexer::addTypes( const std::list< TypeDecl * > & tds ) {
+                for ( auto td : tds ) {
+                        addType( td );
+                        addIds( td->assertions );
+                }
+        }
+
+        void Indexer::addFunctionType( FunctionType * ftype ) {
+                addTypes( ftype->forall );
+                addIds( ftype->returnVals );
+                addIds( ftype->parameters );
+        }
+
         void Indexer::enterScope() {
                 ++scope;

src/SymTab/Indexer.h

@@ -76 +76 @@
                 void addTrait( TraitDecl *decl );
 
+                /// convenience function for adding a list of Ids to the indexer
+                void addIds( const std::list< DeclarationWithType * > & decls );
+
+                /// convenience function for adding a list of forall parameters to the indexer
+                void addTypes( const std::list< TypeDecl * > & tds );
+
+                /// convenience function for adding all of the declarations in a function type to the indexer
+                void addFunctionType( FunctionType * ftype );
+
                 bool doDebug = false; ///< Display debugging trace?
           private:

src/SymTab/Validate.cc

@@ -124 +124 @@
 
         /// Associates forward declarations of aggregates with their definitions
-        struct LinkReferenceToTypes final : public WithIndexer {
+        struct LinkReferenceToTypes final : public WithIndexer, public WithGuards {
                 LinkReferenceToTypes( const Indexer *indexer );
                 void postvisit( TypeInstType *typeInst );
@@ -137 +137 @@
                 void postvisit( UnionDecl *unionDecl );
                 void postvisit( TraitDecl * traitDecl );
+
+                void previsit( StructDecl *structDecl );
+                void previsit( UnionDecl *unionDecl );
+
+                void renameGenericParams( std::list< TypeDecl * > & params );
 
           private:
@@ -147 +152 @@
                 ForwardStructsType forwardStructs;
                 ForwardUnionsType forwardUnions;
+                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
+                bool inGeneric = false;
         };
 
@@ -561 +568 @@
         }
 
+        void LinkReferenceToTypes::renameGenericParams( std::list< TypeDecl * > & params ) {
+                // rename generic type parameters uniquely so that they do not conflict with user-defined function forall parameters, e.g.
+                //   forall(otype T)
+                //   struct Box {
+                //     T x;
+                //   };
+                //   forall(otype T)
+                //   void f(Box(T) b) {
+                //     ...
+                //   }
+                // The T in Box and the T in f are different, so internally the naming must reflect that.
+                GuardValue( inGeneric );
+                inGeneric = ! params.empty();
+                for ( TypeDecl * td : params ) {
+                        td->name = "__" + td->name + "_generic_";
+                }
+        }
+
+        void LinkReferenceToTypes::previsit( StructDecl * structDecl ) {
+                renameGenericParams( structDecl->parameters );
+        }
+
+        void LinkReferenceToTypes::previsit( UnionDecl * unionDecl ) {
+                renameGenericParams( unionDecl->parameters );
+        }
+
         void LinkReferenceToTypes::postvisit( StructDecl *structDecl ) {
                 // visit struct members first so that the types of self-referencing members are updated properly
@@ -588 +621 @@
 
         void LinkReferenceToTypes::postvisit( TypeInstType *typeInst ) {
+                // ensure generic parameter instances are renamed like the base type
+                if ( inGeneric && typeInst->baseType ) typeInst->name = typeInst->baseType->name;
                 if ( NamedTypeDecl *namedTypeDecl = local_indexer->lookupType( typeInst->get_name() ) ) {
                         if ( TypeDecl *typeDecl = dynamic_cast< TypeDecl * >( namedTypeDecl ) ) {

src/SynTree/Expression.cc

@@ -88 +88 @@
         Type * type = var->get_type()->clone();
         type->set_lvalue( true );
+
+        // xxx - doesn't quite work yet - get different alternatives with the same cost
+
+        // // enumerators are not lvalues
+        // if ( EnumInstType * inst = dynamic_cast< EnumInstType * >( var->get_type() ) ) {
+        //      assert( inst->baseEnum );
+        //      EnumDecl * decl = inst->baseEnum;
+        //      for ( Declaration * member : decl->members ) {
+        //              if ( member == _var ) {
+        //                      type->set_lvalue( false );
+        //              }
+        //      }
+        // }
+
         set_result( type );
 }
@@ -324 +338 @@
                         return makeSub( refType->get_base() );
                 } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
                 } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
                 } else {
                         assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );

src/Tuples/Explode.h

@@ -16 +16 @@
 #pragma once
 
-#include <iterator>                  // for back_inserter, back_insert_iterator
+#include <iterator>                     // for back_inserter, back_insert_iterator
+#include <utility>                      // for forward
 
-#include "ResolvExpr/Alternative.h"  // for Alternative, AltList
-#include "SynTree/Expression.h"      // for Expression, UniqueExpr, AddressExpr
-#include "SynTree/Type.h"            // for TupleType, Type
-#include "Tuples.h"                  // for maybeImpure
+#include "ResolvExpr/Alternative.h"     // for Alternative, AltList
+#include "ResolvExpr/ExplodedActual.h"  // for ExplodedActual
+#include "SynTree/Expression.h"         // for Expression, UniqueExpr, AddressExpr
+#include "SynTree/Type.h"               // for TupleType, Type
+#include "Tuples.h"                     // for maybeImpure
 
 namespace SymTab {
@@ -39 +41 @@
         }
 
+        /// Append alternative to an OutputIterator of Alternatives
+        template<typename OutputIterator>
+        void append( OutputIterator out, Expression* expr, const ResolvExpr::TypeEnvironment& env, 
+                        const ResolvExpr::Cost& cost, const ResolvExpr::Cost& cvtCost ) {
+                *out++ = ResolvExpr::Alternative{ expr, env, 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& ) {
+                ea.exprs.emplace_back( expr );
+                /// xxx -- merge environment, cost?
+        }
+
         /// helper function used by explode
-        template< typename OutputIterator >
-        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign ) {
+        template< typename Output >
+        void explodeUnique( Expression * expr, const ResolvExpr::Alternative & alt, 
+                        const SymTab::Indexer & indexer, Output&& out, bool isTupleAssign ) {
                 if ( isTupleAssign ) {
                         // tuple assignment needs CastExprs to be recursively exploded to easily get at all of the components
                         if ( CastExpr * castExpr = isReferenceCast( expr ) ) {
                                 ResolvExpr::AltList alts;
-                                explodeUnique( castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
+                                explodeUnique( 
+                                        castExpr->get_arg(), alt, indexer, back_inserter( alts ), isTupleAssign );
                                 for ( ResolvExpr::Alternative & alt : alts ) {
                                         // distribute reference cast over all components
-                                        alt.expr = distributeReference( alt.expr );
-                                        *out++ = alt;
+                                        append( std::forward<Output>(out), distributeReference( alt.release_expr() ), 
+                                                alt.env, 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)
@@ -61 +79 @@
                                 // can open tuple expr and dump its exploded components
                                 for ( Expression * expr : tupleExpr->get_exprs() ) {
-                                        explodeUnique( expr, alt, indexer, out, isTupleAssign );
+                                        explodeUnique( expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
                                 }
                         } else {
@@ -77 +95 @@
                                 for ( unsigned int i = 0; i < tupleType->size(); i++ ) {
                                         TupleIndexExpr * idx = new TupleIndexExpr( arg->clone(), i );
-                                        explodeUnique( idx, alt, indexer, out, isTupleAssign );
+                                        explodeUnique( idx, alt, indexer, std::forward<Output>(out), isTupleAssign );
                                         delete idx;
                                 }
@@ -84 +102 @@
                 } else {
                         // atomic (non-tuple) type - output a clone of the expression in a new alternative
-                        *out++ = ResolvExpr::Alternative( expr->clone(), alt.env, alt.cost, alt.cvtCost );
+                        append( std::forward<Output>(out), expr->clone(), alt.env, alt.cost, alt.cvtCost );
                 }
         }
 
         /// expands a tuple-valued alternative into multiple alternatives, each with a non-tuple-type
-        template< typename OutputIterator >
-        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
-                explodeUnique( alt.expr, alt, indexer, out, isTupleAssign );
+        template< typename Output >
+        void explode( const ResolvExpr::Alternative &alt, const SymTab::Indexer & indexer, 
+                        Output&& out, bool isTupleAssign = false ) {
+                explodeUnique( alt.expr, alt, indexer, std::forward<Output>(out), isTupleAssign );
         }
 
         // explode list of alternatives
-        template< typename AltIterator, typename OutputIterator >
-        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
+        template< typename AltIterator, typename Output >
+        void explode( AltIterator altBegin, AltIterator altEnd, const SymTab::Indexer & indexer, 
+                        Output&& out, bool isTupleAssign = false ) {
                 for ( ; altBegin != altEnd; ++altBegin ) {
-                        explode( *altBegin, indexer, out, isTupleAssign );
+                        explode( *altBegin, indexer, std::forward<Output>(out), isTupleAssign );
                 }
         }
 
-        template< typename OutputIterator >
-        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, OutputIterator out, bool isTupleAssign = false ) {
-                explode( alts.begin(), alts.end(), indexer, out, isTupleAssign );
+        template< typename Output >
+        void explode( const ResolvExpr::AltList & alts, const SymTab::Indexer & indexer, Output&& out, 
+                        bool isTupleAssign = false ) {
+                explode( alts.begin(), alts.end(), indexer, std::forward<Output>(out), isTupleAssign );
         }
 } // namespace Tuples

src/Tuples/TupleAssignment.cc

@@ -251 +251 @@
                 // combine assignment environments into combined expression environment
                 simpleCombineEnvironments( current.begin(), current.end(), matcher->compositeEnv );
-                currentFinder.get_alternatives().push_front( ResolvExpr::Alternative(
+                // xxx -- was push_front
+                currentFinder.get_alternatives().push_back( ResolvExpr::Alternative(
                         new TupleAssignExpr(solved_assigns, matcher->tmpDecls), matcher->compositeEnv, 
                         ResolvExpr::sumCost( current ) + matcher->baseCost ) );

src/libcfa/concurrency/kernel

@@ -108 +108 @@
 #ifdef __CFA_DEBUG__
         // Last function to enable preemption on this processor
-        char * last_enable;
+        const char * last_enable;
 #endif
 };

src/libcfa/concurrency/monitor.c

@@ -823 +823 @@
                 this.monitor_count = thrd->monitors.size;
 
-                this.monitors = malloc( this.monitor_count * sizeof( *this.monitors ) );
+                this.monitors = (monitor_desc **)malloc( this.monitor_count * sizeof( *this.monitors ) );
                 for( int i = 0; i < this.monitor_count; i++ ) {
                         this.monitors[i] = thrd->monitors[i];

src/libcfa/stdhdr/stddef.h

@@ -4 +4 @@
 // The contents of this file are covered under the licence agreement in the
 // file "LICENCE" distributed with Cforall.
-// 
-// stddef.h -- 
-// 
+//
+// stddef.h --
+//
 // Author           : Peter A. Buhr
 // Created On       : Mon Jul  4 23:25:26 2016
@@ -12 +12 @@
 // Last Modified On : Tue Jul  5 20:40:01 2016
 // Update Count     : 12
-// 
+//
 
 extern "C" {
-#include_next <stddef.h>                                                                // has internal check for multiple expansion
+#include_next <stddef.h>                // has internal check for multiple expansion
+#undef NULL
+#define NULL 0                          // define NULL as 0 rather than (void*)0 to take advantage of zero_t
 } // extern "C"
 

src/libcfa/stdlib

@@ -77 +77 @@
         //printf( "X8\n" );
         T * ptr = (T *)(void *)malloc( (size_t)sizeof(T) );     // C malloc
-    return memset( ptr, (int)fill, sizeof(T) );                 // initial with fill value
+    return (T *)memset( ptr, (int)fill, sizeof(T) );                    // initial with fill value
 } // alloc
 
@@ -87 +87 @@
         //printf( "X10\n" );
         T * ptr = (T *)(void *)malloc( dim * (size_t)sizeof(T) ); // C malloc
-    return memset( ptr, (int)fill, dim * sizeof(T) );
+    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
 } // alloc
 
 static inline forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim ) {
         //printf( "X11\n" );
-        return (void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
+        return (T *)(void *)realloc( (void *)ptr, dim * (size_t)sizeof(T) ); // C realloc
 } // alloc
 forall( dtype T | sized(T) ) T * alloc( T ptr[], size_t dim, char fill );
@@ -103 +103 @@
         //printf( "X14\n" );
     T * ptr = (T *)memalign( align, sizeof(T) );
-    return memset( ptr, (int)fill, sizeof(T) );
+    return (T *)memset( ptr, (int)fill, sizeof(T) );
 } // align_alloc
 
@@ -113 +113 @@
         //printf( "X16\n" );
     T * ptr = (T *)memalign( align, dim * sizeof(T) );
-    return memset( ptr, (int)fill, dim * sizeof(T) );
+    return (T *)memset( ptr, (int)fill, dim * sizeof(T) );
 } // align_alloc
 
@@ -120 +120 @@
 static inline forall( dtype T | sized(T) ) T * memset( T * dest, char c ) {
         //printf( "X17\n" );
-        return memset( dest, c, sizeof(T) );
+        return (T *)memset( dest, c, sizeof(T) );
 } // memset
 extern "C" { void * memcpy( void * dest, const void * src, size_t size ); } // use default C routine for void *
 static inline forall( dtype T | sized(T) ) T * memcpy( T * dest, const T * src ) {
         //printf( "X18\n" );
-        return memcpy( dest, src, sizeof(T) );
+        return (T *)memcpy( dest, src, sizeof(T) );
 } // memcpy
 
@@ -131 +131 @@
 static inline forall( dtype T | sized(T) ) T * memset( T dest[], size_t dim, char c ) {
         //printf( "X19\n" );
-        return (void *)memset( dest, c, dim * sizeof(T) );      // C memset
+        return (T *)(void *)memset( dest, c, dim * sizeof(T) ); // C memset
 } // memset
 static inline forall( dtype T | sized(T) ) T * memcpy( T dest[], const T src[], size_t dim ) {
         //printf( "X20\n" );
-        return (void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
+        return (T *)(void *)memcpy( dest, src, dim * sizeof(T) ); // C memcpy
 } // memcpy
 

src/prelude/prelude.cf

@@ -403 +403 @@
 forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    DT * );
 
-forall( dtype DT ) DT *                 ?=?(                 DT *          &,                   void * );
-forall( dtype DT ) DT *                 ?=?(                 DT * volatile &,                   void * );
-forall( dtype DT ) const DT *           ?=?( const           DT *          &,                   void * );
-forall( dtype DT ) const DT *           ?=?( const           DT * volatile &,                   void * );
-forall( dtype DT ) const DT *           ?=?( const           DT *          &, const             void * );
-forall( dtype DT ) const DT *           ?=?( const           DT * volatile &, const             void * );
-forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,                   void * );
-forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,                   void * );
-forall( dtype DT ) volatile DT *        ?=?(       volatile  DT *          &,       volatile    void * );
-forall( dtype DT ) volatile DT *        ?=?(       volatile  DT * volatile &,       volatile    void * );
-
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,                   void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,                   void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const             void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const             void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &,       volatile    void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &,       volatile    void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT *          &, const volatile    void * );
-forall( dtype DT ) const volatile DT *  ?=?( const volatile  DT * volatile &, const volatile    void * );
-
 forall( dtype DT ) void *                ?=?(                void *          &,                 DT * );
 forall( dtype DT ) void *                ?=?(                void * volatile &,                 DT * );
@@ -441 +421 @@
 forall( dtype DT ) const volatile void * ?=?( const volatile void *          &, const volatile  DT * );
 forall( dtype DT ) const volatile void * ?=?( const volatile void * volatile &, const volatile  DT * );
-
-void *                  ?=?(                void *          &,                void * );
-void *                  ?=?(                void * volatile &,                void * );
-const void *            ?=?( const          void *          &,                void * );
-const void *            ?=?( const          void * volatile &,                void * );
-const void *            ?=?( const          void *          &, const          void * );
-const void *            ?=?( const          void * volatile &, const          void * );
-volatile void *         ?=?(       volatile void *          &,                void * );
-volatile void *         ?=?(       volatile void * volatile &,                void * );
-volatile void *         ?=?(       volatile void *          &,       volatile void * );
-volatile void *         ?=?(       volatile void * volatile &,       volatile void * );
-const volatile void *   ?=?( const volatile void *          &,                void * );
-const volatile void *   ?=?( const volatile void * volatile &,                void * );
-const volatile void *   ?=?( const volatile void *          &, const          void * );
-const volatile void *   ?=?( const volatile void * volatile &, const          void * );
-const volatile void *   ?=?( const volatile void *          &,       volatile void * );
-const volatile void *   ?=?( const volatile void * volatile &,       volatile void * );
-const volatile void *   ?=?( const volatile void *          &, const volatile void * );
-const volatile void *   ?=?( const volatile void * volatile &, const volatile void * );
 
 //forall( dtype DT ) DT *                       ?=?(                DT *          &, zero_t );
@@ -781 +742 @@
 forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    DT * );
 
-forall( dtype DT ) void ?{}(                 DT *          &,                   void * );
-forall( dtype DT ) void ?{}( const           DT *          &,                   void * );
-forall( dtype DT ) void ?{}( const           DT *          &, const             void * );
-forall( dtype DT ) void ?{}(       volatile  DT *          &,                   void * );
-forall( dtype DT ) void ?{}(       volatile  DT *          &,       volatile    void * );
-
-forall( dtype DT ) void ?{}( const volatile  DT *          &,                   void * );
-forall( dtype DT ) void ?{}( const volatile  DT *          &, const             void * );
-forall( dtype DT ) void ?{}( const volatile  DT *          &,       volatile    void * );
-forall( dtype DT ) void ?{}( const volatile  DT *          &, const volatile    void * );
-
 forall( dtype DT ) void ?{}(                 void *          &,                 DT * );
 forall( dtype DT ) void ?{}( const           void *          &,                 DT * );
@@ -802 +752 @@
 forall( dtype DT ) void ?{}( const volatile void *           &, const volatile  DT * );
 
-void    ?{}(                void *          &,                void * );
-void    ?{}( const          void *          &,                void * );
-void    ?{}( const          void *          &, const          void * );
-void    ?{}(       volatile void *          &,                void * );
-void    ?{}(       volatile void *          &,       volatile void * );
-void    ?{}( const volatile void *          &,                void * );
-void    ?{}( const volatile void *          &, const          void * );
-void    ?{}( const volatile void *          &,       volatile void * );
-void    ?{}( const volatile void *          &, const volatile void * );
-
 //forall( dtype DT ) void ?{}(              DT *          &, zero_t );
 //forall( dtype DT ) void ?{}(              DT * volatile &, zero_t );

src/tests/.expect/castError.txt

@@ -5 +5 @@
   charAlternatives are:
 Cost ( 1, 0, 0, 0 ): Cast of:
-     Variable Expression: f: signed int
+     Variable Expression: f: function
+       accepting unspecified arguments
+     ... returning nothing 
+
    ... to:
      char
@@ -23 +26 @@
 
 Cost ( 1, 0, 0, 0 ): Cast of:
-     Variable Expression: f: function
-       accepting unspecified arguments
-     ... returning nothing 
-
+     Variable Expression: f: signed int
    ... to:
      char

src/tests/.expect/completeTypeError.txt

@@ -1 @@
-completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped: 
+completeTypeError.c:33:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: *?
 ...to: 
   Name: v
 
+completeTypeError.c:34:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: *?
+...to: 
+  Name: y
+
+completeTypeError.c:35:1 error: No reasonable alternatives for expression Applying untyped: 
+  Name: foo
+...to: 
+  Name: v
 
 completeTypeError.c:36:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -10 +19 @@
   Name: v
 
-
 completeTypeError.c:37:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: quux
 ...to: 
   Name: v
-
 
 completeTypeError.c:58:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -22 +29 @@
   Name: y
 
-
 completeTypeError.c:59:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: quux
 ...to: 
   Name: y
-
 
 completeTypeError.c:60:1 error: No reasonable alternatives for expression Applying untyped: 
@@ -34 +39 @@
   Name: y
 
-
 completeTypeError.c:72:1 error: No reasonable alternatives for expression Applying untyped: 
   Name: baz
@@ -40 +44 @@
   Name: z
 
-

src/tests/Makefile.am

@@ -141 +141 @@
 typedefRedef-ERR1: typedefRedef.c @CFA_BINDIR@/@CFA_NAME@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
+alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}

src/tests/Makefile.in

@@ -895 +895 @@
         ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
 
+alloc-ERROR: alloc.c @CFA_BINDIR@/@CFA_NAME@
+        ${CC} ${AM_CFLAGS} ${CFLAGS} -DERR1 ${<} -o ${@}
+
 # Tell versions [3.59,3.63) of GNU make to not export all variables.
 # Otherwise a system limit (for SysV at least) may be exceeded.

src/tests/alloc.c

@@ -32 +32 @@
         // allocation, non-array types
 
-        p = (void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
+        p = (int *)(void *)malloc( sizeof(*p) );                   // C malloc, type unsafe
         *p = 0xdeadbeef;
         printf( "C   malloc %#x\n", *p );
@@ -54 +54 @@
         printf( "\n" );
 
-        p = calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
+        p = (int *)calloc( dim, sizeof( *p ) );                    // C array calloc, type unsafe
         printf( "C   array calloc, fill 0\n" );
         for ( int i = 0; i < dim; i += 1 ) { printf( "%#x ", p[i] ); }
@@ -83 +83 @@
         printf( "\n" );
 
-        p = (void *)realloc( p, dim * sizeof(*p) );         // C realloc
+        p = (int *)(void *)realloc( p, dim * sizeof(*p) );         // C realloc
         for ( int i = 0; i < dim; i += 1 ) { p[i] = 0xdeadbeef; }
         printf( "C   realloc\n" );
@@ -256 +256 @@
         stp = malloc();
         printf( "\nSHOULD FAIL\n" );
+#ifdef ERR1
         p = alloc( stp, dim * sizeof(*stp) );
         p = memset( stp, 10 );
         p = memcpy( &st1, &st );
+#endif
 } // main
 

src/tests/completeTypeError.c

@@ -12 +12 @@
         void *v;
 
-        // A * x;
-        // A * y;
-        // B * x;
-        // B * z;
+        A * x;
+        A * y;
+        B * x;
+        B * z;
 
         // okay
         *i;
-        // *x; // picks B
-        // *z;
+        *x; // picks B
+        *z;
         foo(i);
         bar(i);
@@ -29 +29 @@
         bar(v);
         qux(v);
-        foo(v); // questionable, but works at the moment for C compatibility
 
         // bad
         *v;
-        // *y;
+        *y;
+        foo(v);
         baz(v);
         quux(v);

src/tests/dtor-early-exit.c

@@ -22 +22 @@
 
 struct A {
-        char * name;
+        const char * name;
         int * x;
 };

src/tests/init_once.c

@@ -72 +72 @@
         insert( &constructed, &x );
 
-        x.x = malloc(sizeof(int));
+        x.x = (int *)malloc(sizeof(int));
 }
 

src/tests/multiDimension.c

@@ -7 +7 @@
   printf("default constructing\n");
   (this.a){ 123 };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 
@@ -13 +13 @@
   printf("copy constructing\n");
   (this.a){ other.a };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 
@@ -19 +19 @@
   printf("constructing with %d\n", a);
   (this.a){ a };
-  this.ptr = malloc(sizeof(int));
+  this.ptr = (int *)malloc(sizeof(int));
 }
 

src/tests/polymorphism.c

@@ -14 +14 @@
 //
 
+#include <assert.h>
+#include <inttypes.h>
+
 forall(otype T)
 T f(T x, T y) {
@@ -24 +27 @@
 }
 
+forall( otype T, otype U )
+size_t struct_size( T i, U j ) {
+        struct S { T i; U j; };
+        return sizeof(S);
+}
+
+forall( otype T, otype U )
+size_t union_size( T i, U j ) {
+        union B { T i; U j; };
+        return sizeof(B);
+}
+
+// perform some simple operations on aggregates of T and U
+forall( otype T | { void print(T); int ?==?(T, T); }, otype U | { void print(U); U ?=?(U&, zero_t); } )
+U foo(T i, U j) {
+        struct S { T i; U j; };
+        union B { T i; U j; };
+
+        S s;
+        s.i = i;
+        assert(s.i == i);
+
+        B b;
+        b.j = 0;
+        b.i = s.i;
+        return b.j;
+}
+
 int main() {
-        // ensure that x is not changed by the invocation of a polymorphic function
-        int x = 123;
-        int y = 456;
-        int z = f(x, y);
-        printf("%d %d %d\n", x, y, z);
+        {
+                // ensure that x is not changed by the invocation of a polymorphic function
+                int x = 123;
+                int y = 456;
+                int z = f(x, y);
+                printf("%d %d %d\n", x, y, z);
+        }
 
-        // explicitly specialize function
-        int (*f)(int) = ident;
-        ((int(*)(int))ident);
-        printf("%d %d\n", f(5), ((int(*)(int))ident)(5));
+        {
+                // explicitly specialize function
+                int (*f)(int) = ident;
+                ((int(*)(int))ident);
+                printf("%d %d\n", f(5), ((int(*)(int))ident)(5));
+        }
+
+        {
+                // test aggregates with polymorphic members
+                typedef uint32_t x_type;
+                typedef uint64_t y_type;
+
+                x_type x = 3;
+                y_type y = 3;
+
+                struct S {
+                        x_type f1;
+                        y_type f2;
+                };
+                union U {
+                        x_type f1;
+                        y_type f2;
+                };
+                // ensure that the size of aggregates with polymorphic members
+                // matches the size of the aggregates in a monomorphic context
+                assert( struct_size(x, y) == sizeof(S) );
+                assert( union_size(x, y) == sizeof(U) );
+
+                y_type ?=?(y_type & this, zero_t) {
+                        this = (int)0;
+                        return this;
+                }
+
+                void print(x_type x) {
+                        printf("%"PRIu32"\n", x);
+                }
+
+                void print(y_type y) {
+                        printf("%"PRIu64"\n", y);
+                }
+
+                y_type ret = foo(x, y);
+
+                // duplicate logic from inside of foo to ensure the same results
+                U u;
+                u.f2 = 0;
+                u.f1 = x;
+                assert(ret == u.f2);
+        }
 }
 

src/tests/tupleVariadic.c

@@ -73 +73 @@
         [a0, a1, a2, a3] = args;
         a.size = 4;
-        a.data = malloc(sizeof(int)*a.size);
+        a.data = (int *)malloc(sizeof(int)*a.size);
         a.data[0] = a0;
         a.data[1] = a1;

src/tests/vector/vector_int.c

@@ -27 +27 @@
         vec.last = -1;
         vec.capacity = reserve;
-        vec.data = malloc( sizeof( int ) * reserve );
+        vec.data = (int *)malloc( sizeof( int ) * reserve );
 }
 
@@ -33 +33 @@
         vec.last = other.last;
         vec.capacity = other.capacity;
-        vec.data = malloc( sizeof( int ) * other.capacity );
+        vec.data = (int *)malloc( sizeof( int ) * other.capacity );
         for (int i = 0; i < vec.last; i++) {
                 vec.data[i] = other.data[i];
@@ -45 +45 @@
 void reserve( vector_int *vec, int reserve ) {
         if ( reserve > vec->capacity ) {
-                vec->data = realloc( vec->data, sizeof( int ) * reserve );
+                vec->data = (int *)realloc( vec->data, sizeof( int ) * reserve );
                 vec->capacity = reserve;
         }
@@ -54 +54 @@
         if ( vec->last == vec->capacity ) {
                 vec->capacity *= 2;
-                vec->data = realloc( vec->data, sizeof( int ) * vec->capacity );
+                vec->data = (int *)realloc( vec->data, sizeof( int ) * vec->capacity );
         }
         vec->data[ vec->last ] = element;