Do not infer conformance isolation to an isolated protocol

Author: DougGregor

lib/Sema/TypeCheckConcurrency.cpp

@@ -7918,6 +7918,11 @@ ConformanceIsolationRequest::evaluate(Evaluator &evaluator, ProtocolConformance
   if (!ctx.LangOpts.hasFeature(Feature::IsolatedConformances))
     return ActorIsolation::forNonisolated(false);
 
+  // If the protocol itself is isolated, don't infer isolation for the
+  // conformance.
+  if (getActorIsolation(rootNormal->getProtocol()).isActorIsolated())
+    return ActorIsolation::forNonisolated(false);
+
   // In a context where we are inferring @MainActor, if the conforming type
   // is on the main actor, then the conformance is, too.
   auto nominal = dc->getSelfNominalTypeDecl();

test/Concurrency/isolated_conformance_default_actor.swift

@@ -9,6 +9,11 @@ protocol P {
   func f() // expected-note{{mark the protocol requirement 'f()' 'async' to allow actor-isolated conformances}}
 }
 
+@MainActor
+protocol Q {
+  func g()
+}
+
 class CImplicitMainActorNonisolatedConformance: nonisolated P {
   func f() { } // error: explicitly nonisolated conformance
 }
@@ -23,18 +28,32 @@ class CImplicitMainActor: P {
   func f() { } // okay! conformance above is isolated
 }
 
+// If the protocol itself is isolated, don't do anything.
+extension CExplicitMainActor: Q {
+  func g() { }
+}
+
+extension CImplicitMainActor: Q {
+  func g() { }
+}
+
 // expected-note@+2{{add '@preconcurrency' to the 'P' conformance to defer isolation checking to run time}}
 // expected-note@+1{{add '@MainActor' to the 'P' conformance to restrict it to main actor-isolated code}}
 nonisolated class CNonIsolated: P {
   @MainActor func f() { } // expected-error{{main actor-isolated instance method 'f()' cannot be used to satisfy nonisolated requirement from protocol 'P'}}
 }
 
 func acceptSendablePMeta<T: Sendable & P>(_: T.Type) { }
+func acceptSendableQMeta<T: Sendable & Q>(_: T.Type) { }
 
 nonisolated func testConformancesFromNonisolated() {
   let _: any P = CExplicitMainActor() // expected-error{{main actor-isolated conformance of 'CExplicitMainActor' to 'P' cannot be used in nonisolated context}}
   let _: any P = CImplicitMainActor() // expected-error{{main actor-isolated conformance of 'CImplicitMainActor' to 'P' cannot be used in nonisolated context}}
 
   let _: any P = CNonIsolated()
   let _: any P = CImplicitMainActorNonisolatedConformance()
+
+  // Okay, these are nonisolated conformances.
+  let _: any Q = CExplicitMainActor()
+  let _: any Q = CImplicitMainActor()
 }