Merge pull request swiftlang#26262 from xedin/new-diag-for-non-matching-overloads

[CSDiagnostics] Use special error message when call didn't match exactly

Author: xedin

include/swift/AST/DiagnosticsSema.def

@@ -56,6 +56,15 @@ ERROR(ambiguous_member_overload_set,none,
       "ambiguous reference to member %0", (DeclName))
 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 %1",
+      (DescriptiveDeclKind, DeclName))
+ERROR(no_overloads_match_exactly_in_call_no_labels,none,
+      "no exact matches in call to %0 %1",
+      (DescriptiveDeclKind, DeclBaseName))
+ERROR(no_overloads_match_exactly_in_call_special,none,
+      "no exact matches in call to %0",
+      (DescriptiveDeclKind))
 
 ERROR(ambiguous_subscript,none,
       "ambiguous subscript with base type %0 and index type %1",

lib/Sema/ConstraintSystem.cpp

@@ -2490,8 +2490,29 @@ bool ConstraintSystem::diagnoseAmbiguityWithFixes(
                   diag::could_not_find_subscript_member_did_you_mean,
                   getType(UDE->getBase()));
     } else {
-      TC.diagnose(commonAnchor->getLoc(), diag::ambiguous_reference_to_decl,
-                  decl->getDescriptiveKind(), decl->getFullName());
+      auto name = decl->getFullName();
+      // Three choices here:
+      // 1. If this is a special name avoid printing it because
+      //    printing kind is sufficient;
+      // 2. If all of the labels match, print a full name;
+      // 3. If labels in different choices are different, it means
+      //    that we can only print a base name.
+      if (name.isSpecial()) {
+        TC.diagnose(commonAnchor->getLoc(),
+                    diag::no_overloads_match_exactly_in_call_special,
+                    decl->getDescriptiveKind());
+      } else if (llvm::all_of(distinctChoices,
+                              [&name](const ValueDecl *choice) {
+                                return choice->getFullName() == name;
+                              })) {
+        TC.diagnose(commonAnchor->getLoc(),
+                    diag::no_overloads_match_exactly_in_call,
+                    decl->getDescriptiveKind(), name);
+      } else {
+        TC.diagnose(commonAnchor->getLoc(),
+                    diag::no_overloads_match_exactly_in_call_no_labels,
+                    decl->getDescriptiveKind(), name.getBaseName());
+      }
     }
 
     for (const auto &viable : viableSolutions) {

test/decl/ext/protocol.swift

@@ -236,13 +236,9 @@ extension P4 where Self.AssocP4 == Bool {
 }
 
 func testP4(_ s4a: S4a, s4b: S4b, s4c: S4c, s4d: S4d) {
-  // FIXME: Both of the 'ambiguous' examples below are indeed ambiguous,
-  //        because they don't match on conformance and same-type
-  //        requirement of different overloads, but diagnostic
-  //        could be improved to point out exactly what is missing in each case.
-  s4a.extP4a() // expected-error{{ambiguous reference to instance method 'extP4a()'}}
+  s4a.extP4a() // expected-error{{no exact matches in call to instance method 'extP4a()'}}
   s4b.extP4a() // ok
-  s4c.extP4a() // expected-error{{ambiguous reference to instance method 'extP4a()'}}
+  s4c.extP4a() // expected-error{{no exact matches in call to instance method 'extP4a()'}}
   s4c.extP4Int() // okay
   var b1 = s4d.extP4a() // okay, "Bool" version
   b1 = true // checks type above

validation-test/Sema/type_checker_crashers_fixed/rdar45470505.swift

@@ -4,8 +4,8 @@ extension BinaryInteger {
   init(bytes: [UInt8]) { fatalError() }
 
   init<S: Sequence>(bytes: S) where S.Iterator.Element == UInt8 {
-    self.init(bytes // expected-error {{ambiguous reference to initializer 'init(_:)'}}
-// expected-note@-1 {{}}
+    self.init(bytes // expected-error {{no exact matches in call to initializer}}
+    // expected-note@-1 {{}}
 
 extension
 // expected-error@-1 {{declaration is only valid at file scope}}