[SE-0470] Treat metatype of archetype/existential type with no protocol requirements as Sendable

A metatype for an archetype or existential with no (non-marker)
protocol requirements cannot, by definition, carry any (isolated)
protocol conformances with it, so it's safe to treat such metatypes as
Sendable.

(cherry picked from commit 8626404)

Author: DougGregor

lib/AST/ConformanceLookup.cpp

@@ -66,6 +66,15 @@ swift::collectExistentialConformances(CanType fromType,
   return fromType->getASTContext().AllocateCopy(conformances);
 }
 
+static bool containsNonMarkerProtocols(ArrayRef<ProtocolDecl *> protocols) {
+  for (auto proto : protocols) {
+    if (!proto->isMarkerProtocol())
+      return true;
+  }
+
+  return false;
+}
+
 ProtocolConformanceRef
 swift::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   ASTContext &ctx = protocol->getASTContext();
@@ -146,6 +155,12 @@ swift::lookupExistentialConformance(Type type, ProtocolDecl *protocol) {
   if (auto conformance = lookupSuperclassConformance(layout.getSuperclass()))
     return conformance;
 
+  // If the protocol is SendableMetatype, and there are no non-marker protocol
+  // requirements, allow it via self-conformance.
+  if (protocol->isSpecificProtocol(KnownProtocolKind::SendableMetatype) &&
+      !containsNonMarkerProtocols(layout.getProtocols()))
+    return ProtocolConformanceRef(ctx.getSelfConformance(protocol));
+
   // We didn't find our protocol in the existential's list; it doesn't
   // conform.
   return ProtocolConformanceRef::forInvalid();
@@ -377,6 +392,48 @@ static ProtocolConformanceRef getBuiltinFunctionTypeConformance(
   return ProtocolConformanceRef::forMissingOrInvalid(type, protocol);
 }
 
+/// Given the instance type of a metatype, determine whether the metatype is
+/// Sendable.
+///
+// Metatypes are generally Sendable, but with isolated conformances we
+// cannot assume that metatypes based on type parameters are Sendable.
+// Therefore, check for conformance to SendableMetatype.
+static bool metatypeWithInstanceTypeIsSendable(Type instanceType) {
+  ASTContext &ctx = instanceType->getASTContext();
+
+  // If we don't have the SendableMetatype protocol at all, just assume all
+  // metatypes are Sendable.
+  auto sendableMetatypeProto =
+      ctx.getProtocol(KnownProtocolKind::SendableMetatype);
+  if (!sendableMetatypeProto)
+    return true;
+
+  // If the instance type is a type parameter, it is not necessarily
+  // SendableMetatype. There will need to be a SendableMetatype requirement,
+  // but we do not have the generic environment to check that.
+  if (instanceType->isTypeParameter())
+    return false;
+
+  // If the instance type conforms to SendableMetatype, then its
+  // metatype is Sendable.
+  auto instanceConformance = lookupConformance(
+      instanceType, sendableMetatypeProto);
+  if (!instanceConformance.isInvalid() &&
+      !instanceConformance.hasMissingConformance())
+    return true;
+
+  // If this is an archetype that is non-SendableMetatype, but there are no
+  // non-marker protocol requirements that could carry conformances, treat
+  // the metatype as Sendable.
+  if (auto archetype = instanceType->getAs<ArchetypeType>()) {
+    if (!containsNonMarkerProtocols(archetype->getConformsTo()))
+      return true;
+  }
+
+  // The instance type is non-Sendable.
+  return false;
+}
+
 /// Synthesize a builtin metatype type conformance to the given protocol, if
 /// appropriate.
 static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
@@ -386,30 +443,11 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
   // All metatypes are Copyable, Escapable, and BitwiseCopyable.
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
-    case KnownProtocolKind::Sendable: {
-      // Metatypes are generally Sendable, but with isolated conformances we
-      // cannot assume that metatypes based on type parameters are Sendable.
-      // Therefore, check for conformance to SendableMetatype.
-      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;
-      }
+    case KnownProtocolKind::Sendable:
+      if (!metatypeWithInstanceTypeIsSendable(metatypeType->getInstanceType()))
+        break;
+
       LLVM_FALLTHROUGH;
-    }
 
     case KnownProtocolKind::Copyable:
     case KnownProtocolKind::Escapable:

lib/SILGen/SILGenDynamicCast.cpp

@@ -18,6 +18,7 @@
 #include "ExitableFullExpr.h"
 #include "swift/Basic/Assertions.h"
 #include "swift/AST/ConformanceLookup.h"
+#include "swift/AST/ExistentialLayout.h"
 #include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/TypeLowering.h"
@@ -302,21 +303,38 @@ namespace {
       return CastStrategy::Address;
     }
 
+    static bool containsNonMarkerProtocols(ArrayRef<ProtocolDecl *> protocols) {
+      for (auto proto : protocols) {
+        if (!proto->isMarkerProtocol())
+          return true;
+      }
+
+      return false;
+    }
+
     CastingIsolatedConformances computedIsolatedConformances() const {
       // Non-existential types don't carry conformances, so we always allow
       // isolated conformances.
       if (!TargetType->isAnyExistentialType())
         return CastingIsolatedConformances::Allow;
 
       // If there is a conformance to SendableMetatype, then this existential
-      // can leave the current isolation domain. Prohibit isolated conformances.
+      // can leave the current isolation domain.
       ASTContext &ctx = TargetType->getASTContext();
       Type checkType;
       if (auto existentialMetatype = TargetType->getAs<ExistentialMetatypeType>())
         checkType = existentialMetatype->getInstanceType();
       else
         checkType = TargetType;
 
+      // If there are no non-marker protocols in the existential, there's no
+      // need to prohibit isolated conformances.
+      auto layout = checkType->getExistentialLayout();
+      if (!containsNonMarkerProtocols(layout.getProtocols()))
+        return CastingIsolatedConformances::Allow;
+
+      // If the type conforms to SendableMetatype, prohibit isolated
+      // conformances.
       auto proto = ctx.getProtocol(KnownProtocolKind::SendableMetatype);
       if (proto && lookupConformance(checkType, proto, /*allowMissing=*/false))
         return CastingIsolatedConformances::Prohibit;

test/Concurrency/sendable_metatype.swift

@@ -2,6 +2,8 @@
 
 // REQUIRES: concurrency
 
+protocol P {
+}
 
 protocol Q {
   static func g()
@@ -31,15 +33,21 @@ nonisolated func passMetaSmuggled<T: Q>(_: T.Type) {
 
 nonisolated func passMetaSmuggledAny<T: Q>(_: T.Type) {
   let x: Any.Type = T.self
-  Task.detached { // expected-error{{risks causing data races}}
-    acceptMeta(x) // expected-note{{closure captures 'x' which is accessible to code in the current task}}
+  Task.detached {
+    acceptMeta(x)
+  }
+}
+
+nonisolated func captureThroughMetaValMoReqs<T>(_: T.Type) {
+  let x = T.self
+  Task.detached {
+    _ = x
   }
 }
 
 nonisolated func passToMainActorSmuggledAny<T: Q>(_: T.Type) async {
   let x: Any.Type = T.self
-  await acceptMetaOnMainActor(x) // expected-error{{sending value of non-Sendable type '(Any).Type' risks causing data races}}
-  // expected-note@-1{{sending task-isolated value of non-Sendable type '(Any).Type' to main actor-isolated global function}}
+  await acceptMetaOnMainActor(x)
 }
 
 // -------------------------------------------------------------------------
@@ -69,9 +77,9 @@ nonisolated func passSendableToMainActorSmuggledAny<T: Sendable>(_: T.Type) asyn
 // -------------------------------------------------------------------------
 // Existential opening
 // -------------------------------------------------------------------------
-nonisolated func passMetaSmuggledAnyFromExistential(_ qT: Q.Type) {
-  let x: Any.Type = qT
-  Task.detached { // expected-error{{risks causing data races}}
+nonisolated func passMetaSmuggledAnyFromExistential(_ pqT: (P & Q).Type) {
+  let x: P.Type = pqT
+  Task.detached { // expected-error{{passing closure as a 'sending' parameter risks causing data races between code in the current task and concurrent execution of the closure}}
     acceptMeta(x) // expected-note{{closure captures 'x' which is accessible to code in the current task}}
   }
 }

test/Concurrency/sendable_metatype_typecheck.swift

@@ -9,6 +9,15 @@ protocol Q {
   static func g()
 }
 
+
+// Sendability of existential metatypes
+fileprivate nonisolated let anyObjectArray: [AnyClass] = []
+
+func testSendableExistential() {
+  _ = anyObjectArray
+}
+
+
 nonisolated func acceptMeta<T>(_: T.Type) { }
 
 nonisolated func staticCallThroughMetaVal<T: Q>(_: T.Type) {
@@ -18,6 +27,13 @@ nonisolated func staticCallThroughMetaVal<T: Q>(_: T.Type) {
   }
 }
 
+nonisolated func captureThroughMetaValMoReqs<T>(_: T.Type) {
+  let x = T.self
+  Task.detached {
+    _ = x
+  }
+}
+
 nonisolated func passMetaVal<T: Q>(_: T.Type) {
   let x = T.self // expected-error{{capture of non-sendable type 'T.Type' in an isolated closure}}
   Task.detached {