[CSStep] Remove disjunction pruning logic from DisjunctionStep

Since old favoring mechanism has been removed this is dead code
now because nothing is going to equate disjunction constraints.

Author: xedin

lib/Sema/CSStep.h

@@ -671,8 +671,6 @@ class TypeVariableStep final : public BindingStep<TypeVarBindingProducer> {
 
 class DisjunctionStep final : public BindingStep<DisjunctionChoiceProducer> {
   Constraint *Disjunction;
-  SmallVector<Constraint *, 4> DisabledChoices;
-
   std::optional<Score> BestNonGenericScore;
   std::optional<std::pair<Constraint *, Score>> LastSolvedChoice;
 
@@ -689,16 +687,12 @@ class DisjunctionStep final : public BindingStep<DisjunctionChoiceProducer> {
       : BindingStep(cs, {cs, disjunction, favoredChoices}, solutions),
         Disjunction(disjunction) {
     assert(Disjunction->getKind() == ConstraintKind::Disjunction);
-    pruneOverloadSet(Disjunction);
     ++cs.solverState->NumDisjunctions;
   }
 
   ~DisjunctionStep() override {
     // Rewind back any changes left after attempting last choice.
     ActiveChoice.reset();
-    // Re-enable previously disabled overload choices.
-    for (auto *choice : DisabledChoices)
-      choice->setEnabled();
   }
 
   StepResult resume(bool prevFailed) override;
@@ -751,46 +745,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();
-    if (choice->getKind() != ConstraintKind::BindOverload)
-      return;
-
-    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 std::optional<Score>
   getBestScore(SmallVectorImpl<Solution> &solutions) {