[Isolated conformances] Allow conformance isolation to differ from the type's

With the move to explicitly specifying the global actor for an isolated
conformance, we can now have conformances whose isolation differs from
that of the type, including having actors with global-actor-isolated
conformances. Introduce this generalization to match the proposal, and
update/add tests accordingly.

Author: DougGregor

include/swift/AST/DiagnosticsSema.def

@@ -8319,31 +8319,28 @@ ERROR(attr_abi_incompatible_with_silgen_name,none,
 //===----------------------------------------------------------------------===//
 // MARK: Isolated conformances
 //===----------------------------------------------------------------------===//
-ERROR(isolated_conformance_not_global_actor_isolated,none,
-      "isolated conformance is only permitted on global-actor-isolated types",
-      ())
 ERROR(isolated_conformance_experimental_feature,none,
       "isolated conformances require experimental feature "
       " 'IsolatedConformances'", ())
 ERROR(nonisolated_conformance_depends_on_isolated_conformance,none,
-      "conformance of %0 to %1 depends on %2 conformance of %3 to %4; mark it as 'isolated'",
-      (Type, DeclName, ActorIsolation, Type, DeclName))
+      "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_mismatch_with_associated_isolation,none,
       "%0 conformance of %1 to %2 cannot depend on %3 conformance of %4 to %5",
       (ActorIsolation, Type, DeclName, ActorIsolation, Type, DeclName))
 NOTE(add_isolated_to_conformance,none,
      "add '%0' to the %1 conformance to restrict it to %2 code",
     (StringRef, DeclName, ActorIsolation))
 ERROR(isolated_conformance_with_sendable,none,
-      "isolated conformance of %0 to %1 cannot be used to satisfy conformance "
+      "%4 conformance of %0 to %1 cannot be used to satisfy conformance "
       "requirement for a %select{`Sendable`|`SendableMetatype`}2 type "
-      "parameter %3", (Type, DeclName, bool, Type))
+      "parameter %3", (Type, DeclName, bool, Type, ActorIsolation))
 ERROR(isolated_conformance_with_sendable_simple,none,
-      "isolated conformance of %0 to %1 cannot be used to satisfy conformance "
-      "requirement for a `Sendable` type parameter ",
-      (Type, DeclName))
+      "%2 conformance of %0 to %1 cannot be used to satisfy "
+      "conformance requirement for a `Sendable` type parameter ",
+      (Type, DeclName, ActorIsolation))
 ERROR(isolated_conformance_wrong_domain,none,
-      "%0 isolated conformance of %1 to %2 cannot be used in %3 context",
+      "%0 conformance of %1 to %2 cannot be used in %3 context",
       (ActorIsolation, Type, DeclName, ActorIsolation))
 
 //===----------------------------------------------------------------------===//

lib/Sema/CSDiagnostics.cpp

@@ -16,6 +16,7 @@
 
 #include "CSDiagnostics.h"
 #include "MiscDiagnostics.h"
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckProtocol.h"
 #include "TypeCheckType.h"
 #include "TypoCorrection.h"
@@ -9566,7 +9567,8 @@ bool IncorrectInlineArrayLiteralCount::diagnoseAsError() {
 bool DisallowedIsolatedConformance::diagnoseAsError() {
   emitDiagnostic(diag::isolated_conformance_with_sendable_simple,
                  conformance->getType(),
-                 conformance->getProtocol()->getName());
+                 conformance->getProtocol()->getName(),
+                 getConformanceIsolation(conformance));
 
   auto selectedOverload = getCalleeOverloadChoiceIfAvailable(getLocator());
   if (!selectedOverload)

lib/Sema/TypeCheckGeneric.cpp

@@ -13,6 +13,7 @@
 // This file implements support for generics.
 //
 //===----------------------------------------------------------------------===//
+#include "TypeCheckConcurrency.h"
 #include "TypeCheckProtocol.h"
 #include "TypeCheckType.h"
 #include "TypeChecker.h"
@@ -936,7 +937,8 @@ void TypeChecker::diagnoseRequirementFailure(
           reqFailureInfo
             .IsolatedConformanceProto->isSpecificProtocol(
               KnownProtocolKind::SendableMetatype),
-          req.getFirstType());
+          req.getFirstType(),
+          getConformanceIsolation(isolatedConformance));
       diagnosticNote = diag::type_does_not_inherit_or_conform_requirement;
       break;
     }

lib/Sema/TypeCheckProtocol.cpp

@@ -2542,20 +2542,11 @@ checkIndividualConformance(NormalProtocolConformance *conformance) {
       ComplainLoc, diag::unchecked_conformance_not_special, ProtoType);
   }
 
-  // Complain if the conformance is isolated but the conforming type is
-  // not global-actor-isolated.
-  if (conformance->isGlobalActorIsolated()) {
-    auto enclosingNominal = DC->getSelfNominalTypeDecl();
-    if (!enclosingNominal ||
-        !getActorIsolation(enclosingNominal).isGlobalActor()) {
-      Context.Diags.diagnose(
-          ComplainLoc, diag::isolated_conformance_not_global_actor_isolated);
-    }
-    
-    if (!Context.LangOpts.hasFeature(Feature::IsolatedConformances)) {
-      Context.Diags.diagnose(
-          ComplainLoc, diag::isolated_conformance_experimental_feature);
-    }
+  // Complain if the global-actor-isolated conformances are not enabled.
+  if (conformance->isGlobalActorIsolated() &&
+      !Context.LangOpts.hasFeature(Feature::IsolatedConformances)) {
+    Context.Diags.diagnose(
+        ComplainLoc, diag::isolated_conformance_experimental_feature);
   }
 
   bool allowImpliedConditionalConformance = false;
@@ -3330,14 +3321,6 @@ static bool hasExplicitGlobalActorAttr(ValueDecl *decl) {
   return !globalActorAttr->first->isImplicit();
 }
 
-/// Determine whether the given actor isolation matches that of the enclosing
-/// type.
-static bool isolationMatchesEnclosingType(
-    ActorIsolation isolation, NominalTypeDecl *nominal) {
-  auto nominalIsolation = getActorIsolation(nominal);
-  return isolation == nominalIsolation;
-}
-
 std::optional<ActorIsolation>
 ConformanceChecker::checkActorIsolation(ValueDecl *requirement,
                                         ValueDecl *witness,
@@ -3400,13 +3383,10 @@ ConformanceChecker::checkActorIsolation(ValueDecl *requirement,
 
     return std::nullopt;
   case ActorReferenceResult::EntersActor:
-    // If the conformance itself is isolated, and the witness isolation
-    // matches the enclosing type's isolation, treat this as being in the
-    // same concurrency domain.
+    // If the conformance itself is isolated to the same isolation domain as
+    // the witness, treat this as being in the same concurrency domain.
     if (Conformance->isGlobalActorIsolated() &&
-        refResult.isolation.isGlobalActor() &&
-        isolationMatchesEnclosingType(
-            refResult.isolation, DC->getSelfNominalTypeDecl())) {
+        refResult.isolation == getConformanceIsolation(Conformance)) {
       sameConcurrencyDomain = true;
       isIsolatedConformance = true;
     }
@@ -5244,14 +5224,19 @@ static void ensureRequirementsAreSatisfied(ASTContext &ctx,
               // If the conformance we're checking isn't isolated at all, it
               // needs "isolated".
               if (!conformance->isGlobalActorIsolated()) {
+                auto isolation = getConformanceIsolation(isolatedConformance);
+                std::string globalActorStr = "@" +
+                    isolation.getGlobalActor().getString();
                 ctx.Diags.diagnose(
                     conformance->getLoc(),
                     diag::nonisolated_conformance_depends_on_isolated_conformance,
                     typeInContext, conformance->getProtocol()->getName(),
                     getConformanceIsolation(isolatedConformance),
                     isolatedConformance->getType(),
-                    isolatedConformance->getProtocol()->getName()
-               ).fixItInsert(conformance->getProtocolNameLoc(), "isolated ");
+                    isolatedConformance->getProtocol()->getName(),
+                    globalActorStr
+               ).fixItInsert(conformance->getProtocolNameLoc(),
+                             globalActorStr + " ");
 
                 return true;
               }

test/Concurrency/Runtime/isolated_conformance.swift

@@ -16,8 +16,11 @@ protocol P {
   func f()
 }
 
-@MainActor
-class MyClass: @MainActor P {
+protocol Q {
+  func g()
+}
+
+nonisolated class MyClass: @MainActor P {
   func f() {
     print("MyClass.f()")
 
@@ -26,6 +29,22 @@ class MyClass: @MainActor P {
   }
 }
 
+actor SomeActor { }
+
+@globalActor
+struct SomeGlobalActor {
+  static let shared = SomeActor()
+}
+
+extension MyClass: @SomeGlobalActor Q {
+  @SomeGlobalActor func g() {
+    print("MyClass.g()")
+
+    // Make sure we're on this actor.
+    SomeGlobalActor.shared.assumeIsolated { _ in }
+  }
+}
+
 struct Wrapper<T> {
   var wrapped: T
 }
@@ -37,6 +56,13 @@ extension Wrapper: P where T: P {
   }
 }
 
+extension Wrapper: Q where T: Q {
+  func g() {
+    print("Wrapper for ", terminator: "")
+    wrapped.g()
+  }
+}
+
 @available(SwiftStdlib 5.9, *)
 struct WrapMany<each T> {
   var wrapped: (repeat each T)
@@ -49,12 +75,21 @@ extension WrapMany: P where repeat each T: P {
   }
 }
 
-extension Int: P {
+@available(SwiftStdlib 5.9, *)
+extension WrapMany: Q where repeat each T: Q {
+  func g() {
+    print("Wrapper for many")
+  }
+}
+
+extension Int: P, Q {
   func f() { }
+  func g() { }
 }
 
-extension String: P {
+extension String: P, Q {
   func f() { }
+  func g() { }
 }
 
 func tryCastToP(_ value: any Sendable) -> Bool {
@@ -67,12 +102,22 @@ func tryCastToP(_ value: any Sendable) -> Bool {
   return false
 }
 
+func tryCastToQ(_ value: any Sendable) -> Bool {
+  if let q = value as? any Q {
+    q.g()
+    return true
+  }
+
+  print("Conformance did not match")
+  return false
+}
+
 // CHECK: Testing on the main actor
 // CHECK-NEXT: MyClass.f()
 // CHECK-NEXT: Wrapper for MyClass.f()
 print("Testing on the main actor")
-let mc = MyClass()
-let wrappedMC = Wrapper(wrapped: mc)
+nonisolated let mc = MyClass()
+nonisolated let wrappedMC = Wrapper(wrapped: mc)
 precondition(tryCastToP(mc))
 precondition(tryCastToP(wrappedMC))
 
@@ -96,13 +141,34 @@ await Task.detached { @MainActor in
 
 }.value
 
+// CHECK: Testing a separate task on a different global actor
+// CHECK-NEXT: MyClass.g()
+// CHECK-NEXT: Wrapper for MyClass.g()
+print("Testing a separate task on a different global actor")
+await Task.detached { @SomeGlobalActor in
+  precondition(tryCastToQ(mc))
+  precondition(tryCastToQ(wrappedMC))
+
+  if #available(SwiftStdlib 5.9, *) {
+    let wrappedMany = WrapMany(wrapped: (17, mc, "Pack"))
+    precondition(tryCastToQ(wrappedMany))
+  }
+
+  // Not on the main actor any more.
+  precondition(!tryCastToP(mc))
+  precondition(!tryCastToP(wrappedMC))
+}.value
+
 // CHECK: Testing a separate task off the main actor
 print("Testing a separate task off the main actor")
 await Task.detached {
   if #available(SwiftStdlib 6.2, *) {
     precondition(!tryCastToP(mc))
     precondition(!tryCastToP(wrappedMC))
 
+    precondition(!tryCastToQ(mc))
+    precondition(!tryCastToQ(wrappedMC))
+
     let wrappedMany = WrapMany(wrapped: (17, mc, "Pack"))
     precondition(!tryCastToP(wrappedMany))
   } else {

test/Concurrency/isolated_conformance.swift

@@ -4,7 +4,7 @@
 // REQUIRES: concurrency
 
 protocol P {
-  func f() // expected-note 2{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
+  func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
 }
 
 // ----------------------------------------------------------------------------
@@ -22,23 +22,24 @@ class CWithNonIsolated: P {
 actor SomeActor { }
 
 // Isolated conformances need a global-actor-constrained type.
-class CNonIsolated: @MainActor P { // expected-error{{isolated conformance is only permitted on global-actor-isolated types}}
+class CNonIsolated: @MainActor P {
   func f() { }
 }
 
-extension SomeActor: @MainActor P { // expected-error{{isolated conformance is only permitted on global-actor-isolated types}}
-  nonisolated func f() { }
+extension SomeActor: @MainActor P {
+  @MainActor func f() { }
 }
 
 @globalActor
 struct SomeGlobalActor {
   static let shared = SomeActor()
 }
 
-// Isolation of the conformance needs to match that of the enclosing type.
+// Isolation of the conformance can be different from that of the enclosing
+// type, so long as the witnesses match up.
 @MainActor
 class CMismatchedIsolation: @SomeGlobalActor P {
-  @SomeGlobalActor func f() { } // expected-error{{global actor 'SomeGlobalActor'-isolated instance method 'f()' cannot be used to satisfy nonisolated requirement from protocol 'P'}}
+  @SomeGlobalActor func f() { }
 }
 
 @MainActor
@@ -52,7 +53,7 @@ protocol Q {
   associatedtype A: P
 }
 
-// expected-error@+2{{conformance of 'SMissingIsolation' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as 'isolated'}}{{27-27=isolated }}
+// expected-error@+2{{conformance of 'SMissingIsolation' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as '@MainActor'}}{{27-27=@MainActor }}
 @MainActor
 struct SMissingIsolation: Q {
   typealias A = C
@@ -62,7 +63,7 @@ struct PWrapper<T: P>: P {
   func f() { }
 }
 
-// expected-error@+2{{conformance of 'SMissingIsolationViaWrapper' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as 'isolated'}}
+// expected-error@+2{{conformance of 'SMissingIsolationViaWrapper' to 'Q' depends on main actor-isolated conformance of 'C' to 'P'; mark it as '@MainActor'}}
 @MainActor
 struct SMissingIsolationViaWrapper: Q {
   typealias A = PWrapper<C>
@@ -111,18 +112,30 @@ func acceptSendableP<T: Sendable & P>(_: T) { }
 // expected-note@-1{{'acceptSendableP' declared here}}
 
 func acceptSendableMetaP<T: SendableMetatype & P>(_: T) { }
-// expected-note@-1{{'acceptSendableMetaP' declared here}}
+// expected-note@-1 3{{'acceptSendableMetaP' declared here}}
 
 @MainActor
 func testIsolationConformancesInCall(c: C) {
   acceptP(c) // okay
 
-  acceptSendableP(c) // expected-error{{isolated conformance of 'C' to 'P' cannot be used to satisfy conformance requirement for a `Sendable` type parameter}}
+  acceptSendableP(c) // expected-error{{main actor-isolated conformance of 'C' to 'P' cannot be used to satisfy conformance requirement for a `Sendable` type parameter}}
   acceptSendableMetaP(c) // expected-error{{isolated conformance of 'C' to 'P' cannot be used to satisfy conformance requirement for a `Sendable` type parameter}}
 }
 
+@MainActor
+func testIsolatedConformancesOfActor(a: SomeActor) {
+  acceptP(a)
+  acceptSendableMetaP(a) // expected-error{{main actor-isolated conformance of 'SomeActor' to 'P' cannot be used to satisfy conformance requirement for a `Sendable` type parameter}}
+}
+
+@SomeGlobalActor
+func testIsolatedConformancesOfOtherGlobalActor(c: CMismatchedIsolation) {
+  acceptP(c)
+  acceptSendableMetaP(c)  // expected-error{{global actor 'SomeGlobalActor'-isolated conformance of 'CMismatchedIsolation' to 'P' cannot be used to satisfy conformance requirement for a `Sendable` type parameter}}
+}
+
 func testIsolationConformancesFromOutside(c: C) {
-  acceptP(c) // expected-error{{main actor-isolated isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
-  let _: any P = c // expected-error{{main actor-isolated isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
-  let _ = PWrapper<C>() // expected-error{{main actor-isolated isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
+  acceptP(c) // expected-error{{main actor-isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
+  let _: any P = c // expected-error{{main actor-isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
+  let _ = PWrapper<C>() // expected-error{{main actor-isolated conformance of 'C' to 'P' cannot be used in nonisolated context}}
 }

test/ModuleInterface/isolated_conformance.swift

@@ -10,7 +10,7 @@ public protocol MyProtocol {
 @MainActor
 public class MyClass { }
 
-// CHECK: extension isolated_conformance.MyClass : @MainActor isolated_conformance.MyProtocol {
+// CHECK: extension isolated_conformance.MyClass : @{{.*}}MainActor isolated_conformance.MyProtocol {
 extension MyClass: @MainActor MyProtocol {
   @MainActor public func f() { }
 }

test/Serialization/isolated_conformance.swift

@@ -12,5 +12,5 @@ func acceptMyProtocol(_: some MyProtocol) { }
 
 nonisolated func f(mc: MyClass) {
   acceptMyProtocol(mc)
-  // expected-error@-1{{main actor-isolated isolated conformance of 'MyClass' to 'MyProtocol' cannot be used in nonisolated context}}
+  // expected-error@-1{{main actor-isolated conformance of 'MyClass' to 'MyProtocol' cannot be used in nonisolated context}}
 }