Use a marker protocol SendableMetatype to model T.Type: Sendable

Introduce a marker protocol SendableMetatype that is used to indicate
when the metatype of a type will conform to Sendable. Specifically,
`T: SendableMetatype` implies `T.Type: Sendable`. When strict
metatype sendability is enabled, metatypes are only sendable when `T:
SendableMetatype`.

All nominal types implicitly conform to `SendableMetatype`, as do the
various builtin types, function types, etc. The `Sendable` marker
protocol now inherits from `SendableMetatype`, so that `T: Sendable`
implies `T.Type: Sendable`.

Thank you Slava for the excellent idea!

Author: DougGregor

include/swift/AST/KnownProtocols.def

@@ -107,6 +107,7 @@ PROTOCOL(Encodable)
 PROTOCOL(Decodable)
 
 PROTOCOL(Sendable)
+PROTOCOL(SendableMetatype)
 PROTOCOL(UnsafeSendable)
 
 PROTOCOL_(ObjectiveCBridgeable)

lib/AST/ConformanceLookup.cpp

@@ -367,6 +367,8 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
       if (isBitwiseCopyableFunctionType(functionType))
         return synthesizeConformance();
       break;
+    case KnownProtocolKind::SendableMetatype:
+      return synthesizeConformance();
     default:
       break;
     }
@@ -387,21 +389,22 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
     case KnownProtocolKind::Sendable:
       // Metatypes are generally Sendable, but under StrictSendableMetatypes we
       // cannot assume that metatypes based on type parameters are Sendable.
+      // Therefore, check for conformance to SendableMetatype.
       if (ctx.LangOpts.hasFeature(Feature::StrictSendableMetatypes)) {
-        Type instanceType = metatypeType->getInstanceType();
-
-        // If the instance type is a type parameter, it is not necessarily
-        // Sendable. There will need to be a Sendable requirement.
-        if (instanceType->isTypeParameter())
-          break;
-
-        // If the instance type is an archetype or existential, check whether
-        // it conforms to Sendable.
-        // FIXME: If the requirement machine were to infer T.Type: Sendable
-        // from T: Sendable, we wouldn't need this for archetypes.
-        if (instanceType->is<ArchetypeType>() ||
-            instanceType->isAnyExistentialType()) {
-          auto instanceConformance = lookupConformance(instanceType, protocol);
+        auto sendableMetatypeProto = 
+            ctx.getProtocol(KnownProtocolKind::SendableMetatype);
+        if (sendableMetatypeProto) {
+          Type instanceType = metatypeType->getInstanceType();
+
+          // If the instance type is a type parameter, it is not necessarily
+          // Sendable. There will need to be a Sendable requirement.
+          if (instanceType->isTypeParameter())
+            break;
+
+          // If the instance type conforms to SendableMetatype, then its
+          // metatype is Sendable.
+          auto instanceConformance = lookupConformance(
+              instanceType, sendableMetatypeProto);
           if (instanceConformance.isInvalid() ||
               instanceConformance.hasMissingConformance())
             break;
@@ -414,6 +417,7 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
     case KnownProtocolKind::Copyable:
     case KnownProtocolKind::Escapable:
     case KnownProtocolKind::BitwiseCopyable:
+    case KnownProtocolKind::SendableMetatype:
       return ProtocolConformanceRef(
           ctx.getBuiltinConformance(type, protocol,
                                     BuiltinConformanceKind::Synthesized));
@@ -433,6 +437,7 @@ getBuiltinBuiltinTypeConformance(Type type, const BuiltinType *builtinType,
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
     case KnownProtocolKind::Sendable:
+    case KnownProtocolKind::SendableMetatype:
     case KnownProtocolKind::Copyable:
     case KnownProtocolKind::Escapable: {
       ASTContext &ctx = protocol->getASTContext();
@@ -447,7 +452,8 @@ getBuiltinBuiltinTypeConformance(Type type, const BuiltinType *builtinType,
         break;
       }
 
-      // All other builtin types are Sendable, Copyable, and Escapable.
+      // All other builtin types are Sendable, SendableMetatype, Copyable, and
+      // Escapable.
       return ProtocolConformanceRef(
           ctx.getBuiltinConformance(type, protocol,
                                   BuiltinConformanceKind::Synthesized));
@@ -616,6 +622,13 @@ LookupConformanceInModuleRequest::evaluate(
   if (!nominal || isa<ProtocolDecl>(nominal))
     return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 
+  // All nominal types implicitly conform to SendableMetatype.
+  if (protocol->isSpecificProtocol(KnownProtocolKind::SendableMetatype)) {
+    return ProtocolConformanceRef(
+      ctx.getBuiltinConformance(type, protocol,
+                                BuiltinConformanceKind::Synthesized));
+  }
+
   // Expand conformances added by extension macros.
   //
   // FIXME: This expansion should only be done if the

lib/IRGen/GenMeta.cpp

@@ -6985,6 +6985,7 @@ SpecialProtocol irgen::getSpecialProtocolID(ProtocolDecl *P) {
   case KnownProtocolKind::Copyable:
   case KnownProtocolKind::Escapable:
   case KnownProtocolKind::BitwiseCopyable:
+  case KnownProtocolKind::SendableMetatype:
     return SpecialProtocol::None;
   }
 

lib/Sema/TypeCheckProtocol.cpp

@@ -2339,7 +2339,8 @@ static void diagnoseConformanceImpliedByConditionalConformance(
 /// to the given protocol. This should return true when @unchecked can be
 /// used to disable those semantic checks.
 static bool hasAdditionalSemanticChecks(ProtocolDecl *proto) {
-  return proto->isSpecificProtocol(KnownProtocolKind::Sendable);
+  return proto->isSpecificProtocol(KnownProtocolKind::Sendable) ||
+      proto->isSpecificProtocol(KnownProtocolKind::SendableMetatype);
 }
 
 /// Determine whether a conformance to this protocol can be determined at

stdlib/public/core/Sendable.swift

@@ -10,6 +10,9 @@
 //
 //===----------------------------------------------------------------------===//
 
+/// A type `T` whose metatype `T.Type` is `Sendable`.
+@_marker public protocol SendableMetatype: ~Copyable, ~Escapable { }
+
 /// A thread-safe type whose values can be shared across arbitrary concurrent
 /// contexts without introducing a risk of data races. Values of the type may
 /// have no shared mutable state, or they may protect that state with a lock or
@@ -132,7 +135,7 @@
 /// ### Sendable Metatypes
 ///
 /// Metatypes such as `Int.Type` implicitly conform to the `Sendable` protocol.
-@_marker public protocol Sendable: ~Copyable, ~Escapable { }
+@_marker public protocol Sendable: SendableMetatype, ~Copyable, ~Escapable { }
 
 ///
 /// A type whose values can safely be passed across concurrency domains by copying,

test/Concurrency/sendable_metatype.swift

@@ -54,6 +54,14 @@ nonisolated func passMetaWithSendableSmuggled<T: Sendable & Q>(_: T.Type) {
   }
 }
 
+nonisolated func passMetaWithSendableSmuggled<T: SendableMetatype & Q>(_: T.Type) {
+  let x: any Q.Type = T.self
+  Task.detached {
+    acceptMeta(x) // okay, because T: SendableMetatype implies T.Type: Sendable
+    x.g() // okay, because T: SendableMetatype implies T.Type: Sendable
+  }
+}
+
 nonisolated func passSendableToMainActorSmuggledAny<T: Sendable>(_: T.Type) async {
   let x: Sendable.Type = T.self
   await acceptMetaOnMainActor(x)

test/Concurrency/sendable_metatype_typecheck.swift

@@ -51,10 +51,24 @@ nonisolated func passMetaSendable<T: Sendable & Q>(_: T.Type) {
   }
 }
 
+nonisolated func passMetaSendableMeta<T: SendableMetatype & Q>(_: T.Type) {
+  Task.detached {
+    acceptMeta(T.self)
+  }
+}
+
 nonisolated func passMetaWithSendableVal<T: Sendable & Q>(_: T.Type) {
   let x = T.self
   Task.detached {
     acceptMeta(x) // okay, because T is Sendable implies T.Type: Sendable
     x.g() // okay, because T is Sendable implies T.Type: Sendable
   }
 }
+
+nonisolated func passMetaWithMetaSendableVal<T: SendableMetatype & Q>(_: T.Type) {
+  let x = T.self
+  Task.detached {
+    acceptMeta(x) // okay, because T is Sendable implies T.Type: Sendable
+    x.g() // okay, because T is Sendable implies T.Type: Sendable
+  }
+}

test/SymbolGraph/Symbols/SkipProtocolImplementations.swift

@@ -38,7 +38,7 @@
 // - ExtraStruct.Inner
 // (ExtraStruct.Inner will have two sourceOrigins because it has two relationships: a memberOf and a
 // conformsTo)
-// COUNT-COUNT-3: sourceOrigin
+// COUNT-COUNT-4: sourceOrigin
 // COUNT-NOT: sourceOrigin
 
 public protocol SomeProtocol {

test/api-digester/Outputs/Cake-abi.txt

@@ -111,6 +111,7 @@ cake: Class C7 has added a conformance to an existing protocol P1
 cake: Class SuperClassChange has added a conformance to an existing protocol P1
 cake: Enum IceKind has removed conformance to BitwiseCopyable
 cake: Enum IceKind has removed conformance to Sendable
+cake: Enum IceKind has removed conformance to SendableMetatype
 cake: Protocol P3 has added inherited protocol P4
 cake: Protocol P3 has removed inherited protocol P2
 cake: Struct fixedLayoutStruct has added a conformance to an existing protocol P2

test/api-digester/Outputs/Cake.txt

@@ -51,6 +51,7 @@ cake: EnumElement FrozenKind.AddedCase has been added as a new enum case
 /* Conformance changes */
 cake: Enum IceKind has removed conformance to BitwiseCopyable
 cake: Enum IceKind has removed conformance to Sendable
+cake: Enum IceKind has removed conformance to SendableMetatype
 cake: Func ObjCProtocol.removeOptional() is no longer an optional requirement
 cake: Protocol P3 has added inherited protocol P4
 cake: Protocol P3 has removed inherited protocol P2