Merge pull request #38700 from hborla/improve-transitive-conformance-heuristic

[ConstraintSystem] Improve the "transitive conformance" heuristic and remove early conformance checking from `DisjunctionStep::shouldSkip`

Author: hborla

lib/Sema/CSSimplify.cpp

@@ -6485,6 +6485,12 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyTransitivelyConformsTo(
   // If the type doesn't conform, let's check whether
   // an Optional or Unsafe{Mutable}Pointer from it would.
 
+  // If the current score is equal to the best score, fail without checking
+  // implicit conversions, because an implicit conversion would lead to a
+  // worse score anyway.
+  if (solverState && solverState->BestScore && CurrentScore == *solverState->BestScore)
+    return SolutionKind::Error;
+
   SmallVector<Type, 4> typesToCheck;
 
   // T -> Optional<T>

lib/Sema/CSStep.cpp

@@ -639,59 +639,6 @@ bool DisjunctionStep::shouldSkip(const DisjunctionChoice &choice) const {
     }
   }
 
-  // If the solver already found a solution with a choice that did not
-  // introduce any conversions (i.e., the score is not worse than the
-  // current score), we can skip any generic operators with conformance
-  // requirements that are not satisfied by any known argument types.
-  auto argFnType = CS.getAppliedDisjunctionArgumentFunction(Disjunction);
-  auto checkRequirementsEarly = [&]() -> bool {
-    auto bestScore = getBestScore(Solutions);
-    if (!(bestScore && choice.isGenericOperator() && argFnType))
-      return false;
-
-    auto currentScore = getCurrentScore();
-    for (unsigned i = 0; i < NumScoreKinds; ++i) {
-      if (i == SK_NonDefaultLiteral)
-        continue;
-
-      if (bestScore->Data[i] > currentScore.Data[i])
-        return false;
-    }
-
-    return true;
-  };
-  if (checkRequirementsEarly()) {
-    Constraint *constraint = choice;
-    auto *decl = constraint->getOverloadChoice().getDecl();
-    if (decl->getBaseIdentifier().isArithmeticOperator()) {
-      auto *useDC = constraint->getOverloadUseDC();
-      auto choiceType = CS.getEffectiveOverloadType(
-          constraint->getLocator(), constraint->getOverloadChoice(),
-          /*allowMembers=*/true, useDC);
-      auto choiceFnType = choiceType->getAs<FunctionType>();
-      auto genericFnType = decl->getInterfaceType()->getAs<GenericFunctionType>();
-      auto signature = genericFnType->getGenericSignature();
-
-      for (auto argParamPair : llvm::zip(argFnType->getParams(),
-                                         choiceFnType->getParams())) {
-        auto argType = std::get<0>(argParamPair).getPlainType();
-        auto paramType = std::get<1>(argParamPair).getPlainType();
-
-        // Only check argument types with no type variables that will be matched
-        // against a plain type parameter.
-        argType = argType->getCanonicalType()->getWithoutSpecifierType();
-        if (argType->hasTypeVariable() || !paramType->isTypeParameter())
-          continue;
-
-        for (auto *protocol : signature->getRequiredProtocols(paramType)) {
-          if (!TypeChecker::conformsToProtocol(argType, protocol,
-                                               useDC->getParentModule()))
-            return skip("unsatisfied");
-        }
-      }
-    }
-  }
-
   // Don't attempt to solve for generic operators if we already have
   // a non-generic solution.