[Concurrency] Reshape initial values of executor checking so tests pass on Linux

Author: ktoso

stdlib/public/Concurrency/Actor.cpp

@@ -335,10 +335,9 @@ enum IsCurrentExecutorCheckMode: unsigned {
 static IsCurrentExecutorCheckMode isCurrentExecutorMode =
     Swift6_UseCheckIsolated_AllowCrash;
 
-
 // Shimming call to Swift runtime because Swift Embedded does not have
 // these symbols defined.
-bool swift_bincompat_useLegacyNonCrashingExecutorChecks() {
+bool __swift_bincompat_useLegacyNonCrashingExecutorChecks() {
 #if !SWIFT_CONCURRENCY_EMBEDDED
   return swift::runtime::bincompat::
       swift_bincompat_useLegacyNonCrashingExecutorChecks();
@@ -347,22 +346,30 @@ bool swift_bincompat_useLegacyNonCrashingExecutorChecks() {
 #endif
 }
 
-// Check override of executor checking mode.
-static void checkIsCurrentExecutorMode(void *context) {
-  auto useLegacyMode =
-      swift_bincompat_useLegacyNonCrashingExecutorChecks();
+// Done this way because of the interaction with the initial value of
+// 'unexpectedExecutorLogLevel'
+bool swift_bincompat_useLegacyNonCrashingExecutorChecks() {
+  bool legacyMode = __swift_bincompat_useLegacyNonCrashingExecutorChecks();
 
   // Potentially, override the platform detected mode, primarily used in tests.
 #if SWIFT_STDLIB_HAS_ENVIRON
-  if (const char *modeStr = runtime::environment::concurrencyIsCurrentExecutorLegacyModeOverride()) {
+  if (const char *modeStr = runtime::environment::
+        concurrencyIsCurrentExecutorLegacyModeOverride()) {
     if (strcmp(modeStr, "nocrash") == 0 || strcmp(modeStr, "legacy") == 0) {
-      useLegacyMode = true;
+      return true;
     } else if (strcmp(modeStr, "crash") == 0 || strcmp(modeStr, "swift6") == 0) {
-      useLegacyMode = false;
+      return false; // don't use the legacy mode
     } // else, just use the platform detected mode
-  }
+  } // no override, use the default mode
 #endif // SWIFT_STDLIB_HAS_ENVIRON
 
+  return legacyMode;
+}
+
+// Check override of executor checking mode.
+static void checkIsCurrentExecutorMode(void *context) {
+  bool useLegacyMode =
+      swift_bincompat_useLegacyNonCrashingExecutorChecks();
   isCurrentExecutorMode = useLegacyMode ? Legacy_NoCheckIsolated_NonCrashing
                                         : Swift6_UseCheckIsolated_AllowCrash;
 }
@@ -382,6 +389,11 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef expectedExecutor)
   static swift::once_t checkModeToken;
   swift::once(checkModeToken, checkIsCurrentExecutorMode, nullptr);
 
+  fprintf(stderr, "[%s:%d](%s) MODE = %s\n", __FILE_NAME__, __LINE__, __FUNCTION__,
+          isCurrentExecutorMode == Swift6_UseCheckIsolated_AllowCrash
+              ? "Swift6_UseCheckIsolated_AllowCrash"
+              : "Legacy_NoCheckIsolated_NonCrashing");
+
   if (!current) {
     // We have no current executor, i.e. we are running "outside" of Swift
     // Concurrency. We could still be running on a thread/queue owned by
@@ -521,12 +533,9 @@ static void checkUnexpectedExecutorLogLevel(void *context) {
   if (!levelStr)
     return;
 
-  auto isCurrentExecutorLegacyMode =
-      swift_bincompat_useLegacyNonCrashingExecutorChecks();
-
   long level = strtol(levelStr, nullptr, 0);
   if (level >= 0 && level < 3) {
-    if (isCurrentExecutorLegacyMode) {
+    if (swift_bincompat_useLegacyNonCrashingExecutorChecks()) {
       // legacy mode permits doing nothing or just logging, since the method
       // used to perform the check itself is not going to crash:
       unexpectedExecutorLogLevel = level;

test/Concurrency/Runtime/actor_assert_precondition_executor_default_mode.swift renamed to test/Concurrency/Runtime/actor_assert_precondition_executor.swift

@@ -1,7 +1,7 @@
 // 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
+// RUN: %env-SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE=swift6 %target-run %t/a.out
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
@@ -12,7 +12,7 @@
 // UNSUPPORTED: use_os_stdlib
 // UNSUPPORTED: freestanding
 
-// rdar://119743909 fails in optimze tests.
+// rdar://119743909 fails in optimize tests.
 // UNSUPPORTED: swift_test_mode_optimize
 // UNSUPPORTED: swift_test_mode_optimize_size
 

test/Concurrency/Runtime/actor_assert_precondition_executor_checkIsolated_main_customMain_swift6_mode.swift renamed to test/Concurrency/Runtime/actor_assert_precondition_executor_checkIsolated_main_customExecutorOnMain_swift6_mode.swift

@@ -1,7 +1,7 @@
 // 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
+// RUN: %env-SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE=legacy %target-run %t/a.out
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency

test/Concurrency/Runtime/actor_assume_executor.swift

@@ -6,7 +6,7 @@
 // will be able to have this behavior, however new apps will not. We use the
 // overrides to test the logic for legacy code remains functional.
 //
-// RUN: env %env-SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=1 %env-SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE=nocrash %target-run %t/a.out 2>&1 | %FileCheck %s
+// RUN: %env-SWIFT_UNEXPECTED_EXECUTOR_LOG_LEVEL=1 %env-SWIFT_IS_CURRENT_EXECUTOR_LEGACY_MODE_OVERRIDE=legacy %target-run %t/a.out 2>&1 | %FileCheck %s
 
 // REQUIRES: executable_test
 // REQUIRES: concurrency
@@ -66,14 +66,14 @@ actor MyActor {
 struct Runner {
   static func main() async {
     print("Launching a main-actor task")
-    // CHECK: warning: data race detected: @MainActor function at main/data_race_detection_legacy_warning.swift:30 was not called on the main thread
+    // CHECK: data race detected: @MainActor function at main/data_race_detection_legacy_warning.swift:30 was not called on the main thread
     launchFromMainThread()
     sleep(1)
 
     let actor = MyActor()
     let actorFn = await actor.getTaskOnMyActor()
     print("Launching an actor-instance task")
-    // CHECK: warning: data race detected: actor-isolated function at main/data_race_detection_legacy_warning.swift:59 was not called on the same actor
+    // CHECK: data race detected: actor-isolated function at main/data_race_detection_legacy_warning.swift:59 was not called on the same actor
     launchTask(actorFn)
 
     sleep(1)