Use the "prohibits isolated conformances" check for capture metatypes

When checking whether a capture of a metatype is Sendable, we had an
incomplete and incorrect check for SendableMetatype conformance.
Replace that with the proper "prohibits isolated conformances" check
on the generic signature, which matches what we do on the caller side.

Fixes issue #82905 / rdar://155399531.

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -3119,36 +3119,22 @@ namespace {
           mayExecuteConcurrentlyWith(
               localFunc.getAsDeclContext(), getDeclContext(),
               /*includeSending*/true)) {
-        auto innermostGenericDC = localFunc.getAsDeclContext();
-        while (innermostGenericDC && !innermostGenericDC->isGenericContext())
-          innermostGenericDC = innermostGenericDC->getParent();
-
-        GenericSignature genericSig = innermostGenericDC
-            ? innermostGenericDC->getGenericSignatureOfContext()
-            : GenericSignature();
-
         for (const auto &capturedType :
                  localFunc.getCaptureInfo().getCapturedTypes()) {
-          unsigned genericDepth;
           Type type = capturedType.getType();
           if (auto archetype = type->getAs<ArchetypeType>()) {
-            genericDepth = archetype->getInterfaceType()->getRootGenericParam()
-                ->getDepth();
-          } else if (type->isTypeParameter()) {
-            genericDepth = type->getRootGenericParam()->getDepth();
+            // If the generic signature of the environment prohibits this
+            // type to have an isolated conformance, there is nothing to
+            // diagnose.
+            Type interfaceType = archetype->getInterfaceType();
+            auto genericEnv = archetype->getGenericEnvironment();
+            auto genericSig = genericEnv->getGenericSignature();
+            if (genericSig->prohibitsIsolatedConformance(interfaceType))
+              continue;
           } else {
             continue;
           }
 
-          // If the local function is generic and this is one of its generic
-          // parameters, ignore it.
-          if (genericSig.getNextDepth() > 0 &&
-              genericDepth >= genericSig.getNextDepth())
-            continue;
-
-          if (type->isTypeParameter() && innermostGenericDC)
-            type = innermostGenericDC->mapTypeIntoContext(type);
-
           // Check that the metatype is sendable.
           SendableCheckContext sendableContext(getDeclContext(), preconcurrency);
           diagnoseNonSendableTypes(MetatypeType::get(type),

test/Concurrency/sendable_metatype_typecheck.swift

@@ -21,7 +21,7 @@ func testSendableExistential() {
 nonisolated func acceptMeta<T>(_: T.Type) { }
 
 nonisolated func staticCallThroughMetaVal<T: Q>(_: T.Type) {
-  let x = T.self // expected-warning{{capture of non-Sendable type 'T.Type' in an isolated closure}}
+  let x = T.self
   Task.detached {
     x.g() // expected-warning{{capture of non-Sendable type 'T.Type' in an isolated closure}}
   }
@@ -35,7 +35,7 @@ nonisolated func captureThroughMetaValMoReqs<T>(_: T.Type) {
 }
 
 nonisolated func passMetaVal<T: Q>(_: T.Type) {
-  let x = T.self // expected-warning{{capture of non-Sendable type 'T.Type' in an isolated closure}}
+  let x = T.self
   Task.detached {
     acceptMeta(x) // expected-warning{{capture of non-Sendable type}}
   }
@@ -188,3 +188,20 @@ func f<T: P>(_: T.Type) {
     }
   }
 }
+
+func sendableSequence<S: AsyncSequence & Sendable>(_ s: S) throws {
+  Task.detached {
+    for try await i in s {
+      print(i)
+    }
+  }
+}
+
+func nonSendableSequence<S: AsyncSequence>(_ s: S) throws {
+  Task.detached {
+    for try await i in s { // expected-warning{{capture of non-Sendable type 'S.AsyncIterator.Type' in an isolated closure}}
+      // expected-warning@-1{{capture of non-Sendable type 'S.Type' in an isolated closure}}
+      print(i)
+    }
+  }
+}