PoC Allow a SerialExecutor to check its own tracking for isolation checks

Author: ktoso

stdlib/public/Concurrency/Actor.cpp

@@ -313,6 +313,12 @@ bool _task_serialExecutor_isSameExclusiveExecutionContext(
     const Metadata *selfType,
     const SerialExecutorWitnessTable *wtable);
 
+extern "C" SWIFT_CC(swift)
+bool _task_serialExecutor_checkIsolated(
+    HeapObject *executor,
+    const Metadata *selfType,
+    const SerialExecutorWitnessTable *wtable);
+
 SWIFT_CC(swift)
 static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef executor) {
   auto current = ExecutorTrackingInfo::current();
@@ -342,11 +348,16 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef executor) {
     return _task_serialExecutor_isSameExclusiveExecutionContext(
         currentExecutor.getIdentity(),
         executor.getIdentity(),
-        swift_getObjectType(currentExecutor.getIdentity()),
+        currentExecutor.getIdentity() ? swift_getObjectType(currentExecutor.getIdentity()) : 0,
         executor.getSerialExecutorWitnessTable());
   }
 
-  return false;
+  _task_serialExecutor_checkIsolated(
+      executor.getIdentity(),
+      swift_getObjectType(executor.getIdentity()),
+      executor.getSerialExecutorWitnessTable());
+
+  return true;
 }
 
 /// Logging level for unexpected executors:

stdlib/public/Concurrency/Executor.swift

@@ -100,6 +100,20 @@ public protocol SerialExecutor: Executor {
   ///            perspective–to execute code assuming one on the other.
   @available(SwiftStdlib 5.9, *)
   func isSameExclusiveExecutionContext(other: Self) -> Bool
+
+  /// Must crash if unable to confirm that the calling thread belongs to this executor.
+  @available(SwiftStdlib 9999, *)
+  func checkIsolated()
+
+}
+
+@available(SwiftStdlib 9999, *)
+extension SerialExecutor {
+  @available(SwiftStdlib 9999, *)
+  @_unavailableInEmbedded
+  public func checkIsolated() {
+    fatalError("Cannot confirm to be executing on \(Self.self)")
+  }
 }
 
 /// An executor that may be used as preferred executor by a task.
@@ -361,6 +375,13 @@ internal func _task_serialExecutor_isSameExclusiveExecutionContext<E>(current cu
   currentExecutor.isSameExclusiveExecutionContext(other: executor)
 }
 
+@available(SwiftStdlib 9999, *)
+@_silgen_name("_task_serialExecutor_checkIsolated")
+internal func _task_serialExecutor_checkIsolated<E>(executor: E)
+    where E: SerialExecutor {
+  executor.checkIsolated()
+}
+
 /// Obtain the executor ref by calling the executor's `asUnownedSerialExecutor()`.
 /// The obtained executor ref will have all the user-defined flags set on the executor.
 @available(SwiftStdlib 5.9, *)

test/Concurrency/Runtime/actor_assert_precondition_executor_checkIsolated.swift

@@ -0,0 +1,92 @@
+// RUN: %empty-directory(%t)
+// RUN: %target-build-swift -Xfrontend -disable-availability-checking -parse-as-library %s -o %t/a.out
+// RUN: %target-codesign %t/a.out
+// RUN:  %target-run %t/a.out
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+
+// UNSUPPORTED: back_deployment_runtime
+// UNSUPPORTED: back_deploy_concurrency
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: freestanding
+
+// rdar://119743909 fails in optimize tests.
+// UNSUPPORTED: swift_test_mode_optimize
+// UNSUPPORTED: swift_test_mode_optimize_size
+
+//import StdlibUnittest
+import Dispatch
+
+extension DispatchSerialQueue {
+  func checkIsolated() {
+    print("CHECK \(self)")
+    dispatchPrecondition(condition: .onQueue(self))
+  }
+}
+
+/// We only do the executor dance because missing 'asUnownedSerialExecutor'
+/// on DispatchSerialQueue on some platforms.
+final class NaiveQueueExecutor: SerialExecutor {
+  let queue: DispatchSerialQueue
+
+  init(queue: DispatchSerialQueue) {
+    self.queue = queue
+  }
+
+  public func enqueue(_ unowned: UnownedJob) {
+    queue.sync {
+      unowned.runSynchronously(on: self.asUnownedSerialExecutor())
+    }
+  }
+
+  public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+    UnownedSerialExecutor(ordinary: self)
+  }
+
+  func checkIsolated() {
+    dispatchPrecondition(condition: .onQueue(self.queue))
+  }
+}
+
+
+actor FamousActor {
+  let queue: DispatchSerialQueue
+  let executor: NaiveQueueExecutor
+
+  init() {
+    self.queue = DispatchSerialQueue(label: "MyQueue")
+    self.executor = NaiveQueueExecutor(queue: queue)
+  }
+
+  nonisolated var unownedExecutor: UnownedSerialExecutor {
+    self.executor.asUnownedSerialExecutor()
+  }
+
+  nonisolated func callCheck() async {
+    print("Before queue.sync {}")
+    self.queue.sync {
+      print("Before preconditionIsolated")
+      self.preconditionIsolated()
+      print("After preconditionIsolated")
+    }
+  }
+}
+
+@main struct Main {
+  static func main() async {
+//    let tests = TestSuite("AssertPreconditionActorExecutor")
+
+    if #available(SwiftStdlib 9999, *) {
+      // === MainActor --------------------------------------------------------
+
+//      tests.test("queue.async { preconditionIsolated() } ") {
+        await FamousActor().callCheck()
+//      }
+
+    }
+
+//    await runAllTestsAsync()
+  }
+}