Favor operators based on existing binds via both basename and type

Author: gregomni

include/swift/Sema/ConstraintSystem.h

@@ -2467,6 +2467,16 @@ 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/CSSolver.cpp

@@ -2013,7 +2013,8 @@ static Constraint *tryOptimizeGenericDisjunction(
   llvm_unreachable("covered switch");
 }
 
-// Performance hack: favor operator overloads with types we're already binding elsewhere in this expression.
+// Performance hack: favor operator overloads with decl or type we're already
+// binding elsewhere in this expression.
 static void existingOperatorBindingsForDisjunction(ConstraintSystem &CS, ArrayRef<Constraint *> constraints, SmallVectorImpl<Constraint *> &found) {
   auto *choice = constraints.front();
   if (choice->getKind() != ConstraintKind::BindOverload)
@@ -2025,6 +2026,9 @@ static void existingOperatorBindingsForDisjunction(ConstraintSystem &CS, ArrayRe
   auto decl = overload.getDecl();
   if (!decl->isOperator())
     return;
+  auto baseName = decl->getBaseName();
+
+  SmallSet<TypeBase *, 8> typesFound;
 
   for (auto overload : CS.getResolvedOverloads()) {
     auto resolved = overload.second;
@@ -2035,12 +2039,33 @@ static void existingOperatorBindingsForDisjunction(ConstraintSystem &CS, ArrayRe
     if (!representativeDecl->isOperator())
       continue;
 
-    for (auto *constraint : constraints) {
-      if (constraint->isFavored())
+    if (representativeDecl->getBaseName() == baseName) {
+      // Favor exactly the same decl, if we have a binding to the same name.
+      for (auto *constraint : constraints) {
+        if (constraint->isFavored())
+          continue;
+        auto choice = constraint->getOverloadChoice();
+        if (choice.getDecl() == representativeDecl) {
+          found.push_back(constraint);
+          break;
+        }
+      }
+    } else {
+      // Favor the same type, if we have a binding to an operator of that type.
+      auto representativeType = representativeDecl->getInterfaceType();
+      if (typesFound.count(representativeType.getPointer()))
         continue;
-      auto choice = constraint->getOverloadChoice();
-      if (choice.getDecl()->getInterfaceType()->isEqual(representativeDecl->getInterfaceType()))
-        found.push_back(constraint);
+      typesFound.insert(representativeType.getPointer());
+
+      for (auto *constraint : constraints) {
+        if (constraint->isFavored())
+          continue;
+        auto choice = constraint->getOverloadChoice();
+        if (choice.getDecl()->getInterfaceType()->isEqual(representativeType)) {
+          found.push_back(constraint);
+          break;
+        }
+      }
     }
   }
 }

lib/Sema/CSStep.cpp

@@ -615,8 +615,12 @@ bool DisjunctionStep::shortCircuitDisjunctionAt(
   auto &ctx = CS.getASTContext();
 
   // If the successfully applied constraint is favored, we'll consider that to
-  // be the "best".
-  if (lastSuccessfulChoice->isFavored() && !currentChoice->isFavored()) {
+  // 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();