[Constraint solver] Remove a hand-rolled clone of getUnboundBindOverloadDisjunction

Use the real one instead.

Author: DougGregor

lib/Sema/CSGen.cpp

@@ -605,98 +605,79 @@ namespace {
                               mustConsider = nullptr) {
     // Find the type variable associated with the function, if any.
     auto tyvarType = CS.getType(expr->getFn())->getAs<TypeVariableType>();
-    if (!tyvarType)
+    if (!tyvarType || CS.getFixedType(tyvarType))
       return;
 
     // This type variable is only currently associated with the function
     // being applied, and the only constraint attached to it should
     // be the disjunction constraint for the overload group.
-    auto &CG = CS.getConstraintGraph();
-    llvm::SetVector<Constraint *> disjunctions;
-    CG.gatherConstraints(tyvarType, disjunctions,
-                         ConstraintGraph::GatheringKind::EquivalenceClass,
-                         [](Constraint *constraint) -> bool {
-                           return constraint->getKind() ==
-                                  ConstraintKind::Disjunction;
-                         });
-    if (disjunctions.empty())
+    auto disjunction = CS.getUnboundBindOverloadDisjunction(tyvarType);
+    if (!disjunction)
       return;
 
-    // Look for the disjunction that binds the overload set.
-    for (auto *disjunction : disjunctions) {
-      auto oldConstraints = disjunction->getNestedConstraints();
-      auto csLoc = CS.getConstraintLocator(expr->getFn());
+    auto oldConstraints = disjunction->getNestedConstraints();
+    auto csLoc = CS.getConstraintLocator(expr->getFn());
 
-      // Only replace the disjunctive overload constraint.
-      if (oldConstraints[0]->getKind() != ConstraintKind::BindOverload) {
-        continue;
+    if (mustConsider) {
+      bool hasMustConsider = false;
+      for (auto oldConstraint : oldConstraints) {
+        auto overloadChoice = oldConstraint->getOverloadChoice();
+        if (overloadChoice.isDecl() &&
+            mustConsider(overloadChoice.getDecl()))
+          hasMustConsider = true;
       }
-
-      if (mustConsider) {
-        bool hasMustConsider = false;
-        for (auto oldConstraint : oldConstraints) {
-          auto overloadChoice = oldConstraint->getOverloadChoice();
-          if (overloadChoice.isDecl() &&
-              mustConsider(overloadChoice.getDecl()))
-            hasMustConsider = true;
-        }
-        if (hasMustConsider) {
-          continue;
-        }
+      if (hasMustConsider) {
+        return;
       }
+    }
 
-      // Copy over the existing bindings, dividing the constraints up
-      // into "favored" and non-favored lists.
-      SmallVector<Constraint *, 4> favoredConstraints;
-      SmallVector<Constraint *, 4> fallbackConstraints;
-      for (auto oldConstraint : oldConstraints) {
-        if (!oldConstraint->getOverloadChoice().isDecl())
-          continue;
-        auto decl = oldConstraint->getOverloadChoice().getDecl();
-        if (!decl->getAttrs().isUnavailable(CS.getASTContext()) &&
-            isFavored(decl))
-          favoredConstraints.push_back(oldConstraint);
-        else
-          fallbackConstraints.push_back(oldConstraint);
-      }
+    // Copy over the existing bindings, dividing the constraints up
+    // into "favored" and non-favored lists.
+    SmallVector<Constraint *, 4> favoredConstraints;
+    SmallVector<Constraint *, 4> fallbackConstraints;
+    for (auto oldConstraint : oldConstraints) {
+      if (!oldConstraint->getOverloadChoice().isDecl())
+        return;
+      auto decl = oldConstraint->getOverloadChoice().getDecl();
+      if (!decl->getAttrs().isUnavailable(CS.getASTContext()) &&
+          isFavored(decl))
+        favoredConstraints.push_back(oldConstraint);
+      else
+        fallbackConstraints.push_back(oldConstraint);
+    }
 
-      // If we did not find any favored constraints, we're done.
-      if (favoredConstraints.empty()) break;
+    // If we did not find any favored constraints, we're done.
+    if (favoredConstraints.empty()) return;
 
-      if (favoredConstraints.size() == 1) {
-        auto overloadChoice = favoredConstraints[0]->getOverloadChoice();
-        auto overloadType = overloadChoice.getDecl()->getInterfaceType();
-        auto resultType = overloadType->getAs<AnyFunctionType>()->getResult();
-        CS.setFavoredType(expr, resultType.getPointer());
-      }
+    if (favoredConstraints.size() == 1) {
+      auto overloadChoice = favoredConstraints[0]->getOverloadChoice();
+      auto overloadType = overloadChoice.getDecl()->getInterfaceType();
+      auto resultType = overloadType->getAs<AnyFunctionType>()->getResult();
+      CS.setFavoredType(expr, resultType.getPointer());
+    }
 
-      // Remove the original constraint from the inactive constraint
-      // list and add the new one.
-      CS.removeInactiveConstraint(disjunction);
+    // Remove the original constraint from the inactive constraint
+    // list and add the new one.
+    CS.removeInactiveConstraint(disjunction);
 
-      // Create the disjunction of favored constraints.
-      auto favoredConstraintsDisjunction =
-          Constraint::createDisjunction(CS,
-                                        favoredConstraints,
-                                        csLoc);
-      
-      favoredConstraintsDisjunction->setFavored();
-      
-      llvm::SmallVector<Constraint *, 2> aggregateConstraints;
-      aggregateConstraints.push_back(favoredConstraintsDisjunction);
+    // Create the disjunction of favored constraints.
+    auto favoredConstraintsDisjunction =
+        Constraint::createDisjunction(CS, favoredConstraints, csLoc);
+    favoredConstraintsDisjunction->setFavored();
 
-      if (!fallbackConstraints.empty()) {
-        // Find the disjunction of fallback constraints. If any
-        // constraints were added here, create a new disjunction.
-        Constraint *fallbackConstraintsDisjunction =
-          Constraint::createDisjunction(CS, fallbackConstraints, csLoc);
+    llvm::SmallVector<Constraint *, 2> aggregateConstraints;
+    aggregateConstraints.push_back(favoredConstraintsDisjunction);
 
-        aggregateConstraints.push_back(fallbackConstraintsDisjunction);
-      }
+    if (!fallbackConstraints.empty()) {
+      // Find the disjunction of fallback constraints. If any
+      // constraints were added here, create a new disjunction.
+      Constraint *fallbackConstraintsDisjunction =
+        Constraint::createDisjunction(CS, fallbackConstraints, csLoc);
 
-      CS.addDisjunctionConstraint(aggregateConstraints, csLoc);
-      break;
+      aggregateConstraints.push_back(fallbackConstraintsDisjunction);
     }
+
+    CS.addDisjunctionConstraint(aggregateConstraints, csLoc);
   }
 
   size_t getOperandCount(Type t) {

lib/Sema/ConstraintSystem.h

@@ -3122,12 +3122,14 @@ class ConstraintSystem {
                                   bool restoreOnFail,
                                   llvm::function_ref<bool(Constraint *)> pred);
 
+public:
   // Given a type variable, attempt to find the disjunction of
   // bind overloads associated with it. This may return null in cases where
   // the disjunction has either not been created or binds the type variable
   // in some manner other than by binding overloads.
   Constraint *getUnboundBindOverloadDisjunction(TypeVariableType *tyvar);
 
+private:
   /// Given a type variable that might represent an overload set, retrieve
   ///
   /// \returns the set of overload choices to which this type variable
@@ -3748,7 +3750,7 @@ class TypeVarBindingProducer : public BindingProducer<TypeVariableBinding> {
 /// easy to work with disjunction and encapsulates
 /// some other important information such as locator.
 class DisjunctionChoiceProducer : public BindingProducer<DisjunctionChoice> {
-  // The disjunciton choices that this producer will iterate through.
+  // The disjunction choices that this producer will iterate through.
   ArrayRef<Constraint *> Choices;
 
   // The ordering of disjunction choices. We index into Choices