Fix the evaluation of #isolation in non-AFD contexts, most importantly

closures.

The fixes for initializers are just setting the stage for doing this
properly: we should be able to just change the isolation computation
in Sema and fix up the tests.

Author: rjmccall

lib/SILGen/SILGenExpr.cpp

@@ -7393,15 +7393,38 @@ RValue RValueEmitter::visitMacroExpansionExpr(MacroExpansionExpr *E,
   return RValue();
 }
 
+/// getActorIsolationOfContext doesn't return the right isolation for
+/// initializer contexts. Fixing that is a lot of work, so just
+/// hack around it for now here.
+static ActorIsolation getRealActorIsolationOfContext(DeclContext *DC) {
+  if (auto init = dyn_cast<Initializer>(DC)) {
+    return getActorIsolation(init);
+  } else {
+    return getActorIsolationOfContext(DC);
+  }
+}
+
 RValue RValueEmitter::visitCurrentContextIsolationExpr(
     CurrentContextIsolationExpr *E, SGFContext C) {
-  auto afd =
-    dyn_cast_or_null<AbstractFunctionDecl>(SGF.F.getDeclRef().getDecl());
-  if (afd) {
-    auto isolation = getActorIsolation(afd);
-    auto ctor = dyn_cast_or_null<ConstructorDecl>(afd);
+
+  auto isolation = getRealActorIsolationOfContext(SGF.FunctionDC);
+
+  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);
+  }
+
+  if (isolation == ActorIsolation::ActorInstance) {
+    auto ctor = dyn_cast<ConstructorDecl>(SGF.FunctionDC);
     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
@@ -7410,21 +7433,11 @@ RValue RValueEmitter::visitCurrentContextIsolationExpr(
         SGF.emitFlowSensitiveSelfIsolation(E, isolation);
       return RValue(SGF, E, isolationValue);
     }
-
-    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);
-    }
   }
 
+  // Otherwise, just trust the underlying expression. We really don't
+  // need to do this at all --- we assume we can produce the isolation
+  // value from scratch in other situations --- but whatever.
   return visit(E->getActor(), C);
 }
 

test/Concurrency/isolated_nonsending_isolation_macro_sil.swift

@@ -19,3 +19,69 @@ func take(iso: (any Actor)?) {}
 // CHECK:   apply [[FUNC]]([[ACTOR]]) : $@convention(thin) (@guaranteed Optional<any Actor>) -> ()
 // CHECK:   release_value [[ACTOR]]
 // CHECK: } // end sil function '$s39isolated_nonsending_isolation_macro_sil21nonisolatedNonsendingyyYaF'
+
+//   Check that we emit #isolation correctly in closures.
+// CHECK-LABEL: // closure #1 in containsClosure()
+// CHECK-NEXT:  // Isolation: caller_isolation_inheriting
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK-NEXT:    // function_ref take(iso:)
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @
+// CHECK-NEXT:    apply [[FN]](%0)
+func containsClosure() {
+  let closure: nonisolated(nonsending) () async -> Void = {
+    take(iso: #isolation)
+  }
+}
+
+//   Check that we emit #isolation correctly in defer bodies.
+nonisolated(nonsending)
+func hasDefer() async {
+  defer {
+    take(iso: #isolation)
+  }
+  do {}
+}
+// CHECK-LABEL: sil hidden @$s39isolated_nonsending_isolation_macro_sil8hasDeferyyYaF :
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK:         // function_ref $defer
+// CHECK-NEXT:    [[DEFER:%.*]] = function_ref
+// CHECK-NEXT:    apply [[DEFER]](%0)
+
+// CHECK-LABEL: // $defer #1 () in hasDefer()
+// CHECK-NEXT:  // Isolation: caller_isolation_inheriting
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK-NEXT:    // function_ref take(iso:)
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @
+// CHECK-NEXT:    apply [[FN]](%0)
+
+//   Check that we emit #isolation correctly in nested defer bodies.
+nonisolated(nonsending)
+func hasNestedDefer() async {
+  defer {
+    defer {
+      take(iso: #isolation)
+    }
+    do {}
+  }
+  do {}
+}
+
+// CHECK-LABEL: sil hidden @$s39isolated_nonsending_isolation_macro_sil14hasNestedDeferyyYaF :
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK:         // function_ref $defer #1 () in hasNestedDefer()
+// CHECK-NEXT:    [[DEFER:%.*]] = function_ref
+// CHECK-NEXT:    apply [[DEFER]](%0)
+
+// CHECK-LABEL: // $defer #1 () in hasNestedDefer()
+// CHECK-NEXT:  // Isolation: caller_isolation_inheriting
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK:         // function_ref $defer #1 () in $defer #1 () in hasNestedDefer()
+// CHECK-NEXT:    [[DEFER:%.*]] = function_ref
+// CHECK-NEXT:    apply [[DEFER]](%0)
+
+// CHECK-LABEL: // $defer #1 () in $defer #1 () in hasNestedDefer()
+// CHECK-NEXT:  // Isolation: caller_isolation_inheriting
+// CHECK:       bb0(%0 : $Optional<any Actor>):
+// CHECK-NEXT:    // function_ref take(iso:)
+// CHECK-NEXT:    [[FN:%.*]] = function_ref @
+// CHECK-NEXT:    apply [[FN]](%0)