cleanup

Author: ktoso

stdlib/cmake/modules/AddSwiftStdlib.cmake

@@ -1810,7 +1810,7 @@ function(add_swift_target_library name)
   if (SWIFTLIB_IS_STDLIB)
     list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-warn-implicit-overrides")
     list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-enable-ossa-modules")
-    list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-enable-lexical-lifetimes=true") # FIXME: undo this
+    list(APPEND SWIFTLIB_SWIFT_COMPILE_FLAGS "-Xfrontend;-enable-lexical-lifetimes=false")
   endif()
 
   if(NOT SWIFT_BUILD_RUNTIME_WITH_HOST_COMPILER AND NOT BUILD_STANDALONE AND

stdlib/public/BackDeployConcurrency/Actor.cpp

@@ -285,9 +285,6 @@ JobPriority swift::swift_task_getCurrentThreadPriority() {
 SWIFT_CC(swift)
 static bool swift_task_isCurrentExecutorImpl(ExecutorRef executor) {
   if (auto currentTracking = ExecutorTrackingInfo::current()) {
-            currentTracking->getActiveExecutor().getIdentity(),
-            currentTracking->getActiveExecutor().isMainExecutor() ? "y" : "n",
-            currentTracking->getActiveExecutor().isDefaultActor() ? "y" : "n");
     return currentTracking->getActiveExecutor() == executor;
   }
 

stdlib/public/Concurrency/Actor.cpp

@@ -301,7 +301,7 @@ static bool swift_task_isCurrentExecutorImpl(ExecutorRef executor) {
     return currentTracking->getActiveExecutor() == executor;
   }
 
-  // TODO(ktoso): checking the "is main thread" is not correct, main executor can be not main thread
+  // TODO(ktoso): checking the "is main thread" is not correct, main executor can be not main thread, relates to rdar://106188692
   return executor.isMainExecutor() && isExecutingOnMainThread();
 }
 

stdlib/public/Concurrency/CMakeLists.txt

@@ -107,7 +107,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   UncheckedContinuation.swift
   GlobalActor.swift
   MainActor.swift
-  Job.swift
+  PartialAsyncTask.swift
   SourceCompatibilityShims.swift
   Task.cpp
   Task.swift
@@ -150,7 +150,6 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
     ${SWIFT_STANDARD_LIBRARY_SWIFT_FLAGS}
     -parse-stdlib
     -Xfrontend -enable-experimental-concurrency
-    -Xfrontend -enable-experimental-move-only # FIXME: REMOVE THIS
     -diagnostic-style swift
     ${SWIFT_RUNTIME_CONCURRENCY_SWIFT_FLAGS}
   ${swift_concurrency_options}

stdlib/public/Concurrency/Executor.swift

@@ -15,7 +15,9 @@ import Swift
 /// A service that can execute jobs.
 @available(SwiftStdlib 5.1, *)
 public protocol Executor: AnyObject, Sendable {
+
   @available(*, deprecated, message: "Implement 'enqueue(_: __owned Job)' instead")
+  @available(SwiftStdlib 5.1, *)
   func enqueue(_ job: UnownedJob)
 
   @available(SwiftStdlib 5.9, *)
@@ -43,6 +45,7 @@ public protocol SerialExecutor: Executor {
 
   /// Convert this executor value to the optimized form of borrowed
   /// executor references.
+  @available(SwiftStdlib 5.9, *)
   func asUnownedSerialExecutor() -> UnownedSerialExecutor
 }
 
@@ -59,6 +62,7 @@ extension Executor {
 
 @available(SwiftStdlib 5.9, *)
 extension SerialExecutor {
+  @available(SwiftStdlib 5.9, *)
   public func asUnownedSerialExecutor() -> UnownedSerialExecutor {
     UnownedSerialExecutor(ordinary: self)
   }
@@ -116,7 +120,7 @@ internal func _getJobTaskId(_ job: UnownedJob) -> UInt64
 internal func _enqueueOnExecutor<E>(job unownedJob: UnownedJob, executor: E)
 where E: SerialExecutor {
   if #available(SwiftStdlib 5.9, *) {
-    executor.enqueue(Job(context: unownedJob.context))
+    executor.enqueue(Job(context: unownedJob._context))
   } else {
     executor.enqueue(unownedJob)
   }

stdlib/public/Concurrency/ExecutorAssertions.swift

@@ -34,7 +34,7 @@ import SwiftShims
 ///   programming error.
 ///
 /// - Parameter executor: the expected current executor
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 public
 func preconditionTaskOnExecutor(
     _ executor: some SerialExecutor,
@@ -71,7 +71,7 @@ func preconditionTaskOnExecutor(
 ///   programming error.
 ///
 /// - Parameter actor: the actor whose serial executor we expect to be the current executor
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 public
 func preconditionTaskOnActorExecutor(
     _ actor: some Actor,
@@ -108,7 +108,7 @@ func preconditionTaskOnActorExecutor(
 ///   assumption is a serious programming error.
 ///
 /// - Parameter executor: the expected current executor
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 public
 func assertTaskOnExecutor(
     _ executor: some SerialExecutor,
@@ -143,7 +143,7 @@ func assertTaskOnExecutor(
 ///
 ///
 /// - Parameter actor: the actor whose serial executor we expect to be the current executor
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 public
 func assertTaskOnActorExecutor(
     _ actor: some Actor,
@@ -180,7 +180,7 @@ func assertTaskOnActorExecutor(
 /// if another actor uses the same serial executor--by using ``MainActor/sharedUnownedExecutor``
 /// as its own ``Actor/unownedExecutor``--this check will succeed, as from a concurrency safety
 /// perspective, the serial executor guarantees mutual exclusion of those two actors.
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 @_unavailableFromAsync(message: "await the call to the @MainActor closure directly")
 public
 func assumeOnMainActorExecutor<T>(
@@ -218,7 +218,7 @@ func assumeOnMainActorExecutor<T>(
 /// if another actor uses the same serial executor--by using that actor's ``Actor/unownedExecutor``
 /// as its own ``Actor/unownedExecutor``--this check will succeed, as from a concurrency safety
 /// perspective, the serial executor guarantees mutual exclusion of those two actors.
-@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@available(SwiftStdlib 5.9, *) 
 @_unavailableFromAsync(message: "express the closure as an explicit function declared on the specified 'actor' instead")
 public
 func assumeOnActorExecutor<Act: Actor, T>(

stdlib/public/Concurrency/PartialAsyncTask.swift

@@ -28,16 +28,21 @@ internal func _swiftJobRun(_ job: UnownedJob,
 ///
 /// Unless you're implementing a scheduler,
 /// you don't generally interact with jobs directly.
+///
+/// An `UnownedJob` must be eventually run *exactly once* using ``runSynchronously(on:)``.
+/// Not doing so is effectively going to leak and "hang" the work that the job represents (e.g. a ``Task``).
 @available(SwiftStdlib 5.1, *)
 @frozen
 public struct UnownedJob: Sendable {
-  internal var context: Builtin.Job
+  private var context: Builtin.Job
 
   @usableFromInline
+  @available(SwiftStdlib 5.9, *)
   internal init(context: Builtin.Job) {
     self.context = context
   }
 
+  /// Create an `UnownedJob` whose lifetime must be managed carefully until it is run exactly once.
   @available(SwiftStdlib 5.9, *)
   public init(_ job: __owned Job) {
     self.context = job.context
@@ -50,14 +55,52 @@ public struct UnownedJob: Sendable {
     return JobPriority(rawValue: raw)
   }
 
+  @available(SwiftStdlib 5.9, *)
+  internal var _context: Builtin.Job {
+    context
+  }
+
+  /// Deprecated API to run a job on a specific executor.
   @_alwaysEmitIntoClient
   @inlinable
   @available(*, deprecated, renamed: "Job.runSynchronously(on:)")
   public func _runSynchronously(on executor: UnownedSerialExecutor) {
-      _swiftJobRun(self, executor)
+    _swiftJobRun(self, executor)
+  }
+
+  /// Run this job on the passed in executor.
+  ///
+  /// This operation runs the job on the calling thread and *blocks* until the job completes.
+  /// The intended use of this method is for an executor to determine when and where it
+  /// wants to run the job and then call this method on it.
+  ///
+  /// The passed in executor reference is used to establish the executor context for the job,
+  /// and should be the same executor as the one semantically calling the `runSynchronously` method.
+  ///
+  /// - Parameter executor: the executor this job will be semantically running on.
+  @_alwaysEmitIntoClient
+  @inlinable
+  public func runSynchronously(on executor: UnownedSerialExecutor) {
+    _swiftJobRun(self, executor)
   }
+
 }
 
+@available(SwiftStdlib 5.9, *)
+extension UnownedJob: CustomStringConvertible {
+  @available(SwiftStdlib 5.9, *)
+  public var description: String {
+    let id = _getJobTaskId(self)
+    /// Tasks are always assigned an unique ID, however some jobs may not have it set,
+    /// and it appearing as 0 for _different_ jobs may lead to misunderstanding it as
+    /// being "the same 0 id job", we specifically print 0 (id not set) as nil.
+    if (id > 0) {
+      return "\(Self.self)(id: \(id))"
+    } else {
+      return "\(Self.self)(id: nil)"
+    }
+  }
+}
 
 /// A unit of scheduleable work.
 ///
@@ -75,12 +118,11 @@ public struct Job: Sendable {
   }
 
   public init(_ job: UnownedJob) {
-    self.context = job.context
+    self.context = job._context
   }
 
   public var priority: JobPriority {
-    // let raw = _swift_concurrency_jobPriority(UnownedJob(context: self.context)) // TODO: do we also surface this or the base priority?
-    let raw = _taskCurrentPriority(context as! Builtin.NativeObject)
+    let raw = _swift_concurrency_jobPriority(UnownedJob(context: self.context))
     return JobPriority(rawValue: raw)
   }
 
@@ -102,24 +144,21 @@ public struct Job: Sendable {
 @available(SwiftStdlib 5.9, *)
 extension Job {
 
-  /// Run the job synchronously.
+  /// Run this job on the passed in executor.
   ///
-  /// This operation consumes the job, preventing it accidental use after it has ben run.
+  /// This operation runs the job on the calling thread and *blocks* until the job completes.
+  /// The intended use of this method is for an executor to determine when and where it
+  /// wants to run the job and then call this method on it.
   ///
-  /// Converting a `Job` to an `UnownedJob` and invoking `runSynchronously` on it multiple times is undefined behavior,
-  /// as a job can only ever be run once, and must not be accessed after it has been run.
-  @_alwaysEmitIntoClient
-  @inlinable
-  __consuming public func runSynchronously(on executor: some SerialExecutor) {
-    _swiftJobRun(UnownedJob(self), UnownedSerialExecutor(ordinary: executor))
-  }
-
-  /// Run the job synchronously.
+  /// The passed in executor reference is used to establish the executor context for the job,
+  /// and should be the same executor as the one semantically calling the `runSynchronously` method.
   ///
   /// This operation consumes the job, preventing it accidental use after it has ben run.
   ///
-  /// Converting a `Job` to an `UnownedJob` and invoking `runSynchronously` on it multiple times is undefined behavior,
+  /// Converting a `Job` to an ``UnownedJob`` and invoking ``UnownedJob/runSynchronously(_:)` on it multiple times is undefined behavior,
   /// as a job can only ever be run once, and must not be accessed after it has been run.
+  ///
+  /// - Parameter executor: the executor this job will be semantically running on.
   @_alwaysEmitIntoClient
   @inlinable
   __consuming public func runSynchronously(on executor: UnownedSerialExecutor) {

test/Concurrency/Runtime/custom_executors_assume_main_asyncmain.swift

@@ -1,4 +1,4 @@
-// RUN: %target-run-simple-swift( -Xfrontend enable-experimental-move-only -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s
+// RUN: %target-run-simple-swift( -Xfrontend -enable-experimental-move-only -Xfrontend -disable-availability-checking %import-libdispatch -parse-as-library) | %FileCheck %s
 
 // REQUIRES: concurrency
 // REQUIRES: executable_test