Protocols that predate concurrency downgrade Sendable checking.

When the Error and CodingKey protocols introduced their Sendable
requirements, we carved out special Sendable checking rules that
suppressed diagnostics when a type becaming Sendable implicitly via
conformance to Error or CodingKey. Extend that logic to any protocol
that predates concurrency, so that existing libraries can benefit from
the same staging we used for Error and CodingKey.

In the future, we can mark Error and CodingKey to eliminate the
special case.

Author: DougGregor

lib/Sema/TypeCheckProtocol.cpp

@@ -6027,6 +6027,27 @@ diagnoseMissingAppendInterpolationMethod(NominalTypeDecl *typeDecl) {
   }
 }
 
+/// Determine whether this conformance is implied by another conformance
+/// to a protocol that predated concurrency.
+static bool isImpliedByConformancePredatingConcurrency(
+    NormalProtocolConformance *conformance) {
+  if (conformance->getSourceKind() != ConformanceEntryKind::Implied)
+    return false;
+
+  auto implied = conformance->getImplyingConformance();
+  if (!implied)
+    return false;
+
+  auto impliedProto = implied->getProtocol();
+  if (impliedProto->predatesConcurrency() ||
+      impliedProto->isSpecificProtocol(KnownProtocolKind::Error) ||
+      impliedProto->isSpecificProtocol(KnownProtocolKind::CodingKey))
+    return true;
+
+  // Recurse to look further.
+  return isImpliedByConformancePredatingConcurrency(implied);
+}
+
 void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
   auto *const dc = idc->getAsGenericContext();
   auto *sf = dc->getParentSourceFile();
@@ -6052,8 +6073,7 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
 
   ProtocolConformance *SendableConformance = nullptr;
   bool sendableConformanceIsUnchecked = false;
-  ProtocolConformance *errorConformance = nullptr;
-  ProtocolConformance *codingKeyConformance = nullptr;
+  bool sendableConformancePredatesConcurrency = false;
   bool anyInvalid = false;
   for (auto conformance : conformances) {
     // Check and record normal conformances.
@@ -6086,6 +6106,8 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
       if (auto normal = conformance->getRootNormalConformance()) {
         if (normal->isUnchecked())
           sendableConformanceIsUnchecked = true;
+        else if (isImpliedByConformancePredatingConcurrency(normal))
+          sendableConformancePredatesConcurrency = true;
       }
     } else if (proto->isSpecificProtocol(KnownProtocolKind::DistributedActor)) {
       if (auto classDecl = dyn_cast<ClassDecl>(nominal)) {
@@ -6115,17 +6137,13 @@ void TypeChecker::checkConformancesInContext(IterableDeclContext *idc) {
     } else if (proto->isSpecificProtocol(
                    KnownProtocolKind::UnsafeSendable)) {
       sendableConformanceIsUnchecked = true;
-    } else if (proto->isSpecificProtocol(KnownProtocolKind::Error)) {
-      errorConformance = conformance;
-    } else if (proto->isSpecificProtocol(KnownProtocolKind::CodingKey)) {
-      codingKeyConformance = conformance;
     }
   }
 
   // Check constraints of Sendable.
   if (SendableConformance && !sendableConformanceIsUnchecked) {
     SendableCheck check = SendableCheck::Explicit;
-    if (errorConformance || codingKeyConformance)
+    if (sendableConformancePredatesConcurrency)
       check = SendableCheck::ImpliedByStandardProtocol;
     else if (SendableConformance->getSourceKind() ==
                  ConformanceEntryKind::Synthesized)

test/Concurrency/predates_concurrency.swift

@@ -75,3 +75,23 @@ func testCallsWithAsync() async {
   c.f() // expected-error{{expression is 'async' but is not marked with 'await'}}
   // expected-note@-1{{calls to instance method 'f()' from outside of its actor context are implicitly asynchronous}}
 }
+
+// ---------------------------------------------------------------------------
+// Protocols that inherit Sendable and predate concurrency.
+// ---------------------------------------------------------------------------
+@_predatesConcurrency protocol P: Sendable { }
+protocol Q: P { }
+
+class NS { } // expected-note{{class 'NS' does not conform to the 'Sendable' protocol}}
+
+struct S1: P {
+  var ns: NS
+}
+
+struct S2: Q {
+  var ns: NS
+}
+
+struct S3: Q, Sendable {
+  var ns: NS // expected-error{{stored property 'ns' of 'Sendable'-conforming struct 'S3' has non-sendable type 'NS'}}
+}