[ConstraintSystem] Bring back one-way pattern solving for for-in statements (outside closures)

Type-checker separates `where` clause from `for-in` statement's pattern/sequence
in closure contexts  which works as a natural barrier for inference, but
for-in statements in i.e. function bodies still type-check all of the for-in
statement components together, so we need to make sure that where clause
cannot be used to infer a type of the pattern before its sequence expression.

Resolves: rdar://117220710

Author: xedin

include/swift/Sema/SyntacticElementTarget.h

@@ -469,6 +469,8 @@ class SyntacticElementTarget {
   bool shouldBindPatternVarsOneWay() const {
     if (kind == Kind::expression)
       return expression.bindPatternVarsOneWay;
+    if (kind == Kind::forEachStmt)
+      return !ignoreForEachWhereClause() && forEachStmt.stmt->getWhere();
     return false;
   }
 

test/stmt/foreach.swift

@@ -295,3 +295,24 @@ do {
     }
   }
 }
+
+// rdar://117220710 - The compiler incorrectly infers `v` pattern to be optional.
+do {
+  struct S {
+    var test: Int
+  }
+
+  func check(_: S?, _: S?) -> Bool { false }
+
+  func test(data: [S]?, exclusion: S?) {
+    for v in data ?? [] where check(v, exclusion) {
+      _ = v.test // Ok
+    }
+  }
+
+  let _ = { (data: [S]?, exclusion: S?) in
+    for v in data ?? [] where check(v, exclusion) {
+      _ = v.test // Ok
+    }
+  }
+}