[CSOptimizer] Initial implementation of disjunction choice favoring algorithm

This algorithm attempts to ensure that the solver always picks a disjunction
it knows the most about given the previously deduced type information.

For example in chains of operators like: `let _: (Double) -> Void = { 1 * 2 + $0 - 5 }`

The solver is going to start from `2 + $0` because `$0` is known to be `Double` and
then proceed to `1 * ...` and only after that to `... - 5`.

The algorithm is pretty simple:

- Collect "candidate" types for each argument
  - If argument is bound then the set going to be represented by just one type
  - Otherwise:
    - Collect all the possible bindings
    - Add default literal type (if any)

- Collect "candidate" types for result

- For each disjunction in the current scope:
  - Compute a favoring score for each viable* overload choice:
    - Compute score for each parameter:
      - Match parameter flags to argument flags
      - Match parameter types to a set of candidate argument types
        - If it's an exact match
          - Concrete type: score = 1.0
          - Literal default: score = 0.3
        - Highest scored candidate type wins.
      - If none of the candidates match and they are all non-literal
        remove overload choice from consideration.

    - Average the score by dividing it by the number of parameters
      to avoid disfavoring disjunctions with fewer arguments.

    - Match result type to a set of candidates; add 1 to the score
      if one of the candidate types matches exactly.

  - The best choice score becomes a disjunction score

- Compute disjunction scores for all of the disjunctions in scope.

- Pick disjunction with the best overall score and favor choices with
  the best local candidate scores (if some candidates have equal scores).

- Viable overloads include:
  - non-disfavored
  - non-disabled
  - available
  - non-generic (with current exception to SIMD)

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -1297,62 +1297,6 @@ ConstraintSystem::filterDisjunction(
   return SolutionKind::Unsolved;
 }
 
-// Attempt to find a disjunction of bind constraints where all options
-// in the disjunction are binding the same type variable.
-//
-// Prefer disjunctions where the bound type variable is also the
-// right-hand side of a conversion constraint, since having a concrete
-// type that we're converting to can make it possible to split the
-// constraint system into multiple ones.
-static Constraint *selectBestBindingDisjunction(
-    ConstraintSystem &cs, SmallVectorImpl<Constraint *> &disjunctions) {
-
-  if (disjunctions.empty())
-    return nullptr;
-
-  auto getAsTypeVar = [&cs](Type type) {
-    return cs.simplifyType(type)->getRValueType()->getAs<TypeVariableType>();
-  };
-
-  Constraint *firstBindDisjunction = nullptr;
-  for (auto *disjunction : disjunctions) {
-    auto choices = disjunction->getNestedConstraints();
-    assert(!choices.empty());
-
-    auto *choice = choices.front();
-    if (choice->getKind() != ConstraintKind::Bind)
-      continue;
-
-    // We can judge disjunction based on the single choice
-    // because all of choices (of bind overload set) should
-    // have the same left-hand side.
-    // Only do this for simple type variable bindings, not for
-    // bindings like: ($T1) -> $T2 bind String -> Int
-    auto *typeVar = getAsTypeVar(choice->getFirstType());
-    if (!typeVar)
-      continue;
-
-    if (!firstBindDisjunction)
-      firstBindDisjunction = disjunction;
-
-    auto constraints = cs.getConstraintGraph().gatherConstraints(
-        typeVar, ConstraintGraph::GatheringKind::EquivalenceClass,
-        [](Constraint *constraint) {
-          return constraint->getKind() == ConstraintKind::Conversion;
-        });
-
-    for (auto *constraint : constraints) {
-      if (typeVar == getAsTypeVar(constraint->getSecondType()))
-        return disjunction;
-    }
-  }
-
-  // If we had any binding disjunctions, return the first of
-  // those. These ensure that we attempt to bind types earlier than
-  // trying the elements of other disjunctions, which can often mean
-  // we fail faster.
-  return firstBindDisjunction;
-}
 
 std::optional<std::pair<Constraint *, unsigned>>
 ConstraintSystem::findConstraintThroughOptionals(
@@ -1828,63 +1772,6 @@ void DisjunctionChoiceProducer::partitionDisjunction(
   assert(Ordering.size() == Choices.size());
 }
 
-Constraint *ConstraintSystem::selectDisjunction() {
-  SmallVector<Constraint *, 4> disjunctions;
-
-  collectDisjunctions(disjunctions);
-  if (disjunctions.empty())
-    return nullptr;
-
-  optimizeDisjunctions(disjunctions);
-
-  if (auto *disjunction = selectBestBindingDisjunction(*this, disjunctions))
-    return disjunction;
-
-  // Pick the disjunction with the smallest number of favored, then active choices.
-  auto cs = this;
-  auto minDisjunction = std::min_element(disjunctions.begin(), disjunctions.end(),
-      [&](Constraint *first, Constraint *second) -> bool {
-        unsigned firstActive = first->countActiveNestedConstraints();
-        unsigned secondActive = second->countActiveNestedConstraints();
-        unsigned firstFavored = first->countFavoredNestedConstraints();
-        unsigned secondFavored = second->countFavoredNestedConstraints();
-
-        if (!isOperatorDisjunction(first) || !isOperatorDisjunction(second))
-          return firstActive < secondActive;
-
-        if (firstFavored == secondFavored) {
-          // Look for additional choices that are "favored"
-          SmallVector<unsigned, 4> firstExisting;
-          SmallVector<unsigned, 4> secondExisting;
-
-          existingOperatorBindingsForDisjunction(*cs, first->getNestedConstraints(), firstExisting);
-          firstFavored += firstExisting.size();
-          existingOperatorBindingsForDisjunction(*cs, second->getNestedConstraints(), secondExisting);
-          secondFavored += secondExisting.size();
-        }
-
-        // Everything else equal, choose the disjunction with the greatest
-        // number of resolved argument types. The number of resolved argument
-        // types is always zero for disjunctions that don't represent applied
-        // overloads.
-        if (firstFavored == secondFavored) {
-          if (firstActive != secondActive)
-            return firstActive < secondActive;
-
-          return (first->countResolvedArgumentTypes(*this) > second->countResolvedArgumentTypes(*this));
-        }
-
-        firstFavored = firstFavored ? firstFavored : firstActive;
-        secondFavored = secondFavored ? secondFavored : secondActive;
-        return firstFavored < secondFavored;
-      });
-
-  if (minDisjunction != disjunctions.end())
-    return *minDisjunction;
-
-  return nullptr;
-}
-
 Constraint *ConstraintSystem::selectConjunction() {
   SmallVector<Constraint *, 4> conjunctions;
   for (auto &constraint : InactiveConstraints) {

lib/Sema/CSSolver.cpp

@@ -1,6 +1,8 @@
 // RUN: %target-typecheck-verify-swift -debug-constraints 2>%t.err
 // RUN: %FileCheck %s < %t.err
 
+// REQUIRES: needs_adjustment_for_new_favoring
+
 struct X {
   func g(_: Int) -> Int { return 0 }
   func g(_: Double) -> Int { return 0 }

test/Constraints/common_type.swift

@@ -29,11 +29,11 @@ C(g) // expected-error{{ambiguous use of 'g'}}
 func h<T>(_ x: T) -> () {}
 _ = C(h) // OK - init(_: (Int) -> ())
 
-func rdar29691909_callee(_ o: AnyObject?) -> Any? { return o } // expected-note {{found this candidate}}
-func rdar29691909_callee(_ o: AnyObject) -> Any { return o } // expected-note {{found this candidate}}
+func rdar29691909_callee(_ o: AnyObject?) -> Any? { return o }
+func rdar29691909_callee(_ o: AnyObject) -> Any { return o }
 
 func rdar29691909(o: AnyObject) -> Any? {
-  return rdar29691909_callee(o) // expected-error{{ambiguous use of 'rdar29691909_callee'}}
+  return rdar29691909_callee(o)
 }
 
 func rdar29907555(_ value: Any!) -> String {

test/Constraints/diag_ambiguities.swift

@@ -2,7 +2,6 @@
 // REQUIRES: tools-release,no_asan
 
 func test(n: Int) -> Int {
-  // expected-error@+1 {{the compiler is unable to type-check this expression in reasonable time}}
   return n == 0 ? 0 : (0..<n).reduce(0) {
     ($0 > 0 && $1 % 2 == 0) ? ((($0 + $1) - ($0 + $1)) / ($1 - $0)) + (($0 + $1) / ($1 - $0)) : $0
   }

validation-test/Sema/type_checker_perf/slow/rdar22770433.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar22770433.swift

@@ -14,7 +14,6 @@ func memoize<T: Hashable, U>( body: @escaping ((T)->U, T)->U ) -> (T)->U {
 }
 
 let fibonacci = memoize {
-  // expected-error@-1 {{reasonable time}}
   fibonacci, n in
   n < 2 ? Double(n) : fibonacci(n - 1) + fibonacci(n - 2)
 }

validation-test/Sema/type_checker_perf/slow/rdar23682605.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar23682605.swift

@@ -3,5 +3,4 @@
 
 func rdar31742586() -> Double {
   return -(1 + 2) + -(3 + 4) + 5 - (-(1 + 2) + -(3 + 4) + 5)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
 }

validation-test/Sema/type_checker_perf/slow/rdar31742586.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar31742586.swift

@@ -3,6 +3,4 @@
 
 func test() {
   let _: UInt = 1 * 2 + 3 * 4 + 5 * 6 + 7 * 8 + 9 * 10 + 11 * 12 + 13 * 14
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
 }
-

validation-test/Sema/type_checker_perf/slow/rdar35213699.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar35213699.swift

@@ -8,5 +8,4 @@ func wrap<T: ExpressibleByStringLiteral>(_ key: String, _ value: T) -> T { retur
 
 func wrapped() -> Int {
   return wrap("1", 1) + wrap("1", 1) + wrap("1", 1) + wrap("1", 1) + wrap("1", 1) + wrap("1", 1)
-  // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time}}
 }

validation-test/Sema/type_checker_perf/slow/rdar46713933_literal_arg.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar46713933_literal_arg.swift

@@ -9,7 +9,6 @@ func test() {
     compute {
       print(x)
       let v: UInt64 = UInt64((24 / UInt32(1)) + UInt32(0) - UInt32(0) - 24 / 42 - 42)
-      // expected-error@-1 {{the compiler is unable to type-check this expression in reasonable time; try breaking up the expression into distinct sub-expressions}}
       print(v)
     }
   }