Changeset 1f44196 for src/ResolvExpr/AlternativeFinder.cc

Timestamp:

Nov 29, 2016, 3:30:59 PM (9 years ago)

Author:

Peter A. Buhr <pabuhr@…>

Branches:

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

Children:

8e5724e

Parents:

3a2128f (diff), 9129a84 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge branch 'master' of plg2:software/cfa/cfa-cc

Conflicts:

src/Parser/parser.cc

File:

• src/ResolvExpr/AlternativeFinder.cc (modified) (31 diffs)

src/ResolvExpr/AlternativeFinder.cc

@@ -38 +38 @@
 #include "SynTree/TypeSubstitution.h"
 #include "SymTab/Validate.h"
-#include "Tuples/TupleAssignment.h"
-#include "Tuples/NameMatcher.h"
+#include "Tuples/Tuples.h"
+#include "Tuples/Explode.h"
 #include "Common/utility.h"
 #include "InitTweak/InitTweak.h"
+#include "InitTweak/GenInit.h"
 #include "ResolveTypeof.h"
 
@@ -64 +65 @@
         }
 
+        Cost sumCost( const AltList &in ) {
+                Cost total;
+                for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
+                        total += i->cost;
+                }
+                return total;
+        }
+
         namespace {
                 void printAlts( const AltList &list, std::ostream &os, int indent = 0 ) {
@@ -76 +85 @@
                                 out.push_back( i->expr->clone() );
                         }
-                }
-
-                Cost sumCost( const AltList &in ) {
-                        Cost total;
-                        for ( AltList::const_iterator i = in.begin(); i != in.end(); ++i ) {
-                                total += i->cost;
-                        }
-                        return total;
                 }
 
@@ -101 +102 @@
                                 PruneStruct current( candidate );
                                 std::string mangleName;
-                                for ( std::list< Type* >::const_iterator retType = candidate->expr->get_results().begin(); retType != candidate->expr->get_results().end(); ++retType ) {
-                                        Type *newType = (*retType)->clone();
+                                {
+                                        Type * newType = candidate->expr->get_result()->clone();
                                         candidate->env.apply( newType );
-                                        mangleName += SymTab::Mangler::mangle( newType );
+                                        mangleName = SymTab::Mangler::mangle( newType );
                                         delete newType;
                                 }
@@ -133 +134 @@
                                 if ( ! target->second.isAmbiguous ) {
                                         Alternative &alt = *target->second.candidate;
-                                        for ( std::list< Type* >::iterator result = alt.expr->get_results().begin(); result != alt.expr->get_results().end(); ++result ) {
-                                                alt.env.applyFree( *result );
-                                        }
+                                        alt.env.applyFree( alt.expr->get_result() );
                                         *out++ = alt;
                                 }
                         }
-
-                }
-
-                template< typename InputIterator, typename OutputIterator >
-                void findMinCost( InputIterator begin, InputIterator end, OutputIterator out ) {
-                        AltList alternatives;
-
-                        // select the alternatives that have the minimum parameter cost
-                        Cost minCost = Cost::infinity;
-                        for ( AltList::iterator i = begin; i != end; ++i ) {
-                                if ( i->cost < minCost ) {
-                                        minCost = i->cost;
-                                        i->cost = i->cvtCost;
-                                        alternatives.clear();
-                                        alternatives.push_back( *i );
-                                } else if ( i->cost == minCost ) {
-                                        i->cost = i->cvtCost;
-                                        alternatives.push_back( *i );
-                                }
-                        }
-                        std::copy( alternatives.begin(), alternatives.end(), out );
-                }
-
-                template< typename InputIterator >
-                void simpleCombineEnvironments( InputIterator begin, InputIterator end, TypeEnvironment &result ) {
-                        while ( begin != end ) {
-                                result.simpleCombine( (*begin++).env );
-                        }
                 }
 
                 void renameTypes( Expression *expr ) {
-                        for ( std::list< Type* >::iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
-                                (*i)->accept( global_renamer );
-                        }
+                        expr->get_result()->accept( global_renamer );
                 }
         }
@@ -204 +173 @@
                 for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
                         if ( adjust ) {
-                                adjustExprTypeList( i->expr->get_results().begin(), i->expr->get_results().end(), i->env, indexer );
+                                adjustExprType( i->expr->get_result(), i->env, indexer );
                         }
                 }
@@ -240 +209 @@
         }
 
+        // std::unordered_map< Expression *, UniqueExpr * > ;
+
         template< typename StructOrUnionType >
-        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, const std::string &name ) {
+        void AlternativeFinder::addAggMembers( StructOrUnionType *aggInst, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+                // by this point, member must be a name expr
+                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
+                const std::string & name = nameExpr->get_name();
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -254 +228 @@
         }
 
+        void AlternativeFinder::addTupleMembers( TupleType * tupleType, Expression *expr, const Cost &newCost, const TypeEnvironment & env, Expression * member ) {
+                if ( ConstantExpr * constantExpr = dynamic_cast< ConstantExpr * >( member ) ) {
+                        // get the value of the constant expression as an int, must be between 0 and the length of the tuple type to have meaning
+                        // xxx - this should be improved by memoizing the value of constant exprs
+                        // during parsing and reusing that information here.
+                        std::stringstream ss( constantExpr->get_constant()->get_value() );
+                        int val;
+                        std::string tmp;
+                        if ( ss >> val && ! (ss >> tmp) ) {
+                                if ( val >= 0 && (unsigned int)val < tupleType->size() ) {
+                                        alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                                } // if
+                        } // if
+                } else if ( NameExpr * nameExpr = dynamic_cast< NameExpr * >( member ) ) {
+                        // xxx - temporary hack until 0/1 are int constants
+                        if ( nameExpr->get_name() == "0" || nameExpr->get_name() == "1" ) {
+                                std::stringstream ss( nameExpr->get_name() );
+                                int val;
+                                ss >> val;
+                                alternatives.push_back( Alternative( new TupleIndexExpr( expr->clone(), val ), env, newCost ) );
+                        }
+                } // if
+        }
+
         void AlternativeFinder::visit( ApplicationExpr *applicationExpr ) {
                 alternatives.push_back( Alternative( applicationExpr->clone(), env, Cost::zero ) );
@@ -259 +257 @@
 
         Cost computeConversionCost( Alternative &alt, const SymTab::Indexer &indexer ) {
-                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( alt.expr );
-                assert( appExpr );
-                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
-                assert( pointer );
-                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
-                assert( function );
+                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( alt.expr );
+                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
 
                 Cost convCost( 0, 0, 0 );
@@ -270 +265 @@
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
                 std::list< Expression* >& actuals = appExpr->get_args();
+
+                std::list< Type * > formalTypes;
+                std::list< Type * >::iterator formalType = formalTypes.end();
+
                 for ( std::list< Expression* >::iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
+
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                printAll( (*actualExpr)->get_results(), std::cerr, 8 );
+                                (*actualExpr)->get_result()->print( std::cerr, 8 );
                         )
                         std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
-                        for ( std::list< Type* >::iterator actual = (*actualExpr)->get_results().begin(); actual != (*actualExpr)->get_results().end(); ++actual ) {
-                                if ( formal == formals.end() ) {
-                                        if ( function->get_isVarArgs() ) {
-                                                convCost += Cost( 1, 0, 0 );
-                                                break;
-                                        } else {
-                                                return Cost::infinity;
+                        std::list< Type * > flatActualTypes;
+                        flatten( (*actualExpr)->get_result(), back_inserter( flatActualTypes ) );
+                        for ( std::list< Type* >::iterator actualType = flatActualTypes.begin(); actualType != flatActualTypes.end(); ++actualType ) {
+
+
+                                // tuple handling code
+                                if ( formalType == formalTypes.end() ) {
+                                        // the type of the formal parameter may be a tuple type. To make this easier to work with,
+                                        // flatten the tuple type and traverse the resulting list of types, incrementing the formal
+                                        // iterator once its types have been extracted. Once a particular formal parameter's type has
+                                        // been exhausted load the next formal parameter's type.
+                                        if ( formal == formals.end() ) {
+                                                if ( function->get_isVarArgs() ) {
+                                                        convCost += Cost( 1, 0, 0 );
+                                                        break;
+                                                } else {
+                                                        return Cost::infinity;
+                                                }
                                         }
+                                        formalTypes.clear();
+                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
+                                        formalType = formalTypes.begin();
+                                        ++formal;
                                 }
+
                                 PRINT(
                                         std::cerr << std::endl << "converting ";
-                                        (*actual)->print( std::cerr, 8 );
+                                        (*actualType)->print( std::cerr, 8 );
                                         std::cerr << std::endl << " to ";
                                         (*formal)->get_type()->print( std::cerr, 8 );
                                 )
-                                Cost newCost = conversionCost( *actual, (*formal)->get_type(), indexer, alt.env );
+                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
                                 PRINT(
                                         std::cerr << std::endl << "cost is" << newCost << std::endl;
@@ -305 +321 @@
                                 actualCost += newCost;
 
-                                convCost += Cost( 0, polyCost( (*formal)->get_type(), alt.env, indexer ) + polyCost( *actual, alt.env, indexer ), 0 );
-
-                                formal++;
+                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
+
+                                formalType++;
                         }
                         if ( actualCost != Cost( 0, 0, 0 ) ) {
@@ -356 +372 @@
         /// Adds type variables to the open variable set and marks their assertions
         void makeUnifiableVars( Type *type, OpenVarSet &unifiableVars, AssertionSet &needAssertions ) {
-                for ( std::list< TypeDecl* >::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
+                for ( Type::ForallList::const_iterator tyvar = type->get_forall().begin(); tyvar != type->get_forall().end(); ++tyvar ) {
                         unifiableVars[ (*tyvar)->get_name() ] = (*tyvar)->get_kind();
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
@@ -365 +381 @@
         }
 
-        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, /*const*/ AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave ) {
+        /// instantiate a single argument by matching actuals from [actualIt, actualEnd) against formalType,
+        /// producing expression(s) in out and their total cost in cost.
+        template< typename AltIterator, typename OutputIterator >
+        bool instantiateArgument( Type * formalType, Initializer * defaultValue, AltIterator & actualIt, AltIterator actualEnd, OpenVarSet & openVars, TypeEnvironment & resultEnv, AssertionSet & resultNeed, AssertionSet & resultHave, const SymTab::Indexer & indexer, Cost & cost, OutputIterator out ) {
+                if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
+                        // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
+                        TupleExpr * tupleExpr = new TupleExpr();
+                        for ( Type * type : *tupleType ) {
+                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
+                                        delete tupleExpr;
+                                        return false;
+                                }
+                        }
+                        tupleExpr->set_result( Tuples::makeTupleType( tupleExpr->get_exprs() ) );
+                        *out++ = tupleExpr;
+                } else if ( actualIt != actualEnd ) {
+                        // both actualType and formalType are atomic (non-tuple) types - if they unify
+                        // then accept actual as an argument, otherwise return false (fail to instantiate argument)
+                        Expression * actual = actualIt->expr;
+                        Type * actualType = actual->get_result();
+                        PRINT(
+                                std::cerr << "formal type is ";
+                                formalType->print( std::cerr );
+                                std::cerr << std::endl << "actual type is ";
+                                actualType->print( std::cerr );
+                                std::cerr << std::endl;
+                        )
+                        if ( ! unify( formalType, actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                return false;
+                        }
+                        // move the expression from the alternative to the output iterator
+                        *out++ = actual;
+                        actualIt->expr = nullptr;
+                        cost += actualIt->cost;
+                        ++actualIt;
+                } else {
+                        // End of actuals - Handle default values
+                        if ( SingleInit *si = dynamic_cast<SingleInit *>( defaultValue )) {
+                                // so far, only constant expressions are accepted as default values
+                                if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) ) {
+                                        if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) ) {
+                                                if ( unify( formalType, cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                                        // xxx - Don't know if this is right
+                                                        *out++ = cnstexpr->clone();
+                                                        return true;
+                                                } // if
+                                        } // if
+                                } // if
+                        } // if
+                        return false;
+                } // if
+                return true;
+        }
+
+        bool AlternativeFinder::instantiateFunction( std::list< DeclarationWithType* >& formals, const AltList &actuals, bool isVarArgs, OpenVarSet& openVars, TypeEnvironment &resultEnv, AssertionSet &resultNeed, AssertionSet &resultHave, AltList & out ) {
                 simpleCombineEnvironments( actuals.begin(), actuals.end(), resultEnv );
                 // make sure we don't widen any existing bindings
@@ -373 +443 @@
                 resultEnv.extractOpenVars( openVars );
 
-                /*
-                  Tuples::NameMatcher matcher( formals );
-                  try {
-                  matcher.match( actuals );
-                  } catch ( Tuples::NoMatch &e ) {
-                  std::cerr << "Alternative doesn't match: " << e.message << std::endl;
-                  }
-                */
-                std::list< DeclarationWithType* >::iterator formal = formals.begin();
-                for ( AltList::const_iterator actualExpr = actuals.begin(); actualExpr != actuals.end(); ++actualExpr ) {
-                        for ( std::list< Type* >::iterator actual = actualExpr->expr->get_results().begin(); actual != actualExpr->expr->get_results().end(); ++actual ) {
-                                if ( formal == formals.end() ) {
-                                        return isVarArgs;
-                                }
-                                PRINT(
-                                        std::cerr << "formal type is ";
-                                        (*formal)->get_type()->print( std::cerr );
-                                        std::cerr << std::endl << "actual type is ";
-                                        (*actual)->print( std::cerr );
-                                        std::cerr << std::endl;
-                                )
-                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                        return false;
-                                }
-                                formal++;
-                        }
-                }
-                // Handling of default values
-                while ( formal != formals.end() ) {
-                        if ( ObjectDecl *od = dynamic_cast<ObjectDecl *>( *formal ) )
-                                if ( SingleInit *si = dynamic_cast<SingleInit *>( od->get_init() ))
-                                        // so far, only constant expressions are accepted as default values
-                                        if ( ConstantExpr *cnstexpr = dynamic_cast<ConstantExpr *>( si->get_value()) )
-                                                if ( Constant *cnst = dynamic_cast<Constant *>( cnstexpr->get_constant() ) )
-                                                        if ( unify( (*formal)->get_type(), cnst->get_type(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                                                // XXX Don't know if this is right
-                                                                actuals.push_back( Alternative( cnstexpr->clone(), env, Cost::zero ) );
-                                                                formal++;
-                                                                if ( formal == formals.end()) break;
-                                                        }
-                        return false;
+                // flatten actuals so that each actual has an atomic (non-tuple) type
+                AltList exploded;
+                Tuples::explode( actuals, indexer, back_inserter( exploded ) );
+
+                AltList::iterator actualExpr = exploded.begin();
+                AltList::iterator actualEnd = exploded.end();
+                for ( DeclarationWithType * formal : formals ) {
+                        // match flattened actuals with formal parameters - actuals will be grouped to match
+                        // with formals as appropriate
+                        Cost cost;
+                        std::list< Expression * > newExprs;
+                        ObjectDecl * obj = safe_dynamic_cast< ObjectDecl * >( formal );
+                        if ( ! instantiateArgument( obj->get_type(), obj->get_init(), actualExpr, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( newExprs ) ) ) {
+                                deleteAll( newExprs );
+                                return false;
+                        }
+                        // success - produce argument as a new alternative
+                        assert( newExprs.size() == 1 );
+                        out.push_back( Alternative( newExprs.front(), resultEnv, cost ) );
+                }
+                if ( actualExpr != actualEnd ) {
+                        // there are still actuals remaining, but we've run out of formal parameters to match against
+                        // this is okay only if the function is variadic
+                        if ( ! isVarArgs ) {
+                                return false;
+                        }
+                        out.splice( out.end(), exploded, actualExpr, actualEnd );
                 }
                 return true;
@@ -500 +556 @@
                                 //if ( newNeedParents[ curDecl->get_uniqueId() ][ candDecl->get_uniqueId() ]++ > recursionParentLimit ) continue;
                                 Expression *varExpr = new VariableExpr( candDecl );
-                                deleteAll( varExpr->get_results() );
-                                varExpr->get_results().clear();
-                                varExpr->get_results().push_front( adjType->clone() );
+                                delete varExpr->get_result();
+                                varExpr->set_result( adjType->clone() );
                                 PRINT(
                                         std::cerr << "satisfying assertion " << curDecl->get_uniqueId() << " ";
@@ -545 +600 @@
 
         template< typename OutputIterator >
-        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, AltList &actualAlt, OutputIterator out ) {
+        void AlternativeFinder::makeFunctionAlternatives( const Alternative &func, FunctionType *funcType, const AltList &actualAlt, OutputIterator out ) {
                 OpenVarSet openVars;
                 AssertionSet resultNeed, resultHave;
                 TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
-                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave ) ) {
+                AltList instantiatedActuals; // filled by instantiate function
+                if ( instantiateFunction( funcType->get_parameters(), actualAlt, funcType->get_isVarArgs(), openVars, resultEnv, resultNeed, resultHave, instantiatedActuals ) ) {
                         ApplicationExpr *appExpr = new ApplicationExpr( func.expr->clone() );
-                        Alternative newAlt( appExpr, resultEnv, sumCost( actualAlt ) );
-                        makeExprList( actualAlt, appExpr->get_args() );
+                        Alternative newAlt( appExpr, resultEnv, sumCost( instantiatedActuals ) );
+                        makeExprList( instantiatedActuals, appExpr->get_args() );
                         PRINT(
                                 std::cerr << "need assertions:" << std::endl;
@@ -574 +630 @@
                                 PointerType pt( Type::Qualifiers(), v.clone() );
                                 UntypedExpr *vexpr = untypedExpr->clone();
-                                vexpr->get_results().push_front( pt.clone() );
+                                vexpr->set_result( pt.clone() );
                                 alternatives.push_back( Alternative( vexpr, env, Cost()) );
                                 return;
@@ -587 +643 @@
                 combos( argAlternatives.begin(), argAlternatives.end(), back_inserter( possibilities ) );
 
-                Tuples::TupleAssignSpotter tassign( this );
-                if ( tassign.isTupleAssignment( untypedExpr, possibilities ) ) {
-                        // take care of possible tuple assignments, or discard expression
-                        return;
-                } // else ...
+                // take care of possible tuple assignments
+                // if not tuple assignment, assignment is taken care of as a normal function call
+                Tuples::handleTupleAssignment( *this, untypedExpr, possibilities );
 
                 AltList candidates;
@@ -604 +658 @@
                                 // check if the type is pointer to function
                                 PointerType *pointer;
-                                if ( func->expr->get_results().size() == 1 && ( pointer = dynamic_cast< PointerType* >( func->expr->get_results().front() ) ) ) {
+                                if ( ( pointer = dynamic_cast< PointerType* >( func->expr->get_result() ) ) ) {
                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -640 +694 @@
                                                 // check if the type is pointer to function
                                                 PointerType *pointer;
-                                                if ( funcOp->expr->get_results().size() == 1
-                                                        && ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_results().front() ) ) ) {
+                                                if ( ( pointer = dynamic_cast< PointerType* >( funcOp->expr->get_result() ) ) ) {
                                                         if ( FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() ) ) {
                                                                 for ( std::list< AltList >::iterator actualAlt = possibilities.begin(); actualAlt != possibilities.end(); ++actualAlt ) {
@@ -665 +718 @@
 
                         PRINT(
-                                ApplicationExpr *appExpr = dynamic_cast< ApplicationExpr* >( withFunc->expr );
-                                assert( appExpr );
-                                PointerType *pointer = dynamic_cast< PointerType* >( appExpr->get_function()->get_results().front() );
-                                assert( pointer );
-                                FunctionType *function = dynamic_cast< FunctionType* >( pointer->get_base() );
-                                assert( function );
+                                ApplicationExpr *appExpr = safe_dynamic_cast< ApplicationExpr* >( withFunc->expr );
+                                PointerType *pointer = safe_dynamic_cast< PointerType* >( appExpr->get_function()->get_result() );
+                                FunctionType *function = safe_dynamic_cast< FunctionType* >( pointer->get_base() );
                                 std::cerr << "Case +++++++++++++" << std::endl;
                                 std::cerr << "formals are:" << std::endl;
@@ -692 +742 @@
 
         bool isLvalue( Expression *expr ) {
-                for ( std::list< Type* >::const_iterator i = expr->get_results().begin(); i != expr->get_results().end(); ++i ) {
-                        if ( !(*i)->get_isLvalue() ) return false;
-                } // for
-                return true;
+                // xxx - recurse into tuples?
+                return expr->has_result() && expr->get_result()->get_isLvalue();
         }
 
@@ -709 +757 @@
 
         void AlternativeFinder::visit( CastExpr *castExpr ) {
-                for ( std::list< Type* >::iterator i = castExpr->get_results().begin(); i != castExpr->get_results().end(); ++i ) {
-                        *i = resolveTypeof( *i, indexer );
-                        SymTab::validateType( *i, &indexer );
-                        adjustExprType( *i, env, indexer );
-                } // for
+                Type *& toType = castExpr->get_result();
+                toType = resolveTypeof( toType, indexer );
+                SymTab::validateType( toType, &indexer );
+                adjustExprType( toType, env, indexer );
 
                 AlternativeFinder finder( indexer, env );
@@ -727 +774 @@
                         // that are cast directly.  The candidate is invalid if it has fewer results than there are types to cast
                         // to.
-                        int discardedValues = (*i).expr->get_results().size() - castExpr->get_results().size();
+                        int discardedValues = (*i).expr->get_result()->size() - castExpr->get_result()->size();
                         if ( discardedValues < 0 ) continue;
-                        std::list< Type* >::iterator candidate_end = (*i).expr->get_results().begin();
-                        std::advance( candidate_end, castExpr->get_results().size() );
+                        // xxx - may need to go into tuple types and extract relavent types and use unifyList
                         // unification run for side-effects
-                        unifyList( castExpr->get_results().begin(), castExpr->get_results().end(),
-                                           (*i).expr->get_results().begin(), candidate_end,
-                                   i->env, needAssertions, haveAssertions, openVars, indexer );
-                        Cost thisCost = castCostList( (*i).expr->get_results().begin(), candidate_end,
-                                                                                  castExpr->get_results().begin(), castExpr->get_results().end(),
-                                                                                  indexer, i->env );
+                        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 ) {
                                 // count one safe conversion for each value that is thrown away
@@ -760 +802 @@
 
                 for ( AltList::const_iterator agg = funcFinder.alternatives.begin(); agg != funcFinder.alternatives.end(); ++agg ) {
-                        if ( agg->expr->get_results().size() == 1 ) {
-                                if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_results().front() ) ) {
-                                        addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                                } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_results().front() ) ) {
-                                        addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
-                                } // if
+                        if ( StructInstType *structInst = dynamic_cast< StructInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( structInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( agg->expr->get_result() ) ) {
+                                addAggMembers( unionInst, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
+                        } else if ( TupleType * tupleType = dynamic_cast< TupleType * >( agg->expr->get_result() ) ) {
+                                addTupleMembers( tupleType, agg->expr, agg->cost, agg->env, memberExpr->get_member() );
                         } // if
                 } // for
@@ -791 +833 @@
                         renameTypes( alternatives.back().expr );
                         if ( StructInstType *structInst = dynamic_cast< StructInstType* >( (*i)->get_type() ) ) {
-                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
+                                NameExpr nameExpr( "" );
+                                addAggMembers( structInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
                         } else if ( UnionInstType *unionInst = dynamic_cast< UnionInstType* >( (*i)->get_type() ) ) {
-                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, "" );
+                                NameExpr nameExpr( "" );
+                                addAggMembers( unionInst, &newExpr, Cost( 0, 0, 1 ), env, &nameExpr );
                         } // if
                 } // for
@@ -894 +938 @@
                         alternatives.push_back( Alternative( new AttrExpr( new VariableExpr( funcDecl ), argType->clone() ), env, Cost::zero ) );
                         for ( std::list< DeclarationWithType* >::iterator i = function->get_returnVals().begin(); i != function->get_returnVals().end(); ++i ) {
-                                alternatives.back().expr->get_results().push_back( (*i)->get_type()->clone() );
+                                alternatives.back().expr->set_result( (*i)->get_type()->clone() );
                         } // for
                 } // if
@@ -917 +961 @@
                                                         finder.find( attrExpr->get_expr() );
                                                         for ( AltList::iterator choice = finder.alternatives.begin(); choice != finder.alternatives.end(); ++choice ) {
-                                                                if ( choice->expr->get_results().size() == 1 ) {
-                                                                        resolveAttr(*i, function, choice->expr->get_results().front(), choice->env );
+                                                                if ( choice->expr->get_result()->size() == 1 ) {
+                                                                        resolveAttr(*i, function, choice->expr->get_result(), choice->env );
                                                                 } // fi
                                                         } // for
@@ -960 +1004 @@
                                         AssertionSet needAssertions, haveAssertions;
                                         Alternative newAlt( 0, third->env, first->cost + second->cost + third->cost );
-                                        std::list< Type* > commonTypes;
-                                        if ( unifyList( second->expr->get_results().begin(), second->expr->get_results().end(), third->expr->get_results().begin(), third->expr->get_results().end(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonTypes ) ) {
+                                        Type* commonType = nullptr;
+                                        if ( unify( second->expr->get_result(), third->expr->get_result(), newAlt.env, needAssertions, haveAssertions, openVars, indexer, commonType ) ) {
                                                 ConditionalExpr *newExpr = new ConditionalExpr( first->expr->clone(), second->expr->clone(), third->expr->clone() );
-                                                std::list< Type* >::const_iterator original = second->expr->get_results().begin();
-                                                std::list< Type* >::const_iterator commonType = commonTypes.begin();
-                                                for ( ; original != second->expr->get_results().end() && commonType != commonTypes.end(); ++original, ++commonType ) {
-                                                        if ( *commonType ) {
-                                                                newExpr->get_results().push_back( *commonType );
-                                                        } else {
-                                                                newExpr->get_results().push_back( (*original)->clone() );
-                                                        } // if
-                                                } // for
+                                                newExpr->set_result( commonType ? commonType : second->expr->get_result()->clone() );
                                                 newAlt.expr = newExpr;
                                                 inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( alternatives ) );
@@ -999 +1035 @@
                         TupleExpr *newExpr = new TupleExpr;
                         makeExprList( *i, newExpr->get_exprs() );
-                        for ( std::list< Expression* >::const_iterator resultExpr = newExpr->get_exprs().begin(); resultExpr != newExpr->get_exprs().end(); ++resultExpr ) {
-                                for ( std::list< Type* >::const_iterator resultType = (*resultExpr)->get_results().begin(); resultType != (*resultExpr)->get_results().end(); ++resultType ) {
-                                        newExpr->get_results().push_back( (*resultType)->clone() );
-                                } // for
-                        } // for
+                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
 
                         TypeEnvironment compositeEnv;
@@ -1024 +1056 @@
                 }
         }
+
+        void AlternativeFinder::visit( TupleIndexExpr *tupleExpr ) {
+                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
+        }
+
+        void AlternativeFinder::visit( TupleAssignExpr *tupleAssignExpr ) {
+                alternatives.push_back( Alternative( tupleAssignExpr->clone(), env, Cost::zero ) );
+        }
+
+        void AlternativeFinder::visit( UniqueExpr *unqExpr ) {
+                AlternativeFinder finder( indexer, env );
+                finder.findWithAdjustment( unqExpr->get_expr() );
+                for ( Alternative & alt : finder.alternatives ) {
+                        // ensure that the id is passed on to the UniqueExpr alternative so that the expressions are "linked"
+                        UniqueExpr * newUnqExpr = new UniqueExpr( alt.expr->clone(), unqExpr->get_id() );
+                        alternatives.push_back( Alternative( newUnqExpr, alt.env, alt.cost ) );
+                }
+        }
+
 } // namespace ResolvExpr