Increase impact of arg/param mismatch if param has generic param but arg does not.

Author: Greg Titus

lib/Sema/CSSimplify.cpp

@@ -15276,6 +15276,20 @@ ConstraintSystem::SolutionKind ConstraintSystem::simplifyFixConstraint(
       }
     }
 
+    // Mismatches where param involves a generic parameter means a poor
+    // generic parameter match, overload is much less viable.
+    if (!type1->hasTypeVariable() && type2->hasTypeVariable()) {
+      SmallPtrSet<TypeVariableType *, 4> typeVariables;
+      type2->getTypeVariables(typeVariables);
+      if (llvm::any_of(typeVariables, [&](const TypeVariableType *tv) {
+            auto tvLocator = tv->getImpl().getLocator();
+            return tvLocator
+                       ->isLastElement<LocatorPathElt::GenericParameter>() &&
+                   tvLocator->getAnchor() == locator.getAnchor();
+          }))
+        impact += 6;
+    }
+
     // De-prioritize `Builtin.RawPointer` and `OpaquePointer` parameters
     // because they usually clash with generic parameter mismatches e.g.
     //

test/Constraints/diagnostics.swift

@@ -1124,7 +1124,7 @@ func rdar17170728() {
     // expected-error@-1 4 {{optional type 'Int?' cannot be used as a boolean; test for '!= nil' instead}}
   }
 
-  let _ = [i, j, k].reduce(0 as Int?) { // expected-error {{missing argument label 'into:' in call}}
+  let _ = [i, j, k].reduce(0 as Int?) { // expected-error {{missing argument label 'into:' in call}}}
     // expected-error@-1 {{cannot convert value of type 'Int?' to expected argument type '(inout @escaping (Bool, Bool) -> Bool?, Int?) throws -> ()'}}
     $0 && $1 ? $0 + $1 : ($0 ? $0 : ($1 ? $1 : nil))
     // expected-error@-1 {{binary operator '+' cannot be applied to two 'Bool' operands}}
@@ -1552,19 +1552,19 @@ func testNilCoalescingOperatorRemoveFix() {
   let _ = "" /* This is a comment */ ?? "" // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{13-43=}}
 
   let _ = "" // This is a comment
-    ?? "" // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{1554:13-1555:10=}}
+    ?? "" // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{-1:13-+0:10=}}
 
   let _ = "" // This is a comment
     /*
      * The blank line below is part of the test case, do not delete it
      */
-    ?? "" // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{1557:13-1561:10=}}
+    ?? "" // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{-4:13-+0:10=}}
 
-  if ("" ?? // This is a comment // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{9-1564:9=}}
+  if ("" ?? // This is a comment // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{9-+1:9=}}
       "").isEmpty {}
 
   if ("" // This is a comment
-      ?? "").isEmpty {} // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{1566:9-1567:12=}}
+      ?? "").isEmpty {} // expected-warning {{left side of nil coalescing operator '??' has non-optional type 'String', so the right side is never used}} {{-1:9-+0:12=}}
 }
 
 // https://github.com/apple/swift/issues/74617

test/Constraints/issue-74700.swift

@@ -0,0 +1,29 @@
+// RUN: %target-typecheck-verify-swift
+
+protocol Idable<ID> {
+  associatedtype ID
+  var id: ID { get }
+}
+func test74700() {
+  @dynamicMemberLookup struct Binding<C> {
+    subscript(dynamicMember member: String) -> String { "" }
+  }
+  struct ForEach<Data, ID, Content> where Data : RandomAccessCollection, ID: Hashable {
+    init(_ data: Data, content: (Data.Element) -> Content) where ID == Data.Element.ID, Data.Element : Idable {}
+    // expected-note@-1 {{where 'Data.Element' = 'User'}}
+    init<C>(_ data: Binding<C>, content: (Binding<C.Element>) -> Content) where Data == Array<C>, ID == C.Element.ID, C : MutableCollection, C : RandomAccessCollection, C.Element : Idable, C.Index : Hashable {}
+  }
+
+  struct User {
+    let name: String // expected-note {{'name' declared here}}
+  }
+
+  struct ContentView {
+    let users: [User] = []
+    func body() -> Void {
+      ForEach(users) { user in // expected-error {{initializer 'init(_:content:)' requires that 'User' conform to 'Idable'}}
+        return user.nam // expected-error {{value of type 'User' has no member 'nam'; did you mean 'name'?}}
+      }
+    }
+  }
+}

test/expr/expressions.swift

@@ -785,8 +785,9 @@ func testNilCoalescePrecedence(cond: Bool, a: Int?, r: ClosedRange<Int>?) {
   // ?? should have higher precedence than logical operators like || and comparisons.
   if cond || (a ?? 42 > 0) {}  // Ok.
   if (cond || a) ?? 42 > 0 {}  // expected-error {{cannot be used as a boolean}} {{15-15=(}} {{16-16= != nil)}}
-  // expected-error@-1 {{binary operator '>' cannot be applied to operands of type 'Bool' and 'Int'}}  expected-note@-1 {{overloads for '>' exist with these partially matching parameter list}}
+  // expected-error@-1 {{binary operator '>' cannot be applied to operands of type 'Bool' and 'Int'}}
   // expected-error@-2 {{binary operator '??' cannot be applied to operands of type 'Bool' and 'Int'}}
+  // expected-note@-3 {{overloads for '>' exist with these partially matching parameter lists: (Int, Int)}}
   if (cond || a) ?? (42 > 0) {}  // expected-error {{cannot be used as a boolean}} {{15-15=(}} {{16-16= != nil)}}
 
   if cond || a ?? 42 > 0 {}    // Parses as the first one, not the others.