[ConstraintSystem] Allow the solver to find other solutions after

successfully finding a solution by favoring operators already bound
elsewhere.

Favoring existing operator bindings often lets the solver find a solution
fast, but it's not necessarily the best solution.

Author: hborla

include/swift/Sema/ConstraintSystem.h

@@ -2467,16 +2467,6 @@ class ConstraintSystem {
       favoredConstraints.push_back(constraint);
     }
 
-    /// Whether or not the given constraint is only favored during this scope.
-    bool isTemporarilyFavored(Constraint *constraint) {
-      assert(constraint->isFavored());
-
-      for (auto test : favoredConstraints)
-        if (test == constraint)
-          return true;
-      return false;
-    }
-
   private:
     /// The list of constraints that have been retired along the
     /// current path, this list is used in LIFO fashion when constraints

lib/Sema/CSStep.cpp

@@ -614,25 +614,6 @@ bool DisjunctionStep::shortCircuitDisjunctionAt(
     Constraint *currentChoice, Constraint *lastSuccessfulChoice) const {
   auto &ctx = CS.getASTContext();
 
-  // If the successfully applied constraint is favored, we'll consider that to
-  // be the "best".  If it was only temporarily favored because it matched other
-  // operator bindings, we can even short-circuit other favored constraints.
-  if (lastSuccessfulChoice->isFavored() &&
-      (!currentChoice->isFavored() ||
-       (CS.solverState->isTemporarilyFavored(lastSuccessfulChoice) &&
-        !CS.solverState->isTemporarilyFavored(currentChoice)))) {
-#if !defined(NDEBUG)
-    if (lastSuccessfulChoice->getKind() == ConstraintKind::BindOverload) {
-      auto overloadChoice = lastSuccessfulChoice->getOverloadChoice();
-      assert((!overloadChoice.isDecl() ||
-              !overloadChoice.getDecl()->getAttrs().isUnavailable(ctx)) &&
-             "Unavailable decl should not be favored!");
-    }
-#endif
-
-    return true;
-  }
-
   // Anything without a fix is better than anything with a fix.
   if (currentChoice->getFix() && !lastSuccessfulChoice->getFix())
     return true;
@@ -670,36 +651,6 @@ bool DisjunctionStep::shortCircuitDisjunctionAt(
     if (isSIMDOperator(currentChoice->getOverloadChoice().getDecl()) &&
         !isSIMDOperator(lastSuccessfulChoice->getOverloadChoice().getDecl()))
       return true;
-
-    // Otherwise if we have an existing solution, bind tyvars bound to the same
-    // decl in the solution to the choice tyvar. We can continue finding more
-    // solutions, but all the instances of the operator that chose the same
-    // overload as this successful choice will be bound togeter.
-    if (Solutions.size()) {
-      auto lastTyvar =
-          lastSuccessfulChoice->getFirstType()->getAs<TypeVariableType>();
-      auto lastRep = CS.getRepresentative(lastTyvar);
-
-      for (auto overload : Solutions[0].overloadChoices) {
-        auto overloadChoice = overload.getSecond().choice;
-        if (!overloadChoice.isDecl() ||
-            overloadChoice.getDecl() !=
-                lastSuccessfulChoice->getOverloadChoice().getDecl())
-          continue;
-
-        auto choiceTyvar =
-            CS.getType(simplifyLocatorToAnchor(overload.getFirst()))
-                ->getAs<TypeVariableType>();
-        if (!choiceTyvar)
-          continue;
-
-        auto rep = CS.getRepresentative(choiceTyvar);
-        if (lastRep != rep) {
-          CS.mergeEquivalenceClasses(rep, lastRep, /*updateWorkList=*/false);
-          lastRep = CS.getRepresentative(lastRep);
-        }
-      }
-    }
   }
   return false;
 }

lib/Sema/CSStep.h

@@ -649,7 +649,6 @@ class DisjunctionStep final : public BindingStep<DisjunctionChoiceProducer> {
       : BindingStep(cs, {cs, disjunction}, solutions), Disjunction(disjunction),
         AfterDisjunction(erase(disjunction)) {
     assert(Disjunction->getKind() == ConstraintKind::Disjunction);
-    pruneOverloadSet(Disjunction);
     ++cs.solverState->NumDisjunctions;
   }
 
@@ -697,43 +696,6 @@ class DisjunctionStep final : public BindingStep<DisjunctionChoiceProducer> {
   /// simplified further, false otherwise.
   bool attempt(const DisjunctionChoice &choice) override;
 
-  // Check if selected disjunction has a representative
-  // this might happen when there are multiple binary operators
-  // chained together. If so, disable choices which differ
-  // from currently selected representative.
-  void pruneOverloadSet(Constraint *disjunction) {
-    auto *choice = disjunction->getNestedConstraints().front();
-    auto *typeVar = choice->getFirstType()->getAs<TypeVariableType>();
-    if (!typeVar)
-      return;
-
-    auto *repr = typeVar->getImpl().getRepresentative(nullptr);
-    if (!repr || repr == typeVar)
-      return;
-
-    for (auto overload : CS.getResolvedOverloads()) {
-      auto resolved = overload.second;
-      if (!resolved.boundType->isEqual(repr))
-        continue;
-
-      auto &representative = resolved.choice;
-      if (!representative.isDecl())
-        return;
-
-      // Disable all of the overload choices which are different from
-      // the one which is currently picked for representative.
-      for (auto *constraint : disjunction->getNestedConstraints()) {
-        auto choice = constraint->getOverloadChoice();
-        if (!choice.isDecl() || choice.getDecl() == representative.getDecl())
-          continue;
-
-        constraint->setDisabled();
-        DisabledChoices.push_back(constraint);
-      }
-      break;
-    }
-  };
-
   // Figure out which of the solutions has the smallest score.
   static Optional<Score> getBestScore(SmallVectorImpl<Solution> &solutions) {
     assert(!solutions.empty());