Changes in src/ResolvExpr/AlternativeFinder.cc [b6fe7e6:3b58d91]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -174 +174 @@
                         }
                 }
+
+                // flatten tuple type into list of types
+                template< typename OutputIterator >
+                void flatten( Type * type, OutputIterator out ) {
+                        if ( TupleType * tupleType = dynamic_cast< TupleType * >( type ) ) {
+                                for ( Type * t : *tupleType ) {
+                                        flatten( t, out );
+                                }
+                        } else {
+                                *out++ = type;
+                        }
+                }
         }
 
@@ -197 +209 @@
         }
 
-        void AlternativeFinder::find( Expression *expr, bool adjust, bool prune ) {
+        void AlternativeFinder::find( Expression *expr, bool adjust ) {
                 expr->accept( *this );
                 if ( alternatives.empty() ) {
@@ -207 +219 @@
                         }
                 }
-                if ( prune ) {
-                        PRINT(
-                                std::cerr << "alternatives before prune:" << std::endl;
-                                printAlts( alternatives, std::cerr );
-                        )
-                        AltList::iterator oldBegin = alternatives.begin();
-                        pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
-                        if ( alternatives.begin() == oldBegin ) {
-                                std::ostringstream stream;
-                                stream << "Can't choose between alternatives for expression ";
-                                expr->print( stream );
-                                stream << "Alternatives are:";
-                                AltList winners;
-                                findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
-                                printAlts( winners, stream, 8 );
-                                throw SemanticError( stream.str() );
-                        }
-                        alternatives.erase( oldBegin, alternatives.end() );
-                        PRINT(
-                                std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
-                        )
-                }
+                PRINT(
+                        std::cerr << "alternatives before prune:" << std::endl;
+                        printAlts( alternatives, std::cerr );
+                )
+                AltList::iterator oldBegin = alternatives.begin();
+                pruneAlternatives( alternatives.begin(), alternatives.end(), front_inserter( alternatives ), indexer );
+                if ( alternatives.begin() == oldBegin ) {
+                        std::ostringstream stream;
+                        stream << "Can't choose between alternatives for expression ";
+                        expr->print( stream );
+                        stream << "Alternatives are:";
+                        AltList winners;
+                        findMinCost( alternatives.begin(), alternatives.end(), back_inserter( winners ) );
+                        printAlts( winners, stream, 8 );
+                        throw SemanticError( stream.str() );
+                }
+                alternatives.erase( oldBegin, alternatives.end() );
+                PRINT(
+                        std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
+                )
 
                 // Central location to handle gcc extension keyword for all expression types.
@@ -236 +246 @@
         }
 
-        void AlternativeFinder::findWithAdjustment( Expression *expr, bool prune ) {
-                find( expr, true, prune );
+        void AlternativeFinder::findWithAdjustment( Expression *expr ) {
+                find( expr, true );
         }
 
         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, Expression * member ) {
+                NameExpr * nameExpr = safe_dynamic_cast< NameExpr * >( member );
+                const std::string & name = nameExpr->get_name();
+
                 std::list< Declaration* > members;
                 aggInst->lookup( name, members );
@@ -270 +283 @@
                 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;
@@ -279 +297 @@
                         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;
+                        for ( std::list< Type* >::iterator actualType = (*actualExpr)->get_results().begin(); actualType != (*actualExpr)->get_results().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 +336 @@
                                 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 ) ) {
@@ -382 +413 @@
                 */
                 std::list< DeclarationWithType* >::iterator formal = formals.begin();
+
+                std::list< Type * > formalTypes;
+                std::list< Type * >::iterator formalType = formalTypes.end();
+
                 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;
+                        std::list< Type* > & actualTypes = actualExpr->expr->get_results();
+                        for ( std::list< Type* >::iterator actualType = actualTypes.begin(); actualType != actualTypes.end(); ++actualType ) {
+                                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() ) {
+                                                return isVarArgs;
+                                        }
+                                        formalTypes.clear();
+                                        flatten( (*formal)->get_type(), back_inserter( formalTypes ) );
+                                        formalType = formalTypes.begin();
+                                        ++formal;
                                 }
                                 PRINT(
@@ -391 +437 @@
                                         (*formal)->get_type()->print( std::cerr );
                                         std::cerr << std::endl << "actual type is ";
-                                        (*actual)->print( std::cerr );
+                                        (*actualType)->print( std::cerr );
                                         std::cerr << std::endl;
                                 )
-                                if ( ! unify( (*formal)->get_type(), *actual, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
+                                if ( ! unify( *formalType, *actualType, resultEnv, resultNeed, resultHave, openVars, indexer ) ) {
                                         return false;
                                 }
-                                formal++;
-                        }
-                }
+                                ++formalType;
+                        }
+                }
+
+                // xxx - a tuple type was not completely matched
+                // partially handle the tuple with default arguments??
+                if ( formalType != formalTypes.end() ) return false;
+
                 // Handling of default values
                 while ( formal != formals.end() ) {
@@ -762 +813 @@
                         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() );
+                                        addAggMembers( structInst, agg->expr, agg->cost, 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() );
+                                        addAggMembers( unionInst, agg->expr, agg->cost, memberExpr->get_member() );
                                 } // if
                         } // if
@@ -791 +842 @@
                         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 ), &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 ), &nameExpr );
                         } // if
                 } // for
@@ -1014 +1067 @@
                 alternatives.push_back( Alternative( impCpCtorExpr->clone(), env, Cost::zero ) );
         }
-
-        void AlternativeFinder::visit( ConstructorExpr * ctorExpr ) {
-                AlternativeFinder finder( indexer, env );
-                // don't prune here, since it's guaranteed all alternatives will have the same type
-                // (giving the alternatives different types is half of the point of ConstructorExpr nodes)
-                finder.findWithAdjustment( ctorExpr->get_callExpr(), false );
-                for ( Alternative & alt : finder.alternatives ) {
-                        alternatives.push_back( Alternative( new ConstructorExpr( alt.expr->clone() ), alt.env, alt.cost ) );
-                }
-        }
 } // namespace ResolvExpr