Add a diagnostic group for the diagnostic about non-Sendable metatypes.

This is a new restriction that folks are sure to run into, so provide
it with some actionable documentation. Fixes rdar://152450956.

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

@@ -5717,7 +5717,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))

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.