Merge pull request #80384 from DougGregor/isolated-conformances-checkedcast-enable

Prohibit isolated conformances for checked casts to potentially-SendableMetatype types

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8470,9 +8470,6 @@ NOTE(note_isolate_conformance_to_global_actor,none,
 NOTE(note_depends_on_isolated_conformance,none,
      "conformance depends on %0 conformance of %1 to %kind2",
      (ActorIsolation, Type, const ValueDecl *))
-ERROR(nonisolated_conformance_depends_on_isolated_conformance,none,
-      "conformance of %0 to %1 depends on %2 conformance of %3 to %4; mark it as '%5'",
-      (Type, DeclName, ActorIsolation, Type, DeclName, StringRef))
 ERROR(isolated_conformance_with_sendable,none,
       "%4 conformance of %0 to %1 cannot satisfy conformance "
       "requirement for a %select{`Sendable`|`SendableMetatype`}2 type "

include/swift/Basic/Features.def

@@ -488,9 +488,6 @@ ADOPTABLE_EXPERIMENTAL_FEATURE(AsyncCallerExecution, false)
 /// Allow custom availability domains to be defined and referenced.
 SUPPRESSIBLE_EXPERIMENTAL_FEATURE(CustomAvailability, true)
 
-/// Be strict about the Sendable conformance of metatypes.
-EXPERIMENTAL_FEATURE(StrictSendableMetatypes, true)
-
 /// Allow public enumerations to be extensible by default
 /// regardless of whether the module they are declared in
 /// is resilient or not.

lib/AST/ConformanceLookup.cpp

@@ -387,10 +387,10 @@ static ProtocolConformanceRef getBuiltinMetaTypeTypeConformance(
   if (auto kp = protocol->getKnownProtocolKind()) {
     switch (*kp) {
     case KnownProtocolKind::Sendable:
-      // Metatypes are generally Sendable, but under StrictSendableMetatypes we
+      // 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.
-      if (ctx.LangOpts.hasFeature(Feature::StrictSendableMetatypes)) {
+      if (ctx.LangOpts.hasFeature(Feature::IsolatedConformances)) {
         auto sendableMetatypeProto = 
             ctx.getProtocol(KnownProtocolKind::SendableMetatype);
         if (sendableMetatypeProto) {

lib/AST/FeatureSet.cpp

@@ -276,7 +276,6 @@ UNINTERESTING_FEATURE(NonfrozenEnumExhaustivity)
 UNINTERESTING_FEATURE(ClosureIsolation)
 UNINTERESTING_FEATURE(Extern)
 UNINTERESTING_FEATURE(ConsumeSelfInDeinit)
-UNINTERESTING_FEATURE(StrictSendableMetatypes)
 
 static bool usesFeatureBitwiseCopyable2(Decl *decl) {
   if (!decl->getModuleContext()->isStdlibModule()) {

lib/SILGen/SILGenDynamicCast.cpp

@@ -308,16 +308,17 @@ namespace {
       if (!TargetType->isAnyExistentialType())
         return CastingIsolatedConformances::Allow;
 
-      // Only do this if isolated conformances are enabled.
+      // If there is a conformance to SendableMetatype, then this existential
+      // can leave the current isolation domain. Prohibit isolated conformances.
       ASTContext &ctx = TargetType->getASTContext();
-      if (!ctx.LangOpts.hasFeature(Feature::IsolatedConformances))
-        return CastingIsolatedConformances::Allow;
+      Type checkType;
+      if (auto existentialMetatype = TargetType->getAs<ExistentialMetatypeType>())
+        checkType = existentialMetatype->getInstanceType();
+      else
+        checkType = TargetType;
 
       auto proto = ctx.getProtocol(KnownProtocolKind::SendableMetatype);
-
-      // If there is a conformance to SendableMetatype, then this existential
-      // can leave the current isolation domain. Prohibit isolated conformances.
-      if (proto && lookupConformance(TargetType, proto, /*allowMissing=*/false))
+      if (proto && lookupConformance(checkType, proto, /*allowMissing=*/false))
         return CastingIsolatedConformances::Prohibit;
 
       return CastingIsolatedConformances::Allow;

lib/Sema/TypeCheckConcurrency.cpp

@@ -3011,7 +3011,7 @@ namespace {
       // FIXME: When passing to a sending parameter, should this be handled
       // by region isolation? Or should it always be handled by region
       // isolation?
-      if (ctx.LangOpts.hasFeature(Feature::StrictSendableMetatypes) &&
+      if (ctx.LangOpts.hasFeature(Feature::IsolatedConformances) &&
           (mayExecuteConcurrentlyWith(
               localFunc.getAsDeclContext(), getDeclContext()) ||
            (explicitClosure && explicitClosure->isPassedToSendingParameter()))) {

test/Concurrency/isolated_conformance_inference.swift

@@ -0,0 +1,53 @@
+// RUN: %target-swift-frontend -typecheck -verify -target %target-swift-5.1-abi-triple -swift-version 6 -enable-experimental-feature IsolatedConformances -enable-experimental-feature InferIsolatedConformances %s
+
+// REQUIRES: swift_feature_IsolatedConformances
+// REQUIRES: swift_feature_InferIsolatedConformances
+// REQUIRES: concurrency
+
+protocol P {
+  func f()
+}
+
+@SomeGlobalActor
+protocol Q {
+  func g()
+}
+
+@globalActor
+actor SomeGlobalActor {
+  static let shared = SomeGlobalActor()
+}
+
+@SomeGlobalActor
+protocol R {
+  func h()
+}
+
+@SomeGlobalActor
+class CExplicit: P {
+  func f() { } // okay! conformance above is isolated
+}
+
+// If the protocol itself is isolated, don't do anything.
+extension CExplicit: Q {
+  func g() { }
+}
+
+// expected-error@+3{{conformance of 'CNonIsolated' to protocol 'P' crosses into global actor 'SomeGlobalActor'-isolated code and can cause data races}}
+// expected-note@+2{{turn data races into runtime errors with '@preconcurrency'}}
+// expected-note@+1{{isolate this conformance to the global actor 'SomeGlobalActor' with '@SomeGlobalActor'}}{{33-33=@SomeGlobalActor }}
+nonisolated class CNonIsolated: P {
+  @SomeGlobalActor func f() { } // expected-note{{global actor 'SomeGlobalActor'-isolated instance method 'f()' cannot satisfy nonisolated requirement}}
+}
+
+func acceptSendablePMeta<T: Sendable & P>(_: T.Type) { }
+func acceptSendableQMeta<T: Sendable & Q>(_: T.Type) { }
+
+nonisolated func testConformancesFromNonisolated() {
+  let _: any P = CExplicit() // expected-error{{global actor 'SomeGlobalActor'-isolated conformance of 'CExplicit' to 'P' cannot be used in nonisolated context}}
+
+  let _: any P = CNonIsolated()
+
+  // Okay, these are nonisolated conformances.
+  let _: any Q = CExplicit()
+}

test/Concurrency/isolated_conformance_sil.swift

@@ -1,7 +1,4 @@
-// RUN: %target-swift-frontend -target %target-swift-5.1-abi-triple -Xllvm -sil-print-types -emit-silgen -enable-experimental-feature IsolatedConformances -verify %s | %FileCheck %s
-
-// REQUIRES: swift_feature_IsolatedConformances
-// REQUIRES: concurrency
+// RUN: %target-swift-frontend -target %target-swift-5.1-abi-triple -Xllvm -sil-print-types -emit-silgen -verify %s | %FileCheck %s
 
 protocol P { }
 

test/Concurrency/sendable_metatype.swift

@@ -1,7 +1,7 @@
-// RUN: %target-typecheck-verify-swift -swift-version 6 -enable-experimental-feature StrictSendableMetatypes -emit-sil -o /dev/null
+// RUN: %target-typecheck-verify-swift -swift-version 6 -enable-experimental-feature IsolatedConformances -emit-sil -o /dev/null
 
 // REQUIRES: concurrency
-// REQUIRES: swift_feature_StrictSendableMetatypes
+// REQUIRES: swift_feature_IsolatedConformances
 
 
 protocol Q {

test/Concurrency/sendable_metatype_typecheck.swift

@@ -1,7 +1,7 @@
-// RUN: %target-typecheck-verify-swift -swift-version 6 -enable-experimental-feature StrictSendableMetatypes
+// RUN: %target-typecheck-verify-swift -swift-version 6 -enable-experimental-feature IsolatedConformances
 
 // REQUIRES: concurrency
-// REQUIRES: swift_feature_StrictSendableMetatypes
+// REQUIRES: swift_feature_IsolatedConformances
 
 // This test checks for typecheck-only diagnostics involving non-sendable
 // metatypes.