[concurrency] Add a new entrypoint: swift_task_isCurrentExecutorWithFlags.

This entrypoint is similar to swift_task_isCurrentExecutor except that it
provides an ABI level option flag that enables one to configure its behavior in
a backwards deployable manner via the option flag.

I used this to expose at the ABI level the ability to check the current executor
without crashing on failure, while preserving the current behavior of
swift_task_isCurrentExecutor (which crashes on failure).

I am going to use this to implement swift_task_runOnMainActor.

Author: gottesmm

include/swift/Runtime/Concurrency.h

@@ -963,6 +963,45 @@ TaskExecutorRef swift_task_getPreferredTaskExecutor(void);
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 bool swift_task_isCurrentExecutor(SerialExecutorRef executor);
 
+/// This is an options enum that is used to pass flags to
+/// swift_task_isCurrentExecutorWithFlags. It is meant to be a flexible toggle.
+///
+/// Since this is an options enum, so all values should be powers of 2.
+///
+/// NOTE: We are purposely leaving this as a uint64_t so that on all platforms
+/// this could be a pointer to a different enum instance if we need it to be.
+enum swift_task_is_current_executor_flag : uint64_t {
+  /// We aren't passing any flags.
+  None = 0x0,
+
+  /// This is not used today, but is just future ABI reservation.
+  ///
+  /// The intention is that we may want the ability to tell future versions of
+  /// the runtime that this uint64_t is actually a pointer that it should
+  /// dereference and then have further extended behavior controlled by a
+  /// different enum. By placing this here, we ensure that we will have a tagged
+  /// pointer compatible flag for this purpose.
+  TaggedPointer = 0x1,
+
+  /// This is not used today, but is just future ABI reservation.
+  ///
+  /// \see swift_task_is_current_executor_flag::TaggedPointer
+  TaggedPointer2 = 0x2,
+
+  /// This is not used today, but is just future ABI reservation.
+  ///
+  /// \see swift_task_is_current_executor_flag::TaggedPointer
+  TaggedPointer3 = 0x4,
+
+  /// The routine should assert on failure.
+  Assert = 0x8,
+};
+
+SWIFT_EXPORT_FROM(swift_Concurrency)
+SWIFT_CC(swift)
+bool swift_task_isCurrentExecutorWithFlags(
+    SerialExecutorRef executor, swift_task_is_current_executor_flag flags);
+
 SWIFT_EXPORT_FROM(swift_Concurrency) SWIFT_CC(swift)
 void swift_task_reportUnexpectedExecutor(
     const unsigned char *file, uintptr_t fileLength, bool fileIsASCII,

stdlib/public/CompatibilityOverride/CompatibilityOverrideConcurrency.def

@@ -136,6 +136,11 @@ OVERRIDE_ACTOR(task_isCurrentExecutor, bool,
                SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift),
                swift::, (SerialExecutorRef executor), (executor))
 
+OVERRIDE_ACTOR(task_isCurrentExecutorWithFlags, bool,
+               SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swift), swift::,
+               (SerialExecutorRef executor, swift_task_is_current_executor_flag flags),
+               (executor, flags))
+
 OVERRIDE_ACTOR(task_switch, void,
                SWIFT_EXPORT_FROM(swift_Concurrency), SWIFT_CC(swiftasync),
                swift::, (SWIFT_ASYNC_CONTEXT AsyncContext *resumeToContext,

stdlib/public/Concurrency/Actor.cpp

@@ -379,15 +379,6 @@ bool swift_bincompat_useLegacyNonCrashingExecutorChecks() {
   return legacyMode;
 }
 
-// Check override of executor checking mode.
-static void checkIsCurrentExecutorMode(void *context) {
-  bool useLegacyMode =
-      swift_bincompat_useLegacyNonCrashingExecutorChecks();
-  auto checkMode = static_cast<IsCurrentExecutorCheckMode *>(context);
-  *checkMode = useLegacyMode ? Legacy_NoCheckIsolated_NonCrashing
-                             : Swift6_UseCheckIsolated_AllowCrash;
-}
-
 // Implemented in Swift to avoid some annoying hard-coding about
 // TaskExecutor's protocol witness table.  We could inline this
 // with effort, though.
@@ -402,9 +393,16 @@ extern "C" SWIFT_CC(swift) void _swift_task_enqueueOnExecutor(
     Job *job, HeapObject *executor, const Metadata *executorType,
     const SerialExecutorWitnessTable *wtable);
 
+namespace {
+using SwiftTaskIsCurrentExecutorOptions =
+    OptionSet<swift_task_is_current_executor_flag>;
+}
+
 SWIFT_CC(swift)
-static bool isCurrentExecutor(SerialExecutorRef expectedExecutor,
-                              IsCurrentExecutorCheckMode checkMode) {
+static bool swift_task_isCurrentExecutorWithFlagsImpl(
+    SerialExecutorRef expectedExecutor,
+    swift_task_is_current_executor_flag flags) {
+  auto options = SwiftTaskIsCurrentExecutorOptions(flags);
   auto current = ExecutorTrackingInfo::current();
 
   if (!current) {
@@ -423,14 +421,14 @@ static bool isCurrentExecutor(SerialExecutorRef expectedExecutor,
 
     // Otherwise, as last resort, let the expected executor check using
     // external means, as it may "know" this thread is managed by it etc.
-    if (checkMode == Swift6_UseCheckIsolated_AllowCrash) {
+    if (options.contains(swift_task_is_current_executor_flag::Assert)) {
       swift_task_checkIsolated(expectedExecutor); // will crash if not same context
 
       // checkIsolated did not crash, so we are on the right executor, after all!
       return true;
     }
 
-    assert(checkMode == Legacy_NoCheckIsolated_NonCrashing);
+    assert(!options.contains(swift_task_is_current_executor_flag::Assert));
     return false;
   }
 
@@ -461,7 +459,7 @@ static bool isCurrentExecutor(SerialExecutorRef expectedExecutor,
   // the crashing 'dispatch_assert_queue(main queue)' which will either crash
   // or confirm we actually are on the main queue; or the custom expected
   // executor has a chance to implement a similar queue check.
-  if (checkMode == Legacy_NoCheckIsolated_NonCrashing) {
+  if (!options.contains(swift_task_is_current_executor_flag::Assert)) {
     if ((expectedExecutor.isMainExecutor() && !currentExecutor.isMainExecutor()) ||
         (!expectedExecutor.isMainExecutor() && currentExecutor.isMainExecutor())) {
       return false;
@@ -522,7 +520,7 @@ static bool isCurrentExecutor(SerialExecutorRef expectedExecutor,
   // Note that this only works because the closure in assumeIsolated is
   // synchronous, and will not cause suspensions, as that would require the
   // presence of a Task.
-  if (checkMode == Swift6_UseCheckIsolated_AllowCrash) {
+  if (options.contains(swift_task_is_current_executor_flag::Assert)) {
     swift_task_checkIsolated(expectedExecutor); // will crash if not same context
 
     // The checkIsolated call did not crash, so we are on the right executor.
@@ -531,10 +529,20 @@ static bool isCurrentExecutor(SerialExecutorRef expectedExecutor,
 
   // In the end, since 'checkIsolated' could not be used, so we must assume
   // that the executors are not the same context.
-  assert(checkMode == Legacy_NoCheckIsolated_NonCrashing);
+  assert(!options.contains(swift_task_is_current_executor_flag::Assert));
   return false;
 }
 
+// Check override of executor checking mode.
+static void swift_task_setDefaultExecutorCheckingFlags(void *context) {
+  bool useLegacyMode = swift_bincompat_useLegacyNonCrashingExecutorChecks();
+  auto checkMode = static_cast<swift_task_is_current_executor_flag *>(context);
+  if (!useLegacyMode) {
+    *checkMode = swift_task_is_current_executor_flag(
+        *checkMode | swift_task_is_current_executor_flag::Assert);
+  }
+}
+
 SWIFT_CC(swift)
 static bool
 swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor) {
@@ -546,11 +554,14 @@ swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor) {
   // instead must call into 'checkIsolated' or crash directly.
   //
   // Whenever we confirm an executor equality, we can return true, in any mode.
-  static IsCurrentExecutorCheckMode checkMode;
-  static swift::once_t checkModeToken;
-  swift::once(checkModeToken, checkIsCurrentExecutorMode, &checkMode);
+  static swift_task_is_current_executor_flag isCurrentExecutorFlag;
+  static swift::once_t isCurrentExecutorFlagToken;
+  swift::once(isCurrentExecutorFlagToken,
+              swift_task_setDefaultExecutorCheckingFlags,
+              &isCurrentExecutorFlag);
 
-  return isCurrentExecutor(expectedExecutor, checkMode);
+  return swift_task_isCurrentExecutorWithFlags(expectedExecutor,
+                                               isCurrentExecutorFlag);
 }
 
 /// Logging level for unexpected executors:
@@ -2337,11 +2348,8 @@ static void swift_task_deinitOnExecutorImpl(void *object,
   //
   // Note that isCurrentExecutor() returns true for @MainActor
   // when running on the main thread without any executor.
-  //
-  // We always use "legacy" checking mode here, because that's the desired
-  // behaviour for this use case. This does not change with SDK version or
-  // language mode.
-  if (isCurrentExecutor(newExecutor, Legacy_NoCheckIsolated_NonCrashing)) {
+  if (swift_task_isCurrentExecutorWithFlags(
+          newExecutor, swift_task_is_current_executor_flag::None)) {
     return work(object); // 'return' forces tail call
   }
 

test/abi/Inputs/macOS/x86_64/concurrency/baseline-asserts

@@ -997,6 +997,7 @@ _swift_task_getMainExecutor
 _swift_task_hasTaskGroupStatusRecord
 _swift_task_isCancelled
 _swift_task_isCurrentExecutor
+_swift_task_isCurrentExecutorWithFlags
 _swift_task_isOnExecutor
 _swift_task_isOnExecutor_hook
 _swift_task_localValueGet

test/abi/macOS/arm64/concurrency.swift

@@ -371,3 +371,4 @@ Added: _$ss15SuspendingClockV7InstantV3nowADvpZMV
 Added: _$ss9TaskLocalC18_enclosingInstance7wrapped7storagexs5NeverO_s24ReferenceWritableKeyPathCyAGxGAIyAgByxGGtcipZMV
 
 Added: _swift_taskGroup_initializeWithOptions
+Added: _swift_task_isCurrentExecutorWithFlags

unittests/runtime/CompatibilityOverrideConcurrency.cpp

@@ -330,6 +330,11 @@ TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_startOnMainActorImpl) {
   swift_task_startOnMainActor(nullptr);
 }
 
+TEST_F(CompatibilityOverrideConcurrencyTest,
+       test_swift_task_isCurrentExecutorWithFlags) {
+  swift_task_isCurrentExecutorWithFlags(swift_task_getMainExecutor(), 0);
+}
+
 #if RUN_ASYNC_MAIN_DRAIN_QUEUE_TEST
 TEST_F(CompatibilityOverrideConcurrencyTest, test_swift_task_asyncMainDrainQueue) {