Make @preconcurrency import hide sendable variance

When the conformance checker and override checker detect a difference in a function type’s @sendable attribute that varies in an illegal way, they now check if the protocol/base class was imported with an @preconcurrency import, and either limit the diagnostic or suggest adding @preconcurrency to the import as appropriate.

Completes rdar://91109455.

Author: beccadax

lib/Sema/TypeCheckDeclOverride.cpp

@@ -15,6 +15,7 @@
 //===----------------------------------------------------------------------===//
 #include "MiscDiagnostics.h"
 #include "TypeCheckAvailability.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckDecl.h"
 #include "TypeCheckObjC.h"
 #include "TypeChecker.h"
@@ -548,12 +549,20 @@ static void diagnoseGeneralOverrideFailure(ValueDecl *decl,
     diags.diagnose(decl, diag::override_multiple_decls_base,
                    decl->getName());
     break;
-  case OverrideCheckingAttempt::MismatchedSendability:
-    // FIXME: suppress if any matches brought in via @preconcurrency import?
-    diags.diagnose(decl, diag::override_sendability_mismatch,
-                   decl->getName())
-      .warnUntilSwiftVersion(6);
+  case OverrideCheckingAttempt::MismatchedSendability: {
+    SendableCheckContext fromContext(decl->getDeclContext(),
+                                     SendableCheck::Explicit);
+    auto baseDeclClass =
+        decl->getOverriddenDecl()->getDeclContext()->getSelfClassDecl();
+
+    diagnoseSendabilityErrorBasedOn(baseDeclClass, fromContext,
+                                    [&](DiagnosticBehavior limit) {
+      diags.diagnose(decl, diag::override_sendability_mismatch, decl->getName())
+          .limitBehavior(limit);
+      return false;
+    });
     break;
+  }
   case OverrideCheckingAttempt::BaseName:
     diags.diagnose(decl, diag::override_multiple_decls_arg_mismatch,
                    decl->getName());
@@ -1288,11 +1297,19 @@ bool OverrideMatcher::checkOverride(ValueDecl *baseDecl,
     return true;
 
   if (attempt == OverrideCheckingAttempt::MismatchedSendability) {
-    // FIXME: suppress if any matches brought in via @preconcurrency import?
-    diags.diagnose(decl, diag::override_sendability_mismatch,
-                   decl->getName())
-      .warnUntilSwiftVersion(6);
-    diags.diagnose(baseDecl, diag::overridden_here);
+    SendableCheckContext fromContext(decl->getDeclContext(),
+                                     SendableCheck::Explicit);
+    auto baseDeclClass = baseDecl->getDeclContext()->getSelfClassDecl();
+
+    diagnoseSendabilityErrorBasedOn(baseDeclClass, fromContext,
+                                    [&](DiagnosticBehavior limit) {
+      diags.diagnose(decl, diag::override_sendability_mismatch,
+                     decl->getName())
+        .limitBehavior(limit);
+      diags.diagnose(baseDecl, diag::overridden_here)
+        .limitBehavior(limit);
+      return false;
+    });
   }
   // Catch-all to make sure we don't silently accept something we shouldn't.
   else if (attempt != OverrideCheckingAttempt::PerfectMatch) {

lib/Sema/TypeCheckProtocol.cpp

@@ -4288,19 +4288,32 @@ ConformanceChecker::resolveWitnessViaLookup(ValueDecl *requirement) {
                          requirement->getName());
         });
     }
-    if (best.Kind == MatchKind::RequiresNonSendable)
-      diagnoseOrDefer(requirement, getASTContext().isSwiftVersionAtLeast(6),
-                      [this, requirement, witness]
-                          (NormalProtocolConformance *conformance) {
-        auto &diags = DC->getASTContext().Diags;
+    if (best.Kind == MatchKind::RequiresNonSendable) {
+      SendableCheckContext sendFrom(witness->getDeclContext(),
+                                    SendableCheck::Explicit);
 
-        diags.diagnose(getLocForDiagnosingWitness(conformance, witness),
-                       diag::witness_not_as_sendable,
-                       witness->getDescriptiveKind(), witness->getName(),
-                       conformance->getProtocol()->getName())
-            .warnUntilSwiftVersion(6);
-        diags.diagnose(requirement, diag::less_sendable_reqt_here);
-      });
+      auto behavior = sendFrom.diagnosticBehavior(Conformance->getProtocol());
+      if (behavior != DiagnosticBehavior::Ignore) {
+        bool isError = behavior < DiagnosticBehavior::Warning;
+        
+        diagnoseOrDefer(requirement, isError,
+                        [this, requirement, witness, sendFrom](
+                          NormalProtocolConformance *conformance) {
+          diagnoseSendabilityErrorBasedOn(conformance->getProtocol(), sendFrom,
+                                          [&](DiagnosticBehavior limit) {
+            auto &diags = DC->getASTContext().Diags;
+            diags.diagnose(getLocForDiagnosingWitness(conformance, witness),
+                           diag::witness_not_as_sendable,
+                           witness->getDescriptiveKind(), witness->getName(),
+                           conformance->getProtocol()->getName())
+                .limitBehavior(limit);
+            diags.diagnose(requirement, diag::less_sendable_reqt_here)
+                .limitBehavior(limit);
+            return false;
+          });
+        });
+      }
+    }
 
     auto check = checkWitness(requirement, best);
 

test/Concurrency/Inputs/NonStrictModule.swift

@@ -1,3 +1,11 @@
-public class NonStrictClass { }
-
 public struct NonStrictStruct { }
+
+open class NonStrictClass {
+  open func send(_ body: @Sendable () -> Void) {}
+  open func dontSend(_ body: () -> Void) {}
+}
+
+public protocol NonStrictProtocol {
+  func send(_ body: @Sendable () -> Void)
+  func dontSend(_ body: () -> Void)
+}

test/Concurrency/Inputs/StrictModule.swift

@@ -1,3 +1,11 @@
 public struct StrictStruct: Hashable { }
 
-open class StrictClass { }
+open class StrictClass {
+  open func send(_ body: @Sendable () -> Void) {}
+  open func dontSend(_ body: () -> Void) {}
+}
+
+public protocol StrictProtocol {
+  func send(_ body: @Sendable () -> Void)
+  func dontSend(_ body: () -> Void)
+}

test/Concurrency/sendable_preconcurrency.swift

@@ -39,3 +39,23 @@ func testA(ns: NS, mt: MyType, mt2: MyType2, mt3: MyType3, sc: StrictClass, nsc:
 }
 
 extension NonStrictStruct: @unchecked Sendable { }
+
+class StrictSubclass: StrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: @Sendable () -> ()) {} // expected-warning {{declaration 'dontSend' has a type with different sendability from any potential overrides}}
+}
+
+struct StrictConformer: StrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: @Sendable () -> Void) {} // expected-warning {{sendability of function types in instance method 'dontSend' does not match requirement in protocol 'StrictProtocol'}}
+}
+
+class NonStrictSubclass: NonStrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: @Sendable () -> ()) {} // no-warning
+}
+
+struct NonStrictConformer: NonStrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: @Sendable () -> Void) {} // no-warning
+}

test/Concurrency/sendable_without_preconcurrency.swift

@@ -33,3 +33,23 @@ func testA(ns: NS, mt: MyType, mt2: MyType2, sc: StrictClass, nsc: NonStrictClas
 }
 
 extension NonStrictStruct: @unchecked Sendable { }
+
+class StrictSubclass: StrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: () -> ()) {}
+}
+
+struct StrictConformer: StrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: () -> Void) {}
+}
+
+class NonStrictSubclass: NonStrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: () -> ()) {}
+}
+
+struct NonStrictConformer: NonStrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: () -> Void) {}
+}

test/Concurrency/sendable_without_preconcurrency_2.swift

@@ -34,3 +34,23 @@ func testA(ns: NS, mt: MyType, mt2: MyType2, sc: StrictClass, nsc: NonStrictClas
 }
 
 extension NonStrictStruct: @unchecked Sendable { }
+
+class StrictSubclass: StrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: @Sendable () -> ()) {} // expected-warning {{declaration 'dontSend' has a type with different sendability from any potential overrides}}
+}
+
+struct StrictConformer: StrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: @Sendable () -> Void) {} // expected-warning {{sendability of function types in instance method 'dontSend' does not match requirement in protocol 'StrictProtocol'}}
+}
+
+class NonStrictSubclass: NonStrictClass {
+  override func send(_ body: () -> ()) {}
+  override func dontSend(_ body: @Sendable () -> ()) {} // expected-warning {{declaration 'dontSend' has a type with different sendability from any potential overrides}}
+}
+
+struct NonStrictConformer: NonStrictProtocol {
+  func send(_ body: () -> Void) {}
+  func dontSend(_ body: @Sendable () -> Void) {} // expected-warning {{sendability of function types in instance method 'dontSend' does not match requirement in protocol 'NonStrictProtocol'}}
+}

test/attr/attr_concurrent.swift

@@ -135,8 +135,8 @@ class SuperSendable {
 
 class SubSendable: SuperSendable {
   override func runsInBackground(_: () -> Void) {}
-  override func runsInForeground(_: @Sendable () -> Void) {} // expected-warning {{declaration 'runsInForeground' has a type with different sendability from any potential overrides; this is an error in Swift 6}}
-  override func runnableInBackground() -> () -> Void { fatalError() }  // expected-warning {{declaration 'runnableInBackground()' has a type with different sendability from any potential overrides; this is an error in Swift 6}}
+  override func runsInForeground(_: @Sendable () -> Void) {} // expected-warning {{declaration 'runsInForeground' has a type with different sendability from any potential overrides}}
+  override func runnableInBackground() -> () -> Void { fatalError() }  // expected-warning {{declaration 'runnableInBackground()' has a type with different sendability from any potential overrides}}
   override func runnableInForeground() -> @Sendable () -> Void { fatalError() }
 }
 
@@ -149,7 +149,7 @@ protocol AbstractSendable {
 
 struct ConcreteSendable: AbstractSendable {
   func runsInBackground(_: () -> Void) {}
-  func runsInForeground(_: @Sendable () -> Void) {} // expected-warning {{sendability of function types in instance method 'runsInForeground' does not match requirement in protocol 'AbstractSendable'; this is an error in Swift 6}}
-  func runnableInBackground() -> () -> Void { fatalError() } // expected-warning {{sendability of function types in instance method 'runnableInBackground()' does not match requirement in protocol 'AbstractSendable'; this is an error in Swift 6}}
+  func runsInForeground(_: @Sendable () -> Void) {} // expected-warning {{sendability of function types in instance method 'runsInForeground' does not match requirement in protocol 'AbstractSendable'}}
+  func runnableInBackground() -> () -> Void { fatalError() } // expected-warning {{sendability of function types in instance method 'runnableInBackground()' does not match requirement in protocol 'AbstractSendable'}}
   func runnableInForeground() -> @Sendable () -> Void { fatalError() }
 }

test/decl/protocol/conforms/associated_type.swift

@@ -64,7 +64,7 @@ struct X1b : P1 {
 struct SendableX1b : P1 {
   typealias A = @Sendable (Int) -> Int
 
-  func f(_: (Int) -> Int) { } // expected-warning {{sendability of function types in instance method 'f' does not match requirement in protocol 'P1'; this is an error in Swift 6}}
+  func f(_: (Int) -> Int) { } // expected-warning {{sendability of function types in instance method 'f' does not match requirement in protocol 'P1'}}
 }
 
 struct X1c : P1 {
@@ -99,15 +99,15 @@ struct X2b : P2 { // expected-error{{type 'X2b' does not conform to protocol 'P2
 }
 
 struct X2c : P2 {
-  func f(_: @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'f' does not match requirement in protocol 'P2'; this is an error in Swift 6}}
-  func g(_: @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'g' does not match requirement in protocol 'P2'; this is an error in Swift 6}}
+  func f(_: @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'f' does not match requirement in protocol 'P2'}}
+  func g(_: @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'g' does not match requirement in protocol 'P2'}}
   func h(_: @Sendable (Int) -> Int) { }
   func i(_: @Sendable (Int) -> Int) { }
 }
 
 struct X2d : P2 { // expected-error{{type 'X2d' does not conform to protocol 'P2'}}
   func f(_: @escaping @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping @Sendable (Int) -> Int) -> ()'}}
-  func g(_: @escaping @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'g' does not match requirement in protocol 'P2'; this is an error in Swift 6}}
+  func g(_: @escaping @Sendable (Int) -> Int) { } // expected-warning{{sendability of function types in instance method 'g' does not match requirement in protocol 'P2'}}
   func h(_: @escaping @Sendable (Int) -> Int) { } // expected-note{{candidate has non-matching type '(@escaping @Sendable (Int) -> Int) -> ()'}}
   func i(_: @escaping @Sendable (Int) -> Int) { }
 }