[Concurrency] Futher prevent crashes in legacy mode of isCurrentExecutor

Author: ktoso

stdlib/public/Concurrency/Actor.cpp

@@ -374,6 +374,12 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor)
 
   // To support old applications on apple platforms which assumed this call
   // does not crash, try to use a more compatible mode for those apps.
+  //
+  // We only allow returning `false` directly from this function when operating
+  // in 'Legacy_NoCheckIsolated_NonCrashing' mode. If allowing crashes, we
+  // instead must call into 'checkIsolated' or crash directly.
+  //
+  // Whenever we confirm an executor equality, we can return true, in any mode.
   static swift::once_t checkModeToken;
   swift::once(checkModeToken, checkIsCurrentExecutorMode, nullptr);
 
@@ -425,40 +431,47 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor)
     // If the expected executor is a default actor, it makes no sense to try
     // the 'checkIsolated' call, it must be equal to the other actor, or it is
     // not the same isolation domain.
-    swift_Concurrency_fatalError(0, "Incorrect actor executor assumption");
+    if (isCurrentExecutorMode == Default_UseCheckIsolated_AllowCrash) {
+      swift_Concurrency_fatalError(0, "Incorrect actor executor assumption");
+    }
     return false;
   }
 
   if (expectedExecutor.isMainExecutor() && !currentExecutor.isMainExecutor()) {
-    // TODO: Invoke checkIsolated() on "main" SerialQueue once it implements `checkIsolated`, otherwise messages will be sub-par and hard to address
-    swift_Concurrency_fatalError(0, "Incorrect actor executor assumption; Expected MainActor executor");
+    if (isCurrentExecutorMode == Default_UseCheckIsolated_AllowCrash) {
+      // TODO: Invoke checkIsolated() on "main" SerialQueue once it implements `checkIsolated`, for potentially better/more consistent error messages
+      swift_Concurrency_fatalError(0, "Incorrect actor executor assumption; Expected MainActor executor");
+    }
     return false;
   } else if (!expectedExecutor.isMainExecutor() && currentExecutor.isMainExecutor()) {
-    // TODO: Invoke checkIsolated() on "main" SerialQueue once it implements `checkIsolated`, otherwise messages will be sub-par and hard to address
-    swift_Concurrency_fatalError(0, "Incorrect actor executor assumption; Expected not-MainActor executor");
+    if (isCurrentExecutorMode == Default_UseCheckIsolated_AllowCrash) {
+      // TODO: Invoke checkIsolated() on "main" SerialQueue once it implements `checkIsolated`, for potentially better/more consistent error messages
+      swift_Concurrency_fatalError(0, "Incorrect actor executor assumption; Expected not-MainActor executor");
+    }
     return false;
   }
 
   if (expectedExecutor.isComplexEquality()) {
-    if (!swift_compareWitnessTables(
-        reinterpret_cast<const WitnessTable*>(currentExecutor.getSerialExecutorWitnessTable()),
-        reinterpret_cast<const  WitnessTable*>(expectedExecutor.getSerialExecutorWitnessTable()))) {
-      // different witness table, we cannot invoke complex equality call
-      return false;
-    }
-
-    // Avoid passing nulls to Swift for the isSame check:
-    if (!currentExecutor.getIdentity() || !expectedExecutor.getIdentity()) {
-      return false;
+    if (currentExecutor.getIdentity() && expectedExecutor.getIdentity() &&
+        swift_compareWitnessTables(
+            reinterpret_cast<const WitnessTable *>(
+                currentExecutor.getSerialExecutorWitnessTable()),
+            reinterpret_cast<const WitnessTable *>(
+                expectedExecutor.getSerialExecutorWitnessTable()))) {
+
+      auto isSameExclusiveExecutionContextResult =
+          _task_serialExecutor_isSameExclusiveExecutionContext(
+              currentExecutor.getIdentity(), expectedExecutor.getIdentity(),
+              swift_getObjectType(currentExecutor.getIdentity()),
+              expectedExecutor.getSerialExecutorWitnessTable());
+
+      // if the 'isSameExclusiveExecutionContext' returned true we trust
+      // it and return; if it was false, we need to give checkIsolated another
+      // chance to check.
+      if (isSameExclusiveExecutionContextResult) {
+        return true;
+      }
     }
-
-    auto result = _task_serialExecutor_isSameExclusiveExecutionContext(
-        currentExecutor.getIdentity(),
-        expectedExecutor.getIdentity(),
-        swift_getObjectType(currentExecutor.getIdentity()),
-        expectedExecutor.getSerialExecutorWitnessTable());
-
-    return result;
   }
 
   // This provides a last-resort check by giving the expected SerialExecutor the
@@ -488,7 +501,6 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor)
     return true;
   }
 
-  // Using legacy mode, if no explicit executor match worked, we assume `false`
   assert(isCurrentExecutorMode == Legacy_NoCheckIsolated_NonCrashing);
   return false;
 }