Changes in src/ResolvExpr/AlternativeFinder.cc [6c3a988f:722617d]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -267 +267 @@
                 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 ) {
-                        Type * actualType = (*actualExpr)->get_result();
+
                         PRINT(
                                 std::cerr << "actual expression:" << std::endl;
                                 (*actualExpr)->print( std::cerr, 8 );
                                 std::cerr << "--- results are" << std::endl;
-                                actualType->print( std::cerr, 8 );
-                        )
+                                (*actualExpr)->get_result()->print( std::cerr, 8 );
+                        )
+                        std::list< DeclarationWithType* >::iterator startFormal = formal;
                         Cost actualCost;
-                        if ( formal == formals.end() ) {
-                                if ( function->get_isVarArgs() ) {
-                                        convCost += Cost( 1, 0, 0 );
-                                        continue;
+                        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 ";
+                                        (*actualType)->print( std::cerr, 8 );
+                                        std::cerr << std::endl << " to ";
+                                        (*formalType)->print( std::cerr, 8 );
+                                )
+                                Cost newCost = conversionCost( *actualType, *formalType, indexer, alt.env );
+                                PRINT(
+                                        std::cerr << std::endl << "cost is" << newCost << std::endl;
+                                )
+
+                                if ( newCost == Cost::infinity ) {
+                                        return newCost;
+                                }
+                                convCost += newCost;
+                                actualCost += newCost;
+
+                                convCost += Cost( 0, polyCost( *formalType, alt.env, indexer ) + polyCost( *actualType, alt.env, indexer ), 0 );
+
+                                formalType++;
+                        }
+                        if ( actualCost != Cost( 0, 0, 0 ) ) {
+                                std::list< DeclarationWithType* >::iterator startFormalPlusOne = startFormal;
+                                startFormalPlusOne++;
+                                if ( formal == startFormalPlusOne ) {
+                                        // not a tuple type
+                                        Type *newType = (*startFormal)->get_type()->clone();
+                                        alt.env.apply( newType );
+                                        *actualExpr = new CastExpr( *actualExpr, newType );
                                 } else {
-                                        return Cost::infinity;
+                                        TupleType *newType = new TupleType( Type::Qualifiers() );
+                                        for ( std::list< DeclarationWithType* >::iterator i = startFormal; i != formal; ++i ) {
+                                                newType->get_types().push_back( (*i)->get_type()->clone() );
+                                        }
+                                        alt.env.apply( newType );
+                                        *actualExpr = new CastExpr( *actualExpr, newType );
                                 }
                         }
-                        Type * formalType = (*formal)->get_type();
-                        PRINT(
-                                std::cerr << std::endl << "converting ";
-                                actualType->print( std::cerr, 8 );
-                                std::cerr << std::endl << " to ";
-                                formalType->print( std::cerr, 8 );
-                        )
-                        Cost newCost = conversionCost( actualType, formalType, indexer, alt.env );
-                        PRINT(
-                                std::cerr << std::endl << "cost is" << newCost << std::endl;
-                        )
-
-                        if ( newCost == Cost::infinity ) {
-                                return newCost;
-                        }
-                        convCost += newCost;
-                        actualCost += newCost;
-                        if ( actualCost != Cost( 0, 0, 0 ) ) {
-                                Type *newType = formalType->clone();
-                                alt.env.apply( newType );
-                                *actualExpr = new CastExpr( *actualExpr, newType );
-                        }
-                        convCost += Cost( 0, polyCost( formalType, alt.env, indexer ) + polyCost( actualType, alt.env, indexer ), 0 );
-                        ++formal; // can't be in for-loop update because of the continue
+
                 }
                 if ( formal != formals.end() ) {
@@ -328 +364 @@
                         }
                         convCost += newCost;
+
                         convCost += Cost( 0, polyCost( assert->second.formalType, alt.env, indexer ) + polyCost( assert->second.actualType, alt.env, indexer ), 0 );
                 }
@@ -339 +376 @@
                         unifiableVars[ (*tyvar)->get_name() ] = TypeDecl::Data{ *tyvar };
                         for ( std::list< DeclarationWithType* >::iterator assert = (*tyvar)->get_assertions().begin(); assert != (*tyvar)->get_assertions().end(); ++assert ) {
-                                needAssertions[ *assert ].isUsed = true;
+                                needAssertions[ *assert ] = true;
                         }
 ///     needAssertions.insert( needAssertions.end(), (*tyvar)->get_assertions().begin(), (*tyvar)->get_assertions().end() );
@@ -351 +388 @@
                 if ( TupleType * tupleType = dynamic_cast< TupleType * >( formalType ) ) {
                         // formalType is a TupleType - group actuals into a TupleExpr whose type unifies with the TupleType
-                        std::list< Expression * > exprs;
+                        TupleExpr * tupleExpr = new TupleExpr();
                         for ( Type * type : *tupleType ) {
-                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( exprs ) ) ) {
-                                        deleteAll( exprs );
+                                if ( ! instantiateArgument( type, defaultValue, actualIt, actualEnd, openVars, resultEnv, resultNeed, resultHave, indexer, cost, back_inserter( tupleExpr->get_exprs() ) ) ) {
+                                        delete tupleExpr;
                                         return false;
                                 }
                         }
-                        *out++ = new TupleExpr( exprs );
-                } else if ( TypeInstType * ttype = Tuples::isTtype( formalType ) ) {
-                        // xxx - mixing default arguments with variadic??
-                        std::list< Expression * > exprs;
-                        for ( ; actualIt != actualEnd; ++actualIt ) {
-                                exprs.push_back( actualIt->expr->clone() );
-                                cost += actualIt->cost;
-                        }
-                        Expression * arg = nullptr;
-                        if ( exprs.size() == 1 && Tuples::isTtype( exprs.front()->get_result() ) ) {
-                                // 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.
-                                arg = exprs.front();
-                        } else {
-                                arg = new TupleExpr( exprs );
-                        }
-                        assert( arg && arg->get_result() );
-                        if ( ! unify( ttype, arg->get_result(), resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
-                                return false;
-                        }
-                        *out++ = arg;
+                        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
@@ -466 +483 @@
         void addToIndexer( AssertionSet &assertSet, SymTab::Indexer &indexer ) {
                 for ( AssertionSet::iterator i = assertSet.begin(); i != assertSet.end(); ++i ) {
-                        if ( i->second.isUsed ) {
+                        if ( i->second == true ) {
                                 i->first->accept( indexer );
                         }
@@ -477 +494 @@
                 if ( begin == end ) {
                         if ( newNeed.empty() ) {
-                                PRINT(
-                                        std::cerr << "all assertions satisfied, output alternative: ";
-                                        newAlt.print( std::cerr );
-                                        std::cerr << std::endl;
-                                );
                                 *out++ = newAlt;
                                 return;
@@ -498 +510 @@
 
                 ForwardIterator cur = begin++;
-                if ( ! cur->second.isUsed ) {
+                if ( ! cur->second ) {
                         inferRecursive( begin, end, newAlt, openVars, decls, newNeed, /*needParents,*/ level, indexer, out );
                         return; // xxx - should this continue? previously this wasn't here, and it looks like it should be
@@ -542 +554 @@
                                 assert( (*candidate)->get_uniqueId() );
                                 DeclarationWithType *candDecl = static_cast< DeclarationWithType* >( Declaration::declFromId( (*candidate)->get_uniqueId() ) );
-
-                                // everything with an empty idChain was pulled in by the current assertion.
-                                // add current assertion's idChain + current assertion's ID so that the correct inferParameters can be found.
-                                for ( auto & a : newerNeed ) {
-                                        if ( a.second.idChain.empty() ) {
-                                                a.second.idChain = cur->second.idChain;
-                                                a.second.idChain.push_back( curDecl->get_uniqueId() );
-                                        }
-                                }
-
                                 //AssertionParentSet newNeedParents( needParents );
                                 // skip repeatingly-self-recursive assertion satisfaction
@@ -567 +569 @@
                                 )
                                 ApplicationExpr *appExpr = static_cast< ApplicationExpr* >( newerAlt.expr );
-                                // follow the current assertion's ID chain to find the correct set of inferred parameters to add the candidate to (i.e. the set of inferred parameters belonging to the entity which requested the assertion parameter).
-                                InferredParams * inferParameters = &appExpr->get_inferParams();
-                                for ( UniqueId id : cur->second.idChain ) {
-                                        inferParameters = (*inferParameters)[ id ].inferParams.get();
-                                }
                                 // XXX: this is a memory leak, but adjType can't be deleted because it might contain assertions
-                                (*inferParameters)[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
+                                appExpr->get_inferParams()[ curDecl->get_uniqueId() ] = ParamEntry( (*candidate)->get_uniqueId(), adjType->clone(), curDecl->get_type()->clone(), varExpr );
                                 inferRecursive( begin, end, newerAlt, newOpenVars, newDecls, newerNeed, /*newNeedParents,*/ level, indexer, out );
                         } else {
@@ -612 +609 @@
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 AltList instantiatedActuals; // filled by instantiate function
-                if ( targetType && ! targetType->isVoid() && ! funcType->get_returnVals().empty() ) {
+                if ( targetType && ! targetType->isVoid() ) {
                         // attempt to narrow based on expected target type
                         Type * returnType = funcType->get_returnVals().front()->get_type();
@@ -1078 +1075 @@
         }
 
-        void AlternativeFinder::visit( UntypedTupleExpr *tupleExpr ) {
+        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
                 std::list< AlternativeFinder > subExprAlternatives;
                 findSubExprs( tupleExpr->get_exprs().begin(), tupleExpr->get_exprs().end(), back_inserter( subExprAlternatives ) );
@@ -1084 +1081 @@
                 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( *i, exprs );
+                        TupleExpr *newExpr = new TupleExpr;
+                        makeExprList( *i, newExpr->get_exprs() );
+                        newExpr->set_result( Tuples::makeTupleType( newExpr->get_exprs() ) );
 
                         TypeEnvironment compositeEnv;
                         simpleCombineEnvironments( i->begin(), i->end(), compositeEnv );
-                        alternatives.push_back( Alternative( new TupleExpr( exprs ) , compositeEnv, sumCost( *i ) ) );
+                        alternatives.push_back( Alternative( newExpr, compositeEnv, sumCost( *i ) ) );
                 } // for
-        }
-
-        void AlternativeFinder::visit( TupleExpr *tupleExpr ) {
-                alternatives.push_back( Alternative( tupleExpr->clone(), env, Cost::zero ) );
         }