Merge pull request #75016 from gottesmm/pr-d4640c7e2919faea7bc7eb96ebd8af643108e2d8

[region-isolation] When determining isolation from a class_method, check for global actor isolation first.

Author: gottesmm

include/swift/AST/ActorIsolation.h

@@ -180,6 +180,12 @@ class ActorIsolation {
     return parameterIndex;
   }
 
+  /// Returns true if this actor-instance isolation appllies to the self
+  /// parameter of a method.
+  bool isActorInstanceForSelfParameter() const {
+    return getActorInstanceParameter() == 0;
+  }
+
   bool isSILParsed() const { return silParsed; }
 
   bool isActorIsolated() const {

lib/SILOptimizer/Utils/SILIsolationInfo.cpp

@@ -602,40 +602,55 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
         bool isNonIsolatedUnsafe = exprAnalysis.hasNonisolatedUnsafe();
         {
           auto isolation = swift::getActorIsolation(dre->getDecl());
-          if (isolation.isActorIsolated() &&
-              (isolation.getKind() != ActorIsolation::ActorInstance ||
-               isolation.getActorInstanceParameter() == 0)) {
-            if (cmi->getOperand()->getType().isAnyActor()) {
+
+          if (isolation.isActorIsolated()) {
+            // Check if we have a global actor and handle it appropriately.
+            if (isolation.getKind() == ActorIsolation::GlobalActor) {
+              bool localNonIsolatedUnsafe =
+                  isNonIsolatedUnsafe | isolation.isNonisolatedUnsafe();
+              return SILIsolationInfo::getGlobalActorIsolated(
+                         cmi, isolation.getGlobalActor())
+                  .withUnsafeNonIsolated(localNonIsolatedUnsafe);
+            }
+
+            // In this case, we have an actor instance that is self.
+            if (isolation.getKind() != ActorIsolation::ActorInstance &&
+                isolation.isActorInstanceForSelfParameter()) {
+              bool localNonIsolatedUnsafe =
+                  isNonIsolatedUnsafe | isolation.isNonisolatedUnsafe();
               return SILIsolationInfo::getActorInstanceIsolated(
-                  cmi, cmi->getOperand(),
-                  cmi->getOperand()
-                      ->getType()
-                      .getNominalOrBoundGenericNominal());
+                         cmi, cmi->getOperand(),
+                         cmi->getOperand()
+                             ->getType()
+                             .getNominalOrBoundGenericNominal())
+                  .withUnsafeNonIsolated(localNonIsolatedUnsafe);
             }
-            return SILIsolationInfo::getGlobalActorIsolated(
-                cmi, isolation.getGlobalActor());
           }
-
-          isNonIsolatedUnsafe |= isolation.isNonisolatedUnsafe();
         }
 
         if (auto type = dre->getType()->getNominalOrBoundGenericNominal()) {
           if (auto isolation = swift::getActorIsolation(type)) {
-            if (isolation.isActorIsolated() &&
-                (isolation.getKind() != ActorIsolation::ActorInstance ||
-                 isolation.getActorInstanceParameter() == 0)) {
-              if (cmi->getOperand()->getType().isAnyActor()) {
+            if (isolation.isActorIsolated()) {
+              // Check if we have a global actor and handle it appropriately.
+              if (isolation.getKind() == ActorIsolation::GlobalActor) {
+                bool localNonIsolatedUnsafe =
+                    isNonIsolatedUnsafe | isolation.isNonisolatedUnsafe();
+                return SILIsolationInfo::getGlobalActorIsolated(
+                           cmi, isolation.getGlobalActor())
+                    .withUnsafeNonIsolated(localNonIsolatedUnsafe);
+              }
+
+              // In this case, we have an actor instance that is self.
+              if (isolation.getKind() != ActorIsolation::ActorInstance &&
+                  isolation.isActorInstanceForSelfParameter()) {
+                bool localNonIsolatedUnsafe =
+                    isNonIsolatedUnsafe | isolation.isNonisolatedUnsafe();
                 return SILIsolationInfo::getActorInstanceIsolated(
                            cmi, cmi->getOperand(),
                            cmi->getOperand()
                                ->getType()
                                .getNominalOrBoundGenericNominal())
-                    .withUnsafeNonIsolated(isNonIsolatedUnsafe);
-              }
-
-              if (auto globalIso = SILIsolationInfo::getGlobalActorIsolated(
-                      cmi, isolation.getGlobalActor())) {
-                return globalIso.withUnsafeNonIsolated(isNonIsolatedUnsafe);
+                    .withUnsafeNonIsolated(localNonIsolatedUnsafe);
               }
             }
           }

test/Concurrency/transfernonsendable.swift

@@ -40,6 +40,7 @@ actor MyActor {
   func useSendableFunction(_: @Sendable () -> Void) {}
   func useNonSendableFunction(_: () -> Void) {}
   func doSomething() {}
+  @MainActor func useKlassMainActor(_ x: NonSendableKlass) {}
 }
 
 final actor FinalActor {
@@ -1809,3 +1810,16 @@ actor FunctionWithSendableResultAndIsolationActor {
         return ""
     }
 }
+
+@MainActor
+func testThatGlobalActorTakesPrecedenceOverActorIsolationOnMethods() async {
+  let a = MyActor()
+  let ns = NonSendableKlass()
+
+  // 'ns' should be main actor isolated since useKlassMainActor is @MainActor
+  // isolated. Previously we would let MyActor take precedence here...
+  a.useKlassMainActor(ns)
+
+  // Meaning we would get an error here.
+  Task { @MainActor in print(ns) }
+}