Allow @preconcurrency to suppress an implied Sendable conformance

When a retroactive conformance to a protocol that inherits from `Sendable`
introduces an implicit `Sendable` conformance, allow `@preconcurrency`
to suppress the diagnostic about the `Sendable` conformance being
introduced outside of the original source file.

Fixes rdar://125080066.

Author: DougGregor

include/swift/Sema/Concurrency.h

@@ -52,7 +52,8 @@ bool diagnoseNonSendableFromDeinit(
 /// the given nominal type from the given declaration context.
 std::optional<DiagnosticBehavior>
 getConcurrencyDiagnosticBehaviorLimit(NominalTypeDecl *nominal,
-                                      const DeclContext *fromDC);
+                                      const DeclContext *fromDC,
+                                      bool ignoreExplicitConformance = false);
 
 } // namespace swift
 

lib/Sema/TypeCheckConcurrency.cpp

@@ -836,7 +836,8 @@ DiagnosticBehavior SendableCheckContext::diagnosticBehavior(
 
 std::optional<DiagnosticBehavior>
 swift::getConcurrencyDiagnosticBehaviorLimit(NominalTypeDecl *nominal,
-                                             const DeclContext *fromDC) {
+                                             const DeclContext *fromDC,
+                                             bool ignoreExplicitConformance) {
   ModuleDecl *importedModule = nullptr;
   if (nominal->getAttrs().hasAttribute<PreconcurrencyAttr>()) {
     // If the declaration itself has the @preconcurrency attribute,
@@ -859,7 +860,8 @@ swift::getConcurrencyDiagnosticBehaviorLimit(NominalTypeDecl *nominal,
 
   // When the type is explicitly non-Sendable, @preconcurrency imports
   // downgrade the diagnostic to a warning in Swift 6.
-  if (hasExplicitSendableConformance(nominal))
+  if (!ignoreExplicitConformance &&
+      hasExplicitSendableConformance(nominal))
     return DiagnosticBehavior::Warning;
 
   // When the type is implicitly non-Sendable, `@preconcurrency` suppresses
@@ -870,12 +872,15 @@ swift::getConcurrencyDiagnosticBehaviorLimit(NominalTypeDecl *nominal,
 }
 
 std::optional<DiagnosticBehavior>
-SendableCheckContext::preconcurrencyBehavior(Decl *decl) const {
+SendableCheckContext::preconcurrencyBehavior(
+    Decl *decl,
+    bool ignoreExplicitConformance) const {
   if (!decl)
     return std::nullopt;
 
   if (auto *nominal = dyn_cast<NominalTypeDecl>(decl)) {
-    return getConcurrencyDiagnosticBehaviorLimit(nominal, fromDC);
+    return getConcurrencyDiagnosticBehaviorLimit(nominal, fromDC,
+                                                 ignoreExplicitConformance);
   }
 
   return std::nullopt;
@@ -5847,8 +5852,16 @@ bool swift::checkSendableConformance(
 
   // Sendable can only be used in the same source file.
   auto conformanceDecl = conformanceDC->getAsDecl();
-  auto behavior = SendableCheckContext(conformanceDC, check)
-      .defaultDiagnosticBehavior();
+  SendableCheckContext checkContext(conformanceDC, check);
+  DiagnosticBehavior behavior = checkContext.defaultDiagnosticBehavior();
+  if (conformance->getSourceKind() == ConformanceEntryKind::Implied &&
+      conformance->getProtocol()->isSpecificProtocol(
+          KnownProtocolKind::Sendable)) {
+    if (auto optBehavior = checkContext.preconcurrencyBehavior(
+            nominal, /*ignoreExplicitConformance=*/true))
+      behavior = *optBehavior;
+  }
+
   if (conformanceDC->getOutermostParentSourceFile() &&
       conformanceDC->getOutermostParentSourceFile() !=
       nominal->getOutermostParentSourceFile()) {

lib/Sema/TypeCheckConcurrency.h

@@ -391,7 +391,9 @@ struct SendableCheckContext {
   /// type in this context.
   DiagnosticBehavior diagnosticBehavior(NominalTypeDecl *nominal) const;
 
-  std::optional<DiagnosticBehavior> preconcurrencyBehavior(Decl *decl) const;
+  std::optional<DiagnosticBehavior> preconcurrencyBehavior(
+      Decl *decl,
+      bool ignoreExplicitConformance = false) const;
 
   /// Whether we are in an explicit conformance to Sendable.
   bool isExplicitSendableConformance() const;

test/Concurrency/Inputs/NonStrictModule.swift

@@ -10,3 +10,8 @@ public protocol NonStrictProtocol {
   func send(_ body: @Sendable () -> Void)
   func dontSend(_ body: () -> Void)
 }
+
+open class NonStrictClass2 { }
+open class NonStrictClass3 { }
+
+public protocol MySendableProto: Sendable {}

test/Concurrency/predates_concurrency_import.swift

@@ -63,3 +63,8 @@ struct HasStatics {
   // expected-warning@-2{{static property 'ss' is not concurrency-safe because non-'Sendable' type 'StrictStruct' may have shared mutable state}}
   // expected-note@-3{{isolate 'ss' to a global actor, or conform 'StrictStruct' to 'Sendable'}}
 }
+
+extension NonStrictClass2: @retroactive MySendableProto { }
+
+extension NonStrictClass3: @retroactive Sendable { }
+// expected-warning@-1{{conformance to 'Sendable' must occur in the same source file as class 'NonStrictClass3'; use '@unchecked Sendable' for retroactive conformance}}