[Concurrency] Fix nonisolated(nonsending) interaction with #isolation

Author: ktoso

lib/SILGen/SILGenExpr.cpp

@@ -7295,15 +7295,30 @@ RValue RValueEmitter::visitMacroExpansionExpr(MacroExpansionExpr *E,
 
 RValue RValueEmitter::visitCurrentContextIsolationExpr(
     CurrentContextIsolationExpr *E, SGFContext C) {
-  // If we are in an actor initializer that is isolated to self, the
-  // current isolation is flow-sensitive; use that instead of the
-  // synthesized expression.
-  if (auto ctor = dyn_cast_or_null<ConstructorDecl>(
-          SGF.F.getDeclRef().getDecl())) {
-    auto isolation = getActorIsolation(ctor);
-    if (ctor->isDesignatedInit() &&
+  auto afd =
+    dyn_cast_or_null<AbstractFunctionDecl>(SGF.F.getDeclRef().getDecl());
+  if (afd) {
+    auto isolation = getActorIsolation(afd);
+    if (isolation == ActorIsolation::CallerIsolationInheriting) {
+      auto *isolatedArg = SGF.F.maybeGetIsolatedArgument();
+      assert(isolatedArg &&
+             "Caller Isolation Inheriting without isolated parameter");
+      ManagedValue isolatedMV;
+      if (isolatedArg->getOwnershipKind() == OwnershipKind::Guaranteed) {
+        isolatedMV = ManagedValue::forBorrowedRValue(isolatedArg);
+      } else {
+        isolatedMV = ManagedValue::forUnmanagedOwnedValue(isolatedArg);
+      }
+      return RValue(SGF, E, isolatedMV);
+    }
+
+    auto ctor = dyn_cast_or_null<ConstructorDecl>(afd);
+    if (ctor && ctor->isDesignatedInit() &&
         isolation == ActorIsolation::ActorInstance &&
         isolation.getActorInstance() == ctor->getImplicitSelfDecl()) {
+      // If we are in an actor initializer that is isolated to self, the
+      // current isolation is flow-sensitive; use that instead of the
+      // synthesized expression.
       auto isolationValue =
         SGF.emitFlowSensitiveSelfIsolation(E, isolation);
       return RValue(SGF, E, isolationValue);

lib/Sema/TypeCheckConcurrency.cpp

@@ -4384,10 +4384,15 @@ namespace {
 
       case ActorIsolation::Unspecified:
       case ActorIsolation::Nonisolated:
-      case ActorIsolation::CallerIsolationInheriting:
       case ActorIsolation::NonisolatedUnsafe:
         actorExpr = new (ctx) NilLiteralExpr(loc, /*implicit=*/false);
         break;
+      case ActorIsolation::CallerIsolationInheriting:
+        // For caller isolation this expression will be replaced in SILGen
+        // because we're adding an implicit isolated parameter that #isolated
+        // must resolve to, but cannot do so during AST expansion quite yet.
+        actorExpr = new (ctx) NilLiteralExpr(loc, /*implicit=*/false);
+        break;
       }
 
 

test/Concurrency/Runtime/isolated_macro_in_nonisolated_nonsending_func.swift

@@ -0,0 +1,72 @@
+// RUN: %target-run-simple-swift( -Xfrontend -disable-availability-checking -parse-as-library) | %FileCheck %s --dump-input=always
+
+// REQUIRES: concurrency
+// REQUIRES: executable_test
+// REQUIRES: concurrency_runtime
+
+// rdar://78109470
+// UNSUPPORTED: back_deployment_runtime
+// UNSUPPORTED: freestanding
+
+import _Concurrency
+import StdlibUnittest
+
+@main struct Main {
+  static func main() async {
+    await explicitIsolatedParam()
+    // CHECK: go - explicitIsolatedParam
+    // CHECK: outerIsolation = #isolation = Optional(Swift.MainActor)
+    // CHECK: Task{} #isolation = nil
+    // CHECK: Task{ [outerIsolation] } outerIsolation = Optional(Swift.MainActor), #iso = Optional(Swift.MainActor)
+    // CHECK: done - explicitIsolatedParam
+
+    print()
+    await nonisolatedNonsending()
+    // CHECK: go - nonisolatedNonsending
+    // CHECK: outerIsolation = #isolation = Optional(Swift.MainActor)
+    // CHECK: Task{} #isolation = nil
+    // CHECK: Task{ [outerIsolation] } outerIsolation = Optional(Swift.MainActor), #iso = nil
+    // CHECK: done - nonisolatedNonsending
+  }
+}
+
+func explicitIsolatedParam(isolation: isolated (any Actor)? = #isolation) async {
+  print("go - \(#function)")
+  MainActor.assertIsolated()
+
+  let outerIsolation = #isolation
+  print("outerIsolation = #isolation = \(String(describing: outerIsolation))")
+
+  await Task {
+    let iso = #isolation
+    print("Task{} #isolation = \(String(describing: iso))")
+  }.value
+
+  await Task {
+    let iso = #isolation
+    print("Task{ [outerIsolation] } outerIsolation = \(String(describing: isolation)), #iso = \(String(describing: iso))")
+  }.value
+
+  print("done - \(#function)")
+}
+
+
+nonisolated(nonsending) func nonisolatedNonsending() async {
+  print("go - \(#function)")
+  MainActor.assertIsolated()
+
+  let outerIsolation = #isolation
+  print("outerIsolation = #isolation = \(String(describing: outerIsolation))") // WRONG; this is nil today
+
+  await Task {
+    let iso = #isolation
+    print("Task{} #isolation = \(String(describing: iso))")
+  }.value
+
+  await Task {
+    let iso = #isolation
+    print("Task{ [outerIsolation] } outerIsolation = \(String(describing: outerIsolation)), #iso = \(String(describing: iso))")
+  }.value
+
+  print("done - \(#function)")
+}