[ConstraintSystem] New "stable" disjunction selection algorithm

Prelude.

The core idea behind `shrink` is simple - reduce overload sets via
a bottom-up walk'n'solve that would utilize previously discovered
solutions along the way. This helps in some circumstances but requires
rollbacks and AST modification (if choices produced by previous steps
fail to produce solutions higher up). For some expressions, especially
ones with multiple generic overload sets, `shrink` is actively harmful
because it would never be able to produce useful results.

The Algorithm.

These changes integrate core idea of local information propagation
from `shrink` into the disjunction selection algorithm itself.

The algorithm itself is as follows - at the beginning use existing
selection algorithm (based on favoring, active choices, etc.) to
select the first disjunction to attempt, and push it to the stack
of "selected" disjunctions; next time solver requests a disjunction,
use the last selected one to pick the closest disjunction to it in
the AST order preferring parents over children.

For example:

```
         +
       /   \
     *     Float(<some variable e.g. `r` = 10))
   /  \
 exp   Float(1.0)
  |
 2.0
```

If solver starts by picking `Float(r)` first, it would then
attempt `+`, `exp` in that order. If it did pick `Float(1.0)`
then, the sequence is `*`, `+` and finally `exp`.

Since the main idea here to is keep everything as local as possible
along a given path, that means special handling for closures and tuples:

- Closures: if last disjunction is a call with a trailing closure argument,
  and such argument is resolved (constraint are generate for the body) -
  use selection algorithm to peek next disjunction from the body of the
  closure, and solve everything inside before moving to the next member
  in the chain (if any). This helps with linked member expressions e.g.
  `.map { ... }.filter { ... }.reduce { ... }`;

- Tuples: The idea here is to keep solving local to a current element
  until it runs out of disjunction, and then use selection algorithm to
  peek from the pool of disjunctions associated with other elements of
  the tuple.

Resolves: SR-10130
Resolves: rdar://48992848
Resolves: rdar://23682605
Resolves: rdar://46713933

Author: xedin

lib/Sema/CSSolver.cpp

@@ -2171,6 +2171,168 @@ Constraint *ConstraintSystem::selectDisjunction() {
   if (disjunctions.empty())
     return nullptr;
 
+  // If there are only a few disjunctions available,
+  // let's just use selection alogirthm.
+  if (disjunctions.size() <= 2)
+    return selectBestDisjunction(disjunctions);
+
+  if (SelectedDisjunctions.empty())
+    return selectBestDisjunction(disjunctions);
+
+  auto *lastDisjunction = SelectedDisjunctions.back()->getLocator();
+
+  // First, let's built a dictionary of all disjunctions accessible
+  // via their anchoring expressions.
+  llvm::SmallDenseMap<ASTNode, Constraint *> anchoredDisjunctions;
+  for (auto *disjunction : disjunctions) {
+    if (auto anchor = simplifyLocatorToAnchor(disjunction->getLocator()))
+      anchoredDisjunctions.insert({anchor, disjunction});
+  }
+
+  auto lookupDisjunctionInCache =
+      [&anchoredDisjunctions](Expr *expr) -> Constraint * {
+    auto disjunction = anchoredDisjunctions.find(expr);
+    return disjunction != anchoredDisjunctions.end() ? disjunction->second
+                                                     : nullptr;
+  };
+
+  auto findDisjunction = [&](Expr *expr) -> Constraint * {
+    if (!expr || !(isa<UnresolvedDotExpr>(expr) || isa<ApplyExpr>(expr)))
+      return nullptr;
+
+    // For applications i.e. calls, let's match their function first.
+    if (auto *apply = dyn_cast<ApplyExpr>(expr)) {
+      if (auto disjunction = lookupDisjunctionInCache(apply->getFn()))
+        return disjunction;
+    }
+
+    return lookupDisjunctionInCache(expr);
+  };
+
+  auto findClosestDisjunction = [&](Expr *expr) -> Constraint * {
+    Constraint *selectedDisjunction = nullptr;
+    expr->forEachChildExpr([&](Expr *expr) -> Expr * {
+      if (auto *disjunction = findDisjunction(expr)) {
+        selectedDisjunction = disjunction;
+        return nullptr;
+      }
+      return expr;
+    });
+    return selectedDisjunction;
+  };
+
+  if (auto *expr = getAsExpr(lastDisjunction->getAnchor())) {
+    // If this disjunction is derived from an overload set expression,
+    // let's look one level higher since its immediate parent is an
+    // operator application.
+    if (isa<OverloadedDeclRefExpr>(expr))
+      expr = getParentExpr(expr);
+
+    bool isMemberRef = isa<UnresolvedDotExpr>(expr);
+
+    // Implicit `.init` calls need some special handling.
+    if (lastDisjunction->isLastElement<LocatorPathElt::ConstructorMember>()) {
+      if (auto *call = dyn_cast<CallExpr>(expr)) {
+        expr = call->getFn();
+        isMemberRef = true;
+      }
+    }
+
+    if (isMemberRef) {
+      auto *parent = getParentExpr(expr);
+      // If this is a member application e.g. `.test(...)`,
+      // then let's see whether one of the arguments is a
+      // closure and if so, select the "best" disjunction
+      // from its body to be attempted next. This helps to
+      // type-check operator chains in a freshly resolved
+      // closure before moving to the next member in that
+      // chain of expressions for example:
+      //
+      // arr.map { $0 + 1 * 3 ... }.filter { ... }.reduce(0, +)
+      //
+      // Attempting to solve the body of the `.map` right after
+      // it has been selected helps to split up the constraint
+      // system.
+      if (auto *call = dyn_cast_or_null<CallExpr>(parent)) {
+        if (auto *arguments = call->getArgs()) {
+          for (const auto &argument : *arguments) {
+            auto *argExpr = argument.getExpr()->getSemanticsProvidingExpr();
+            auto *closure = dyn_cast<ClosureExpr>(argExpr);
+            // Even if the body of this closure participates in type-check
+            // it would be handled one statement at a time via a conjunction
+            // constraint.
+            if (!(closure && closure->hasSingleExpressionBody()))
+              continue;
+
+            // Note that it's important that we select the best possible
+            // disjunction from the body of the closure first, it helps
+            // to prune the solver space.
+            SmallVector<Constraint *, 4> innerDisjunctions;
+
+            for (auto *disjunction : disjunctions) {
+              auto *choice = disjunction->getNestedConstraints()[0];
+              if (choice->getKind() == ConstraintKind::BindOverload &&
+                  choice->getOverloadUseDC() == closure)
+                innerDisjunctions.push_back(disjunction);
+            }
+
+            if (!innerDisjunctions.empty())
+              return selectBestDisjunction(innerDisjunctions);
+          }
+        }
+      }
+    }
+
+    // First, let's see whether there is a direct parent in scope, since
+    // parent is the one which is going to use the result type of the
+    // last disjunction.
+    if (auto *parent = getParentExpr(expr)) {
+      if (isMemberRef && isa<CallExpr>(parent))
+        parent = getParentExpr(parent);
+
+      if (auto disjunction = findDisjunction(parent))
+        return disjunction;
+
+      // If parent is a tuple, let's collect disjunctions associated
+      // with its elements and run selection algorithm on them.
+      if (auto *tuple = dyn_cast_or_null<TupleExpr>(parent)) {
+        auto *elementExpr = expr;
+
+        // If current element has any unsolved disjunctions, let's
+        // attempt the closest to keep solving the local element.
+        if (auto disjunction = findClosestDisjunction(elementExpr))
+          return disjunction;
+
+        SmallVector<Constraint *, 4> tupleDisjunctions;
+        // Find all of the disjunctions that are nested inside of
+        // the current tuple for selection.
+        for (auto *disjunction : disjunctions) {
+          auto anchor = disjunction->getLocator()->getAnchor();
+          if (auto *expr = getAsExpr(anchor)) {
+            while ((expr = getParentExpr(expr))) {
+              if (expr == tuple) {
+                tupleDisjunctions.push_back(disjunction);
+                break;
+              }
+            }
+          }
+        }
+
+        // Let's use a pool of all disjunctions associated with
+        // this tuple. Picking the best one, regardless of the
+        // element would stir solving towards solving everything
+        // in a particular element.
+        if (!tupleDisjunctions.empty())
+          return selectBestDisjunction(tupleDisjunctions);
+      }
+    }
+
+    // If parent is not available (e.g. because it's already bound),
+    // let's look into the arguments, and find the closest unbound one.
+    if (auto *closestDisjunction = findClosestDisjunction(expr))
+      return closestDisjunction;
+  }
+
   return selectBestDisjunction(disjunctions);
 }
 

test/IDE/complete_ambiguous.swift

@@ -448,8 +448,8 @@ struct Struct123: Equatable {
 }
 func testBestSolutionFilter() {
   let a = Struct123();
-  let b = [Struct123]().first(where: { $0 == a && 1 + 90 * 5 / 8 == 45 * -10 })?.structMem != .#^BEST_SOLUTION_FILTER?xfail=rdar73282163^#
-  let c = min(10.3, 10 / 10.4) < 6 / 7 ? true : Optional(a)?.structMem != .#^BEST_SOLUTION_FILTER2?check=BEST_SOLUTION_FILTER;xfail=rdar73282163^#
+  let b = [Struct123]().first(where: { $0 == a && 1 + 90 * 5 / 8 == 45 * -10 })?.structMem != .#^BEST_SOLUTION_FILTER^#
+  min(10.3, 10 / 10.4) < 6 / 7 ? true : Optional(a)?.structMem != .#^BEST_SOLUTION_FILTER2?check=BEST_SOLUTION_FILTER^#
 }
 
 // BEST_SOLUTION_FILTER: Begin completions

validation-test/Sema/type_checker_perf/fast/mixed_double_and_float_operators.swift

@@ -0,0 +1,10 @@
+// RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1 -solver-disable-shrink
+// REQUIRES: OS=macosx,tools-release,no_asan
+
+import Foundation
+
+var r: Float  = 0
+var x: Double = 0
+var y: Double = 0
+
+let _ = (1.0 - 1.0 / (1.0 + exp(-5.0 * (r - 0.05)/0.01))) * Float(x) + Float(y)

validation-test/Sema/type_checker_perf/slow/rdar23682605.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar23682605.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/rdar46713933_literal_arg.swift renamed to validation-test/Sema/type_checker_perf/fast/rdar46713933_literal_arg.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/fast/sr10130.swift

@@ -0,0 +1,16 @@
+// RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
+// REQUIRES: tools-release,no_asan
+
+import Foundation
+
+let itemsPerRow = 10
+let size: CGFloat = 20
+let margin: CGFloat = 10
+
+let _ = (0..<100).map { (row: CGFloat($0 / itemsPerRow), col: CGFloat($0 % itemsPerRow)) }
+                 .map {
+                        CGRect(x: $0.col * (size + margin) + margin,
+                               y: $0.row * (size + margin) + margin,
+                               width: size,
+                               height: size)
+                 }