Changes in src/ResolvExpr/AlternativeFinder.cc [b0837e4:6137fbb]

File:

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

src/ResolvExpr/AlternativeFinder.cc

@@ -122 +122 @@
                                                 )
                                                 mapPlace->second.isAmbiguous = true;
-                                        } else {
-                                                PRINT(
-                                                        std::cerr << "cost " << candidate->cost << " loses to " << mapPlace->second.candidate->cost << std::endl;
-                                                )
                                         }
                                 } else {
@@ -131 +127 @@
                                 }
                         }
+
+                        PRINT(
+                                std::cerr << "there are " << selected.size() << " alternatives before elimination" << std::endl;
+                        )
 
                         // accept the alternatives that were unambiguous
@@ -180 +180 @@
                         throw SemanticError( "No reasonable alternatives for expression ", expr );
                 }
+                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
+                        if ( adjust ) {
+                                adjustExprType( i->expr->get_result(), i->env, indexer );
+                        }
+                }
                 if ( prune ) {
-                        auto oldsize = alternatives.size();
                         PRINT(
                                 std::cerr << "alternatives before prune:" << std::endl;
@@ -200 +204 @@
                         alternatives.erase( oldBegin, alternatives.end() );
                         PRINT(
-                                std::cerr << "there are " << oldsize << " alternatives before elimination" << std::endl;
-                        )
-                        PRINT(
                                 std::cerr << "there are " << alternatives.size() << " alternatives after elimination" << std::endl;
                         )
-                }
-                // adjust types after pruning so that types substituted by pruneAlternatives are correctly adjusted
-                for ( AltList::iterator i = alternatives.begin(); i != alternatives.end(); ++i ) {
-                        if ( adjust ) {
-                                adjustExprType( i->expr->get_result(), i->env, indexer );
-                        }
                 }
 
@@ -323 +318 @@
         Cost computeExpressionConversionCost( Expression *& actualExpr, Type * formalType, const SymTab::Indexer &indexer, const TypeEnvironment & env ) {
                 Cost convCost = computeConversionCost( actualExpr->result, formalType, indexer, env );
-
-                // if there is a non-zero conversion cost, ignoring poly cost, then the expression requires conversion.
-                // ignore poly cost for now, since this requires resolution of the cast to infer parameters and this
-                // does not currently work for the reason stated below.
+                // if ( convCost != Cost::zero ) {
+
+                // xxx - temporary -- ignore poly cost, since this causes some polymorphic functions to be cast, which causes the specialize
+                // pass to try to specialize them, which currently does not work. Once that is fixed, remove the next 3 lines and uncomment the
+                // previous line.
                 Cost tmpCost = convCost;
                 tmpCost.incPoly( -tmpCost.get_polyCost() );
                 if ( tmpCost != Cost::zero ) {
-                // if ( convCost != Cost::zero ) {
                         Type *newType = formalType->clone();
                         env.apply( newType );
@@ -636 +631 @@
                                         std::cerr << std::endl;
                                 )
+                                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 = &newerAlt.expr->get_inferParams();
+                                InferredParams * inferParameters = &appExpr->get_inferParams();
                                 for ( UniqueId id : cur->second.idChain ) {
                                         inferParameters = (*inferParameters)[ id ].inferParams.get();
@@ -684 +680 @@
                 OpenVarSet openVars;
                 AssertionSet resultNeed, resultHave;
-                TypeEnvironment resultEnv( func.env );
+                TypeEnvironment resultEnv;
                 makeUnifiableVars( funcType, openVars, resultNeed );
                 resultEnv.add( funcType->get_forall() ); // add all type variables as open variables now so that those not used in the parameter list are still considered open
@@ -918 +914 @@
                                 thisCost.incSafe( discardedValues );
                                 Alternative newAlt( restructureCast( i->expr->clone(), toType ), i->env, i->cost, thisCost );
-                                inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                // xxx - this doesn't work at the moment, since inferParameters requires an ApplicationExpr as the alternative.
+                                // Once this works, it should be possible to infer parameters on a cast expression and specialize any function.
+
+                                // inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                candidates.emplace_back( std::move( newAlt ) );
                         } // if
                 } // for
@@ -1297 +1297 @@
                                         // count one safe conversion for each value that is thrown away
                                         thisCost.incSafe( discardedValues );
-                                        Alternative newAlt( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost );
-                                        inferParameters( needAssertions, haveAssertions, newAlt, openVars, back_inserter( candidates ) );
+                                        candidates.push_back( Alternative( new InitExpr( restructureCast( alt.expr->clone(), toType ), initAlt.designation->clone() ), newEnv, alt.cost, thisCost ) );
                                 }
                         }