[ConstraintSystem] NFC: Replace isOperatorBindOverload with isOperatorDisjunction

Author: xedin

include/swift/Sema/ConstraintSystem.h

@@ -5307,6 +5307,8 @@ Type isRawRepresentable(ConstraintSystem &cs, Type type,
 Type getDynamicSelfReplacementType(Type baseObjTy, const ValueDecl *member,
                                    ConstraintLocator *memberLocator);
 
+ValueDecl *getOverloadChoiceDecl(Constraint *choice);
+
 class DisjunctionChoice {
   ConstraintSystem &CS;
   unsigned Index;
@@ -5332,7 +5334,7 @@ class DisjunctionChoice {
   }
 
   bool isUnavailable() const {
-    if (auto *decl = getDecl(Choice))
+    if (auto *decl = getOverloadChoiceDecl(Choice))
       return CS.isDeclUnavailable(decl, Choice->getLocator());
     return false;
   }
@@ -5360,23 +5362,12 @@ class DisjunctionChoice {
   void propagateConversionInfo(ConstraintSystem &cs) const;
 
   static ValueDecl *getOperatorDecl(Constraint *choice) {
-    auto *decl = getDecl(choice);
+    auto *decl = getOverloadChoiceDecl(choice);
     if (!decl)
       return nullptr;
 
     return decl->isOperator() ? decl : nullptr;
   }
-
-  static ValueDecl *getDecl(Constraint *constraint) {
-    if (constraint->getKind() != ConstraintKind::BindOverload)
-      return nullptr;
-
-    auto choice = constraint->getOverloadChoice();
-    if (choice.getKind() != OverloadChoiceKind::Decl)
-      return nullptr;
-
-    return choice.getDecl();
-  }
 };
 
 class TypeVariableBinding {

lib/Sema/CSSolver.cpp

@@ -1734,18 +1734,6 @@ Constraint *ConstraintSystem::getUnboundBindOverloadDisjunction(
   return result->first;
 }
 
-static bool isOperatorBindOverload(Constraint *bindOverload) {
-  if (bindOverload->getKind() != ConstraintKind::BindOverload)
-    return false;
-
-  auto choice = bindOverload->getOverloadChoice();
-  if (!choice.isDecl())
-    return false;
-
-  auto *funcDecl = dyn_cast<FuncDecl>(choice.getDecl());
-  return funcDecl && funcDecl->getOperatorDecl();
-}
-
 // Performance hack: if there are two generic overloads, and one is
 // more specialized than the other, prefer the more-specialized one.
 static Constraint *tryOptimizeGenericDisjunction(
@@ -1882,7 +1870,7 @@ void DisjunctionChoiceProducer::partitionGenericOperators(
     SmallVectorImpl<unsigned>::iterator first,
     SmallVectorImpl<unsigned>::iterator last) {
   auto *argFnType = CS.getAppliedDisjunctionArgumentFunction(Disjunction);
-  if (!isOperatorBindOverload(Choices.front()) || !argFnType)
+  if (!isOperatorDisjunction(Disjunction) || !argFnType)
     return;
 
   auto operatorName = Choices[0]->getOverloadChoice().getName();
@@ -2056,11 +2044,8 @@ void DisjunctionChoiceProducer::partitionDisjunction(
   }
 
   // Partition SIMD operators.
-  if (isOperatorBindOverload(Choices[0])) {
+  if (isOperatorDisjunction(Disjunction)) {
     forEachChoice(Choices, [&](unsigned index, Constraint *constraint) -> bool {
-      if (!isOperatorBindOverload(constraint))
-        return false;
-
       if (isSIMDOperator(constraint->getOverloadChoice().getDecl())) {
         simdOperators.push_back(index);
         return true;
@@ -2114,8 +2099,7 @@ Constraint *ConstraintSystem::selectDisjunction() {
         unsigned firstFavored = first->countFavoredNestedConstraints();
         unsigned secondFavored = second->countFavoredNestedConstraints();
 
-        if (!isOperatorBindOverload(first->getNestedConstraints().front()) ||
-            !isOperatorBindOverload(second->getNestedConstraints().front()))
+        if (!isOperatorDisjunction(first) || !isOperatorDisjunction(second))
           return firstActive < secondActive;
 
         if (firstFavored == secondFavored) {

lib/Sema/ConstraintSystem.cpp

@@ -5690,17 +5690,18 @@ TypeVarBindingProducer::getDefaultBinding(Constraint *constraint) const {
              : binding;
 }
 
+ValueDecl *constraints::getOverloadChoiceDecl(Constraint *choice) {
+  if (choice->getKind() != ConstraintKind::BindOverload)
+    return nullptr;
+  return choice->getOverloadChoice().getDeclOrNull();
+}
+
 bool constraints::isOperatorDisjunction(Constraint *disjunction) {
   assert(disjunction->getKind() == ConstraintKind::Disjunction);
 
   auto choices = disjunction->getNestedConstraints();
-  if (choices.empty())
-    return false;
-
-  auto *choice = choices.front();
-  if (choice->getKind() != ConstraintKind::BindOverload)
-    return false;
+  assert(!choices.empty());
 
-  auto *decl = choice->getOverloadChoice().getDeclOrNull();
+  auto *decl = getOverloadChoiceDecl(choices.front());
   return decl ? decl->isOperator() : false;
 }