[ConstraintSystem] Use isDeclSubstitutable instead of compareDeclarations

to order generic operator overload choices.

Author: hborla

lib/Sema/CSSolver.cpp

@@ -2197,8 +2197,7 @@ void ConstraintSystem::partitionDisjunction(
     auto *declA = dyn_cast<ValueDecl>(Choices[lhs]->getOverloadChoice().getDecl());
     auto *declB = dyn_cast<ValueDecl>(Choices[rhs]->getOverloadChoice().getDecl());
 
-    auto result = TypeChecker::compareDeclarations(DC, declA, declB);
-    return result == Comparison::Better;
+    return TypeChecker::isDeclSubstitutable(declA, declB);
   });
 
   everythingElse.append(genericOverloads.begin(), genericOverloads.end());

lib/Sema/CSStep.cpp

@@ -574,7 +574,7 @@ bool IsDeclSubstitutableRequest::evaluate(Evaluator &evaluator,
   return substTypeA->isEqual(substTypeB);
 }
 
-static bool isDeclSubstitutable(ValueDecl *declA, ValueDecl *declB) {
+bool TypeChecker::isDeclSubstitutable(ValueDecl *declA, ValueDecl *declB) {
   return evaluateOrDefault(declA->getASTContext().evaluator,
                            IsDeclSubstitutableRequest{ declA, declB },
                            false);
@@ -616,10 +616,8 @@ bool DisjunctionStep::shouldSkip(const DisjunctionChoice &choice) const {
     auto *declA = LastSolvedChoice->first->getOverloadChoice().getDecl();
     auto *declB = static_cast<Constraint *>(choice)->getOverloadChoice().getDecl();
 
-    if (TypeChecker::compareDeclarations(CS.DC, declA, declB) == Comparison::Better) {
-      if (isDeclSubstitutable(declA, /*by=*/declB))
-        return skip("subtype");
-    }
+    if (TypeChecker::isDeclSubstitutable(declA, declB))
+      return skip("subtype");
   }
 
   // If the solver already found a solution with a choice that did not

lib/Sema/TypeChecker.h

@@ -903,6 +903,11 @@ isUnsupportedMemberTypeAccess(Type type, TypeDecl *typeDecl);
 Comparison compareDeclarations(DeclContext *dc, ValueDecl *decl1,
                                ValueDecl *decl2);
 
+/// Checks whether the first decl is a refinement of the second
+/// decl, meaning that the second decl can always be used in place
+/// of the first one and the expression will still type check.
+bool isDeclSubstitutable(ValueDecl *declA, ValueDecl *declB);
+
 /// Build a type-checked reference to the given value.
 Expr *buildCheckedRefExpr(VarDecl *D, DeclContext *UseDC, DeclNameLoc nameLoc,
                           bool Implicit);