[region-isolation] Values that are captured by an actor isolated closures are transferred to that closure.

This commit makes it so that we treat values captured by an actor isolated
closure as being transferred to that closure. I also introduced a new diagnostic
for these warnings that puts the main warning on the capture point of the value
so the user is able to see the actual capture that causes the transfer to occur:

```swift
  nonisolated func testLocal2() async {
    let l = NonSendableKlass()

    // This is not safe since we use l later.
    self.assumeIsolated { isolatedSelf in
      isolatedSelf.ns = l
    }

    useValue(l) // expected-note {{access here could race}}
  }
```

```
test.swift:74:14: warning: main actor-isolated closure captures value of non-Sendable type 'NonSendableKlass' from nonisolated context; later accesses to value could race
    useValue(x) // expected-warning {{main actor-isolated closure captures value of non-Sendable type 'NonSendableKlass' from nonisolated context; later accesses to value could race}}
             ^
test.swift:76:12: note: access here could race
  useValue(x) // expected-note {{access here could race}}
           ^
```

One thing to keep in mind is that if we have a function argument being captured
in this way, we still emit the "call site passes `self`" error. I am going to
begin cleaning that up in the next commit in this PR so that we emit a better
error here. But it makes sense to split these into two separate commits since
they are doing different things.

rdar://121345525

Author: gottesmm

include/swift/AST/DiagnosticsSIL.def

@@ -898,6 +898,9 @@ WARNING(regionbasedisolation_transfer_yields_race_no_isolation, none,
 WARNING(regionbasedisolation_transfer_yields_race_with_isolation, none,
         "transferring value of non-Sendable type %0 from %1 context to %2 context; later accesses could race",
         (Type, ActorIsolation, ActorIsolation))
+WARNING(regionbasedisolation_isolated_capture_yields_race, none,
+        "%1 closure captures value of non-Sendable type %0 from %2 context; later accesses to value could race",
+        (Type, ActorIsolation, ActorIsolation))
 WARNING(regionbasedisolation_transfer_yields_race_transferring_parameter, none,
         "transferring value of non-Sendable type %0 into transferring parameter; later accesses could race",
         (Type))

include/swift/AST/Expr.h

@@ -3846,6 +3846,20 @@ class AbstractClosureExpr : public DeclContext, public Expr {
     Bits.AbstractClosureExpr.Discriminator = InvalidDiscriminator;
   }
 
+  /// If we find that a capture x of this AbstractClosureExpr belongs to a
+  /// different isolation domain than the closure, add an ApplyIsolationCrossing
+  /// to foundIsolationCrossing.
+  ///
+  /// \p foundIsolationCrossings an out parameter that contains the
+  /// ApplyIsolationCrossing if any of the captures are isolation crossing and
+  /// the index of the capture in the capture array. We return the index since
+  /// all captures may not cross isolation boundaries and we may need to be able
+  /// to look up the corresponding capture at the SIL level by index.
+  void getIsolationCrossing(
+      SmallVectorImpl<
+          std::tuple<CapturedValue, unsigned, ApplyIsolationCrossing>>
+          &foundIsolationCrossings);
+
   CaptureInfo getCaptureInfo() const { return Captures; }
   void setCaptureInfo(CaptureInfo captures) { Captures = captures; }
 

lib/AST/Expr.cpp

@@ -2927,3 +2927,55 @@ Type ThrownErrorDestination::getContextErrorType() const {
   auto conversion = storage.get<Conversion *>();
   return conversion->conversion->getType();
 }
+
+void AbstractClosureExpr::getIsolationCrossing(
+    SmallVectorImpl<std::tuple<CapturedValue, unsigned, ApplyIsolationCrossing>>
+        &foundIsolationCrossings) {
+  /// For each capture...
+  for (auto pair : llvm::enumerate(getCaptureInfo().getCaptures())) {
+    auto capture = pair.value();
+
+    // First check quickly if we have dynamic self metadata. This is Sendable
+    // data so we don't care about it.
+    if (capture.isDynamicSelfMetadata())
+      continue;
+
+    auto declIsolation = swift::getActorIsolation(capture.getDecl());
+
+    // Then see if we have an opaque value.
+    if (auto *opaqueValue = capture.getOpaqueValue()) {
+      continue;
+    }
+
+    // If our decl is actor isolated...
+    if (declIsolation.isActorIsolated()) {
+      // And our closure is also actor isolated, then add the apply isolation
+      // crossing if the actors are different.
+      if (actorIsolation.isActorIsolated()) {
+        if (declIsolation.getActor() == actorIsolation.getActor()) {
+          continue;
+        }
+
+        foundIsolationCrossings.emplace_back(
+            capture, pair.index(),
+            ApplyIsolationCrossing(declIsolation, actorIsolation));
+        continue;
+      }
+
+      // Otherwise, our closure is not actor isolated but our decl is actor
+      // isolated. Add it.
+      foundIsolationCrossings.emplace_back(
+          capture, pair.index(),
+          ApplyIsolationCrossing(declIsolation, actorIsolation));
+      continue;
+    }
+
+    if (!actorIsolation.isActorIsolated()) {
+      continue;
+    }
+
+    foundIsolationCrossings.emplace_back(
+        capture, pair.index(),
+        ApplyIsolationCrossing(declIsolation, actorIsolation));
+  }
+}

lib/SILOptimizer/Analysis/RegionAnalysis.cpp

@@ -1574,6 +1574,31 @@ class PartitionOpTranslator {
     }
   }
 
+  /// Handles the semantics for SIL applies that cross isolation.
+  ///
+  /// Semantically this causes all arguments of the applysite to be transferred.
+  void translateIsolatedPartialApply(PartialApplyInst *pai) {
+    ApplySite applySite(pai);
+
+    // For each argument operand.
+    for (auto &op : applySite.getArgumentOperands()) {
+      // See if we tracked it.
+      if (auto value = tryToTrackValue(op.get())) {
+        // If we are tracking it, transfer it and if it is actor derived, mark
+        // our partial apply as actor derived.
+        builder.addTransfer(value->getRepresentative().getValue(), &op);
+      }
+    }
+
+    // Now that we have transferred everything into the partial_apply, perform
+    // an assign fresh for the partial_apply. If we use any of the transferred
+    // values later, we will error, so it is safe to just create a new value.
+    auto paiValue = tryToTrackValue(pai).value();
+    SILValue rep = paiValue.getRepresentative().getValue();
+    markValueAsActorDerived(rep);
+    translateSILAssignFresh(rep);
+  }
+
   void translateSILPartialApply(PartialApplyInst *pai) {
     assert(!isIsolationBoundaryCrossingApply(pai));
 
@@ -1583,6 +1608,14 @@ class PartitionOpTranslator {
       return translateSILPartialApplyAsyncLetBegin(pai);
     }
 
+    // Check if our closure is isolated to a specific actor. If it is, we need
+    // to treat all of the captures as being transferred.
+    if (auto *ace = pai->getLoc().getAsASTNode<AbstractClosureExpr>()) {
+      if (ace->getActorIsolation().isActorIsolated()) {
+        return translateIsolatedPartialApply(pai);
+      }
+    }
+
     SILMultiAssignOptions options;
     for (auto arg : pai->getOperandValues()) {
       if (auto value = tryToTrackValue(arg)) {