QoI: Improve diagnostics for failed @objc inference.

When we cannot infer an @objc name due to an ambiguity, provide a
specific error with Fix-Its for various courses of action (pick a
specific name, make it @nonobjc). Also, be sure to suppress redundant
diagnostics for Objective-C selector checking when checking protocol
conformances: a match-with-renaming will emit the appropriate '@objc'
when it's needed, so we don't need a follow-up diagnostic here.

Finishes rdar://problem/26518216.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -2701,6 +2701,13 @@ ERROR(objc_override_property_name_mismatch,none,
       "Objective-C property has a different name from the "
       "property it overrides (%0 vs. %1)", (Identifier, Identifier))
 
+ERROR(objc_ambiguous_inference,none,
+      "ambiguous inference of Objective-C name for %0 %1 (%2 vs %3)",
+      (DescriptiveDeclKind, DeclName, ObjCSelector, ObjCSelector))
+NOTE(objc_ambiguous_inference_candidate,none,
+     "%0 (in protocol %1) provides Objective-C name %2",
+     (DeclName, DeclName, ObjCSelector))
+
 ERROR(nonlocal_bridged_to_objc,none,
       "conformance of %0 to %1 can only be written in module %2",
       (Identifier, Identifier, Identifier))

lib/Sema/TypeCheckDecl.cpp

@@ -2269,18 +2269,42 @@ static void inferObjCName(TypeChecker &tc, ValueDecl *decl) {
   // When no override determined the Objective-C name, look for
   // requirements for which this declaration is a witness.
   Optional<ObjCSelector> requirementObjCName;
+  ValueDecl *firstReq = nullptr;
   for (auto req : tc.findWitnessedObjCRequirements(decl,
                                                    /*onlyFirst=*/false)) {
     // If this is the first requirement, take its name.
     if (!requirementObjCName) {
       requirementObjCName = req->getObjCRuntimeName();
+      firstReq = req;
       continue;
     }
 
     // If this requirement has a different name from one we've seen,
-    // bail out and let protocol-conformance diagnostics handle this.
-    if (*requirementObjCName != *req->getObjCRuntimeName())
-      return;
+    // note the ambiguity.
+    if (*requirementObjCName != *req->getObjCRuntimeName()) {
+      tc.diagnose(decl, diag::objc_ambiguous_inference,
+                  decl->getDescriptiveKind(), decl->getFullName(),
+                  *requirementObjCName, *req->getObjCRuntimeName());
+      
+      // Note the candidates and what Objective-C names they provide.
+      auto diagnoseCandidate = [&](ValueDecl *req) {
+        auto proto = cast<ProtocolDecl>(req->getDeclContext());
+        auto diag = tc.diagnose(decl,
+                                diag::objc_ambiguous_inference_candidate,
+                                req->getFullName(),
+                                proto->getFullName(),
+                                *req->getObjCRuntimeName());
+        fixDeclarationObjCName(diag, decl, req->getObjCRuntimeName());
+      };
+      diagnoseCandidate(firstReq);
+      diagnoseCandidate(req);
+
+      // Suggest '@nonobjc' to suppress this error, and not try to
+      // infer @objc for anything.
+      tc.diagnose(decl, diag::optional_req_near_match_nonobjc, true)
+        .fixItInsert(decl->getAttributeInsertionLoc(false), "@nonobjc ");
+      break;
+    }
   }
 
   // If we have a name, install it via an @objc attribute.

lib/Sema/TypeCheckProtocol.cpp

@@ -3653,6 +3653,7 @@ void ConformanceChecker::checkConformance() {
 
       // Objective-C checking for @objc requirements.
       if (requirement->isObjC() &&
+          requirement->getFullName() == witness->getFullName() &&
           !requirement->getAttrs().isUnavailable(TC.Context)) {
         // The witness must also be @objc.
         if (!witness->isObjC()) {

test/decl/protocol/objc.swift

@@ -130,6 +130,19 @@ class C4b : P4 {
 // Don't infer when there is an ambiguity.
 class C4_5a : P4, P5 {
   func method(x: Int, y: Int) { }
-  // expected-error@-1{{Objective-C method 'methodWithX:y:' provided by method 'method(x:y:)' does not match the requirement's selector ('foo:bar:')}}
-  // expected-error@-2{{Objective-C method 'methodWithX:y:' provided by method 'method(x:y:)' does not match the requirement's selector ('wibble:wobble:')}}
+  // expected-error@-1{{ambiguous inference of Objective-C name for instance method 'method(x:y:)' ('foo:bar:' vs 'wibble:wobble:')}}
+  // expected-note@-2{{'method(x:y:)' (in protocol 'P4') provides Objective-C name 'foo:bar:'}}{{3-3=@objc(foo:bar:) }}
+  // expected-note@-3{{'method(x:y:)' (in protocol 'P5') provides Objective-C name 'wibble:wobble:'}}{{3-3=@objc(wibble:wobble:) }}
+  // expected-note@-4{{add '@nonobjc' to silence this error}}{{3-3=@nonobjc }}
+  // expected-error@-5{{Objective-C method 'foo:bar:' provided by method 'method(x:y:)' does not match the requirement's selector ('wibble:wobble:')}}
+}
+
+// Don't complain about a selector mismatch in cases where the
+// selector will be inferred.
+@objc protocol P6 {
+  func doSomething(_ sender: AnyObject?) // expected-note{{requirement 'doSomething' declared here}}
+}
+
+class C6a : P6 {
+  func doSomething(sender: AnyObject?) { } // expected-error{{method 'doSomething(sender:)' has different argument names from those required by protocol 'P6' ('doSomething')}}{{20-20=_ }}{{none}}
 }