[Diagnostics] Add a tailored diagnostic for function mismatch in argument positions

If parameter has a function type and no argument overload choices
match let's diagnose that specifically.

Resolves: [SR-12689](https://bugs.swift.org/browse/SR-12689)
Resolves: rdar://problem/62481592

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -253,6 +253,10 @@ ERROR(no_candidates_match_result_type,none,
       "no '%0' candidates produce the expected contextual result type %1",
       (StringRef, Type))
 
+ERROR(no_candidates_match_argument_type,none,
+      "no '%0' candidates produce the expected type %1 for parameter #%2",
+      (StringRef, Type, unsigned))
+
 ERROR(cannot_infer_closure_parameter_type,none,
       "unable to infer type of a closure parameter %0 in the current context",
        (StringRef))

lib/Sema/CSFix.cpp

@@ -408,6 +408,57 @@ bool AllowFunctionTypeMismatch::diagnose(const Solution &solution,
   return coalesceAndDiagnose(solution, {}, asNote);
 }
 
+bool AllowFunctionTypeMismatch::diagnoseForAmbiguity(
+    CommonFixesArray commonFixes) const {
+  if (ContextualMismatch::diagnoseForAmbiguity(commonFixes))
+    return true;
+
+  auto *locator = getLocator();
+  // If this is a mismatch between two function types at argument
+  // position, there is a tailored diagnostic for that.
+  if (auto argConv =
+          locator->getLastElementAs<LocatorPathElt::ApplyArgToParam>()) {
+    auto &cs = getConstraintSystem();
+    auto &DE = cs.getASTContext().Diags;
+    auto &solution = *commonFixes[0].first;
+
+    auto info = getStructuralTypeContext(solution, locator);
+    if (!info)
+      return false;
+
+    auto *argLoc = cs.getConstraintLocator(simplifyLocatorToAnchor(locator));
+
+    auto overload = solution.getOverloadChoiceIfAvailable(
+        solution.getCalleeLocator(argLoc));
+    if (!overload)
+      return false;
+
+    auto name = overload->choice.getName().getBaseName();
+    DE.diagnose(getLoc(getAnchor()), diag::no_candidates_match_argument_type,
+                name.userFacingName(), std::get<2>(*info),
+                argConv->getParamIdx());
+
+    for (auto &entry : commonFixes) {
+      auto &solution = *entry.first;
+      auto overload = solution.getOverloadChoiceIfAvailable(
+          solution.getCalleeLocator(argLoc));
+
+      if (!(overload && overload->choice.isDecl()))
+        continue;
+
+      auto *decl = overload->choice.getDecl();
+      if (decl->getLoc().isValid()) {
+        DE.diagnose(decl, diag::found_candidate_type,
+                    solution.simplifyType(overload->openedType));
+      }
+    }
+
+    return true;
+  }
+
+  return false;
+}
+
 AllowFunctionTypeMismatch *
 AllowFunctionTypeMismatch::create(ConstraintSystem &cs, Type lhs, Type rhs,
                                   ConstraintLocator *locator, unsigned index) {

lib/Sema/CSFix.h

@@ -1117,6 +1117,8 @@ class AllowFunctionTypeMismatch final : public ContextualMismatch {
                            bool asNote = false) const override;
 
   bool diagnose(const Solution &solution, bool asNote = false) const override;
+
+  bool diagnoseForAmbiguity(CommonFixesArray commonFixes) const override;
 };
 
 

test/Sema/diag_ambiguous_overloads.swift

@@ -126,3 +126,37 @@ func getCounts(_ scheduler: sr5154_Scheduler, _ handler: @escaping ([Count]) ->
   })
 }
 
+// SR-12689
+func SR12689(_ u: UnsafeBufferPointer<UInt16>) {}
+
+let array : [UInt16] = [1, 2]
+
+array.withUnsafeBufferPointer {
+  SR12689(UnsafeRawPointer($0).bindMemory(to: UInt16.self, capacity: 1)) // expected-error {{cannot convert value of type 'UnsafePointer<UInt16>' to expected argument type 'UnsafeBufferPointer<UInt16>'}}
+  // expected-error@-1 {{no exact matches in call to initializer}}
+  // expected-note@-2 {{candidate expects value of type 'UnsafeRawPointer' for parameter #1}}
+  // expected-note@-3 {{candidate expects value of type 'UnsafeMutableRawPointer' for parameter #1}}
+  // expected-note@-4 {{candidate expects value of type 'OpaquePointer' for parameter #1}}
+  // expected-note@-5 {{candidate expects value of type 'Builtin.RawPointer' for parameter #1}}
+
+  UnsafeRawPointer($0) as UnsafeBufferPointer<UInt16> // expected-error {{cannot convert value of type 'UnsafeRawPointer' to type 'UnsafeBufferPointer<UInt16>' in coercion}}
+  // expected-error@-1 {{no exact matches in call to initializer}}
+  // expected-note@-2 {{found candidate with type '(UnsafeRawPointer) -> UnsafeRawPointer'}}
+  // expected-note@-3 {{found candidate with type '(Builtin.RawPointer) -> UnsafeRawPointer'}}
+  // expected-note@-4 {{found candidate with type '(OpaquePointer) -> UnsafeRawPointer'}}
+  // expected-note@-5 {{found candidate with type '(UnsafeMutableRawPointer) -> UnsafeRawPointer'}}
+}
+
+func SR12689_1(_ u: Int) -> String { "" } // expected-note {{found this candidate}} expected-note {{candidate expects value of type 'Int' for parameter #1}}
+func SR12689_1(_ u: String) -> Double { 0 } // expected-note {{found this candidate}} expected-note {{candidate expects value of type 'String' for parameter #1}}
+func SR12689_2(_ u: Int) {}
+
+SR12689_2(SR12689_1(1 as Double)) // expected-error {{no exact matches in call to global function 'SR12689_1'}}
+SR12689_1(1 as Double) as Int // expected-error {{no exact matches in call to global function 'SR12689_1'}}
+
+// Ambiguos OverloadRefExpr
+func SR12689_O(_ p: Int) {} // expected-note {{found candidate with type '(Int) -> ()'}}
+func SR12689_O(_ p: Double) {} // expected-note {{found candidate with type '(Double) -> ()'}}
+func SR12689_3(_ param: (String)-> Void) {}
+
+SR12689_3(SR12689_O) // expected-error {{no 'SR12689_O' candidates produce the expected type '(String) -> Void' for parameter #0}}