minor cleanup, add missing public init

WIP on distributed actors and executors

wip-on-assume

cleaned up assumeOnMainActorExecutor

rebase cleanups

Author: ktoso

lib/AST/Decl.cpp

@@ -5220,7 +5220,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/Actor.cpp

@@ -297,10 +297,14 @@ JobPriority swift::swift_task_getCurrentThreadPriority() {
 
 SWIFT_CC(swift)
 static bool swift_task_isCurrentExecutorImpl(ExecutorRef executor) {
+  fprintf(stderr, "[%s:%d](%s)                    check executor:%p isMain:%d\n", __FILE_NAME__, __LINE__, __FUNCTION__, executor, executor.isMainExecutor() ? 1 : 0);
   if (auto currentTracking = ExecutorTrackingInfo::current()) {
+    fprintf(stderr, "[%s:%d](%s) current tracking, active executor:%p\n", __FILE_NAME__, __LINE__, __FUNCTION__, currentTracking->getActiveExecutor());
     return currentTracking->getActiveExecutor() == executor;
   }
 
+  fprintf(stderr, "[%s:%d](%s)    executor.isMainExecutor:%d\n", __FILE_NAME__, __LINE__, __FUNCTION__, executor.isMainExecutor() ? 1 : 0);
+  fprintf(stderr, "[%s:%d](%s) isExecutingOnMainThread():%d\n", __FILE_NAME__, __LINE__, __FUNCTION__, isExecutingOnMainThread() ? 1 : 0);
   return executor.isMainExecutor() && isExecutingOnMainThread();
 }
 

stdlib/public/Concurrency/AssumeActorExecutor.swift

@@ -0,0 +1,82 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the Swift.org open source project
+//
+// Copyright (c) 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
+
+/// A safe way to synchronously assume that the current execution context belongs to the MainActor.
+///
+/// This API should only be used as last resort, when it is not possible to express the current
+/// execution context definitely belongs to the main actor in other ways. E.g. one may need to use
+/// this in a delegate style API, where a synchronous method is guaranteed to be called by the
+/// main actor, however it is not possible to annotate this legacy API with `@MainActor`.
+///
+/// If the current executor is *not* the MainActor's serial executor, this function will crash.
+///
+/// Note that this check is performed against the MainActor's serial executor, meaning that
+/// 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.
+///
+/// - Parameters:
+///   - operation:
+///   - file:
+///   - line:
+/// - Returns:
+/// - Throws:
+@available(SwiftStdlib 5.9, *) // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+@_unavailableFromAsync(message: "await the call to the @MainActor closure directly")
+public
+func _assumeOnMainActorExecutor<T>(
+    _ operation: @MainActor () throws -> T,
+    file: StaticString = #fileID, line: UInt = #line
+) rethrows -> T {
+  typealias YesMainActor = @MainActor () throws -> T
+  typealias NoMainActor = () throws -> T
+
+  /// This is guaranteed to be fatal if the check fails,
+  /// as this is our "safe" version of this API.
+  guard _taskIsCurrentExecutor(Builtin.buildMainActorExecutorRef()) else {
+    fatalError("Incorrect actor executor assumption; Expected 'MainActor' executor.", file: file, line: line)
+  }
+
+  // To do the unsafe cast, we have to pretend it's @escaping.
+  return try withoutActuallyEscaping(operation) {
+    (_ fn: @escaping YesMainActor) throws -> T in
+    let rawFn = unsafeBitCast(fn, to: NoMainActor.self)
+    return try rawFn()
+  }
+}
+
+//@available(SwiftStdlib 5.9, *)
+//@_alwaysEmitIntoClient // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+//func _preconditionExpectedExecutor(
+//    _ _executor: Builtin.Executor,
+//    file: StaticString = #file, line: UInt = #line) {
+//
+//
+//  let message = ""
+//  precondition(false, , file: file, line: line)
+//
+//  file.utf8CString.withUnsafeBufferPointer { (_ bufPtr: UnsafeBufferPointer<CChar>) in
+//    let fileBasePtr: Builtin.RawPointer = bufPtr.baseAddress!._rawValue
+//
+//    // string lengths exclude trailing \0 byte, which should be there!
+//    let fileLength: Builtin.Word = (bufPtr.count - 1)._builtinWordValue
+//
+//    // we're handing it UTF-8
+//    let falseByte: Int8 = 0
+//    let fileIsASCII: Builtin.Int1 = Builtin.trunc_Int8_Int1(falseByte._value)
+//
+//    _reportUnexpectedExecutor(fileBasePtr, fileLength, fileIsASCII,
+//        line._builtinWordValue, _executor)
+//  }
+//}

stdlib/public/Concurrency/CMakeLists.txt

@@ -79,6 +79,7 @@ add_swift_target_library(swift_Concurrency ${SWIFT_STDLIB_LIBRARY_BUILD_TYPES} I
   ../CompatibilityOverride/CompatibilityOverride.cpp
   Actor.cpp
   Actor.swift
+  AssumeActorExecutor.swift
   AsyncLet.cpp
   AsyncLet.swift
   CheckedContinuation.swift
@@ -104,9 +105,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/Executor.swift

@@ -49,7 +49,7 @@ public protocol SerialExecutor: Executor {
 @available(SwiftStdlib 5.9, *)
 extension Executor {
   public func enqueue(_ job: UnownedJob) {
-    fatalError("Please implement \(Self.self).enqueueJob(_:)")
+    self.enqueue(Job(job))
   }
 
   public func enqueue(_ job: __owned Job) {
@@ -100,18 +100,6 @@ public struct UnownedSerialExecutor: Sendable {
   }
 }
 
-/// Checks if the current task is running on the expected executor.
-///
-/// Generally, Swift programs should be constructed such that it is statically
-/// known that a specific executor is used, for example by using global actors or
-/// custom executors. However, in some APIs it may be useful to provide an
-/// additional runtime check for this, especially when moving towards Swift
-/// concurrency from other runtimes which frequently use such assertions.
-/// - Parameter executor: The expected executor.
-@available(SwiftStdlib 5.9, *)
-@_silgen_name("swift_task_isOnExecutor")
-public func _taskIsOnExecutor<Executor: SerialExecutor>(_ executor: Executor) -> Bool
-
 /// Primarily a debug utility.
 ///
 /// If the passed in Job is a Task, returns the complete 64bit TaskId,
@@ -134,22 +122,6 @@ where E: SerialExecutor {
   }
 }
 
-@available(SwiftStdlib 5.1, *)
-@_transparent
-public // COMPILER_INTRINSIC
-func _checkExpectedExecutor(_filenameStart: Builtin.RawPointer,
-                            _filenameLength: Builtin.Word,
-                            _filenameIsASCII: Builtin.Int1,
-                            _line: Builtin.Word,
-                            _executor: Builtin.Executor) {
-  if _taskIsCurrentExecutor(_executor) {
-    return
-  }
-
-  _reportUnexpectedExecutor(
-    _filenameStart, _filenameLength, _filenameIsASCII, _line, _executor)
-}
-
 #if !SWIFT_STDLIB_SINGLE_THREADED_CONCURRENCY && !SWIFT_STDLIB_TASK_TO_THREAD_MODEL_CONCURRENCY
 // This must take a DispatchQueueShim, not something like AnyObject,
 // or else SILGen will emit a retain/release in unoptimized builds,
@@ -178,3 +150,120 @@ internal final class DispatchQueueShim: @unchecked Sendable, SerialExecutor {
   }
 }
 #endif
+
+// ==== -----------------------------------------------------------------------
+// - MARK: Executor assertions
+
+/// Checks if the current task is running on the expected executor.
+///
+/// Do note that if multiple actors share the same serial executor,
+/// this assertion checks for the executor, not specific actor instance.
+///
+/// Generally, Swift programs should be constructed such that it is statically
+/// known that a specific executor is used, for example by using global actors or
+/// custom executors. However, in some APIs it may be useful to provide an
+/// additional runtime check for this, especially when moving towards Swift
+/// concurrency from other runtimes which frequently use such assertions.
+@available(SwiftStdlib 5.9, *)
+public func preconditionOnSerialExecutor(
+    _ executor: some SerialExecutor,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #fileID, line: UInt = #line) {
+  preconditionOnSerialExecutor(executor.asUnownedSerialExecutor(), file: file, line: line)
+}
+
+@available(SwiftStdlib 5.9, *)
+public func preconditionOnSerialExecutor(
+    _ unowned: UnownedSerialExecutor,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #fileID, line: UInt = #line) {
+  if _taskIsCurrentExecutor(unowned.executor) {
+    return
+  }
+
+  // TODO: log on what executor it was instead of the expected one
+  let message = "Expected executor \(unowned); \(message())"
+  preconditionFailure(
+      message,
+      file: file, line: line)
+}
+
+/// Same as ``preconditionOnSerialExecutor(_:_:file:line)`` however only in DEBUG mode.
+@available(SwiftStdlib 5.9, *)
+public func assertOnSerialExecutor(
+    _ executor: some SerialExecutor,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #fileID, line: UInt = #line) {
+  assertOnSerialExecutor(executor.asUnownedSerialExecutor(), file: file, line: line)
+}
+
+@available(SwiftStdlib 5.9, *)
+public func assertOnSerialExecutor(
+    _ unowned: UnownedSerialExecutor,
+    _ message: @autoclosure () -> String = "",
+    file: StaticString = #fileID, line: UInt = #line) {
+  if _isDebugAssertConfiguration() {
+    if _taskIsCurrentExecutor(unowned.executor) {
+      return
+    }
+
+    // TODO: log on what executor it was instead of the expected one
+    // TODO: fixme use assertion here?
+    fatalError("Expected executor \(unowned); \(message())", file: file, line: line)
+  }
+}
+
+/// Checks if the current task is running on the expected executor.
+///
+/// Generally, Swift programs should be constructed such that it is statically
+/// known that a specific executor is used, for example by using global actors or
+/// custom executors. However, in some APIs it may be useful to provide an
+/// additional runtime check for this, especially when moving towards Swift
+/// concurrency from other runtimes which frequently use such assertions.
+/// - Parameter executor: The expected executor.
+@available(SwiftStdlib 5.9, *)
+@_silgen_name("swift_task_isOnExecutor")
+func _taskIsOnExecutor(_ executor: some SerialExecutor) -> Bool
+
+@available(SwiftStdlib 5.1, *)
+@_transparent
+public // COMPILER_INTRINSIC
+func _checkExpectedExecutor(_filenameStart: Builtin.RawPointer,
+                            _filenameLength: Builtin.Word,
+                            _filenameIsASCII: Builtin.Int1,
+                            _line: Builtin.Word,
+                            _executor: Builtin.Executor) {
+  if _taskIsCurrentExecutor(_executor) {
+    return
+  }
+
+  _reportUnexpectedExecutor(
+    _filenameStart, _filenameLength, _filenameIsASCII, _line, _executor)
+}
+
+@available(SwiftStdlib 5.9, *)
+@_alwaysEmitIntoClient // FIXME: use @backDeploy(before: SwiftStdlib 5.9)
+func _checkExpectedExecutor(
+    _ _executor: Builtin.Executor,
+    file: String,
+    line: Int) {
+  if _taskIsCurrentExecutor(_executor) {
+    return
+  }
+
+  file.utf8CString.withUnsafeBufferPointer { (_ bufPtr: UnsafeBufferPointer<CChar>) in
+    let fileBasePtr: Builtin.RawPointer = bufPtr.baseAddress!._rawValue
+
+    // string lengths exclude trailing \0 byte, which should be there!
+    let fileLength: Builtin.Word = (bufPtr.count - 1)._builtinWordValue
+
+    // we're handing it UTF-8
+    let falseByte: Int8 = 0
+    let fileIsASCII: Builtin.Int1 = Builtin.trunc_Int8_Int1(falseByte._value)
+
+    _reportUnexpectedExecutor(
+        fileBasePtr, fileLength, fileIsASCII,
+        line._builtinWordValue,
+        _executor)
+  }
+}