[Diagnostics] When diagnosing an ambiguous overload, don't mention "call"

if the expression is not a function application.

Author: hborla

include/swift/AST/DiagnosticsSema.def

@@ -61,11 +61,8 @@ ERROR(ambiguous_member_overload_set,none,
 ERROR(ambiguous_reference_to_decl,none,
       "ambiguous reference to %0 %1", (DescriptiveDeclKind, DeclName))
 ERROR(no_overloads_match_exactly_in_call,none,
-      "no exact matches in call to %0 %select{%2|}1",
-      (DescriptiveDeclKind, bool, DeclBaseName))
-ERROR(no_overloads_match_exactly_in_assignment,none,
-      "no exact matches in assignment to %0",
-      (DeclBaseName))
+      "no exact matches in %select{reference|call}0 to %1 %select{%3|}2",
+      (bool, DescriptiveDeclKind, bool, DeclBaseName))
 
 NOTE(candidate_partial_match,none,
      "candidate has partially matching parameter list %0",

lib/Sema/ConstraintSystem.cpp

@@ -2807,6 +2807,8 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
     DiagnosticTransaction transaction(getASTContext().Diags);
 
     auto *commonAnchor = commonCalleeLocator->getAnchor();
+    if (auto *callExpr = dyn_cast<CallExpr>(commonAnchor))
+      commonAnchor = callExpr->getDirectCallee();
     auto &DE = getASTContext().Diags;
     auto name = decl->getFullName();
 
@@ -2825,8 +2827,13 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
       DE.diagnose(commonAnchor->getLoc(), diag::no_candidates_match_result_type,
                   baseName.userFacingName(), getContextualType(anchor));
     } else {
+      bool isApplication = llvm::find_if(ArgumentInfos, [&](const auto argInfo) {
+        return argInfo.first->getAnchor() == commonAnchor;
+      }) != ArgumentInfos.end();
+
       DE.diagnose(commonAnchor->getLoc(),
                   diag::no_overloads_match_exactly_in_call,
+                  isApplication,
                   decl->getDescriptiveKind(), name.isSpecial(),
                   name.getBaseName());
     }

test/Constraints/diagnostics.swift

@@ -935,7 +935,7 @@ class CacheValue {
 
 func valueForKey<K>(_ key: K) -> CacheValue? {
   let cache = NSCache<K, CacheValue>()
-  return cache.object(forKey: key)?.value // expected-error {{no exact matches in call to instance method 'value'}}
+  return cache.object(forKey: key)?.value // expected-error {{no exact matches in reference to instance method 'value'}}
 }
 
 // SR-2242: poor diagnostic when argument label is omitted

test/Constraints/patterns.swift

@@ -301,7 +301,7 @@ switch staticMembers {
   // TODO: repeated error message
   case .optProp: break // expected-error* {{not unwrapped}}
 
-  case .method: break // expected-error{{no exact matches in call to static method 'method'}}
+  case .method: break // expected-error{{no exact matches in reference to static method 'method'}}
   case .method(0): break
   case .method(_): break // expected-error{{'_' can only appear in a pattern}}
   case .method(let x): break // expected-error{{cannot appear in an expression}}

test/NameBinding/import-resolution-overload.swift

@@ -46,7 +46,7 @@ scopedFunction = 42
 // FIXME: Should be an error -- a type name and a function cannot overload.
 var _ : Int = TypeNameWins(42)
 
-TypeNameWins = 42 // expected-error {{no exact matches in assignment to 'TypeNameWins'}}
+TypeNameWins = 42 // expected-error {{no exact matches in reference to global function 'TypeNameWins'}}
 var _ : TypeNameWins // no-warning
 
 // rdar://problem/21739333

test/Parse/super.swift

@@ -39,7 +39,7 @@ class D : B {
     super.bar        // expected-error {{expression resolves to an unused function}}
     super.bar()
     // FIXME: should also say "'super.init' cannot be referenced outside of an initializer"
-    super.init // expected-error{{no exact matches in call to initializer}}
+    super.init // expected-error{{no exact matches in reference to initializer}}
     super.init() // expected-error{{'super.init' cannot be called outside of an initializer}}
     super.init(0) // expected-error{{'super.init' cannot be called outside of an initializer}} // expected-error {{missing argument label 'x:' in call}}
     super[0]        // expected-error {{expression resolves to an unused subscript}}