Permit redeclaration of superclass's Sendable-ness

A recent change to `Sendable` conformance handling resulted in subclasses of global-actor-confined classes being rejected if they explicitly declared a conformance to `Sendable`.

This behavior is technically correct because actor-isolated types are implicitly `Sendable`, but the source compatibility regression was not desirable. We are also considering requiring subclasses to explicitly repeat their superclass's `Sendable` conformance, so it makes sense to allow these redundant conformances in the general case to ease that potential transition.

Fixes rdar://88700507.

Author: beccadax

lib/AST/ConformanceLookupTable.cpp

@@ -535,6 +535,8 @@ ConformanceLookupTable::Ordering ConformanceLookupTable::compareConformances(
   //
   // FIXME: Conformance lookup should really depend on source location for
   // this to be 100% correct.
+  // FIXME: When a class and an extension with the same availability declare the
+  // same conformance, this silently takes the class and drops the extension.
   if (lhs->getDeclContext()->isAlwaysAvailableConformanceContext() !=
       rhs->getDeclContext()->isAlwaysAvailableConformanceContext()) {
     return (lhs->getDeclContext()->isAlwaysAvailableConformanceContext()
@@ -544,12 +546,22 @@ ConformanceLookupTable::Ordering ConformanceLookupTable::compareConformances(
 
   // If one entry is fixed and the other is not, we have our answer.
   if (lhs->isFixed() != rhs->isFixed()) {
+    auto isReplaceableOrMarker = [](ConformanceEntry *entry) -> bool {
+      ConformanceEntryKind kind = entry->getRankingKind();
+      if (isReplaceable(kind))
+        return true;
+
+      // Allow replacement of an explicit conformance to a marker protocol.
+      // (This permits redundant explicit declarations of `Sendable`.)
+      return (kind == ConformanceEntryKind::Explicit
+              && entry->getProtocol()->isMarkerProtocol());
+    };
+
     // If the non-fixed conformance is not replaceable, we have a failure to
     // diagnose.
-    diagnoseSuperseded = (lhs->isFixed() &&
-                          !isReplaceable(rhs->getRankingKind())) ||
-                         (rhs->isFixed() &&
-                          !isReplaceable(lhs->getRankingKind()));
+    // FIXME: We should probably diagnose if they have different constraints.
+    diagnoseSuperseded = (lhs->isFixed() && !isReplaceableOrMarker(rhs)) ||
+                         (rhs->isFixed() && !isReplaceableOrMarker(lhs));
 
     return lhs->isFixed() ? Ordering::Before : Ordering::After;
   }

test/Concurrency/sendable_conformance_checking.swift

@@ -151,3 +151,17 @@ actor A10: AsyncThrowingProtocolWithNotSendable {
 class Klass<Output: Sendable>: Sendable {}
 final class SubKlass: Klass<[S]> {}
 public struct S {}
+
+// rdar://88700507 - redundant conformance of @MainActor-isolated subclass to 'Sendable'
+@MainActor class MainSuper {}
+class MainSub: MainSuper, @unchecked Sendable {}
+
+class SendableSuper: @unchecked Sendable {}
+class SendableSub: SendableSuper, @unchecked Sendable {}
+
+class SendableExtSub: SendableSuper {}
+extension SendableExtSub: @unchecked Sendable {}
+
+// Still want to know about same-class redundancy
+class MultiConformance: @unchecked Sendable {} // expected-note {{'MultiConformance' declares conformance to protocol 'Sendable' here}}
+extension MultiConformance: @unchecked Sendable {} // expected-error {{redundant conformance of 'MultiConformance' to protocol 'Sendable'}}