[ConstraintSystem] Move "outer" candidates handling to simplifyMemberConstraint

Further simplify `addOverloadSet` and move "outer" candidate handling
to the only place where it comes up - `simplifyMemberConstraint`.
Also move constraint generation for choices into a separate method.

This is a stepping stone on the path to enable attaching fixes to
the overload choices.

Author: xedin

lib/Sema/CSSimplify.cpp

@@ -4020,9 +4020,21 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyMemberConstraint(
 
   // If we found viable candidates, then we're done!
   if (!result.ViableCandidates.empty()) {
-    addOverloadSet(memberTy, result.ViableCandidates, useDC, locator,
-                   result.getFavoredChoice(), outerAlternatives);
+    llvm::SmallVector<Constraint *, 8> candidates;
+    generateConstraints(candidates, memberTy, result.ViableCandidates,
+                        useDC, locator, result.getFavoredChoice());
 
+    if (!outerAlternatives.empty()) {
+      // If local scope has a single choice,
+      // it should always be preferred.
+      if (candidates.size() == 1)
+        candidates.front()->setFavored();
+
+      generateConstraints(candidates, memberTy, outerAlternatives,
+                          useDC, locator);
+    }
+
+    addOverloadSet(candidates, locator);
     return SolutionKind::Solved;
   }
 

lib/Sema/ConstraintSystem.cpp

@@ -1480,56 +1480,31 @@ void ConstraintSystem::addOverloadSet(Type boundType,
                                       ArrayRef<OverloadChoice> choices,
                                       DeclContext *useDC,
                                       ConstraintLocator *locator,
-                                      OverloadChoice *favoredChoice,
-                                      ArrayRef<OverloadChoice> outerAlternatives) {
-  assert(!choices.empty() && "Empty overload set");
-
+                                      OverloadChoice *favoredChoice) {
   // If there is a single choice, add the bind overload directly.
-  if (choices.size() == 1 && outerAlternatives.empty()) {
+  if (choices.size() == 1) {
     addBindOverloadConstraint(boundType, choices.front(), locator, useDC);
     return;
   }
 
-  auto recordChoice = [&](SmallVectorImpl<Constraint *> &choices,
-                          const OverloadChoice &choice,
-                          bool isFavored = false) {
-    auto *constraint = Constraint::createBindOverload(*this, boundType, choice,
-                                                      useDC, locator);
-    if (isFavored)
-      constraint->setFavored();
-
-    choices.push_back(constraint);
-  };
-
-  SmallVector<Constraint *, 4> overloads;
-  // As we do for other favored constraints, if a favored overload has been
-  // specified, let it be the first term in the disjunction.
-  if (favoredChoice) {
-    assert((!favoredChoice->isDecl() ||
-            !favoredChoice->getDecl()->getAttrs().isUnavailable(
-                getASTContext())) &&
-           "Cannot make unavailable decl favored!");
-    recordChoice(overloads, *favoredChoice, /*isFavored=*/true);
-  }
-
-  for (auto &choice : choices) {
-    if (favoredChoice && (favoredChoice == &choice))
-      continue;
-
-    recordChoice(overloads, choice);
-  }
+  SmallVector<Constraint *, 4> candidates;
+  generateConstraints(candidates, boundType, choices, useDC, locator,
+                      favoredChoice);
+  // For an overload set (disjunction) from newly generated candidates.
+  addOverloadSet(candidates, locator);
+}
 
-  if (!outerAlternatives.empty()) {
-    // If local scope has a single choice,
-    // it should always be preferred.
-    if (overloads.size() == 1)
-      overloads.front()->setFavored();
+void ConstraintSystem::addOverloadSet(ArrayRef<Constraint *> choices,
+                                      ConstraintLocator *locator) {
+  assert(!choices.empty() && "Empty overload set");
 
-    for (auto &choice : outerAlternatives)
-      recordChoice(overloads, choice);
+  // If there is a single choice, attempt it right away.
+  if (choices.size() == 1) {
+    simplifyConstraint(*choices.front());
+    return;
   }
 
-  addDisjunctionConstraint(overloads, locator, ForgetChoice);
+  addDisjunctionConstraint(choices, locator, ForgetChoice);
 }
 
 /// If we're resolving an overload set with a decl that has special type
@@ -2677,3 +2652,34 @@ Expr *constraints::getArgumentExpr(Expr *expr, unsigned index) {
   assert(isa<TupleExpr>(argExpr));
   return cast<TupleExpr>(argExpr)->getElement(index);
 }
+
+void ConstraintSystem::generateConstraints(
+    SmallVectorImpl<Constraint *> &constraints, Type type,
+    ArrayRef<OverloadChoice> choices, DeclContext *useDC,
+    ConstraintLocator *locator, OverloadChoice *favoredChoice) {
+  auto recordChoice = [&](SmallVectorImpl<Constraint *> &choices,
+                          const OverloadChoice &choice,
+                          bool isFavored = false) {
+    auto *constraint =
+        Constraint::createBindOverload(*this, type, choice, useDC, locator);
+    if (isFavored)
+      constraint->setFavored();
+
+    choices.push_back(constraint);
+  };
+
+  if (favoredChoice) {
+    assert((!favoredChoice->isDecl() ||
+            !favoredChoice->getDecl()->getAttrs().isUnavailable(
+                getASTContext())) &&
+           "Cannot make unavailable decl favored!");
+    recordChoice(constraints, *favoredChoice, /*isFavored=*/true);
+  }
+
+  for (const auto &choice : choices) {
+    if (favoredChoice && (favoredChoice == &choice))
+      continue;
+
+    recordChoice(constraints, choice);
+  }
+}

lib/Sema/ConstraintSystem.h

@@ -2417,8 +2417,10 @@ class ConstraintSystem {
   /// sets.
   void addOverloadSet(Type boundType, ArrayRef<OverloadChoice> choices,
                       DeclContext *useDC, ConstraintLocator *locator,
-                      OverloadChoice *favored = nullptr,
-                      ArrayRef<OverloadChoice> outerAlternatives = {});
+                      OverloadChoice *favored = nullptr);
+
+  void addOverloadSet(ArrayRef<Constraint *> choices,
+                      ConstraintLocator *locator);
 
   /// Retrieve the allocator used by this constraint system.
   llvm::BumpPtrAllocator &getAllocator() { return Allocator; }
@@ -2455,6 +2457,12 @@ class ConstraintSystem {
   /// \returns a possibly-sanitized initializer, or null if an error occurred.
   Type generateConstraints(Pattern *P, ConstraintLocatorBuilder locator);
 
+  /// Generate constraints for a given set of overload choices.
+  void generateConstraints(SmallVectorImpl<Constraint *> &constraints,
+                           Type type, ArrayRef<OverloadChoice> choices,
+                           DeclContext *useDC, ConstraintLocator *locator,
+                           OverloadChoice *favoredChoice = nullptr);
+
   /// Propagate constraints in an effort to enforce local
   /// consistency to reduce the time to solve the system.
   ///