rebase cleanups

Author: ktoso

lib/AST/Decl.cpp

@@ -5216,7 +5216,7 @@ NominalTypeDecl::getExecutorOwnedEnqueueFunction() const {
         continue;
 
       auto params = funcDecl->getParameters();
-      if (params->get(0)->getSpecifier() == ParamSpecifier::Owned) {
+      if (params->get(0)->getSpecifier() == ParamSpecifier::LegacyOwned) { // TODO: make this Consuming
         return funcDecl;
       }
     }

stdlib/public/Concurrency/CMakeLists.txt

@@ -104,9 +104,10 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   AsyncThrowingFlatMapSequence.swift
   AsyncThrowingMapSequence.swift
   AsyncThrowingPrefixWhileSequence.swift
+  UncheckedContinuation.swift
   GlobalActor.swift
   MainActor.swift
-  PartialAsyncTask.swift
+  Job.swift
   SourceCompatibilityShims.swift
   Task.cpp
   Task.swift

stdlib/public/Concurrency/Job.swift

@@ -0,0 +1,202 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 2020 - 2021 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
+// See https://swift.org/CONTRIBUTORS.txt for the list of Swift project authors
+//
+//===----------------------------------------------------------------------===//
+
+import Swift
+@_implementationOnly import _SwiftConcurrencyShims
+
+@available(SwiftStdlib 5.1, *)
+@_silgen_name("swift_job_run")
+@usableFromInline
+internal func _swiftJobRun(_ job: UnownedJob,
+                           _ executor: UnownedSerialExecutor) -> ()
+
+// ==== -----------------------------------------------------------------------
+// MARK: UnownedJob
+
+/// A unit of scheduleable work.
+///
+/// Unless you're implementing a scheduler,
+/// you don't generally interact with jobs directly.
+@available(SwiftStdlib 5.1, *)
+@frozen
+public struct UnownedJob: Sendable {
+  internal var context: Builtin.Job
+
+  @usableFromInline
+  internal init(context: Builtin.Job) {
+    self.context = context
+  }
+
+  @available(SwiftStdlib 5.9, *)
+  public init(_ job: __owned Job) {
+    self.context = job.context
+  }
+
+  /// The priority of this job.
+  @available(SwiftStdlib 5.9, *)
+  public var priority: JobPriority {
+    let raw = _swift_concurrency_jobPriority(self)
+    return JobPriority(rawValue: raw)
+  }
+
+  @_alwaysEmitIntoClient
+  @inlinable
+  @available(*, deprecated, renamed: "Job.runSynchronously(on:)")
+  public func _runSynchronously(on executor: UnownedSerialExecutor) {
+      _swiftJobRun(self, executor)
+  }
+}
+
+
+/// A unit of scheduleable work.
+///
+/// Unless you're implementing a scheduler,
+/// you don't generally interact with jobs directly.
+@available(SwiftStdlib 5.9, *)
+@frozen
+@_moveOnly
+public struct Job: Sendable {
+  internal var context: Builtin.Job
+
+  @usableFromInline
+  internal init(context: __owned Builtin.Job) {
+    self.context = context
+  }
+
+  public init(_ job: UnownedJob) {
+    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)
+    return JobPriority(rawValue: raw)
+  }
+
+  // TODO: move only types cannot conform to protocols, so we can't conform to CustomStringConvertible;
+  //       we can still offer a description to be called explicitly though.
+  public var description: String {
+    let id = _getJobTaskId(UnownedJob(context: self.context))
+    /// 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)"
+    }
+  }
+}
+
+@available(SwiftStdlib 5.9, *)
+extension Job {
+
+  /// Run the job synchronously.
+  ///
+  /// 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,
+  /// 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.
+  ///
+  /// 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,
+  /// 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: UnownedSerialExecutor) {
+    _swiftJobRun(UnownedJob(self), executor)
+  }
+}
+
+// ==== -----------------------------------------------------------------------
+// MARK: JobPriority
+
+/// The priority of this job.
+///
+/// The executor determines how priority information affects the way tasks are scheduled.
+/// The behavior varies depending on the executor currently being used.
+/// Typically, executors attempt to run tasks with a higher priority
+/// before tasks with a lower priority.
+/// However, the semantics of how priority is treated are left up to each
+/// platform and `Executor` implementation.
+///
+/// A Job's priority is roughly equivalent to a `TaskPriority`,
+/// however, since not all jobs are tasks, represented as separate type.
+///
+/// Conversions between the two priorities are available as initializers on the respective types.
+@available(SwiftStdlib 5.9, *)
+public struct JobPriority: Sendable {
+  public typealias RawValue = UInt8
+
+  /// The raw priority value.
+  public var rawValue: RawValue
+}
+
+@available(SwiftStdlib 5.9, *)
+extension TaskPriority {
+  /// Convert this ``UnownedJob/Priority`` to a ``TaskPriority``.
+  ///
+  /// Most values are directly interchangeable, but this initializer reserves the right to fail for certain values.
+  @available(SwiftStdlib 5.9, *)
+  public init?(_ p: JobPriority) {
+    guard p.rawValue != 0 else {
+      /// 0 is "undefined"
+      return nil
+    }
+    self = TaskPriority(rawValue: p.rawValue)
+  }
+}
+
+@available(SwiftStdlib 5.9, *)
+extension JobPriority: Equatable {
+  public static func == (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue == rhs.rawValue
+  }
+
+  public static func != (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue != rhs.rawValue
+  }
+}
+
+@available(SwiftStdlib 5.9, *)
+extension JobPriority: Comparable {
+  public static func < (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue < rhs.rawValue
+  }
+
+  public static func <= (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue <= rhs.rawValue
+  }
+
+  public static func > (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue > rhs.rawValue
+  }
+
+  public static func >= (lhs: JobPriority, rhs: JobPriority) -> Bool {
+    lhs.rawValue >= rhs.rawValue
+  }
+}
+
+// ==== -----------------------------------------------------------------------
+// MARK: Runtime functions
+
+@available(SwiftStdlib 5.9, *)
+@_silgen_name("swift_concurrency_jobPriority")
+internal func _swift_concurrency_jobPriority(_ job: UnownedJob) -> UInt8