[CSGen] Use OptionalObject constraint to connect element type and result of next()

Previously this wasn't possible because of `one-way` bind constraints
involved in pattern inference but this no longer the case.

Author: xedin

lib/Sema/CSGen.cpp

@@ -4536,11 +4536,8 @@ generateForEachStmtConstraints(ConstraintSystem &cs,
                                            /*flags=*/0);
   {
     auto nextType = cs.getType(forEachStmtInfo.nextCall);
-    // Note that `OptionalObject` is not used here. This is due to inference
-    // behavior where it would bind `elementType` to the `initType` before
-    // resolving `optional object` constraint which is sometimes too eager.
-    cs.addConstraint(ConstraintKind::Conversion, nextType,
-                     OptionalType::get(elementType), elementTypeLoc);
+    cs.addConstraint(ConstraintKind::OptionalObject, nextType, elementType,
+                     elementTypeLoc);
     cs.addConstraint(ConstraintKind::Conversion, elementType, initType,
                      elementLocator);
   }

lib/Sema/CSSimplify.cpp

@@ -6303,10 +6303,22 @@ bool ConstraintSystem::repairFailures(
   }
 
   case ConstraintLocator::OptionalPayload: {
+    if (lhs->isPlaceholder() || rhs->isPlaceholder())
+      return true;
+
     if (repairViaOptionalUnwrap(*this, lhs, rhs, matchKind, conversionsOrFixes,
                                 locator))
       return true;
 
+    if (path.size() > 1) {
+      path.pop_back();
+      if (path.back().is<LocatorPathElt::SequenceElementType>()) {
+        conversionsOrFixes.push_back(
+            CollectionElementContextualMismatch::create(
+                *this, lhs, rhs, getConstraintLocator(anchor, path)));
+        return true;
+      }
+    }
     break;
   }
 

test/Constraints/rdar107651291.swift

@@ -7,6 +7,6 @@ func foo(xs: [String: [String]], ys: [String: [String]]) {
     for (a, b) in zip(xs, ys) {}
     // expected-error@-1 {{type 'Dictionary<String, [String]>.Element' (aka '(key: String, value: Array<String>)') cannot conform to 'Sequence'}}
     // expected-note@-2 {{only concrete types such as structs, enums and classes can conform to protocols}}
-    // expected-note@-3 {{required by referencing instance method 'next()'}}
+    // expected-note@-3 {{required by global function 'zip' where 'Sequence2' = 'Dictionary<String, [String]>.Element' (aka '(key: String, value: Array<String>)')}}
   }
 }

test/stmt/foreach.swift

@@ -273,3 +273,25 @@ do {
   // https://github.com/apple/swift/issues/65650 - Make sure we say 'String', not 'Any'.
   for (x, y) in [""] {} // expected-error {{tuple pattern cannot match values of non-tuple type 'String'}}
 }
+
+do {
+  class Base : Hashable {
+    static func ==(_: Base, _: Base) -> Bool { false }
+
+    func hash(into hasher: inout Hasher) {}
+  }
+
+  class Child : Base {
+    var value: Int = 0
+  }
+
+  struct Range {
+    func contains(_: Base) -> Bool { return false }
+  }
+
+  func test(data: Set<Child>, _ range: Range) {
+    for v in data where range.contains(v) {
+      _ = v.value // Ok (`v` is inferred from `data` and not from `range`)
+    }
+  }
+}