Sema: Record a default witness for requirements with satisfied Obj-C siblings.

Rather than just skipping requirements with satisfied Obj-C siblings during
`resolveValueWitnesses()`, proactively record a default witness for these
requirements. This prevents lazy value witness resolution from giving the
skipped requirements a default witness after the conformance is already marked
complete, which causes an assertion to fail.

Resolves rdar://119435253

Author: tshortli

lib/Sema/TypeCheckProtocol.cpp

@@ -4390,7 +4390,8 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
   // The compiler will reject actual uses.
   auto Attrs = requirement->getAttrs();
   if (Attrs.hasAttribute<OptionalAttr>() ||
-      Attrs.isUnavailable(getASTContext())) {
+      Attrs.isUnavailable(getASTContext()) ||
+      !shouldRecordMissingWitness(Proto, Conformance, requirement)) {
     return ResolveWitnessResult::Missing;
   }
 
@@ -4403,9 +4404,6 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
     return ResolveWitnessResult::ExplicitFailed;
   }
 
-  if (!shouldRecordMissingWitness(Proto, Conformance, requirement))
-    return ResolveWitnessResult::Missing;
-
   if (!numViable) {
     // Save the missing requirement for later diagnosis.
     getASTContext().addDelayedMissingWitness(Conformance, {requirement, matches});
@@ -5109,13 +5107,13 @@ void ConformanceChecker::resolveValueWitnesses() {
     // async-looking ObjC protocol method requirement into two Swift protocol
     // requirements: an async version and a sync version. Exactly one of the two
     // must be witnessed by the conformer.
-    if (!requirement->isImplicit() &&
-        getObjCRequirementSibling(
-            Proto, requirement, objcRequirementMap,
-            [this](AbstractFunctionDecl *cand) {
-              return !cand->getAttrs().hasAttribute<OptionalAttr>() &&
-                     !cand->isImplicit() && this->Conformance->hasWitness(cand);
-            })) {
+    if (getObjCRequirementSibling(Proto, requirement, objcRequirementMap,
+                                  [this](AbstractFunctionDecl *cand) {
+                                    return static_cast<bool>(
+                                        this->Conformance->getWitness(cand));
+                                  })) {
+      recordOptionalWitness(requirement);
+      finalizeWitness();
       continue;
     }
 

test/ClangImporter/protocol-member-renaming.swift

@@ -9,7 +9,6 @@ class Modern : NSObject, FooDelegate {
 class PreMigration : NSObject, FooDelegate {
   func foo(_ foo: Foo, willConsumeObject object: Any) {}
   // expected-error@-1 {{'foo(_:willConsumeObject:)' has been renamed to 'foo(_:willConsume:)'}} {{24-41=willConsume}}
-  // expected-error@-2 {{method 'foo(_:willConsumeObject:)' has different argument labels from those required by protocol 'FooDelegate' ('foo(_:willConsume:)')}} {{24-41=willConsume}}
 }
 
 class OptionalButUnavailableImpl : OptionalButUnavailable {

test/Serialization/conformance-objc-async.swift

@@ -1,10 +1,10 @@
 // RUN: %empty-directory(%t)
 // RUN: split-file %s %t
-// RUN: %target-swift-emit-module-interface(%t/Conformance.swiftinterface) -module-name Conformance -I %t %t/Conformance.swift
+// RUN: %target-swift-emit-module-interface(%t/Conformance.swiftinterface) -target %target-swift-abi-5.5-triple -module-name Conformance -I %t %t/Conformance.swift
+// RUN: %target-swift-emit-module-interface(%t/Conformance.swiftinterface) -target %target-swift-abi-5.5-triple -module-name Conformance -experimental-lazy-typecheck -I %t %t/Conformance.swift
 // RUN: %target-swift-frontend -compile-module-from-interface %t/Conformance.swiftinterface -module-name Conformance -o /dev/null -I %t
 // REQUIRES: objc_interop
-
-// REQUIRES: rdar119435253
+// REQUIRES: concurrency
 
 //--- module.modulemap
 module ObjCProto {
@@ -20,11 +20,80 @@ module ObjCProto {
 //--- Conformance.swift
 import ObjCProto
 
-public final class ConformsToDoableWithCompletionHandler: Doable {
+public final class DoableWithCompletionHandler: Doable {
+  // Matches synchronous requirement
   public func doIt(completion: @escaping () -> Void) {}
 }
 
-@available(SwiftStdlib 5.5, *)
-public final class ConformsToDoableWithAsync:Doable {
+public final class DoableWithAsync: Doable {
+  // Matches async requirement
+  public func doIt() async {}
+}
+
+public final class DoableWithCompletionHandlerAndAsyncCandidate: Doable {
+  // Matches synchronous requirement
+  public func doIt(completion: @escaping () -> Void) {}
+
+  // Near-miss for async requirement
+  public func doIt() async -> Int {}
+}
+
+public final class DoableWithCompletionHandlerAndAsyncCandidate2: Doable {
+  // Near-miss for async requirement
+  public func doIt() async -> Int {}
+
+  // Matches synchronous requirement
+  public func doIt(completion: @escaping () -> Void) {}
+}
+
+public final class DoableWithCompletionHandlerAndMultipleAsyncCandidates: Doable {
+  // Matches synchronous requirement
+  public func doIt(completion: @escaping () -> Void) {}
+
+  // Multiple near-misses for async requirement
+  public func doIt() async -> Int {}
+  public func doIt() async -> Double {}
+}
+
+public final class DoableWithCompletionHandlerAndMultipleAsyncCandidates2: Doable {
+  // Multiple near-misses for async requirement
+  public func doIt() async -> Int {}
+  public func doIt() async -> Double {}
+
+  // Matches synchronous requirement
+  public func doIt(completion: @escaping () -> Void) {}
+}
+
+public final class DoableWithAsyncAndCompletionHandlerCandidate: Doable {
+  // Matches async requirement
+  public func doIt() async {}
+
+  // Near-miss for synchronous requirement
+  public func doIt(reply: @escaping () -> Void) {}
+}
+
+public final class DoableWithAsyncAndCompletionHandlerCandidate2: Doable {
+  // Near-miss for synchronous requirement
+  public func doIt(reply: @escaping () -> Void) {}
+
+  // Matches async requirement
+  public func doIt() async {}
+}
+
+public final class DoableWithAsyncAndMultipleCompletionHandlerCandidates: Doable {
+  // Matches async requirement
+  public func doIt() async {}
+
+  // Multiple near-misses for synchronous requirement
+  public func doIt(reply: @escaping () -> Void) {}
+  public func doIt(otherReply: @escaping () -> Void) {}
+}
+
+public final class DoableWithAsyncAndMultipleCompletionHandlerCandidates2: Doable {
+  // Multiple near-misses for synchronous requirement
+  public func doIt(otherReply: @escaping () -> Void) {}
+  public func doIt(reply: @escaping () -> Void) {}
+
+  // Matches async requirement
   public func doIt() async {}
 }