Changes in / [1ba5803:4d5e57b]

Location:

src

Files:

• GenPoly/InstantiateGeneric.cc (modified) (4 diffs)
• InitTweak/FixInit.cc (modified) (3 diffs)
• Parser/DeclarationNode.cc (modified) (3 diffs)
• Parser/parser.yy (modified) (8 diffs)
• ResolvExpr/Alternative.cc (modified) (2 diffs)
• ResolvExpr/Alternative.h (modified) (3 diffs)
• ResolvExpr/AlternativeFinder.cc (modified) (21 diffs)
• ResolvExpr/AlternativeFinder.h (modified) (4 diffs)
• ResolvExpr/Resolver.cc (modified) (2 diffs)
• ResolvExpr/TypeEnvironment.cc (modified) (1 diff)
• ResolvExpr/TypeEnvironment.h (modified) (2 diffs)
• 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) (9 diffs)
• SynTree/Expression.cc (modified) (1 diff)
• Tuples/TupleAssignment.cc (modified) (1 diff)
• benchmark/Makefile.am (modified) (2 diffs)
• benchmark/Makefile.in (modified) (2 diffs)
• benchmark/bench.c (added)
• benchmark/csv-data.c (added)
• tests/.expect/castError.txt (modified) (2 diffs)

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
@@ -152 +151 @@
                 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
@@ -207 +198 @@
 
         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(); } );
         }
 
@@ -495 +479 @@
         }
 
-        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

@@ -937 +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 );
@@ -993 +1006 @@
                                 // 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(); } );
-                                indexer.addFunctionType( function->type );
+                                addTypes( indexer, function->type->forall );
+                                addIds( indexer, function->type->returnVals );
+                                addIds( indexer, function->type->parameters );
 
                                 // need to iterate through members in reverse in order for
@@ -1008 +1023 @@
                                         // insert and resolve default/copy constructor call for each field that's unhandled
                                         std::list< Statement * > stmt;
-                                        Expression * arg2 = nullptr;
+                                        Expression * arg2 = 0;
                                         if ( isCopyConstructor( function ) ) {
                                                 // if copy ctor, need to pass second-param-of-this-function.field

src/Parser/DeclarationNode.cc

@@ -10 +10 @@
 // Created On       : Sat May 16 12:34:05 2015
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 20 09:21:52 2017
-// Update Count     : 1031
+// Last Modified On : Sat Sep 23 18:16:48 2017
+// Update Count     : 1024
 //
 
@@ -509 +509 @@
 
 DeclarationNode * DeclarationNode::addQualifiers( DeclarationNode * q ) {
-        if ( ! q ) { delete q; return this; }                           // empty qualifier
+        if ( ! q ) { delete q; return this; }
 
         checkSpecifiers( q );
         copySpecifiers( q );
 
-        if ( ! q->type ) { delete q; return this; }
+        if ( ! q->type ) {
+                delete q;
+                return this;
+        } // if
 
         if ( ! type ) {
-                type = q->type;                                                                 // reuse structure
+                type = q->type;                                                                 // reuse this structure
                 q->type = nullptr;
                 delete q;
@@ -523 +526 @@
         } // if
 
-        if ( q->type->forall ) {                                                        // forall qualifier ?
-                if ( type->forall ) {                                                   // polymorphic routine ?
-                        type->forall->appendList( q->type->forall ); // augment forall qualifier
+        if ( q->type->forall ) {
+                if ( type->forall ) {
+                        type->forall->appendList( q->type->forall );
                 } else {
-                        if ( type->kind == TypeData::Aggregate ) {      // struct/union ?
-                                if ( type->aggregate.params ) {                 // polymorphic ?
-                                        type->aggregate.params->appendList( q->type->forall ); // augment forall qualifier
-                                } else {                                                                // not polymorphic
-                                        type->aggregate.params = q->type->forall; // make polymorphic type
-                                        // change implicit typedef from TYPEDEFname to TYPEGENname
-                                        typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
-                                } // if
-                        } else {                                                                        // not polymorphic
-                                type->forall = q->type->forall;                 // make polymorphic routine
+                        if ( type->kind == TypeData::Aggregate ) {
+                                type->aggregate.params = q->type->forall;
+                                // change implicit typedef from TYPEDEFname to TYPEGENname
+                                typedefTable.changeKind( *type->aggregate.name, TypedefTable::TG );
+                        } else {
+                                type->forall = q->type->forall;
                         } // if
                 } // if
-                q->type->forall = nullptr;                                              // forall qualifier moved
+                q->type->forall = nullptr;
         } // if
 

src/Parser/parser.yy

@@ -10 +10 @@
 // Created On       : Sat Sep  1 20:22:55 2001
 // Last Modified By : Peter A. Buhr
-// Last Modified On : Mon Nov 20 09:45:36 2017
-// Update Count     : 2945
+// Last Modified On : Wed Oct 25 12:28:54 2017
+// Update Count     : 2893
 //
 
@@ -114 +114 @@
         } // for
 } // distExt
-
-// There is an ambiguity for inline generic-routine return-types and generic routines.
-//   forall( otype T ) struct S { int i; } bar( T ) {}
-// Does the forall bind to the struct or the routine, and how would it be possible to explicitly specify the binding.
-//   forall( otype T ) struct S { int T; } forall( otype W ) bar( W ) {}
-
-void rebindForall( DeclarationNode * declSpec, DeclarationNode * funcDecl ) {
-        if ( declSpec->type->kind == TypeData::Aggregate ) { // return is aggregate definition
-                funcDecl->type->forall = declSpec->type->aggregate.params; // move forall from aggregate to function type
-                declSpec->type->aggregate.params = nullptr;
-        } // if
-} // rebindForall
 
 bool forall = false;                                                                    // aggregate have one or more forall qualifiers ?
@@ -360 +348 @@
 
 
-// Handle shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string is ambiguous:
-//   .---------.                                matches IF '(' comma_expression ')' statement . (reduce)
-//   if ( C ) S1 else S2
-//   `-----------------'                matches IF '(' comma_expression ')' statement . (shift) ELSE statement */
+// Handle single shift/reduce conflict for dangling else by shifting the ELSE token. For example, this string
+// is ambiguous:
+// .---------.                          matches IF '(' comma_expression ')' statement . (reduce)
+// if ( C ) S1 else S2
+// `-----------------'          matches IF '(' comma_expression ')' statement . (shift) ELSE statement */
 // Similar issues exit with the waitfor statement.
 
@@ -372 +361 @@
 %precedence TIMEOUT     // token precedence for start of TIMEOUT in WAITFOR statement
 %precedence ELSE        // token precedence for start of else clause in IF/WAITFOR statement
-
-// Handle shift/reduce conflict for generic type by shifting the '(' token. For example, this string is ambiguous:
-//   forall( otype T ) struct Foo { T v; };
-//       .-----.                                matches pointer to function returning a generic (which is impossible without a type)
-//   Foo ( *fp )( int );
-//   `---'                                              matches start of TYPEGENname '('
-// Must be:
-// Foo( int ) ( *fp )( int );
-
-// Order of these lines matters (low-to-high precedence).
-%precedence TYPEGENname
-%precedence '('
 
 %locations                      // support location tracking for error messages
@@ -1788 +1765 @@
 
 typegen_name:                                                                                   // CFA
-        TYPEGENname
-                { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
-        | TYPEGENname '(' ')'
+        TYPEGENname '(' ')'
                 { $$ = DeclarationNode::newFromTypeGen( $1, nullptr ); }
         | TYPEGENname '(' type_list ')'
@@ -1834 +1809 @@
                 }
         | aggregate_key attribute_list_opt typegen_name         // CFA
-                {
-                        // Create new generic declaration with same name as previous forward declaration, where the IDENTIFIER is
-                        // switched to a TYPEGENname. Link any generic arguments from typegen_name to new generic declaration and
-                        // delete newFromTypeGen.
-                        $$ = DeclarationNode::newAggregate( $1, $3->type->symbolic.name, $3->type->symbolic.actuals, nullptr, false )->addQualifiers( $2 );
-                        $3->type->symbolic.name = nullptr;
-                        $3->type->symbolic.actuals = nullptr;
-                        delete $3;
-                }
+                { $$ = $3->addQualifiers( $2 ); }
         ;
 
@@ -2413 +2380 @@
         | declaration_specifier function_declarator with_clause_opt compound_statement
                 {
-                        rebindForall( $1, $2 );
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();
@@ -2440 +2406 @@
         | declaration_specifier KR_function_declarator KR_declaration_list_opt with_clause_opt compound_statement
                 {
-                        rebindForall( $1, $2 );
                         typedefTable.addToEnclosingScope( TypedefTable::ID );
                         typedefTable.leaveScope();

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
@@ -82 +81 @@
                 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 <vector>             // for vector
+#include <list>               // for list
 
 #include "Cost.h"             // for Cost
@@ -25 +25 @@
 
 namespace ResolvExpr {
+        struct Alternative;
+
+        typedef std::list< Alternative > AltList;
+
         struct Alternative {
                 Alternative();
@@ -42 +46 @@
                 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, unique_ptr
+#include <memory>                  // for allocator_traits<>::value_type
 #include <utility>                 // for pair
 #include <vector>                  // for vector
@@ -52 +51 @@
 //#define DEBUG_COST
 
-using std::move;
-
-/// copies any copyable type
-template<typename T>
-T copy(const T& x) { return x; }
-
 namespace ResolvExpr {
         Expression *resolveInVoidContext( Expression *expr, const SymTab::Indexer &indexer, TypeEnvironment &env ) {
@@ -186 +179 @@
                 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 );
                 }
@@ -197 +187 @@
                                 printAlts( alternatives, std::cerr );
                         )
-                        AltList pruned;
-                        pruneAlternatives( alternatives.begin(), alternatives.end(), back_inserter( pruned ) );
-                        if ( failFast && pruned.empty() ) {
+                        AltList::iterator oldBegin = alternatives.begin();
+                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ) );
+                        if ( failFast && alternatives.begin() == oldBegin ) {
                                 std::ostringstream stream;
                                 AltList winners;
@@ -209 +199 @@
                                 throw SemanticError( stream.str() );
                         }
-                        alternatives = move(pruned);
+                        alternatives.erase( oldBegin, alternatives.end() );
                         PRINT(
                                 std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
@@ -581 +571 @@
         /// State to iteratively build a match of parameter expressions to arguments
         struct ArgPack {
-                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
-                // TODO fix this somehow
-                std::vector<Alternative> expls;    ///< Exploded actuals left over from last match
-
-                ArgPack()
-                        : parent(0), expr(), cost(Cost::zero), env(), need(), have(), openVars(), nextArg(0),
-                          tupleStart(0), expls() {}
+                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)
 
                 ArgPack(const TypeEnvironment& env, const AssertionSet& need, const AssertionSet& have,
                                 const OpenVarSet& openVars)
-                        : parent(0), expr(), cost(Cost::zero), env(env), need(need), have(have),
-                          openVars(openVars), nextArg(0), tupleStart(0), expls() {}
-
-                ArgPack(std::size_t parent, Expression* expr, TypeEnvironment&& env, AssertionSet&& need,
-                                AssertionSet&& have, OpenVarSet&& openVars, unsigned nextArg,
-                                unsigned tupleStart = 0, Cost cost = Cost::zero,
-                                std::vector<Alternative>&& expls = std::vector<Alternative>{} )
-                        : parent(parent), expr(expr->clone()), cost(cost), env(move(env)), need(move(need)),
-                          have(move(have)), openVars(move(openVars)), nextArg(nextArg), tupleStart(tupleStart),
-                          expls(move(expls)) {}
-
-                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), expls() {}
-
-
-                // ArgPack(const ArgPack& o)
-                //      : parent(o.parent), expr(o.expr ? o.expr->clone() : nullptr), env(o.env),
-                //        need(o.need), have(o.have), openVars(o.openVars), nextArg(o.nextArg),
-                //        tupleStart(o.tupleStart), expls(o.expls) {}
-
-                // ArgPack(ArgPack&&) = default;
+                        : 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);
+                }
 
                 /// Ends a tuple expression, consolidating the appropriate actuals
-                void endTuple( const std::vector<ArgPack>& packs ) {
-                        // add all expressions in tuple to list, summing cost
+                void endTuple() {
+                        // set up new Tuple alternative
                         std::list<Expression*> exprs;
-                        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;
+                        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;
                 }
         };
@@ -644 +621 @@
         /// 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::size_t& genStart, const SymTab::Indexer& indexer, unsigned nTuples = 0 ) {
+                        const std::vector< AlternativeFinder >& args,
+                        std::vector<ArgPack>& results, std::vector<ArgPack>& nextResults,
+                        const SymTab::Indexer& indexer ) {
                 if ( TupleType* tupleType = dynamic_cast<TupleType*>( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr
-                        ++nTuples;
+                        for ( ArgPack& result : results ) { result.beginTuple(); }
                         for ( Type* type : *tupleType ) {
                                 // xxx - dropping initializer changes behaviour from previous, but seems correct
-                                if ( ! instantiateArgument(
-                                                type, nullptr, args, results, genStart, indexer, nTuples ) )
+                                if ( ! instantiateArgument( type, nullptr, args, results, nextResults, indexer ) )
                                         return false;
-                                nTuples = 0;
-                        }
-                        // re-consititute tuples for final generation
-                        for ( auto i = genStart; i < results.size(); ++i ) {
-                                results[i].endTuple( results );
-                        }
+                        }
+                        for ( ArgPack& result : results ) { result.endTuple(); }
                         return true;
                 } else if ( TypeInstType* ttype = Tuples::isTtype( formalType ) ) {
                         // formalType is a ttype, consumes all remaining arguments
                         // xxx - mixing default arguments with variadic??
-
-                        // completed tuples; will be spliced to end of results to finish
-                        std::vector<ArgPack> finalResults{};
-
+                        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;
+                                }
+                        }
                         // iterate until all results completed
-                        std::size_t genEnd;
-                        ++nTuples;
-                        do {
-                                genEnd = results.size();
-
+                        while ( ! results.empty() ) {
                                 // add another argument to results
-                                for ( std::size_t i = genStart; i < genEnd; ++i ) {
-                                        // use remainder of exploded tuple if present
-                                        if ( ! results[i].expls.empty() ) {
-                                                const Alternative& actual = results[i].expls.front();
-
-                                                TypeEnvironment env = results[i].env;
-                                                OpenVarSet openVars = results[i].openVars;
-
-                                                env.addActual( actual.env, openVars );
-
-                                                std::vector<Alternative> newExpls(
-                                                        std::next( results[i].expls.begin() ), results[i].expls.end() );
-                                                results.emplace_back(
-                                                        i, actual.expr, move(env), copy(results[i].need),
-                                                        copy(results[i].have), move(openVars), results[i].nextArg, nTuples,
-                                                        Cost::zero, move(newExpls) );
-
+                                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();
+                                                }
+                                                // 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) );
+                                                }
                                                 continue;
                                         }
 
-                                        // finish result when out of arguments
-                                        if ( results[i].nextArg >= args.size() ) {
-                                                ArgPack newResult{
-                                                        results[i].env, results[i].need, results[i].have,
-                                                        results[i].openVars };
-                                                newResult.nextArg = results[i].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
-                                        auto j = results[i].nextArg;
-                                        for ( const Alternative& actual : args[j] ) {
-                                                // fresh copies of parent parameters for this iteration
-                                                TypeEnvironment env = results[i].env;
-                                                OpenVarSet openVars = results[i].openVars;
-
-                                                env.addActual( actual.env, openVars );
+                                        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 ) );
-                                                if ( exploded.empty() ) {
-                                                        // skip empty tuple arguments by (near-)cloning parent into next gen
-                                                        results.emplace_back(
-                                                                results[i], move(env), copy(results[i].need),
-                                                                copy(results[i].have), move(openVars), j + 1, actual.cost );
-
-                                                        continue;
+
+                                                // add exploded argument to tuple
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr, cost );
+                                                        cost = Cost::zero;
                                                 }
-
-                                                // trim first element from exploded
-                                                std::vector<Alternative> newExpls;
-                                                newExpls.reserve( exploded.size() - 1 );
-                                                for ( std::size_t i = 1; i < exploded.size(); ++i ) {
-                                                        newExpls.push_back( move(exploded[i]) );
-                                                }
-                                                // add new result
-                                                results.emplace_back(
-                                                        i, exploded.front().expr, move(env), copy(results[i].need),
-                                                        copy(results[i].have), move(openVars), results[i].nextArg + 1,
-                                                        nTuples, actual.cost, move(newExpls) );
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
                                         }
                                 }
 
                                 // reset for next round
-                                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();
+                                results.swap( nextResults );
+                                nextResults.clear();
+                        }
+                        results.swap( finalResults );
+                        return ! results.empty();
                 }
 
                 // iterate each current subresult
-                std::size_t genEnd = results.size();
-                for ( std::size_t i = genStart; i < genEnd; ++i ) {
-                        // use remainder of exploded tuple if present
-                        if ( ! results[i].expls.empty() ) {
-                                const Alternative& actual = results[i].expls.front();
-
-                                TypeEnvironment env = results[i].env;
-                                AssertionSet need = results[i].need, have = results[i].have;
-                                OpenVarSet openVars = results[i].openVars;
-
-                                env.addActual( actual.env, openVars );
+                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();
 
@@ -812 +725 @@
                                 )
 
-                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
-                                        std::vector<Alternative> newExpls(
-                                                std::next( results[i].expls.begin() ), results[i].expls.end() );
-                                        results.emplace_back(
-                                                i, actual.expr, move(env), move(need), move(have), move(openVars),
-                                                results[i].nextArg, nTuples, Cost::zero, move(newExpls) );;
+                                if ( unify( formalType, actualType, result.env, result.need, result.have,
+                                                result.openVars, indexer ) ) {
+                                        ++result.nextExpl;
+                                        nextResults.push_back( std::move(result.withArg( actual.expr )) );
                                 }
 
                                 continue;
-                        }
-
-                        // use default initializers if out of arguments
-                        if ( results[i].nextArg >= args.size() ) {
+                        } else if ( result.nextArg >= args.size() ) {
+                                // use default initializers if out of arguments
                                 if ( ConstantExpr* cnstExpr = getDefaultValue( initializer ) ) {
                                         if ( Constant* cnst = dynamic_cast<Constant*>( cnstExpr->get_constant() ) ) {
-                                                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), results[i].nextArg, nTuples );
+                                                if ( unify( formalType, cnst->get_type(), result.env, result.need,
+                                                                result.have, result.openVars, indexer ) ) {
+                                                        nextResults.push_back( std::move(result.withArg( cnstExpr )) );
                                                 }
                                         }
                                 }
-
                                 continue;
                         }
 
                         // Check each possible next argument
-                        auto j = results[i].nextArg;
-                        for ( const Alternative& actual : args[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( actual.env, openVars );
+                        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
@@ -857 +755 @@
                                 Tuples::explode( actual, indexer, back_inserter( exploded ) );
                                 if ( exploded.empty() ) {
-                                        // skip empty tuple arguments by (near-)cloning parent into next gen
-                                        results.emplace_back(
-                                                results[i], move(env), move(need), move(have), move(openVars), j + 1,
-                                                actual.cost );
-
+                                        // skip empty tuple arguments
+                                        ++aResult.nextArg;
+                                        results.push_back( std::move(aResult) );
                                         continue;
                                 }
@@ -878 +774 @@
 
                                 // attempt to unify types
-                                if ( unify( formalType, actualType, env, need, have, openVars, indexer ) ) {
-                                        // trim first element from exploded
-                                        std::vector<Alternative> newExpls;
-                                        newExpls.reserve( exploded.size() - 1 );
-                                        for ( std::size_t i = 1; i < exploded.size(); ++i ) {
-                                                newExpls.push_back( move(exploded[i]) );
+                                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;
                                         }
-                                        // add new result
-                                        results.emplace_back(
-                                                i, aActual.expr, move(env), move(need), move(have), move(openVars),
-                                                j + 1, nTuples, actual.cost, move(newExpls) );
+                                        nextResults.push_back( std::move(aResult) );
                                 }
                         }
@@ -894 +789 @@
 
                 // reset for next parameter
-                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 );
+                results.swap( nextResults );
+                nextResults.clear();
+
+                return ! results.empty();
         }
 
@@ -945 +818 @@
 
                 // iteratively build matches, one parameter at a time
-                std::vector<ArgPack> results;
-                results.push_back( ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } );
-                std::size_t genStart = 0;
-
+                std::vector<ArgPack> results{ ArgPack{ funcEnv, funcNeed, funcHave, funcOpenVars } };
+                std::vector<ArgPack> nextResults{};
                 for ( DeclarationWithType* formal : funcType->get_parameters() ) {
                         ObjectDecl* obj = strict_dynamic_cast< ObjectDecl* >( formal );
                         if ( ! instantiateArgument(
-                                        obj->get_type(), obj->get_init(), args, results, genStart, indexer ) )
+                                        obj->get_type(), obj->get_init(), args, results, nextResults, indexer ) )
                                 return;
                 }
 
+                // filter out results that don't use all the arguments, and aren't variadic
+                std::vector<ArgPack> finalResults{};
                 if ( funcType->get_isVarArgs() ) {
-                        // 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 ) {
-                                        // use remainder of exploded tuple if present
-                                        if ( ! results[i].expls.empty() ) {
-                                                const Alternative& actual = results[i].expls.front();
-
-                                                TypeEnvironment env = results[i].env;
-                                                OpenVarSet openVars = results[i].openVars;
-
-                                                env.addActual( actual.env, openVars );
-
-                                                std::vector<Alternative> newExpls(
-                                                        std::next( results[i].expls.begin() ), results[i].expls.end() );
-                                                results.emplace_back(
-                                                        i, actual.expr, move(env), copy(results[i].need),
-                                                        copy(results[i].have), move(openVars), results[i].nextArg, 0,
-                                                        Cost::zero, move(newExpls) );
-
+                        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) );
                                                 continue;
                                         }
 
-                                        // finish result when out of arguments
-                                        if ( results[i].nextArg >= args.size() ) {
-                                                validateFunctionAlternative( func, results[i], results, out );
-
-                                                continue;
-                                        }
-
                                         // add each possible next argument
-                                        auto j = results[i].nextArg;
-                                        for ( const Alternative& actual : args[j] ) {
-                                                // fresh copies of parent parameters for this iteration
-                                                TypeEnvironment env = results[i].env;
-                                                OpenVarSet openVars = results[i].openVars;
-
-                                                env.addActual( actual.env, openVars );
+                                        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 ) );
-                                                if ( exploded.empty() ) {
-                                                        // skip empty tuple arguments by (near-)cloning parent into next gen
-                                                        results.emplace_back(
-                                                                results[i], move(env), copy(results[i].need),
-                                                                copy(results[i].have), move(openVars), j + 1, actual.cost );
-                                                        continue;
+
+                                                // add exploded argument to arg list
+                                                for ( Alternative& aActual : exploded ) {
+                                                        aResult.withArg( aActual.expr, cost );
+                                                        cost = Cost::zero;
                                                 }
-
-                                                // trim first element from exploded
-                                                std::vector<Alternative> newExpls;
-                                                newExpls.reserve( exploded.size() - 1 );
-                                                for ( std::size_t i = 1; i < exploded.size(); ++i ) {
-                                                        newExpls.push_back( move(exploded[i]) );
-                                                }
-                                                // add new result
-                                                results.emplace_back(
-                                                        i, exploded.front().expr, move(env), copy(results[i].need),
-                                                        copy(results[i].have), move(openVars), j + 1, 0,
-                                                        actual.cost, move(newExpls) );
+                                                ++aResult.nextArg;
+                                                nextResults.push_back( std::move(aResult) );
                                         }
                                 }
 
-                                genStart = genEnd;
-                        } while ( genEnd != results.size() );
+                                // reset for next round
+                                results.swap( nextResults );
+                                nextResults.clear();
+                        }
                 } else {
                         // filter out results that don't use all the arguments
-                        for ( std::size_t i = genStart; i < results.size(); ++i ) {
-                                ArgPack& result = results[i];
-                                if ( result.expls.empty() && result.nextArg >= args.size() ) {
-                                        validateFunctionAlternative( func, result, results, out );
-                                }
-                        }
+                        for ( ArgPack& result : results ) {
+                                if ( result.nextExpl >= result.expls.size() && result.nextArg >= args.size() ) {
+                                        finalResults.push_back( std::move(result) );
+                                }
+                        }
+                }
+
+                // 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 );
                 }
         }
@@ -1096 +956 @@
                 if ( ! funcOpFinder.alternatives.empty() ) {
                         // add function alternatives to front of argument list
-                        argAlternatives.insert( argAlternatives.begin(), move(funcFinder) );
+                        argAlternatives.insert( argAlternatives.begin(), std::move(funcFinder) );
 
                         for ( AltList::iterator funcOp = funcOpFinder.alternatives.begin();
@@ -1122 +982 @@
 
                 // compute conversionsion costs
-                for ( Alternative& withFunc : candidates ) {
-                        Cost cvtCost = computeApplicationConversionCost( withFunc, indexer );
+                for ( AltList::iterator withFunc = candidates.begin(); withFunc != candidates.end(); ++withFunc ) {
+                        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() );
@@ -1135 +995 @@
                                 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 = move(alternatives);
+                candidates.clear();
+                candidates.splice( candidates.end(), alternatives );
 
                 // use a new list so that alternatives are not examined by addAnonConversions twice.
@@ -1150 +1011 @@
                 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 implicitconversions 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 implicit
+                // conversions to each of the anonymous members, must happen after findMinCost since anon conversions
+                // are never the cheapest expression
                 for ( const Alternative & alt : winners ) {
                         addAnonConversions( alt );
                 }
-                spliceBegin( alternatives, winners );
+                alternatives.splice( alternatives.begin(), winners );
 
                 if ( alternatives.empty() && targetType && ! targetType->isVoid() ) {
@@ -1180 +1041 @@
                 AlternativeFinder finder( indexer, env );
                 finder.find( addressExpr->get_arg() );
-                for ( Alternative& alt : finder.alternatives ) {
-                        if ( isLvalue( alt.expr ) ) {
-                                alternatives.push_back(
-                                        Alternative{ new AddressExpr( alt.expr->clone() ), alt.env, alt.cost } );
+                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 ) );
                         } // if
                 } // for
@@ -1189 +1049 @@
 
         void AlternativeFinder::visit( LabelAddressExpr * expr ) {
-                alternatives.push_back( Alternative{ expr->clone(), env, Cost::zero } );
+                alternatives.push_back( Alternative( expr->clone(), env, Cost::zero) );
         }
 
@@ -1231 +1091 @@
 
                 AltList candidates;
-                for ( Alternative & alt : finder.alternatives ) {
+                for ( std::list< Alternative >::iterator i = finder.alternatives.begin(); i != finder.alternatives.end(); ++i ) {
                         AssertionSet needAssertions, haveAssertions;
                         OpenVarSet openVars;
@@ -1239 +1099 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = alt.expr->get_result()->size() - castExpr->get_result()->size();
+                        int discardedValues = i->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(), 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;
-                        )
+                        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 );
                         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( alt.expr->clone(), toType ), alt.env,
-                                        alt.cost, thisCost );
-                                inferParameters( needAssertions, haveAssertions, newAlt, openVars,
-                                        back_inserter( candidates ) );
+                                Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
+                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
                         } // if
                 } // for
@@ -1549 +1397 @@
 
         void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
-                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< 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::list< Expression * > exprs;
-                        makeExprList( alts, exprs );
+                        makeExprList( *i, exprs );
 
                         TypeEnvironment compositeEnv;
-                        simpleCombineEnvironments( alts.begin(), alts.end(), compositeEnv );
-                        alternatives.push_back(
-                                Alternative{ new TupleExpr( exprs ), compositeEnv, sumCost( alts ) } );
+                        simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
+                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
                 } // for
         }

src/ResolvExpr/AlternativeFinder.h

@@ -31 +31 @@
 
 namespace ResolvExpr {
-        struct ArgPack;
-
         class AlternativeFinder : public Visitor {
           public:
@@ -38 +36 @@
 
                 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();
@@ -56 +54 @@
                 AlternativeFinder& operator= ( AlternativeFinder&& o ) {
                         if (&o == this) return *this;
-
+                        
                         // horrific nasty hack to rebind references...
                         alternatives.~AltList();
@@ -128 +126 @@
                 /// 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 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 std::vector< AlternativeFinder >& 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/Resolver.cc

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

@@ -16 +16 @@
 #pragma once
 
-#include <vector>
-
 #include "SynTree/SynTree.h"
 #include "SynTree/Type.h"
@@ -30 +28 @@
         void combos( InputIterator begin, InputIterator end, OutputIterator out ) {
                 typedef typename InputIterator::value_type SetType;
-                typedef typename std::vector< typename SetType::value_type > ListType;
+                typedef typename std::list< typename SetType::value_type > ListType;
 
                 if ( begin == end )     {
@@ -40 +38 @@
                 begin++;
 
-                std::vector< ListType > recursiveResult;
+                std::list< ListType > recursiveResult;
                 combos( begin, end, back_inserter( recursiveResult ) );
 
-                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;
-                }
+                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
         }
 

src/SymTab/Autogen.cc

@@ -62 +62 @@
                 void previsit( FunctionDecl * functionDecl );
 
+                void previsit( FunctionType * ftype );
+                void previsit( PointerType * ptype );
+
                 void previsit( CompoundStmt * compoundStmt );
 
@@ -69 +72 @@
                 unsigned int functionNesting = 0;     // current level of nested functions
 
+                InitTweak::ManagedTypes managedTypes;
                 std::vector< FuncData > data;
         };
@@ -618 +622 @@
         // generate ctor/dtors/assign for typedecls, e.g., otype T = int *;
         void AutogenerateRoutines::previsit( TypeDecl * typeDecl ) {
+                visit_children = false;
                 if ( ! typeDecl->base ) return;
 
@@ -623 +628 @@
                 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;
         }
 
@@ -631 +645 @@
         }
 
-        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.
+        void AutogenerateRoutines::previsit( FunctionDecl * functionDecl ) {
+                visit_children = false;
+                // record the existence of this function as appropriate
+                managedTypes.handleDWT( functionDecl );
+
+                maybeAccept( functionDecl->type, *visitor );
                 functionNesting += 1;
-                GuardAction( [this]()  { functionNesting -= 1; } );
+                maybeAccept( functionDecl->statements, *visitor );
+                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, Type * addCast = nullptr, bool forward = true );
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast = false, 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, Type * addCast = nullptr ) {
+        Statement * genScalarCall( InitTweak::InitExpander & srcParam, Expression * dstParam, std::string fname, OutputIterator out, Type * type, bool addCast = false ) {
                 bool isReferenceCtorDtor = false;
                 if ( dynamic_cast< ReferenceType * >( type ) && CodeGen::isCtorDtor( fname ) ) {
@@ -68 +68 @@
                         fname = "?=?";
                         dstParam = new AddressExpr( dstParam );
-                        addCast = nullptr;
+                        addCast = false;
                         isReferenceCtorDtor = true;
                 }
@@ -83 +83 @@
                         // remove lvalue as a qualifier, this can change to
                         //   type->get_qualifiers() = Type::Qualifiers();
-                        Type * castType = addCast->clone();
+                        assert( type );
+                        Type * castType = type->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
@@ -114 +115 @@
         /// 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, Type * addCast = nullptr, bool forward = true ) {
+        void genArrayCall( InitTweak::InitExpander & srcParam, Expression *dstParam, const std::string & fname, OutputIterator out, ArrayType *array, bool addCast = false, 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 ( addCast ) {
-                        // peel off array layer from cast
-                        ArrayType * at = strict_dynamic_cast< ArrayType * >( addCast );
-                        addCast = at->base;
-                }
+                if ( ! array->get_dimension() ) return ;
 
                 Expression * begin, * end, * update, * cmp;
@@ -176 +171 @@
 
         template< typename OutputIterator >
-        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, Type * addCast, bool forward ) {
+        Statement * genCall( InitTweak::InitExpander & srcParam, Expression * dstParam, const std::string & fname, OutputIterator out, Type * type, bool addCast, bool forward ) {
                 if ( ArrayType * at = dynamic_cast< ArrayType * >( type ) ) {
                         genArrayCall( srcParam, dstParam, fname, out, at, addCast, forward );
@@ -196 +191 @@
                 if ( isUnnamedBitfield( obj ) ) return;
 
-                Type * addCast = nullptr;
-                if ( (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) ) ) {
-                        assert( dstParam->result );
-                        addCast = dstParam->result;
-                }
+                bool addCast = (fname == "?{}" || fname == "^?{}") && ( !obj || ( obj && ! obj->get_bitfieldWidth() ) );
                 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, public WithGuards {
+        struct LinkReferenceToTypes final : public WithIndexer {
                 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:
@@ -152 +147 @@
                 ForwardStructsType forwardStructs;
                 ForwardUnionsType forwardUnions;
-                /// true if currently in a generic type body, so that type parameter instances can be renamed appropriately
-                bool inGeneric = false;
         };
 
@@ -430 +423 @@
         }
 
-        void checkGenericParameters( ReferenceToType * inst ) {
-                for ( Expression * param : inst->parameters ) {
-                        if ( ! dynamic_cast< TypeExpr * >( param ) ) {
-                                throw SemanticError( "Expression parameters for generic types are currently unsupported: ", inst );
-                        }
-                }
-        }
-
         void LinkReferenceToTypes::postvisit( StructInstType *structInst ) {
                 StructDecl *st = local_indexer->lookupStruct( structInst->get_name() );
@@ -449 +434 @@
                         forwardStructs[ structInst->get_name() ].push_back( structInst );
                 } // if
-                checkGenericParameters( structInst );
         }
 
@@ -462 +446 @@
                         forwardUnions[ unionInst->get_name() ].push_back( unionInst );
                 } // if
-                checkGenericParameters( unionInst );
         }
 
@@ -542 +525 @@
                 // need to carry over the 'sized' status of each decl in the instance
                 for ( auto p : group_iterate( traitDecl->get_parameters(), traitInst->get_parameters() ) ) {
-                        TypeExpr * expr = dynamic_cast< TypeExpr * >( std::get<1>(p) );
-                        if ( ! expr ) {
-                                throw SemanticError( "Expression parameters for trait instances are currently unsupported: ", std::get<1>(p) );
-                        }
+                        TypeExpr * expr = strict_dynamic_cast< TypeExpr * >( std::get<1>(p) );
                         if ( TypeInstType * inst = dynamic_cast< TypeInstType * >( expr->get_type() ) ) {
                                 TypeDecl * formalDecl = std::get<0>(p);
@@ -566 +546 @@
                         } // if
                 } // if
-        }
-
-        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 );
         }
 
@@ -621 +575 @@
 
         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

@@ -324 +324 @@
                         return makeSub( refType->get_base() );
                 } else if ( StructInstType * aggInst = dynamic_cast< StructInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else if ( UnionInstType * aggInst = dynamic_cast< UnionInstType * >( t ) ) {
-                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->parameters.begin() );
+                        return TypeSubstitution( aggInst->get_baseParameters()->begin(), aggInst->get_baseParameters()->end(), aggInst->get_parameters().begin() );
                 } else {
                         assertf( false, "makeSub expects struct or union type for aggregate, but got: %s", toString( t ).c_str() );

src/Tuples/TupleAssignment.cc

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

src/benchmark/Makefile.am

@@ -24 +24 @@
 repeats  = 30
 TIME_FORMAT = "%E"
-PRINT_FORMAT = %20s: #Comments needed for spacing
+PRINT_FORMAT = '%20s\t'
 
 .NOTPARALLEL:
@@ -217 +217 @@
 
 compile-array$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c
 
 compile-attributes$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c
 
 compile-empty$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c
 
 compile-expression$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c
 
 compile-io$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c
 
 compile-monitor$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c              @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c
 
 compile-operators$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c
 
 compile-thread$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c
 
 compile-typeof$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
-
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c
+

src/benchmark/Makefile.in

@@ -254 +254 @@
 repeats = 30
 TIME_FORMAT = "%E"
-PRINT_FORMAT = %20s: #Comments needed for spacing
+PRINT_FORMAT = '%20s\t'
 all: all-am
 
@@ -623 +623 @@
 
 compile-array$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c                @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/array.c
 
 compile-attributes$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/attributes.c
 
 compile-empty$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c         @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w compile/empty.c
 
 compile-expression$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/expression.c
 
 compile-io$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c                   @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/io.c
 
 compile-monitor$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c              @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/monitor.c
 
 compile-operators$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c    @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/operators.c
 
 compile-thread$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/thread.c
 
 compile-typeof$(EXEEXT):
-        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c               @CFA_FLAGS@ ${AM_CFLAGS} ${CFLAGS} ${ccflags}
+        @${CC} -nodebug -quiet -fsyntax-only -w ../tests/typeof.c
 
 # Tell versions [3.59,3.63) of GNU make to not export all variables.

src/tests/.expect/castError.txt

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