Merge pull request #81985 from DougGregor/non-sendable-metatype-capture-diag-fixes-6.2

[6.2] Minor fixes for the non-sendable meta type capture diagnostics

Author: DougGregor

include/swift/AST/DiagnosticGroups.def

@@ -60,6 +60,7 @@ GROUP(PropertyWrappers, "property-wrapper-requirements")
 GROUP(ProtocolTypeNonConformance, "protocol-type-non-conformance")
 GROUP(ResultBuilderMethods, "result-builder-methods")
 GROUP(SendableClosureCaptures, "sendable-closure-captures")
+GROUP(SendableMetatypes, "sendable-metatypes")
 GROUP(SendingRisksDataRace, "sending-risks-data-race")
 GROUP(StrictLanguageFeatures, "strict-language-features")
 GROUP(StrictMemorySafety, "strict-memory-safety")

include/swift/AST/DiagnosticsSema.def

@@ -5662,7 +5662,7 @@ ERROR(non_sendable_isolated_capture,none,
       "capture of %1 with non-Sendable type %0 in an isolated "
       "%select{local function|closure}2",
       (Type, DeclName, bool))
-ERROR(non_sendable_metatype_capture,none,
+GROUPED_ERROR(non_sendable_metatype_capture,SendableMetatypes,none,
       "capture of non-Sendable type %0 in an isolated "
       "%select{local function|closure}1",
       (Type, bool))

lib/Sema/TypeCheckConcurrency.cpp

@@ -3068,7 +3068,8 @@ namespace {
         }
       }
 
-      if (mayExecuteConcurrentlyWith(
+      if (ctx.LangOpts.hasFeature(Feature::RegionBasedIsolation) &&
+          mayExecuteConcurrentlyWith(
               localFunc.getAsDeclContext(), getDeclContext(),
               /*includeSending*/true)) {
         auto innermostGenericDC = localFunc.getAsDeclContext();

test/Concurrency/sendable_metatype_swift5.swift

@@ -0,0 +1,13 @@
+// RUN: %target-typecheck-verify-swift -swift-version 5
+
+// REQUIRES: concurrency
+
+protocol P {
+  static func doSomething()
+}
+
+func doSomethingStatic<T: P>(_: T.Type) {
+  Task { @concurrent in
+    T.doSomething()
+  }
+}

userdocs/diagnostics/sendable-metatypes.md

@@ -0,0 +1,62 @@
+# Sendable metatypes
+
+Types that are shared in concurrent code generally need to conform to `Sendable`. The same is true in generic code when sharing parameters of a generic parameter `T`. For example, the given code will produce an error under strict concurrency checking
+
+```swift
+func doSomethingElsewhere<T>(_ value: T) {
+  Task { @concurrent in
+    print(value) // warning: capture of non-Sendable type 'T'
+  }
+}
+```
+
+because `value` can have a non-Sendable type that is not safe to share. To address this potential data race, the type `T` can be marked as `Sendable`:
+
+```swift
+func doSomethingElsewhere<T: Sendable>(_ value: T) {
+  Task { @concurrent in
+    print(value)
+  }
+}
+```
+
+The same issue can occur when passing the type `T` itself, rather than a value of type `T`. The compiler will indicate such problems by noting that the metatype of `T`, spelled `T.Type`, is not `Sendable`:
+
+```swift
+protocol P {
+  static func doSomething()
+}
+
+func doSomethingStatic<T: P>(_: T.Type) {
+  Task { @concurrent in
+    T.doSomething() // warning: capture of non-Sendable type 'T.Type' in an isolated closure
+  }
+}
+```
+
+In these cases, the type parameter should be required to conform to the `SendableMetatype` protocol, e.g.,
+
+```swift
+func doSomethingStatic<T: P & SendableMetatype>(_: T.Type) {
+  Task { @concurrent in
+    T.doSomething()
+  }
+}
+```
+
+The `SendableMetatype` requirement allows the function to share the type `T` in concurrent code. To maintain data race safety, it prevents callers from using isolated conformances in the call. For example, the following code will be rejected due to a data race:
+
+```swift
+@MainActor
+class C: @MainActor P {
+  static func doSomething() { }
+}
+
+@MainActor
+func test(c: C) {
+  doSomethingStatic(C.self) // error: main actor-isolated conformance of 'C' to 'P' cannot satisfy conformance requirement for a 'Sendable' type parameter
+}
+
+```
+
+The conformance of `C` to `P` can only be used on the main actor, so it cannot be provided to `doSomethingStatic`, which calls the conformance from a different concurrent task.