[region-isolation] If a value is dynamically actor isolated, do not consider it transferred if the transfer statically was to that same actor isolation.

This issue can come up when a value is initially statically disconnected, but
after we performed dataflow, we discovered that it was actually actor isolated
at the transfer point, implying that we are not actually transferring.

Example:

```swift
@mainactor func testGlobalAndGlobalIsolatedPartialApplyMatch2() {
  var ns = (NonSendableKlass(), NonSendableKlass())
  // Regions: (ns.0, ns.1), {(mainActorIsolatedGlobal), @mainactor}

  ns.0 = mainActorIsolatedGlobal
  // Regions: {(ns.0, ns.1, mainActorIsolatedGlobal), @mainactor}

  // This is not a transfer since ns is already main actor isolated.
  let _ = { @mainactor in
    print(ns)
  }

  useValue(ns)
}
```

To do this, I also added to SILFunction an actor isolation that SILGen puts on
the SILFunction during pre function visitation. We don't print it or serialize
it for now.

rdar://123474616

Author: gottesmm

include/swift/SIL/SILFunction.h

@@ -347,6 +347,9 @@ class SILFunction
   /// block indices.
   unsigned BlockListChangeIdx = 0;
 
+  /// The isolation of this function.
+  std::optional<ActorIsolation> actorIsolation;
+
   /// The function's bare attribute. Bare means that the function is SIL-only
   /// and does not require debug info.
   unsigned Bare : 1;
@@ -1367,6 +1370,14 @@ class SILFunction
     return false;
   }
 
+  void setActorIsolation(ActorIsolation newActorIsolation) {
+    actorIsolation = newActorIsolation;
+  }
+
+  std::optional<ActorIsolation> getActorIsolation() const {
+    return actorIsolation;
+  }
+
   //===--------------------------------------------------------------------===//
   // Block List Access
   //===--------------------------------------------------------------------===//

include/swift/SILOptimizer/Utils/PartitionUtils.h

@@ -204,7 +204,7 @@ class SILIsolationInfo {
       return getActorIsolated(actorIsolation);
     if (nomDecl->isActor())
       return {Kind::Actor, nomDecl};
-    return {};
+    return SILIsolationInfo();
   }
 
   static SILIsolationInfo getTaskIsolated(SILValue value) {
@@ -789,6 +789,21 @@ struct PartitionOpEvaluator {
       std::tie(transferredRegionIsolation, isClosureCapturedElt) =
           getIsolationRegionInfo(transferredRegion, op.getSourceOp());
 
+      // Before we do anything, see if our dynamic isolation kind is the same as
+      // the isolation info for our partition op. If they match, this is not a
+      // real transfer operation.
+      //
+      // DISCUSSION: We couldn't not emit this earlier since we needed the
+      // dynamic isolation info of our value.
+      if (transferredRegionIsolation.isActorIsolated()) {
+        if (auto calleeIsolationInfo =
+                SILIsolationInfo::get(op.getSourceInst())) {
+          if (transferredRegionIsolation == calleeIsolationInfo) {
+            return;
+          }
+        }
+      }
+
       // If we merged anything, we need to handle a transfer
       // non-transferrable. We pass in the dynamic isolation region info of our
       // region.

lib/SILGen/SILGen.cpp

@@ -1217,6 +1217,10 @@ void SILGenModule::preEmitFunction(SILDeclRef constant, SILFunction *F,
   if (F->getLoweredFunctionType()->isPolymorphic())
     F->setGenericEnvironment(Types.getConstantGenericEnvironment(constant));
 
+  // Set the actor isolation of the function to its innermost decl context.
+  F->setActorIsolation(
+      getActorIsolationOfContext(constant.getInnermostDeclContext()));
+
   // Create a debug scope for the function using astNode as source location.
   F->setDebugScope(new (M) SILDebugScope(Loc, F));
 

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -1470,6 +1470,7 @@ class PartitionOpTranslator {
     llvm::SmallVector<Element, 8> nonSendableJoinedIndices;
     llvm::SmallVector<Element, 8> nonSendableSeparateIndices;
     for (SILArgument *arg : functionArguments) {
+      // This will decide what the isolation region is.
       if (auto state = tryToTrackValue(arg)) {
         // If we can transfer our parameter, just add it to
         // nonSendableSeparateIndices.
@@ -1485,9 +1486,8 @@ class PartitionOpTranslator {
 
         // Otherwise, it is one of our merged parameters. Add it to the never
         // transfer list and to the region join list.
-        LLVM_DEBUG(llvm::dbgs() << "    %%" << state->getID() << ": " << *arg);
-        valueMap.mergeIsolationRegionInfo(
-            arg, SILIsolationInfo::getTaskIsolated(arg));
+        LLVM_DEBUG(llvm::dbgs() << "    %%" << state->getID() << ": ";
+                   state->print(llvm::dbgs()); llvm::dbgs() << *arg);
         nonSendableJoinedIndices.push_back(state->getID());
       }
     }

lib/SILOptimizer/Utils/PartitionUtils.cpp

@@ -42,13 +42,21 @@ static llvm::cl::opt<bool, true> // The parser
 //===----------------------------------------------------------------------===//
 
 SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
-  if (ApplyExpr *apply = inst->getLoc().getAsASTNode<ApplyExpr>())
-    if (auto crossing = apply->getIsolationCrossing())
-      return SILIsolationInfo::getActorIsolated(crossing->getCalleeIsolation());
+  if (ApplyExpr *apply = inst->getLoc().getAsASTNode<ApplyExpr>()) {
+    if (auto crossing = apply->getIsolationCrossing()) {
+      if (crossing->getCalleeIsolation().isActorIsolated())
+        return SILIsolationInfo::getActorIsolated(
+            crossing->getCalleeIsolation());
+    }
+  }
 
   if (auto fas = FullApplySite::isa(inst)) {
-    if (auto crossing = fas.getIsolationCrossing())
-      return SILIsolationInfo::getActorIsolated(crossing->getCalleeIsolation());
+    if (auto crossing = fas.getIsolationCrossing()) {
+      if (crossing->getCalleeIsolation().isActorIsolated()) {
+        return SILIsolationInfo::getActorIsolated(
+            crossing->getCalleeIsolation());
+      }
+    }
 
     if (fas.hasSelfArgument()) {
       auto &self = fas.getSelfArgumentOperand();
@@ -79,9 +87,18 @@ SILIsolationInfo SILIsolationInfo::get(SILInstruction *inst) {
 }
 
 SILIsolationInfo SILIsolationInfo::get(SILFunctionArgument *arg) {
+  // If we have self and our function is actor isolated, all of our arguments
+  // should be marked as actor isolated.
   if (auto *self = arg->getFunction()->maybeGetSelfArgument()) {
-    if (auto *nomDecl = self->getType().getNominalOrBoundGenericNominal()) {
-      return SILIsolationInfo::getActorIsolated(nomDecl);
+    if (auto functionIsolation = arg->getFunction()->getActorIsolation()) {
+      if (functionIsolation->isActorIsolated()) {
+        if (auto *nomDecl = self->getType().getNominalOrBoundGenericNominal()) {
+          if (auto isolationInfo =
+                  SILIsolationInfo::getActorIsolated(nomDecl)) {
+            return isolationInfo;
+          }
+        }
+      }
     }
   }
 
@@ -171,7 +188,7 @@ bool SILIsolationInfo::operator==(const SILIsolationInfo &other) const {
 
     // Otherwise, try to use the inferred actor decl.
     auto *lhsDecl = tryInferActorDecl();
-    auto *rhsDecl = tryInferActorDecl();
+    auto *rhsDecl = other.tryInferActorDecl();
     if (lhsDecl && rhsDecl)
       return lhsDecl == rhsDecl;
 

test/Concurrency/transfernonsendable_global_actor.swift

@@ -190,10 +190,21 @@ struct Clock {
 @MainActor func testGlobalAndGlobalIsolatedPartialApplyMatch() {
   let ns = mainActorIsolatedGlobal
 
-  // TODO: We should not consider this to be a transfer.
+  // This is not a transfer since ns is already main actor isolated.
   let _ = { @MainActor in
-    print(ns) // expected-tns-warning {{transferring 'ns' may cause a race}}
-    // expected-tns-note @-1 {{main actor-isolated 'ns' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses}}
+    print(ns)
+  }
+
+  useValue(ns)
+}
+
+@MainActor func testGlobalAndGlobalIsolatedPartialApplyMatch2() {
+  var ns = (NonSendableKlass(), NonSendableKlass())
+  ns.0 = mainActorIsolatedGlobal
+
+  // This is not a transfer since ns is already main actor isolated.
+  let _ = { @MainActor in
+    print(ns)
   }
 
   useValue(ns)

test/Concurrency/transfernonsendable_global_actor_transferring.swift

@@ -0,0 +1,35 @@
+// RUN: %target-swift-frontend -emit-sil -swift-version 6 -disable-availability-checking -enable-experimental-feature TransferringArgsAndResults -verify %s -o /dev/null -parse-as-library
+
+// README: Once we loosen the parser so that transferring is rejected in Sema
+// instead of the parser, move into the normal
+// transfernonsendable_global_actor.swift
+
+////////////////////////
+// MARK: Declarations //
+////////////////////////
+
+class NonSendableKlass {}
+
+extension Task where Failure == Never {
+  public static func fakeInit(
+    @_implicitSelfCapture operation: transferring @escaping () async -> Success
+  ) {}
+}
+
+func useValue<T>(_ t: T) {}
+
+/////////////////
+// MARK: Tests //
+/////////////////
+
+@MainActor func testGlobalFakeInit() {
+  let ns = NonSendableKlass()
+
+  // Will be resolved once @MainActor is @Sendable
+  Task.fakeInit { @MainActor in // expected-error {{main actor-isolated value of type '@MainActor () async -> ()' passed as a strongly transferred parameter}}
+    print(ns) // expected-error {{transferring 'ns' may cause a race}}
+    // expected-note @-1 {{disconnected 'ns' is captured by a main actor-isolated closure. main actor-isolated uses in closure may race against later nonisolated uses}}
+  }
+
+  useValue(ns) // expected-note {{use here could race}}
+}

test/Concurrency/transfernonsendable_isolationcrossing_partialapply.swift

@@ -41,7 +41,7 @@ actor ProtectsNonSendable {
     // isolated since this is nonisolated.
     self.assumeIsolated { isolatedSelf in
       isolatedSelf.ns = nsArg // expected-warning {{transferring 'nsArg' may cause a race}}
-      // expected-note @-1 {{actor-isolated 'nsArg' is captured by a actor-isolated closure. actor-isolated uses in closure may race against later nonisolated uses}}
+      // expected-note @-1 {{task-isolated 'nsArg' is captured by a actor-isolated closure. actor-isolated uses in closure may race against later nonisolated uses}}
     }
   }
 
@@ -50,7 +50,7 @@ actor ProtectsNonSendable {
     doSomething(l, nsArg)
     self.assumeIsolated { isolatedSelf in
       isolatedSelf.ns = l // expected-warning {{transferring 'l' may cause a race}}
-      // expected-note @-1 {{actor-isolated 'l' is captured by a actor-isolated closure. actor-isolated uses in closure may race against later nonisolated uses}}
+      // expected-note @-1 {{task-isolated 'l' is captured by a actor-isolated closure. actor-isolated uses in closure may race against later nonisolated uses}}
     }
   }