Make sure that we capture the isolation of a defer function that

implicitly uses the isolation.

Author: rjmccall

lib/Sema/TypeCheckCaptures.cpp

@@ -66,6 +66,7 @@ class FindCapturedVars : public ASTWalker {
   DeclContext *CurDC;
   bool NoEscape, ObjC;
   bool HasGenericParamCaptures;
+  bool HasUsesOfCurrentIsolation = false;
 
 public:
   FindCapturedVars(SourceLoc CaptureLoc,
@@ -91,6 +92,10 @@ class FindCapturedVars : public ASTWalker {
                        CapturedTypes);
   }
 
+  bool hasUsesOfCurrentIsolation() const {
+    return HasUsesOfCurrentIsolation;
+  }
+
   bool hasGenericParamCaptures() const {
     return HasGenericParamCaptures;
   }
@@ -694,6 +699,31 @@ class FindCapturedVars : public ASTWalker {
       checkType(typeValue->getParamType(), E->getLoc());
     }
 
+    // Record that we saw an #isolation expression that hasn't been filled in.
+    if (auto currentIsolation = dyn_cast<CurrentContextIsolationExpr>(E)) {
+      if (!currentIsolation->getActor())
+        HasUsesOfCurrentIsolation = true;
+    }
+
+    // Record that we saw an apply of a function with caller isolation.
+    if (auto apply = dyn_cast<ApplyExpr>(E)) {
+      if (auto type = apply->getFn()->getType()) {
+        if (auto fnType = type->getAs<AnyFunctionType>();
+            fnType && fnType->getIsolation().isNonIsolatedCaller()) {
+          HasUsesOfCurrentIsolation = true;
+        }
+      }
+    }
+
+    // Look into caller-side default arguments.
+    if (auto defArg = dyn_cast<DefaultArgumentExpr>(E)) {
+      if (defArg->isCallerSide()) {
+        if (auto callerSideExpr = defArg->getCallerSideDefaultExpr()) {
+          callerSideExpr->walk(*this);
+        }
+      }
+    }
+
     return Action::Continue(E);
   }
 
@@ -748,13 +778,18 @@ class FindCapturedVars : public ASTWalker {
 /// Given that a local function is isolated to the given var, should we
 /// force a capture of the var?
 static bool shouldCaptureIsolationInLocalFunc(AbstractFunctionDecl *AFD,
-                                              VarDecl *var) {
+                                              VarDecl *var,
+                                              bool hasUsesOfCurrentIsolation) {
   assert(isa<ParamDecl>(var));
 
   // Don't try to capture an isolated parameter of the function itself.
   if (var->getDeclContext() == AFD)
     return false;
 
+  // Force capture if we have uses of the isolation in the function body.
+  if (hasUsesOfCurrentIsolation)
+    return true;
+
   // We only *need* to force a capture of the isolation in an async function
   // (in which case it's needed for executor switching) or if we're in the
   // mode that forces an executor check in all synchronous functions. But
@@ -793,7 +828,8 @@ CaptureInfo CaptureInfoRequest::evaluate(Evaluator &evaluator,
     auto actorIsolation = getActorIsolation(AFD);
     if (actorIsolation.getKind() == ActorIsolation::ActorInstance) {
       if (auto *var = actorIsolation.getActorInstance()) {
-        if (shouldCaptureIsolationInLocalFunc(AFD, var))
+        if (shouldCaptureIsolationInLocalFunc(AFD, var,
+                                              finder.hasUsesOfCurrentIsolation()))
           finder.addCapture(CapturedValue(var, 0, AFD->getLoc()));
       }
     }

test/Concurrency/isolated_nonsending_isolation_macro_sil.swift renamed to test/Concurrency/isolation_macro_sil.swift

@@ -1,4 +1,4 @@
-// RUN: %target-swift-frontend -parse-as-library -emit-sil %s | %FileCheck %s
+// RUN: %target-swift-frontend -parse-as-library -emit-sil %s -module-name test | %FileCheck %s
 
 // REQUIRES: concurrency
 
@@ -9,17 +9,19 @@ nonisolated(nonsending) func nonisolatedNonsending() async {
 
 func take(iso: (any Actor)?) {}
 
+func takeDefaulted(iso: isolated (any Actor)? = #isolation) {}
+
 // CHECK-LABEL: // nonisolatedNonsending()
 // CHECK-NEXT: // Isolation: caller_isolation_inheriting
-// CHECK-NEXT: sil hidden @$s39isolated_nonsending_isolation_macro_sil21nonisolatedNonsendingyyYaF : $@convention(thin) @async (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>) -> () {
+// CHECK-NEXT: sil hidden @$s4test21nonisolatedNonsendingyyYaF : $@convention(thin) @async (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>) -> () {
 // CHECK:      bb0([[ACTOR:%.*]] : $Optional<any Actor>):
 // CHECK:   hop_to_executor [[ACTOR]]
 // CHECK:   retain_value [[ACTOR]]
 // CHECK:   debug_value [[ACTOR]], let, name "iso"
-// CHECK:   [[FUNC:%.*]] = function_ref @$s39isolated_nonsending_isolation_macro_sil4take3isoyScA_pSg_tF : $@convention(thin) (@guaranteed Optional<any Actor>) -> ()
+// CHECK:   [[FUNC:%.*]] = function_ref @$s4test4take3isoyScA_pSg_tF : $@convention(thin) (@guaranteed Optional<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: } // end sil function '$s4test21nonisolatedNonsendingyyYaF'
 
 //   Check that we emit #isolation correctly in closures.
 // CHECK-LABEL: // closure #1 in containsClosure()
@@ -34,6 +36,49 @@ func containsClosure() {
   }
 }
 
+//   Check that we capture variables as necessary to emit #isolation
+//   correctly in defer bodies.
+func deferWithIsolatedParam(_ iso: isolated (any Actor)) {
+  defer {
+    take(iso: #isolation)
+  }
+  do {}
+}
+// CHECK-LABEL: sil hidden @$s4test22deferWithIsolatedParamyyScA_pYiF :
+// CHECK:       bb0(%0 : $any Actor)
+// CHECK:         [[DEFER:%.*]] = function_ref @$s4test22deferWithIsolatedParamyyScA_pYiF6$deferL_yyF :
+// CHECK-NEXT:    apply [[DEFER]](%0)
+
+// CHECK-LABEL: sil private @$s4test22deferWithIsolatedParamyyScA_pYiF6$deferL_yyF :
+// CHECK:       bb0(%0 : @closureCapture $any Actor):
+// CHECK:         [[T0:%.*]] = enum $Optional<any Actor>, #Optional.some!enumelt, %0
+// CHECK:         [[FN:%.*]] = function_ref @$s4test4take3isoyScA_pSg_tF :
+// CHECK-NEXT:    apply [[FN]]([[T0]])
+
+//   Check that that happens even with uses in caller-side default
+//   arguments, which capture analysis was not previously walking into.
+func deferWithIsolatedParam_defaultedUse(_ iso: isolated (any Actor)) {
+  defer {
+    takeDefaulted()
+  }
+  do {}
+}
+
+// CHECK-LABEL: sil hidden @$s4test35deferWithIsolatedParam_defaultedUseyyScA_pYiF :
+// CHECK:       bb0(%0 : $any Actor):
+// CHECK:         [[DEFER:%.*]] = function_ref @$s4test35deferWithIsolatedParam_defaultedUseyyScA_pYiF6$deferL_yyF :
+// CHECK-NEXT:    apply [[DEFER]](%0)
+
+// CHECK-LABEL: sil private @$s4test35deferWithIsolatedParam_defaultedUseyyScA_pYiF6$deferL_yyF :
+// CHECK:       bb0(%0 : @closureCapture $any Actor):
+// CHECK:         [[T0:%.*]] = enum $Optional<any Actor>, #Optional.some!enumelt, %0
+// CHECK:         [[FN:%.*]] = function_ref @$s4test13takeDefaulted3isoyScA_pSgYi_tF :
+// CHECK-NEXT:    apply [[FN]]([[T0]])
+
+// TODO: we can't currently call nonisolated(nonsending) functions in
+// defer bodies because they have to be async, but that should be
+// tested here as well.
+
 //   Check that we emit #isolation correctly in defer bodies.
 nonisolated(nonsending)
 func hasDefer() async {
@@ -42,7 +87,7 @@ func hasDefer() async {
   }
   do {}
 }
-// CHECK-LABEL: sil hidden @$s39isolated_nonsending_isolation_macro_sil8hasDeferyyYaF :
+// CHECK-LABEL: sil hidden @$s4test8hasDeferyyYaF :
 // CHECK:       bb0(%0 : $Optional<any Actor>):
 // CHECK:         // function_ref $defer
 // CHECK-NEXT:    [[DEFER:%.*]] = function_ref
@@ -67,7 +112,7 @@ func hasNestedDefer() async {
   do {}
 }
 
-// CHECK-LABEL: sil hidden @$s39isolated_nonsending_isolation_macro_sil14hasNestedDeferyyYaF :
+// CHECK-LABEL: sil hidden @$s4test14hasNestedDeferyyYaF :
 // CHECK:       bb0(%0 : $Optional<any Actor>):
 // CHECK:         // function_ref $defer #1 () in hasNestedDefer()
 // CHECK-NEXT:    [[DEFER:%.*]] = function_ref