[CSClosure] Explode pattern binding declarations into conjunctions

`one-way` constraints disable some optimizations related to component
selection because they imply strict ordering. This is a problem for
multi-statement closures because variable declarations could involve
complex operator expressions that rely on aforementioned optimizations.

In order to fix that, let's move away from solving whole pattern binding
declaration into scheme that explodes such declarations into indvidual
elements and inlines them into a conjunction.

For example:

```
let x = 42, y = x + 1, z = (x, test())
```

Would result in a conjunction of three elements:

```
x = 42
y = x + 1
z = (x, test())
```

Each element is solved indepedently, which eliminates the need for
`one-way` constraints and re-enables component selection optimizations.

Author: xedin

lib/Sema/CSClosure.cpp

@@ -483,12 +483,81 @@ class ClosureConstraintGenerator
     });
   }
 
+  void visitPatternBinding(PatternBindingDecl *patternBinding,
+                           SmallVectorImpl<ElementInfo> &patterns) {
+    auto *baseLoc = cs.getConstraintLocator(
+        locator, LocatorPathElt::ClosureBodyElement(patternBinding));
+
+    for (unsigned index : range(patternBinding->getNumPatternEntries())) {
+      auto *pattern = TypeChecker::resolvePattern(
+          patternBinding->getPattern(index), patternBinding->getDeclContext(),
+          /*isStmtCondition=*/true);
+
+      if (!pattern) {
+        hadError = true;
+        return;
+      }
+
+      // Reset binding to point to the resolved pattern. This is required
+      // before calling `forPatternBindingDecl`.
+      patternBinding->setPattern(index, pattern,
+                                 patternBinding->getInitContext(index));
+
+      patterns.push_back(makeElement(
+          patternBinding,
+          cs.getConstraintLocator(
+              baseLoc, LocatorPathElt::PatternBindingElement(index))));
+    }
+  }
+
+  void visitPatternBindingElement(PatternBindingDecl *patternBinding) {
+    assert(locator->isLastElement<LocatorPathElt::PatternBindingElement>());
+
+    auto index =
+        locator->castLastElementTo<LocatorPathElt::PatternBindingElement>()
+            .getIndex();
+
+    auto contextualPattern =
+        ContextualPattern::forPatternBindingDecl(patternBinding, index);
+    Type patternType = TypeChecker::typeCheckPattern(contextualPattern);
+
+    // Fail early if pattern couldn't be type-checked.
+    if (!patternType || patternType->hasError()) {
+      hadError = true;
+      return;
+    }
+
+    auto *pattern = patternBinding->getPattern(index);
+    auto *init = patternBinding->getInit(index);
+
+    if (!init && patternBinding->isDefaultInitializable(index) &&
+        pattern->hasStorage()) {
+      init = TypeChecker::buildDefaultInitializer(patternType);
+    }
+
+    auto target = init ? SolutionApplicationTarget::forInitialization(
+                             init, patternBinding->getDeclContext(),
+                             patternType, patternBinding, index,
+                             /*bindPatternVarsOneWay=*/false)
+                       : SolutionApplicationTarget::forUninitializedVar(
+                             patternBinding, index, patternType);
+
+    if (cs.generateConstraints(target, FreeTypeVariableBinding::Disallow)) {
+      hadError = true;
+      return;
+    }
+
+    // Keep track of this binding entry.
+    cs.setSolutionApplicationTarget({patternBinding, index}, target);
+  }
+
   void visitDecl(Decl *decl) {
     if (isSupportedMultiStatementClosure()) {
       if (auto patternBinding = dyn_cast<PatternBindingDecl>(decl)) {
-        SolutionApplicationTarget target(patternBinding);
-        if (cs.generateConstraints(target, FreeTypeVariableBinding::Disallow))
-          hadError = true;
+        if (locator->isLastElement<LocatorPathElt::PatternBindingElement>())
+          visitPatternBindingElement(patternBinding);
+        else
+          llvm_unreachable("cannot visit pattern binding directly");
         return;
       }
     }
@@ -788,6 +857,13 @@ class ClosureConstraintGenerator
             element.is<Expr *>() &&
             (!ctx.LangOpts.Playground && !ctx.LangOpts.DebuggerSupport);
 
+        if (auto *decl = element.dyn_cast<Decl *>()) {
+          if (auto *PDB = dyn_cast<PatternBindingDecl>(decl)) {
+            visitPatternBinding(PDB, elements);
+            continue;
+          }
+        }
+
         elements.push_back(makeElement(
             element,
             cs.getConstraintLocator(
@@ -1600,6 +1676,17 @@ void ConjunctionElement::findReferencedVariables(
 
   TypeVariableRefFinder refFinder(cs, locator->getAnchor(), typeVars);
 
+  if (auto *patternBinding =
+          dyn_cast_or_null<PatternBindingDecl>(element.dyn_cast<Decl *>())) {
+    if (auto patternBindingElt =
+            locator
+                ->getLastElementAs<LocatorPathElt::PatternBindingElement>()) {
+      if (auto *init = patternBinding->getInit(patternBindingElt->getIndex()))
+        init->walk(refFinder);
+      return;
+    }
+  }
+
   if (element.is<Decl *>() || element.is<StmtConditionElement *>() ||
       element.is<Expr *>() || element.isStmt(StmtKind::Return))
     element.walk(refFinder);

test/expr/closure/closures.swift

@@ -115,13 +115,14 @@ func t() {
 func f0(_ a: Any) -> Int { return 1 }
 assert(f0(1) == 1)
 
-
+// TODO(diagnostics): Bad diagnostic - should be `circular reference`
 var selfRef = { selfRef() }
-// expected-note@-1 2{{through reference here}}
-// expected-error@-2 {{circular reference}}
+// expected-error@-1 {{unable to infer closure type in the current context}}
 
-var nestedSelfRef = { // expected-error {{circular reference}} expected-note 2 {{through reference here}}
+// TODO: should be an error `circular reference` but it's diagnosed via overlapped requests
+var nestedSelfRef = {
   var recursive = { nestedSelfRef() }
+  // expected-warning@-1 {{variable 'recursive' was never mutated; consider changing to 'let' constant}}
   recursive()
 }
 

test/expr/expressions.swift

@@ -246,9 +246,11 @@ func test_as_2() {
 func test_lambda() {
   // A simple closure.
   var a = { (value: Int) -> () in markUsed(value+1) }
+  // expected-warning@-1 {{initialization of variable 'a' was never used; consider replacing with assignment to '_' or removing it}}
 
   // A recursive lambda.
-  var fib = { (n: Int) -> Int in // expected-error {{circular reference}} expected-note 2 {{through reference here}}
+  var fib = { (n: Int) -> Int in
+    // expected-warning@-1 {{variable 'fib' was never mutated; consider changing to 'let' constant}}
     if (n < 2) {
       return n
     }

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

@@ -0,0 +1,18 @@
+// RUN: %target-typecheck-verify-swift -solver-expression-time-threshold=1
+// REQUIRES: objc_interop,no_asan
+
+import simd
+
+func test(_: () -> Void) {}
+
+test {
+  let a: simd_float2 = .init()
+  let b: simd_float2 = .init()
+  let c: simd_float2 = .init()
+  let d: simd_float2 = .init()
+
+  let width: Float = 2
+
+  let p = Int(max(20, min(1000, (simd_distance(a, b) + simd_distance(b, c) + simd_distance(c, d)) / width / 4)))
+  print(p)
+}