Revert "[CSOptimizer] Initial implementation of disjunction choice favoring algorithm"

This reverts commit 672ae3d.

Author: xedin

lib/Sema/CSOptimizer.cpp

@@ -1285,6 +1285,62 @@ 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(
@@ -1760,6 +1816,63 @@ 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,8 +1,6 @@
 // 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 }
-func rdar29691909_callee(_ o: AnyObject) -> Any { return o }
+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(o: AnyObject) -> Any? {
-  return rdar29691909_callee(o)
+  return rdar29691909_callee(o) // expected-error{{ambiguous use of 'rdar29691909_callee'}}
 }
 
 func rdar29907555(_ value: Any!) -> String {

test/Constraints/diag_ambiguities.swift

@@ -2,6 +2,7 @@
 // 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/fast/rdar22770433.swift renamed to validation-test/Sema/type_checker_perf/slow/rdar22770433.swift

@@ -14,6 +14,7 @@ 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/fast/rdar23682605.swift renamed to validation-test/Sema/type_checker_perf/slow/rdar23682605.swift

@@ -3,4 +3,5 @@
 
 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/fast/rdar31742586.swift renamed to validation-test/Sema/type_checker_perf/slow/rdar31742586.swift

@@ -3,4 +3,6 @@
 
 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/fast/rdar35213699.swift renamed to validation-test/Sema/type_checker_perf/slow/rdar35213699.swift

@@ -8,4 +8,5 @@ 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/fast/rdar46713933_literal_arg.swift renamed to validation-test/Sema/type_checker_perf/slow/rdar46713933_literal_arg.swift

@@ -9,6 +9,7 @@ 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)
     }
   }