[SE-0470] Warn about isolated conformance to SendableMetatype-inheriting protocol

An isolated conformance to a SendableMetatype-inheriting protocol
cannot actually be used in generic code, because the SendableMetatype
requirement itself prevents it. Warn about this case so folks aren't
surprised at runtime.

This is a part of issue swiftlang#82550 / rdar://154437489.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8681,6 +8681,9 @@ GROUPED_ERROR(isolated_conformance_wrong_domain,IsolatedConformances,none,
 GROUPED_WARNING(isolated_conformance_will_become_nonisolated,IsolatedConformances,none,
       "conformance of %0 to %1 should be marked 'nonisolated' to retain its behavior with upcoming feature 'InferIsolatedConformances'",
       (const ValueDecl *, const ValueDecl *))
+GROUPED_WARNING(isolated_conformance_to_sendable_metatype,IsolatedConformances,none,
+    "%0 conformance of %1 to SendableMetatype-inheriting %kind2 can never "
+    "be used with generic code", (ActorIsolation, Type, const ValueDecl *))
 
 //===----------------------------------------------------------------------===//
 // MARK: @_inheritActorContext

lib/Sema/TypeCheckConcurrency.cpp

@@ -8280,6 +8280,10 @@ RawConformanceIsolationRequest::evaluate(
   if (conformance->getOptions().contains(ProtocolConformanceFlags::Nonisolated))
     return ActorIsolation::forNonisolated(false);
 
+  auto dc = conformance->getDeclContext();
+  ASTContext &ctx = dc->getASTContext();
+  auto proto = conformance->getProtocol();
+
   // If there is an explicitly-specified global actor on the isolation,
   // resolve it and report it.
   if (auto globalActorTypeExpr = conformance->getExplicitGlobalActorIsolation()) {
@@ -8299,16 +8303,27 @@ RawConformanceIsolationRequest::evaluate(
       globalActorTypeExpr->setType(MetatypeType::get(globalActorType));
     }
 
+    // Isolated conformance to a SendableMetatype-inheriting protocol can
+    // never be used generically. Warn about it.
+    if (auto sendableMetatype =
+            ctx.getProtocol(KnownProtocolKind::SendableMetatype)) {
+      if (proto->inheritsFrom(sendableMetatype) &&
+          !getActorIsolation(proto).preconcurrency()) {
+        ctx.Diags.diagnose(
+            conformance->getLoc(),
+            diag::isolated_conformance_to_sendable_metatype,
+            ActorIsolation::forGlobalActor(globalActorType),
+            conformance->getType(),
+            proto);
+      }
+    }
+
     // FIXME: Make sure the type actually is a global actor type, map it into
     // context, etc.
 
     return ActorIsolation::forGlobalActor(globalActorType);
   }
 
-  auto dc = conformance->getDeclContext();
-  ASTContext &ctx = dc->getASTContext();
-  auto proto = conformance->getProtocol();
-
   // If the protocol itself is isolated, don't infer isolation for the
   // conformance.
   if (getActorIsolation(proto).isActorIsolated())

test/Concurrency/isolated_conformance.swift

@@ -147,6 +147,15 @@ struct PSendableS: @MainActor PSendable { // expected-note{{requirement specifie
   func f() { }
 }
 
+protocol R: SendableMetatype {
+  func f()
+}
+
+// expected-warning@+1{{main actor-isolated conformance of 'RSendableSMainActor' to SendableMetatype-inheriting protocol 'R' can never be used with generic code}}
+@MainActor struct RSendableSMainActor: @MainActor R {
+  func f() { }
+}
+
 // ----------------------------------------------------------------------------
 // Use checking of isolated conformances.
 // ----------------------------------------------------------------------------