[CS] Fix IgnoreUnresolvedPatternVar::diagnose such that it returns false

Returning `true` is wrong here as we could have
the error diagnosed by another fix, which if not
handled, would lead to us crashing as we assume
we diagnosed the issue. Instead, return `false`,
allowing us to at least bail with a bad error
rather than a crash.

We still need to go through and update argument
list diagnostic logic to handle patterns, but I'm
leaving that as future work for now.

rdar://107724970
rdar://107651291

Author: hamishknight

lib/Sema/CSFix.cpp

@@ -2139,9 +2139,10 @@ IgnoreResultBuilderWithReturnStmts::create(ConstraintSystem &cs, Type builderTy,
 
 bool IgnoreUnresolvedPatternVar::diagnose(const Solution &solution,
                                           bool asNote) const {
-  // Not being able to infer the type of a pattern should already have been
-  // diagnosed on the pattern's initializer or as a structural issue of the AST.
-  return true;
+  // An unresolved AnyPatternDecl means there was some issue in the match
+  // that means we couldn't infer the pattern. We don't have a diagnostic to
+  // emit here, the failure should be diagnosed by the fix for expression.
+  return false;
 }
 
 IgnoreUnresolvedPatternVar *

test/Constraints/rdar107651291.swift

@@ -0,0 +1,12 @@
+// RUN: %target-typecheck-verify-swift
+
+// rdar://107651291 – Make sure we don't crash
+func foo(xs: [String: [String]], ys: [String: [String]]) {
+  for (key, value) in xs {
+    guard let ys = ys.first(where: { $0.key == key }) else { return }
+    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()'}}
+  }
+}

test/Constraints/rdar107724970.swift

@@ -0,0 +1,17 @@
+// RUN: %target-typecheck-verify-swift
+
+// rdar://107724970 – Make sure we don't crash.
+enum E {
+  case e(Int)
+}
+func foo(_ x: E) {
+  // FIXME: We need to handle pattern arguments in a bunch of places in argument
+  // list diagnostic logic.
+  // https://github.com/apple/swift/issues/65062
+  let fn = { // expected-error {{unable to infer closure type in the current context}}
+    switch x {
+    case E.e(_, _):
+      break
+    }
+  }
+}