[CSOptimizer] Fix selectDisjunction to use favored choices even if disjunction was not optimized

Some disjunctions e.g. explicit coercions, compositions of restrictions,
and implicit CGFloat initializers have favored choices set independently
from optimization algorithm, `selectDisjunction` should account for
such situations.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -244,7 +244,7 @@ static void findFavoredChoicesBasedOnArity(
 
 /// Given a set of disjunctions, attempt to determine
 /// favored choices in the current context.
-static Constraint *determineBestChoicesInContext(
+static void determineBestChoicesInContext(
     ConstraintSystem &cs, SmallVectorImpl<Constraint *> &disjunctions,
     llvm::DenseMap<Constraint *,
                    std::pair<double, llvm::TinyPtrVector<Constraint *>>>
@@ -267,14 +267,14 @@ static Constraint *determineBestChoicesInContext(
 
     auto argumentList = cs.getArgumentList(applicableFn.get()->getLocator());
     if (!argumentList)
-      return nullptr;
+      return;
 
     for (const auto &argument : *argumentList) {
       if (auto *expr = argument.getExpr()) {
         // Directly `<#...#>` or has one inside.
         if (isa<CodeCompletionExpr>(expr) ||
             cs.containsIDEInspectionTarget(expr))
-          return nullptr;
+          return;
       }
     }
 
@@ -924,27 +924,14 @@ static Constraint *determineBestChoicesInContext(
   }
 
   if (bestOverallScore == 0)
-    return nullptr;
+    return;
 
   for (auto &entry : disjunctionScores) {
     TinyPtrVector<Constraint *> favoredChoices;
     for (auto *choice : favoredChoicesPerDisjunction[entry.first])
       favoredChoices.push_back(choice);
     favorings[entry.first] = std::make_pair(entry.second, favoredChoices);
   }
-
-  Constraint *bestDisjunction = nullptr;
-  for (auto *disjunction : disjunctions) {
-    if (disjunctionScores[disjunction] != bestOverallScore)
-      continue;
-
-    if (!bestDisjunction)
-      bestDisjunction = disjunction;
-    else // Multiple disjunctions with the same score.
-      return nullptr;
-  }
-
-  return bestDisjunction;
 }
 
 // Attempt to find a disjunction of bind constraints where all options
@@ -1019,9 +1006,7 @@ ConstraintSystem::selectDisjunction() {
   llvm::DenseMap<Constraint *,
                  std::pair</*bestScore=*/double, llvm::TinyPtrVector<Constraint *>>>
       favorings;
-  if (auto *bestDisjunction =
-          determineBestChoicesInContext(*this, disjunctions, favorings))
-    return std::make_pair(bestDisjunction, favorings[bestDisjunction].second);
+  determineBestChoicesInContext(*this, disjunctions, favorings);
 
   // Pick the disjunction with the smallest number of favored, then active
   // choices.
@@ -1034,16 +1019,23 @@ ConstraintSystem::selectDisjunction() {
         auto &[firstScore, firstFavoredChoices] = favorings[first];
         auto &[secondScore, secondFavoredChoices] = favorings[second];
 
+        bool isFirstSupported = isSupportedDisjunction(first);
+        bool isSecondSupported = isSupportedDisjunction(second);
+
         // Rank based on scores only if both disjunctions are supported.
-        if (isSupportedDisjunction(first) && isSupportedDisjunction(second)) {
+        if (isFirstSupported && isSecondSupported) {
           // If both disjunctions have the same score they should be ranked
           // based on number of favored/active choices.
           if (firstScore != secondScore)
             return firstScore > secondScore;
         }
 
-        unsigned numFirstFavored = firstFavoredChoices.size();
-        unsigned numSecondFavored = secondFavoredChoices.size();
+        unsigned numFirstFavored = isFirstSupported
+                                       ? firstFavoredChoices.size()
+                                       : first->countFavoredNestedConstraints();
+        unsigned numSecondFavored =
+            isSecondSupported ? secondFavoredChoices.size()
+                              : second->countFavoredNestedConstraints();
 
         if (numFirstFavored == numSecondFavored) {
           if (firstActive != secondActive)

test/Constraints/casts_swift6.swift

@@ -25,9 +25,9 @@ func test_compatibility_coercions(_ arr: [Int], _ optArr: [Int]?, _ dict: [Strin
 
   // Make sure we error on the following in Swift 6 mode.
   _ = id(arr) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[Int]' vs. '[String]')}}
-  _ = (arr ?? []) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[String]' vs. '[Int]')}}
-  _ = (arr ?? [] ?? []) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[String]' vs. '[Int]')}}
-  // expected-error@-1{{conflicting arguments to generic parameter 'T' ('[String]' vs. '[Int]')}}
+  _ = (arr ?? []) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[Int]' vs. '[String]')}}
+  _ = (arr ?? [] ?? []) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[Int]' vs. '[String]')}}
+  // expected-error@-1{{conflicting arguments to generic parameter 'T' ('[Int]' vs. '[String]')}}
   _ = (optArr ?? []) as [String] // expected-error {{conflicting arguments to generic parameter 'T' ('[Int]' vs. '[String]'}}
 
   _ = (arr ?? []) as [String]? // expected-error {{'[Int]' is not convertible to '[String]?'}}

validation-test/Sema/type_checker_perf/fast/array_of_literals_and_operators_cast_to_float.swift.gyb

@@ -0,0 +1,10 @@
+// RUN: %scale-test --begin 1 --end 10 --step 1 --select NumLeafScopes %s
+// REQUIRES: asserts,no_asan
+
+let _ = [
+  0,
+%for i in range(2, N+2):
+  1/${i},
+%end
+  1
+] as [Float]