[caller-isolation] Teach Sema how to handle isolation of explicit @execution({concurrent,caller}).

Author: gottesmm

include/swift/AST/Decl.h

@@ -8093,6 +8093,8 @@ class AbstractFunctionDecl : public GenericContext, public ValueDecl {
     return cast_or_null<AbstractFunctionDecl>(ValueDecl::getOverriddenDecl());
   }
 
+  std::optional<ExecutionKind> getExecutionBehavior() const;
+
   /// Whether the declaration is later overridden in the module
   ///
   /// Overrides are resolved during type checking; only query this field after

lib/AST/Decl.cpp

@@ -8471,6 +8471,14 @@ void VarDecl::emitLetToVarNoteIfSimple(DeclContext *UseDC) const {
   }
 }
 
+std::optional<ExecutionKind>
+AbstractFunctionDecl::getExecutionBehavior() const {
+  auto *attr = getAttrs().getAttribute<ExecutionAttr>();
+  if (!attr)
+    return {};
+  return attr->getBehavior();
+}
+
 clang::PointerAuthQualifier VarDecl::getPointerAuthQualifier() const {
   if (auto *clangDecl = getClangDecl()) {
     if (auto *valueDecl = dyn_cast<clang::ValueDecl>(clangDecl)) {

lib/SIL/IR/SILFunctionType.cpp

@@ -2532,6 +2532,16 @@ static CanSILFunctionType getSILFunctionType(
     if (constant) {
       if (constant->kind == SILDeclRef::Kind::Deallocator) {
         actorIsolation = ActorIsolation::forNonisolated(false);
+      } else if (auto *decl = constant->getAbstractFunctionDecl();
+                 decl && decl->getExecutionBehavior().has_value()) {
+        switch (*decl->getExecutionBehavior()) {
+        case ExecutionKind::Concurrent:
+          actorIsolation = ActorIsolation::forNonisolated(false /*unsafe*/);
+          break;
+        case ExecutionKind::Caller:
+          actorIsolation = ActorIsolation::forCallerIsolationInheriting();
+          break;
+        }
       } else {
         actorIsolation =
             getActorIsolationOfContext(constant->getInnermostDeclContext());

lib/Sema/TypeCheckConcurrency.cpp

@@ -4688,6 +4688,7 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
   auto isolatedAttr = decl->getAttrs().getAttribute<IsolatedAttr>();
   auto nonisolatedAttr = decl->getAttrs().getAttribute<NonisolatedAttr>();
   auto globalActorAttr = decl->getGlobalActorAttr();
+  auto concurrentExecutionAttr = decl->getAttrs().getAttribute<ExecutionAttr>();
 
   // Remove implicit attributes if we only care about explicit ones.
   if (onlyExplicit) {
@@ -4697,11 +4698,13 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
       isolatedAttr = nullptr;
     if (globalActorAttr && globalActorAttr->first->isImplicit())
       globalActorAttr = std::nullopt;
+    if (concurrentExecutionAttr && concurrentExecutionAttr->isImplicit())
+      concurrentExecutionAttr = nullptr;
   }
 
-  unsigned numIsolationAttrs = (isolatedAttr ? 1 : 0) +
-                               (nonisolatedAttr ? 1 : 0) +
-                               (globalActorAttr ? 1 : 0);
+  unsigned numIsolationAttrs =
+      (isolatedAttr ? 1 : 0) + (nonisolatedAttr ? 1 : 0) +
+      (globalActorAttr ? 1 : 0) + (concurrentExecutionAttr ? 1 : 0);
   if (numIsolationAttrs == 0) {
     if (isa<DestructorDecl>(decl) && !decl->isImplicit()) {
       return ActorIsolation::forNonisolated(false);
@@ -4815,6 +4818,17 @@ getIsolationFromAttributes(const Decl *decl, bool shouldDiagnose = true,
         .withPreconcurrency(decl->preconcurrency() || isUnsafe);
   }
 
+  // If the declaration is explicitly marked with 'execution', return the
+  // appropriate isolation.
+  if (concurrentExecutionAttr) {
+    switch (concurrentExecutionAttr->getBehavior()) {
+    case ExecutionKind::Concurrent:
+      return ActorIsolation::forNonisolated(false /*is unsafe*/);
+    case ExecutionKind::Caller:
+      return ActorIsolation::forCallerIsolationInheriting();
+    }
+  }
+
   llvm_unreachable("Forgot about an attribute?");
 }
 

test/Concurrency/Runtime/nonisolated_inherits_isolation.swift

@@ -33,6 +33,17 @@ struct CustomActor {
   }
 }
 
+@execution(caller)
+func executionCallerIsolation() async {
+  checkIfOnMainQueue()
+}
+
+// Expected to always crash
+@execution(concurrent)
+func executionConcurrentIsolation() async {
+  checkIfOnMainQueue()
+}
+
 let tests = TestSuite("NonIsolatedInheritsIsolation")
 
 tests.test("checkIfOnMainQueue does not crash on the main queue") { @MainActor () -> () in
@@ -87,6 +98,25 @@ tests.test("Check if nonisolated inheriting nonisolated crashes") { () async ->
   sleep(5)
 }
 
+tests.test("Check if execution concurrent isolation crashes (main actor)") { @MainActor () async -> () in
+  expectCrashLater()
+  await executionConcurrentIsolation()
+}
+
+tests.test("Check if execution concurrent isolation crashes (custom actor)") { @CustomActor () async -> () in
+  expectCrashLater()
+  await executionConcurrentIsolation()
+}
+
+tests.test("Check if execution concurrent isolation does not crash (main actor)") { @MainActor () async -> () in
+  await executionCallerIsolation()
+}
+
+tests.test("Check if execution concurrent isolation does crash (custom actor)") { @CustomActor () async -> () in
+  expectCrashLater()
+  await executionCallerIsolation()
+}
+
 @MainActor func run() async {
   await runAllTestsAsync()
 }

test/Concurrency/attr_execution.swift

@@ -0,0 +1,16 @@
+// RUN: %target-swift-emit-silgen -enable-experimental-feature NonIsolatedAsyncInheritsIsolationFromContext %s | %FileCheck %s
+
+// REQUIRES: asserts
+
+
+// CHECK-LABEL: // concurrentTest()
+// CHECK: // Isolation: nonisolated
+// CHECK: sil hidden [ossa] @$s14attr_execution14concurrentTestyyYaF : $@convention(thin) @async () -> () {
+@execution(concurrent)
+func concurrentTest() async {}
+
+// CHECK-LABEL: // callerTest()
+// CHECK: // Isolation: caller_isolation_inheriting
+// CHECK: sil hidden [ossa] @$s14attr_execution10callerTestyyYaF : $@convention(thin) @async (@sil_isolated @sil_implicit_leading_param @guaranteed Optional<any Actor>) -> () {
+@execution(caller)
+func callerTest() async {}