[Concurrency] Downgrade reportUnexpectedExecutor to error on old SDKs by default

Author: ktoso

include/swift/Runtime/Bincompat.h

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift.org open source project
 //
-// Copyright (c) 2014 - 2020 Apple Inc. and the Swift project authors
+// Copyright (c) 2014 - 2024 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -47,6 +47,17 @@ bool useLegacySwiftValueUnboxingInCasting();
 /// if present.
 bool useLegacySwiftObjCHashing();
 
+/// Legacy semantics allowed for the `swift_task_reportUnexpectedExecutor` to
+/// only log a warning. This changes in future releases and this function
+/// will fatal error always.
+///
+/// Old behavior:
+/// - logging a warning on concurrency violation is allowed
+/// New behavior:
+/// - always fatal error in `swift_task_reportUnexpectedExecutor`
+SWIFT_RUNTIME_STDLIB_SPI
+bool swift_bincompat_useLegacyWarningModeReportUnexpectedExecutor();
+
 } // namespace bincompat
 
 } // namespace runtime

stdlib/public/Concurrency/Actor.cpp

@@ -26,6 +26,7 @@
 #include "swift/Concurrency/Actor.h"
 #include "swift/Runtime/AccessibleFunction.h"
 #include "swift/Runtime/Atomic.h"
+#include "swift/Runtime/Bincompat.h"
 #include "swift/Runtime/Casting.h"
 #include "swift/Runtime/DispatchShims.h"
 #include "swift/Threading/Mutex.h"
@@ -76,6 +77,7 @@ extern "C" void objc_autoreleasePoolPop(void *);
 #endif
 
 using namespace swift;
+using namespace swift::runtime::bincompat;
 
 /// Should we yield the thread?
 static bool shouldYieldThread() {
@@ -353,7 +355,14 @@ static bool swift_task_isCurrentExecutorImpl(SerialExecutorRef executor) {
 /// 0 - no logging
 /// 1 - warn on each instance
 /// 2 - fatal error
-static unsigned unexpectedExecutorLogLevel = 2;
+///
+/// NOTE: The default behavior on Apple platforms depends on the SDK version
+/// an application was linked to. Since Swift 6 the default is to crash,
+/// and the logging behavior is no longer available.
+static unsigned unexpectedExecutorLogLevel =
+    swift_bincompat_useLegacyWarningModeReportUnexpectedExecutor()
+        ? 1 // legacy apps default to the logging mode, and cannot use `checkIsolated`
+        : 2; // new apps will only crash upon concurrency violations, and will call into `checkIsolated`
 
 static void checkUnexpectedExecutorLogLevel(void *context) {
 #if SWIFT_STDLIB_HAS_ENVIRON

stdlib/public/runtime/Bincompat.cpp

@@ -255,6 +255,18 @@ bool useLegacySwiftObjCHashing() {
 #endif
 }
 
+// FIXME(concurrency): Once the release is announced, adjust the logic detecting the SDKs
+bool swift_bincompat_useLegacyWarningModeReportUnexpectedExecutor() {
+#if BINARY_COMPATIBILITY_APPLE
+  return true; // For now, legacy behavior on Apple OSes
+#elif SWIFT_TARGET_OS_DARWIN
+  return true; // For now, use legacy behavior on open-source builds for Apple platforms
+#else
+  return false; // Always use the new behavior on non-Apple OSes
+#endif
+}
+
+
 } // namespace bincompat
 
 } // namespace runtime

test/Concurrency/Runtime/actor_assert_precondition_executor_checkIsolated_bincompat.swift

@@ -0,0 +1,69 @@
+// RUN: %target-run-simple-swift(-parse-as-library -Xfrontend -disable-availability-checking) | %FileCheck %s
+
+// REQUIRES: executable_test
+// REQUIRES: concurrency
+// REQUIRES: concurrency_runtime
+
+// REQUIRES: libdispatch
+
+// UNSUPPORTED: back_deployment_runtime
+// UNSUPPORTED: back_deploy_concurrency
+// UNSUPPORTED: use_os_stdlib
+// UNSUPPORTED: freestanding
+
+final class NaiveQueueExecutor: SerialExecutor {
+  init() {}
+
+  public func enqueue(_ job: consuming ExecutorJob) {
+    job.runSynchronously(on: self.asUnownedSerialExecutor())
+  }
+
+  public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
+    UnownedSerialExecutor(ordinary: self)
+  }
+
+  func checkIsolated() {
+    print("checkIsolated: pretend it is ok!")
+  }
+}
+
+actor ActorOnNaiveQueueExecutor {
+  let executor: NaiveQueueExecutor
+
+  init() {
+    self.executor = NaiveQueueExecutor()
+  }
+
+  nonisolated var unownedExecutor: UnownedSerialExecutor {
+    self.executor.asUnownedSerialExecutor()
+  }
+
+  nonisolated func checkPreconditionIsolated() async {
+    print("Before preconditionIsolated")
+    self.preconditionIsolated()
+    print("After preconditionIsolated")
+
+    print("Before assumeIsolated")
+    self.assumeIsolated { iso in
+      print("Inside assumeIsolated")
+    }
+    print("After assumeIsolated")
+  }
+}
+
+@main struct Main {
+  static func main() async {
+    if #available(SwiftStdlib 6.0, *) {
+      let actor = ActorOnNaiveQueueExecutor()
+      await actor.checkPreconditionIsolated()
+      // CHECK: Before preconditionIsolated
+      // CHECK-NEXT: checkIsolated: pretend it is ok!
+      // CHECK-NEXT: After preconditionIsolated
+
+      // CHECK-NEXT: Before assumeIsolated
+      // CHECK-NEXT: checkIsolated: pretend it is ok!
+      // CHECK-NEXT: Inside assumeIsolated
+      // CHECK-NEXT: After assumeIsolated
+    }
+  }
+}