Changes in src/ResolvExpr/CandidateFinder.cpp [1389810:0292aa4]

File:

• src/ResolvExpr/CandidateFinder.cpp (modified) (5 diffs)

src/ResolvExpr/CandidateFinder.cpp

@@ -1595 +1595 @@
                                         // unification run for side-effects
                                         bool canUnify = unify( toType, cand->expr->result, env, need, have, open, symtab );
-                    (void) canUnify;
+                                        (void) canUnify;
                                         Cost thisCost = computeConversionCost( cand->expr->result, toType, cand->expr->get_lvalue(),
                                                 symtab, env );
@@ -1645 +1645 @@
         /// Prunes a list of candidates down to those that have the minimum conversion cost for a given
         /// return type. Skips ambiguous candidates.
-
-} // anonymous namespace
-
-bool CandidateFinder::pruneCandidates( CandidateList & candidates, CandidateList & out, std::vector<std::string> & errors ) {
-        struct PruneStruct {
-                CandidateRef candidate;
-                bool ambiguous;
-
-                PruneStruct() = default;
-                PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
-        };
-
-        // find lowest-cost candidate for each type
-        std::unordered_map< std::string, PruneStruct > selected;
-        // attempt to skip satisfyAssertions on more expensive alternatives if better options have been found
-        std::sort(candidates.begin(), candidates.end(), [](const CandidateRef & x, const CandidateRef & y){return x->cost < y->cost;});
-        for ( CandidateRef & candidate : candidates ) {
-                std::string mangleName;
-                {
-                        ast::ptr< ast::Type > newType = candidate->expr->result;
-                        assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
-                        candidate->env.apply( newType );
-                        mangleName = Mangle::mangle( newType );
-                }
-
-                auto found = selected.find( mangleName );
-                if (found != selected.end() && found->second.candidate->cost < candidate->cost) {
-                        PRINT(
-                                std::cerr << "cost " << candidate->cost << " loses to "
-                                        << found->second.candidate->cost << std::endl;
-                        )
-                        continue;
-                }
-
-                // xxx - when do satisfyAssertions produce more than 1 result?
-                // this should only happen when initial result type contains
-                // unbound type parameters, then it should never be pruned by
-                // the previous step, since renameTyVars guarantees the mangled name
-                // is unique.
-                CandidateList satisfied;
-                satisfyAssertions(candidate, localSyms, satisfied, errors);
-
-                for (auto & newCand : satisfied) {
-                        // recomputes type key, if satisfyAssertions changed it
+        CandidateList pruneCandidates( CandidateList & candidates ) {
+                struct PruneStruct {
+                        CandidateRef candidate;
+                        bool ambiguous;
+
+                        PruneStruct() = default;
+                        PruneStruct( const CandidateRef & c ) : candidate( c ), ambiguous( false ) {}
+                };
+
+                // find lowest-cost candidate for each type
+                std::unordered_map< std::string, PruneStruct > selected;
+                for ( CandidateRef & candidate : candidates ) {
+                        std::string mangleName;
                         {
-                                ast::ptr< ast::Type > newType = newCand->expr->result;
-                                assertf(newCand->expr->result, "Result of expression %p for candidate is null", newCand->expr.get());
-                                newCand->env.apply( newType );
+                                ast::ptr< ast::Type > newType = candidate->expr->result;
+                                assertf(candidate->expr->result, "Result of expression %p for candidate is null", candidate->expr.get());
+                                candidate->env.apply( newType );
                                 mangleName = Mangle::mangle( newType );
                         }
+
                         auto found = selected.find( mangleName );
                         if ( found != selected.end() ) {
-                                if ( newCand->cost < found->second.candidate->cost ) {
+                                if ( candidate->cost < found->second.candidate->cost ) {
                                         PRINT(
-                                                std::cerr << "cost " << newCand->cost << " beats "
+                                                std::cerr << "cost " << candidate->cost << " beats "
                                                         << found->second.candidate->cost << std::endl;
                                         )
 
-                                        found->second = PruneStruct{ newCand };
-                                } else if ( newCand->cost == found->second.candidate->cost ) {
+                                        found->second = PruneStruct{ candidate };
+                                } else if ( candidate->cost == found->second.candidate->cost ) {
                                         // if one of the candidates contains a deleted identifier, can pick the other,
                                         // since deleted expressions should not be ambiguous if there is another option
                                         // that is at least as good
-                                        if ( findDeletedExpr( newCand->expr ) ) {
+                                        if ( findDeletedExpr( candidate->expr ) ) {
                                                 // do nothing
                                                 PRINT( std::cerr << "candidate is deleted" << std::endl; )
                                         } else if ( findDeletedExpr( found->second.candidate->expr ) ) {
                                                 PRINT( std::cerr << "current is deleted" << std::endl; )
-                                                found->second = PruneStruct{ newCand };
+                                                found->second = PruneStruct{ candidate };
                                         } else {
                                                 PRINT( std::cerr << "marking ambiguous" << std::endl; )
                                                 found->second.ambiguous = true;
                                         }
-                                } else { 
-                                        // xxx - can satisfyAssertions increase the cost?
+                                } else {
                                         PRINT(
-                                                std::cerr << "cost " << newCand->cost << " loses to "
+                                                std::cerr << "cost " << candidate->cost << " loses to "
                                                         << found->second.candidate->cost << std::endl;
-                                        )       
+                                        )
                                 }
                         } else {
-                                selected.emplace_hint( found, mangleName, newCand );
-                        }
-                }
+                                selected.emplace_hint( found, mangleName, candidate );
+                        }
+                }
+
+                // report unambiguous min-cost candidates
+                CandidateList out;
+                for ( auto & target : selected ) {
+                        if ( target.second.ambiguous ) continue;
+
+                        CandidateRef cand = target.second.candidate;
+
+                        ast::ptr< ast::Type > newResult = cand->expr->result;
+                        cand->env.applyFree( newResult );
+                        cand->expr = ast::mutate_field(
+                                cand->expr.get(), &ast::Expr::result, move( newResult ) );
+
+                        out.emplace_back( cand );
+                }
+                return out;
         }
 
-        // report unambiguous min-cost candidates
-        // CandidateList out;
-        for ( auto & target : selected ) {
-                if ( target.second.ambiguous ) continue;
-
-                CandidateRef cand = target.second.candidate;
-
-                ast::ptr< ast::Type > newResult = cand->expr->result;
-                cand->env.applyFree( newResult );
-                cand->expr = ast::mutate_field(
-                        cand->expr.get(), &ast::Expr::result, move( newResult ) );
-
-                out.emplace_back( cand );
-        }
-        // if everything is lost in satisfyAssertions, report the error
-        return !selected.empty();
-}
+} // anonymous namespace
 
 void CandidateFinder::find( const ast::Expr * expr, ResolvMode mode ) {
@@ -1770 +1739 @@
         }
 
-        /*
         if ( mode.satisfyAssns || mode.prune ) {
                 // trim candidates to just those where the assertions are satisfiable
@@ -1793 +1761 @@
                 candidates = move( satisfied );
         }
-        */
 
         if ( mode.prune ) {
@@ -1802 +1769 @@
                 )
 
-                CandidateList pruned;
-                std::vector<std::string> errors;
-                bool found = pruneCandidates( candidates, pruned, errors );
+                CandidateList pruned = pruneCandidates( candidates );
 
                 if ( mode.failFast && pruned.empty() ) {
                         std::ostringstream stream;
-                        if (found) {            
-                                CandidateList winners = findMinCost( candidates );
-                                stream << "Cannot choose between " << winners.size() << " alternatives for "
-                                        "expression\n";
-                                ast::print( stream, expr );
-                                stream << " Alternatives are:\n";
-                                print( stream, winners, 1 );
-                                SemanticError( expr->location, stream.str() );
-                        }
-                        else {
-                                stream << "No alternatives with satisfiable assertions for " << expr << "\n";
-                                for ( const auto& err : errors ) {
-                                        stream << err;
-                                }
-                                SemanticError( expr->location, stream.str() );
-                        }
+                        CandidateList winners = findMinCost( candidates );
+                        stream << "Cannot choose between " << winners.size() << " alternatives for "
+                                "expression\n";
+                        ast::print( stream, expr );
+                        stream << " Alternatives are:\n";
+                        print( stream, winners, 1 );
+                        SemanticError( expr->location, stream.str() );
                 }