// swift-interface-format-version: 1.0 // swift-compiler-version: Apple Swift version 6.3 effective-5.10 (swiftlang-6.3.0.123.4 clang-2100.0.123.2) // swift-module-flags: -target arm64e-apple-ios26.4-macabi -enable-objc-interop -enable-library-evolution -module-link-name swift_Concurrency -parse-stdlib -swift-version 5 -O -library-level api -enforce-exclusivity=unchecked -target-min-inlining-version min -enable-experimental-feature NoncopyableGenerics2 -enable-experimental-feature SuppressedAssociatedTypes -enable-experimental-feature SE427NoInferenceOnExtension -enable-experimental-feature NonescapableTypes -enable-experimental-feature LifetimeDependence -enable-experimental-feature InoutLifetimeDependence -enable-experimental-feature LifetimeDependenceMutableAccessors -enable-experimental-feature MemberImportVisibility -enable-experimental-feature TypedThrows -enable-experimental-feature Macros -enable-experimental-feature FreestandingMacros -enable-experimental-feature BitwiseCopyable -enable-experimental-feature Extern -enable-experimental-feature AllowUnsafeAttribute -enable-experimental-feature ValueGenerics -enable-experimental-feature IsolatedAny -user-module-version 6.3.0.123.11 -module-name _Concurrency // swift-module-flags-ignorable: -enable-lexical-lifetimes=false -strict-memory-safety -formal-cxx-interoperability-mode=off -interface-compiler-version 6.3 import Swift import SwiftShims @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "Use 'any Actor' with 'DistributedActor.asLocalActor' instead") @available(swift, obsoleted: 6.0, message: "Use 'any Actor' with 'DistributedActor.asLocalActor' instead") public typealias AnyActor = Swift.AnyObject & Swift.Sendable @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol Actor : AnyObject, Swift.Sendable { nonisolated var unownedExecutor: _Concurrency.UnownedSerialExecutor { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_defaultActor_initialize") public func _defaultActorInitialize(_ actor: Swift.AnyObject) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_silgen_name("swift_nonDefaultDistributedActor_initialize") public func _nonDefaultDistributedActorInitialize(_ actor: Swift.AnyObject) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_defaultActor_destroy") public func _defaultActorDestroy(_ actor: Swift.AnyObject) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_enqueueMainExecutor") @usableFromInline internal func _enqueueOnMain(_ job: _Concurrency.UnownedJob) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @freestanding(expression) public macro isolation() -> T = Builtin.IsolationMacro @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "Use `.isolation` on @isolated(any) closure values instead.") @_alwaysEmitIntoClient public func extractIsolation(_ fn: @escaping @isolated(any) (repeat each Arg) async throws -> Result) -> (any _Concurrency.Actor)? { return Builtin.extractFunctionIsolation(fn) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func compactMap(_ transform: @escaping @Sendable (Self.Element) async -> ElementOfResult?) -> _Concurrency.AsyncCompactMapSequence { return AsyncCompactMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncCompactMapSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async -> ElementOfResult? @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async -> ElementOfResult?) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncCompactMapSequence : _Concurrency.AsyncSequence { public typealias Element = ElementOfResult @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncCompactMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { public typealias Element = ElementOfResult @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async -> ElementOfResult? @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async -> ElementOfResult?) @inlinable public mutating func next() async rethrows -> ElementOfResult? { while true { guard let element = try await baseIterator.next() else { return nil } if let transformed = await transform(element) { return transformed } } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncCompactMapSequence.Failure) -> ElementOfResult? { while true { guard let element = try await baseIterator.next(isolation: actor) else { return nil } if let transformed = await transform(element) { return transformed } } } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncCompactMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncCompactMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncCompactMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncCompactMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, ElementOfResult : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncCompactMapSequence.Iterator : @unchecked Swift.Sendable where ElementOfResult : Swift.Sendable, Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @inlinable public __consuming func dropFirst(_ count: Swift.Int = 1) -> _Concurrency.AsyncDropFirstSequence { precondition(count >= 0, "Can't drop a negative number of elements from an async sequence") return AsyncDropFirstSequence(self, dropping: count) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncDropFirstSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let count: Swift.Int @usableFromInline internal init(_ base: Base, dropping count: Swift.Int) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropFirstSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncDropFirstSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal var count: Swift.Int @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, count: Swift.Int) @inlinable public mutating func next() async rethrows -> Base.Element? { var remainingToDrop = count while remainingToDrop > 0 { guard try await baseIterator.next() != nil else { count = 0 return nil } remainingToDrop -= 1 } count = 0 return try await baseIterator.next() } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncDropFirstSequence.Failure) -> Base.Element? { var remainingToDrop = count while remainingToDrop > 0 { guard try await baseIterator.next(isolation: actor) != nil else { count = 0 return nil } remainingToDrop -= 1 } count = 0 return try await baseIterator.next(isolation: actor) } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncDropFirstSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncDropFirstSequence.Iterator { return Iterator(base.makeAsyncIterator(), count: count) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncDropFirstSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropFirstSequence { @inlinable public __consuming func dropFirst(_ count: Swift.Int = 1) -> _Concurrency.AsyncDropFirstSequence { precondition(count >= 0, "Can't drop a negative number of elements from an async sequence") return AsyncDropFirstSequence(base, dropping: self.count + count) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropFirstSequence : Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropFirstSequence.Iterator : Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func drop(while predicate: @escaping @Sendable (Self.Element) async -> Swift.Bool) -> _Concurrency.AsyncDropWhileSequence { AsyncDropWhileSequence(self, predicate: predicate) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncDropWhileSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let predicate: (Base.Element) async -> Swift.Bool @usableFromInline internal init(_ base: Base, predicate: @escaping (Base.Element) async -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropWhileSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncDropWhileSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal var predicate: ((Base.Element) async -> Swift.Bool)? @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, predicate: @escaping (Base.Element) async -> Swift.Bool) @inlinable public mutating func next() async rethrows -> Base.Element? { while let predicate = self.predicate { guard let element = try await baseIterator.next() else { return nil } if await predicate(element) == false { self.predicate = nil return element } } return try await baseIterator.next() } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncDropWhileSequence.Failure) -> Base.Element? { while let predicate = self.predicate { guard let element = try await baseIterator.next(isolation: actor) else { return nil } if await predicate(element) == false { self.predicate = nil return element } } return try await baseIterator.next(isolation: actor) } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncDropWhileSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncDropWhileSequence.Iterator { return Iterator(base.makeAsyncIterator(), predicate: predicate) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncDropWhileSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropWhileSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncDropWhileSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func filter(_ isIncluded: @escaping @Sendable (Self.Element) async -> Swift.Bool) -> _Concurrency.AsyncFilterSequence { return AsyncFilterSequence(self, isIncluded: isIncluded) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncFilterSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let isIncluded: (_Concurrency.AsyncFilterSequence.Element) async -> Swift.Bool @usableFromInline internal init(_ base: Base, isIncluded: @escaping (Base.Element) async -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFilterSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncFilterSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let isIncluded: (Base.Element) async -> Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, isIncluded: @escaping (Base.Element) async -> Swift.Bool) @inlinable public mutating func next() async rethrows -> Base.Element? { while true { guard let element = try await baseIterator.next() else { return nil } if await isIncluded(element) { return element } } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncFilterSequence.Failure) -> Base.Element? { while true { guard let element = try await baseIterator.next(isolation: actor) else { return nil } if await isIncluded(element) { return element } } } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncFilterSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncFilterSequence.Iterator { return Iterator(base.makeAsyncIterator(), isIncluded: isIncluded) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncFilterSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFilterSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFilterSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @usableFromInline @preconcurrency internal __consuming func flatMap(_ transform: @escaping @Sendable (Self.Element) async -> SegmentOfResult) -> _Concurrency.AsyncFlatMapSequence where SegmentOfResult : _Concurrency.AsyncSequence @preconcurrency @_alwaysEmitIntoClient @inlinable public __consuming func flatMap(_ transform: @escaping @Sendable (Self.Element) async -> SegmentOfResult) -> _Concurrency.AsyncFlatMapSequence where SegmentOfResult : _Concurrency.AsyncSequence, Self.Failure == SegmentOfResult.Failure { return AsyncFlatMapSequence(self, transform: transform) } @preconcurrency @_alwaysEmitIntoClient @inlinable public __consuming func flatMap(_ transform: @escaping @Sendable (Self.Element) async -> SegmentOfResult) -> _Concurrency.AsyncFlatMapSequence where SegmentOfResult : _Concurrency.AsyncSequence, SegmentOfResult.Failure == Swift.Never { return AsyncFlatMapSequence(self, transform: transform) } @preconcurrency @_alwaysEmitIntoClient @inlinable public __consuming func flatMap(_ transform: @escaping @Sendable (Self.Element) async -> SegmentOfResult) -> _Concurrency.AsyncFlatMapSequence where SegmentOfResult : _Concurrency.AsyncSequence, Self.Failure == Swift.Never, SegmentOfResult.Failure == Swift.Never { return AsyncFlatMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncFlatMapSequence where Base : _Concurrency.AsyncSequence, SegmentOfResult : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async -> SegmentOfResult @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async -> SegmentOfResult) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFlatMapSequence : _Concurrency.AsyncSequence { public typealias Element = SegmentOfResult.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncFlatMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async -> SegmentOfResult @usableFromInline internal var currentIterator: SegmentOfResult.AsyncIterator? @usableFromInline internal var finished: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async -> SegmentOfResult) @inlinable public mutating func next() async rethrows -> SegmentOfResult.Element? { while !finished { if var iterator = currentIterator { do { guard let element = try await iterator.next() else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error } } else { guard let item = try await baseIterator.next() else { finished = true return nil } do { let segment = await transform(item) var iterator = segment.makeAsyncIterator() guard let element = try await iterator.next() else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error } } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncFlatMapSequence.Failure) -> SegmentOfResult.Element? { while !finished { if var iterator = currentIterator { do { let optElement = try await iterator.next(isolation: actor) guard let element = optElement else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error as! Failure } } else { let optItem = try await baseIterator.next(isolation: actor) guard let item = optItem else { finished = true return nil } do { let segment = await transform(item) var iterator = segment.makeAsyncIterator() let optElement = try await iterator.next(isolation: actor) guard let element = optElement else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error as! Failure } } } return nil } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = SegmentOfResult.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncFlatMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncFlatMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncFlatMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFlatMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, SegmentOfResult : Swift.Sendable, Base.Element : Swift.Sendable, SegmentOfResult.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncFlatMapSequence.Iterator : @unchecked Swift.Sendable where SegmentOfResult : Swift.Sendable, Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable, SegmentOfResult.AsyncIterator : Swift.Sendable, SegmentOfResult.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol AsyncIteratorProtocol { associatedtype Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) associatedtype Failure : Swift.Error = any Swift.Error mutating func next() async throws -> Self.Element? @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(Self.Failure) -> Self.Element? } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncIteratorProtocol { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(Self.Failure) -> Self.Element? { do { return try await next() } catch { throw error as! Failure } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncIteratorProtocol { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next() async throws(Self.Failure) -> Self.Element? { return try await next(isolation: nil) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_asyncLet_start") public func _asyncLetStart(asyncLet: Builtin.RawPointer, options: Builtin.RawPointer?, operation: @Sendable () async throws -> T) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_asyncLet_get") public func _asyncLet_get(_ asyncLet: Builtin.RawPointer, _ resultBuffer: Builtin.RawPointer) async @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_asyncLet_get_throwing") public func _asyncLet_get_throwing(_ asyncLet: Builtin.RawPointer, _ resultBuffer: Builtin.RawPointer) async throws @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_asyncLet_finish") public func _asyncLet_finish(_ asyncLet: Builtin.RawPointer, _ resultBuffer: Builtin.RawPointer) async @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func map(_ transform: @escaping @Sendable (Self.Element) async -> Transformed) -> _Concurrency.AsyncMapSequence { return AsyncMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncMapSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async -> Transformed @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async -> Transformed) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncMapSequence : _Concurrency.AsyncSequence { public typealias Element = Transformed @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async -> Transformed @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async -> Transformed) @inlinable public mutating func next() async rethrows -> Transformed? { guard let element = try await baseIterator.next() else { return nil } return await transform(element) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncMapSequence.Failure) -> Transformed? { guard let element = try await baseIterator.next(isolation: actor) else { return nil } return await transform(element) } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Transformed @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Transformed : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncMapSequence.Iterator : @unchecked Swift.Sendable where Transformed : Swift.Sendable, Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @inlinable public __consuming func prefix(_ count: Swift.Int) -> _Concurrency.AsyncPrefixSequence { precondition(count >= 0, "Can't prefix a negative number of elements from an async sequence") return AsyncPrefixSequence(self, count: count) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncPrefixSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let count: Swift.Int @usableFromInline internal init(_ base: Base, count: Swift.Int) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncPrefixSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal var remaining: Swift.Int @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, count: Swift.Int) @inlinable public mutating func next() async rethrows -> Base.Element? { if remaining != 0 { remaining &-= 1 return try await baseIterator.next() } else { return nil } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncPrefixSequence.Failure) -> Base.Element? { if remaining != 0 { remaining &-= 1 return try await baseIterator.next(isolation: actor) } else { return nil } } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncPrefixSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncPrefixSequence.Iterator { return Iterator(base.makeAsyncIterator(), count: count) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncPrefixSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixSequence : Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixSequence.Iterator : Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func prefix(while predicate: @escaping @Sendable (Self.Element) async -> Swift.Bool) rethrows -> _Concurrency.AsyncPrefixWhileSequence { return AsyncPrefixWhileSequence(self, predicate: predicate) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncPrefixWhileSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let predicate: (Base.Element) async -> Swift.Bool @usableFromInline internal init(_ base: Base, predicate: @escaping (Base.Element) async -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixWhileSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public typealias Failure = Base.Failure public typealias AsyncIterator = _Concurrency.AsyncPrefixWhileSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var predicateHasFailed: Swift.Bool @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let predicate: (Base.Element) async -> Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, predicate: @escaping (Base.Element) async -> Swift.Bool) @inlinable public mutating func next() async rethrows -> Base.Element? { if !predicateHasFailed, let nextElement = try await baseIterator.next() { if await predicate(nextElement) { return nextElement } else { predicateHasFailed = true } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(_Concurrency.AsyncPrefixWhileSequence.Failure) -> Base.Element? { if !predicateHasFailed, let nextElement = try await baseIterator.next(isolation: actor) { if await predicate(nextElement) { return nextElement } else { predicateHasFailed = true } } return nil } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncPrefixWhileSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncPrefixWhileSequence.Iterator { return Iterator(base.makeAsyncIterator(), predicate: predicate) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncPrefixWhileSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixWhileSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncPrefixWhileSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol AsyncSequence { associatedtype AsyncIterator : _Concurrency.AsyncIteratorProtocol associatedtype Element where Self.Element == Self.AsyncIterator.Element @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) associatedtype Failure = any Swift.Error where Self.Failure == Self.AsyncIterator.Failure __consuming func makeAsyncIterator() -> Self.AsyncIterator } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @inlinable public func reduce(_ initialResult: Result, _ nextPartialResult: (_ partialResult: Result, Self.Element) async throws -> Result) async rethrows -> Result { var accumulator = initialResult var iterator = makeAsyncIterator() while let element = try await iterator.next() { accumulator = try await nextPartialResult(accumulator, element) } return accumulator } @inlinable public func reduce(into initialResult: __owned Result, _ updateAccumulatingResult: (_ partialResult: inout Result, Self.Element) async throws -> Swift.Void) async rethrows -> Result { var accumulator = initialResult var iterator = makeAsyncIterator() while let element = try await iterator.next() { try await updateAccumulatingResult(&accumulator, element) } return accumulator } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @inlinable @inline(__always) internal func _contains(_ self: Source, where predicate: (Source.Element) async throws -> Swift.Bool) async rethrows -> Swift.Bool where Source : _Concurrency.AsyncSequence { for try await element in self { if try await predicate(element) { return true } } return false } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @inlinable public func contains(where predicate: (Self.Element) async throws -> Swift.Bool) async rethrows -> Swift.Bool { return try await _contains(self, where: predicate) } @inlinable public func allSatisfy(_ predicate: (Self.Element) async throws -> Swift.Bool) async rethrows -> Swift.Bool { return try await !contains { try await !predicate($0) } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence where Self.Element : Swift.Equatable { @inlinable public func contains(_ search: Self.Element) async rethrows -> Swift.Bool { for try await element in self { if element == search { return true } } return false } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @inlinable @inline(__always) internal func _first(_ self: Source, where predicate: (Source.Element) async throws -> Swift.Bool) async rethrows -> Source.Element? where Source : _Concurrency.AsyncSequence { for try await element in self { if try await predicate(element) { return element } } return nil } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @inlinable public func first(where predicate: (Self.Element) async throws -> Swift.Bool) async rethrows -> Self.Element? { return try await _first(self, where: predicate) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @warn_unqualified_access @inlinable public func min(by areInIncreasingOrder: (Self.Element, Self.Element) async throws -> Swift.Bool) async rethrows -> Self.Element? { var it = makeAsyncIterator() guard var result = try await it.next() else { return nil } while let e = try await it.next() { if try await areInIncreasingOrder(e, result) { result = e } } return result } @warn_unqualified_access @inlinable public func max(by areInIncreasingOrder: (Self.Element, Self.Element) async throws -> Swift.Bool) async rethrows -> Self.Element? { var it = makeAsyncIterator() guard var result = try await it.next() else { return nil } while let e = try await it.next() { if try await areInIncreasingOrder(result, e) { result = e } } return result } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence where Self.Element : Swift.Comparable { @warn_unqualified_access @inlinable public func min() async rethrows -> Self.Element? { return try await self.min(by: <) } @warn_unqualified_access @inlinable public func max() async rethrows -> Self.Element? { return try await self.max(by: <) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncStream { public struct Continuation : Swift.Sendable { public enum Termination : Swift.Sendable { case finished case cancelled public static func == (a: _Concurrency.AsyncStream.Continuation.Termination, b: _Concurrency.AsyncStream.Continuation.Termination) -> Swift.Bool public func hash(into hasher: inout Swift.Hasher) public var hashValue: Swift.Int { get } } public enum YieldResult { case enqueued(remaining: Swift.Int) case dropped(Element) case terminated } public enum BufferingPolicy : Swift.Sendable { case unbounded case bufferingOldest(Swift.Int) case bufferingNewest(Swift.Int) } @discardableResult public func yield(_ value: sending Element) -> _Concurrency.AsyncStream.Continuation.YieldResult public func finish() public var onTermination: (@Sendable (_Concurrency.AsyncStream.Continuation.Termination) -> Swift.Void)? { get nonmutating set } } public init(_ elementType: Element.Type = Element.self, bufferingPolicy limit: _Concurrency.AsyncStream.Continuation.BufferingPolicy = .unbounded, _ build: (_Concurrency.AsyncStream.Continuation) -> Swift.Void) @_silgen_name("$sScS9unfolding8onCancelScSyxGxSgyYac_yyYbcSgtcfC") @preconcurrency public init(unfolding produce: @escaping @Sendable () async -> Element?, onCancel: (@Sendable () -> Swift.Void)? = nil) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream : _Concurrency.AsyncSequence { public struct Iterator : _Concurrency.AsyncIteratorProtocol { public mutating func next() async -> Element? @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async -> Element? @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = Swift.Never } public func makeAsyncIterator() -> _Concurrency.AsyncStream.Iterator @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias AsyncIterator = _Concurrency.AsyncStream.Iterator @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = Swift.Never } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream.Continuation { @discardableResult public func yield(with result: __shared sending Swift.Result) -> _Concurrency.AsyncStream.Continuation.YieldResult @discardableResult public func yield() -> _Concurrency.AsyncStream.Continuation.YieldResult where Element == () } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public static func makeStream(of elementType: Element.Type = Element.self, bufferingPolicy limit: _Concurrency.AsyncStream.Continuation.BufferingPolicy = .unbounded) -> (stream: _Concurrency.AsyncStream, continuation: _Concurrency.AsyncStream.Continuation) { var continuation: AsyncStream.Continuation! let stream = AsyncStream(bufferingPolicy: limit) { continuation = $0 } return (stream: stream, continuation: continuation!) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream : @unchecked Swift.Sendable where Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream.Continuation.YieldResult : Swift.Sendable where Element : Swift.Sendable { } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.AsyncStream.Continuation : Swift.Hashable { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func hash(into hasher: inout Swift.Hasher) @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public var hashValue: Swift.Int { get } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public static func == (lhs: _Concurrency.AsyncStream.Continuation, rhs: _Concurrency.AsyncStream.Continuation) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func compactMap(_ transform: @escaping @Sendable (Self.Element) async throws -> ElementOfResult?) -> _Concurrency.AsyncThrowingCompactMapSequence { return AsyncThrowingCompactMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingCompactMapSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async throws -> ElementOfResult? @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async throws -> ElementOfResult?) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingCompactMapSequence : _Concurrency.AsyncSequence { public typealias Element = ElementOfResult public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingCompactMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { public typealias Element = ElementOfResult @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async throws -> ElementOfResult? @usableFromInline internal var finished: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async throws -> ElementOfResult?) @inlinable public mutating func next() async throws -> ElementOfResult? { while !finished { guard let element = try await baseIterator.next() else { finished = true return nil } do { if let transformed = try await transform(element) { return transformed } } catch { finished = true throw error } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> ElementOfResult? { while !finished { guard let element = try await baseIterator.next(isolation: actor) else { finished = true return nil } do { if let transformed = try await transform(element) { return transformed } } catch { finished = true throw error } } return nil } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingCompactMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingCompactMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingCompactMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingCompactMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingCompactMapSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func drop(while predicate: @escaping @Sendable (Self.Element) async throws -> Swift.Bool) -> _Concurrency.AsyncThrowingDropWhileSequence { AsyncThrowingDropWhileSequence(self, predicate: predicate) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingDropWhileSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let predicate: (Base.Element) async throws -> Swift.Bool @usableFromInline internal init(_ base: Base, predicate: @escaping (Base.Element) async throws -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingDropWhileSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingDropWhileSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let predicate: (Base.Element) async throws -> Swift.Bool @usableFromInline internal var finished: Swift.Bool @usableFromInline internal var doneDropping: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, predicate: @escaping (Base.Element) async throws -> Swift.Bool) @inlinable public mutating func next() async throws -> Base.Element? { while !finished && !doneDropping { guard let element = try await baseIterator.next() else { return nil } do { if try await predicate(element) == false { doneDropping = true return element } } catch { finished = true throw error } } guard !finished else { return nil } return try await baseIterator.next() } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> Base.Element? { while !finished && !doneDropping { guard let element = try await baseIterator.next(isolation: actor) else { return nil } do { if try await predicate(element) == false { doneDropping = true return element } } catch { finished = true throw error } } guard !finished else { return nil } return try await baseIterator.next(isolation: actor) } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingDropWhileSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingDropWhileSequence.Iterator { return Iterator(base.makeAsyncIterator(), predicate: predicate) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingDropWhileSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingDropWhileSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingDropWhileSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func filter(_ isIncluded: @escaping @Sendable (Self.Element) async throws -> Swift.Bool) -> _Concurrency.AsyncThrowingFilterSequence { return AsyncThrowingFilterSequence(self, isIncluded: isIncluded) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingFilterSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let isIncluded: (_Concurrency.AsyncThrowingFilterSequence.Element) async throws -> Swift.Bool @usableFromInline internal init(_ base: Base, isIncluded: @escaping (Base.Element) async throws -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFilterSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingFilterSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let isIncluded: (Base.Element) async throws -> Swift.Bool @usableFromInline internal var finished: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, isIncluded: @escaping (Base.Element) async throws -> Swift.Bool) @inlinable public mutating func next() async throws -> Base.Element? { while !finished { guard let element = try await baseIterator.next() else { return nil } do { if try await isIncluded(element) { return element } } catch { finished = true throw error } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> Base.Element? { while !finished { guard let element = try await baseIterator.next(isolation: actor) else { return nil } do { if try await isIncluded(element) { return element } } catch { finished = true throw error } } return nil } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingFilterSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingFilterSequence.Iterator { return Iterator(base.makeAsyncIterator(), isIncluded: isIncluded) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingFilterSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFilterSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFilterSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func flatMap(_ transform: @escaping @Sendable (Self.Element) async throws -> SegmentOfResult) -> _Concurrency.AsyncThrowingFlatMapSequence where SegmentOfResult : _Concurrency.AsyncSequence { return AsyncThrowingFlatMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingFlatMapSequence where Base : _Concurrency.AsyncSequence, SegmentOfResult : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async throws -> SegmentOfResult @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async throws -> SegmentOfResult) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFlatMapSequence : _Concurrency.AsyncSequence { public typealias Element = SegmentOfResult.Element public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingFlatMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async throws -> SegmentOfResult @usableFromInline internal var currentIterator: SegmentOfResult.AsyncIterator? @usableFromInline internal var finished: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async throws -> SegmentOfResult) @inlinable public mutating func next() async throws -> SegmentOfResult.Element? { while !finished { if var iterator = currentIterator { do { guard let element = try await iterator.next() else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error } } else { guard let item = try await baseIterator.next() else { return nil } let segment: SegmentOfResult do { segment = try await transform(item) var iterator = segment.makeAsyncIterator() guard let element = try await iterator.next() else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true currentIterator = nil throw error } } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> SegmentOfResult.Element? { while !finished { if var iterator = currentIterator { do { guard let element = try await iterator.next(isolation: actor) else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true throw error } } else { guard let item = try await baseIterator.next(isolation: actor) else { return nil } let segment: SegmentOfResult do { segment = try await transform(item) var iterator = segment.makeAsyncIterator() guard let element = try await iterator.next(isolation: actor) else { currentIterator = nil continue } currentIterator = iterator return element } catch { finished = true currentIterator = nil throw error } } } return nil } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = SegmentOfResult.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingFlatMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingFlatMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingFlatMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFlatMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, SegmentOfResult : Swift.Sendable, Base.Element : Swift.Sendable, SegmentOfResult.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingFlatMapSequence.Iterator : @unchecked Swift.Sendable where SegmentOfResult : Swift.Sendable, Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable, SegmentOfResult.AsyncIterator : Swift.Sendable, SegmentOfResult.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func map(_ transform: @escaping @Sendable (Self.Element) async throws -> Transformed) -> _Concurrency.AsyncThrowingMapSequence { return AsyncThrowingMapSequence(self, transform: transform) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingMapSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let transform: (Base.Element) async throws -> Transformed @usableFromInline internal init(_ base: Base, transform: @escaping (Base.Element) async throws -> Transformed) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingMapSequence : _Concurrency.AsyncSequence { public typealias Element = Transformed public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingMapSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let transform: (Base.Element) async throws -> Transformed @usableFromInline internal var finished: Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, transform: @escaping (Base.Element) async throws -> Transformed) @inlinable public mutating func next() async throws -> Transformed? { guard !finished, let element = try await baseIterator.next() else { return nil } do { return try await transform(element) } catch { finished = true throw error } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> Transformed? { guard !finished, let element = try await baseIterator.next(isolation: actor) else { return nil } do { return try await transform(element) } catch { finished = true throw error } } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Transformed @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingMapSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingMapSequence.Iterator { return Iterator(base.makeAsyncIterator(), transform: transform) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingMapSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingMapSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Transformed : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingMapSequence.Iterator : @unchecked Swift.Sendable where Transformed : Swift.Sendable, Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncSequence { @preconcurrency @inlinable public __consuming func prefix(while predicate: @escaping @Sendable (Self.Element) async throws -> Swift.Bool) rethrows -> _Concurrency.AsyncThrowingPrefixWhileSequence { return AsyncThrowingPrefixWhileSequence(self, predicate: predicate) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingPrefixWhileSequence where Base : _Concurrency.AsyncSequence { @usableFromInline internal let base: Base @usableFromInline internal let predicate: (Base.Element) async throws -> Swift.Bool @usableFromInline internal init(_ base: Base, predicate: @escaping (Base.Element) async throws -> Swift.Bool) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingPrefixWhileSequence : _Concurrency.AsyncSequence { public typealias Element = Base.Element public typealias Failure = any Swift.Error public typealias AsyncIterator = _Concurrency.AsyncThrowingPrefixWhileSequence.Iterator public struct Iterator : _Concurrency.AsyncIteratorProtocol { @usableFromInline internal var predicateHasFailed: Swift.Bool @usableFromInline internal var baseIterator: Base.AsyncIterator @usableFromInline internal let predicate: (Base.Element) async throws -> Swift.Bool @usableFromInline internal init(_ baseIterator: Base.AsyncIterator, predicate: @escaping (Base.Element) async throws -> Swift.Bool) @inlinable public mutating func next() async throws -> Base.Element? { if !predicateHasFailed, let nextElement = try await baseIterator.next() { do { if try await predicate(nextElement) { return nextElement } else { predicateHasFailed = true } } catch { predicateHasFailed = true throw error } } return nil } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @inlinable public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws -> Base.Element? { if !predicateHasFailed, let nextElement = try await baseIterator.next(isolation: actor) { do { if try await predicate(nextElement) { return nextElement } else { predicateHasFailed = true } } catch { predicateHasFailed = true throw error } } return nil } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias Element = Base.Element @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = _Concurrency.AsyncThrowingPrefixWhileSequence.Failure } @inlinable public __consuming func makeAsyncIterator() -> _Concurrency.AsyncThrowingPrefixWhileSequence.Iterator { return Iterator(base.makeAsyncIterator(), predicate: predicate) } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = _Concurrency.AsyncThrowingPrefixWhileSequence.Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingPrefixWhileSequence : @unchecked Swift.Sendable where Base : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingPrefixWhileSequence.Iterator : @unchecked Swift.Sendable where Base.AsyncIterator : Swift.Sendable, Base.Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct AsyncThrowingStream where Failure : Swift.Error { public struct Continuation : Swift.Sendable { public enum Termination : Swift.Sendable { case finished(Failure?) case cancelled } public enum YieldResult { case enqueued(remaining: Swift.Int) case dropped(Element) case terminated } public enum BufferingPolicy : Swift.Sendable { case unbounded case bufferingOldest(Swift.Int) case bufferingNewest(Swift.Int) } @discardableResult public func yield(_ value: sending Element) -> _Concurrency.AsyncThrowingStream.Continuation.YieldResult public func finish(throwing error: __owned Failure? = nil) public var onTermination: (@Sendable (_Concurrency.AsyncThrowingStream.Continuation.Termination) -> Swift.Void)? { get nonmutating set } } public init(_ elementType: Element.Type = Element.self, bufferingPolicy limit: _Concurrency.AsyncThrowingStream.Continuation.BufferingPolicy = .unbounded, _ build: (_Concurrency.AsyncThrowingStream.Continuation) -> Swift.Void) where Failure == any Swift.Error @preconcurrency public init(unfolding produce: @escaping @Sendable () async throws -> Element?) where Failure == any Swift.Error } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingStream : _Concurrency.AsyncSequence { public struct Iterator : _Concurrency.AsyncIteratorProtocol { public mutating func next() async throws -> Element? @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(Failure) -> Element? @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = Failure } public func makeAsyncIterator() -> _Concurrency.AsyncThrowingStream.Iterator @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias AsyncIterator = _Concurrency.AsyncThrowingStream.Iterator @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingStream.Continuation { @discardableResult public func yield(with result: __shared sending Swift.Result) -> _Concurrency.AsyncThrowingStream.Continuation.YieldResult where Failure == any Swift.Error @discardableResult public func yield() -> _Concurrency.AsyncThrowingStream.Continuation.YieldResult where Element == () } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingStream { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public static func makeStream(of elementType: Element.Type = Element.self, throwing failureType: Failure.Type = Failure.self, bufferingPolicy limit: _Concurrency.AsyncThrowingStream.Continuation.BufferingPolicy = .unbounded) -> (stream: _Concurrency.AsyncThrowingStream, continuation: _Concurrency.AsyncThrowingStream.Continuation) where Failure == any Swift.Error { var continuation: AsyncThrowingStream.Continuation! let stream = AsyncThrowingStream(bufferingPolicy: limit) { continuation = $0 } return (stream: stream, continuation: continuation!) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingStream : @unchecked Swift.Sendable where Element : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncThrowingStream.Continuation.YieldResult : Swift.Sendable where Element : Swift.Sendable { } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.AsyncThrowingStream.Continuation : Swift.Hashable { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func hash(into hasher: inout Swift.Hasher) @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public var hashValue: Swift.Int { get } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public static func == (lhs: _Concurrency.AsyncThrowingStream.Continuation, rhs: _Concurrency.AsyncThrowingStream.Continuation) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct CheckedContinuation : Swift.Sendable where E : Swift.Error { public init(continuation: _Concurrency.UnsafeContinuation, function: Swift.String = #function) public func resume(returning value: sending T) public func resume(throwing error: __owned E) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.CheckedContinuation { @_alwaysEmitIntoClient public func resume(with result: __shared sending Swift.Result) where E == any Swift.Error, Er : Swift.Error { switch result { case .success(let val): self.resume(returning: val) case .failure(let err): self.resume(throwing: err) } } @_alwaysEmitIntoClient public func resume(with result: __shared sending Swift.Result) { switch result { case .success(let val): self.resume(returning: val) case .failure(let err): self.resume(throwing: err) } } @_alwaysEmitIntoClient public func resume() where T == () { self.resume(returning: ()) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withCheckedContinuation(isolation: isolated (any _Concurrency.Actor)? = #isolation, function: Swift.String = #function, _ body: (_Concurrency.CheckedContinuation) -> Swift.Void) async -> sending T { return await Builtin.withUnsafeContinuation { let unsafeContinuation = UnsafeContinuation($0) return body(CheckedContinuation(continuation: unsafeContinuation, function: function)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss23withCheckedContinuation8function_xSS_yScCyxs5NeverOGXEtYalF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withCheckedContinuation(function: Swift.String = #function, _ body: (_Concurrency.CheckedContinuation) -> Swift.Void) async -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withCheckedThrowingContinuation(isolation: isolated (any _Concurrency.Actor)? = #isolation, function: Swift.String = #function, _ body: (_Concurrency.CheckedContinuation) -> Swift.Void) async throws -> sending T { return try await Builtin.withUnsafeThrowingContinuation { let unsafeContinuation = UnsafeContinuation($0) return body(CheckedContinuation(continuation: unsafeContinuation, function: function)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss31withCheckedThrowingContinuation8function_xSS_yScCyxs5Error_pGXEtYaKlF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withCheckedThrowingContinuation(function: Swift.String = #function, _ body: (_Concurrency.CheckedContinuation) -> Swift.Void) async throws -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _createCheckedContinuation(_ continuation: __owned _Concurrency.UnsafeContinuation) -> _Concurrency.CheckedContinuation { return CheckedContinuation(continuation: continuation) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _createCheckedThrowingContinuation(_ continuation: __owned _Concurrency.UnsafeContinuation) -> _Concurrency.CheckedContinuation { return CheckedContinuation(continuation: continuation) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeCheckedContinuation(_ continuation: _Concurrency.CheckedContinuation, _ value: sending T) { continuation.resume(returning: value) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeCheckedThrowingContinuation(_ continuation: _Concurrency.CheckedContinuation, _ value: sending T) { continuation.resume(returning: value) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeCheckedThrowingContinuationWithError(_ continuation: _Concurrency.CheckedContinuation, _ error: consuming any Swift.Error) { continuation.resume(throwing: error) } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public protocol Clock : Swift.Sendable { associatedtype Duration where Self.Duration == Self.Instant.Duration associatedtype Instant : Swift.InstantProtocol var now: Self.Instant { get } var minimumResolution: Self.Duration { get } func sleep(until deadline: Self.Instant, tolerance: Self.Instant.Duration?) async throws } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.Clock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public func measure(_ work: () throws -> Swift.Void) rethrows -> Self.Instant.Duration @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_alwaysEmitIntoClient public func measure(isolation: isolated (any _Concurrency.Actor)? = #isolation, _ work: () async throws -> Swift.Void) async rethrows -> Self.Instant.Duration { let start = now try await work() let end = now return start.duration(to: end) } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_silgen_name("$ss5ClockPsE7measurey8DurationQzyyYaKXEYaKF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_measure(_ work: () async throws -> Swift.Void) async rethrows -> Self.Instant.Duration } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.Clock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_alwaysEmitIntoClient public func sleep(for duration: Self.Instant.Duration, tolerance: Self.Instant.Duration? = nil) async throws { try await sleep(until: now.advanced(by: duration), tolerance: tolerance) } } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public struct ContinuousClock : Swift.Sendable { public struct Instant : Swift.Sendable { } public init() } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.ContinuousClock.Instant : Swift.Codable { public func encode(to encoder: any Swift.Encoder) throws public init(from decoder: any Swift.Decoder) throws } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.Clock where Self == _Concurrency.ContinuousClock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public static var continuous: _Concurrency.ContinuousClock { get } } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.ContinuousClock : _Concurrency.Clock { public var now: _Concurrency.ContinuousClock.Instant { get } public var minimumResolution: Swift.Duration { get } public static var now: _Concurrency.ContinuousClock.Instant { get } public func sleep(until deadline: _Concurrency.ContinuousClock.Instant, tolerance: Swift.Duration? = nil) async throws @available(iOS 16.0, tvOS 16.0, watchOS 9.0, macOS 13.0, *) public typealias Duration = Swift.Duration } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.ContinuousClock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_alwaysEmitIntoClient public var systemEpoch: _Concurrency.ContinuousClock.Instant { get { unsafeBitCast(Duration.seconds(0), to: Instant.self) } } } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.ContinuousClock.Instant : Swift.InstantProtocol { public static var now: _Concurrency.ContinuousClock.Instant { get } public func advanced(by duration: Swift.Duration) -> _Concurrency.ContinuousClock.Instant public func duration(to other: _Concurrency.ContinuousClock.Instant) -> Swift.Duration public func hash(into hasher: inout Swift.Hasher) public static func == (lhs: _Concurrency.ContinuousClock.Instant, rhs: _Concurrency.ContinuousClock.Instant) -> Swift.Bool public static func < (lhs: _Concurrency.ContinuousClock.Instant, rhs: _Concurrency.ContinuousClock.Instant) -> Swift.Bool @_alwaysEmitIntoClient @inlinable public static func + (lhs: _Concurrency.ContinuousClock.Instant, rhs: Swift.Duration) -> _Concurrency.ContinuousClock.Instant { lhs.advanced(by: rhs) } @_alwaysEmitIntoClient @inlinable public static func += (lhs: inout _Concurrency.ContinuousClock.Instant, rhs: Swift.Duration) { lhs = lhs.advanced(by: rhs) } @_alwaysEmitIntoClient @inlinable public static func - (lhs: _Concurrency.ContinuousClock.Instant, rhs: Swift.Duration) -> _Concurrency.ContinuousClock.Instant { lhs.advanced(by: .zero - rhs) } @_alwaysEmitIntoClient @inlinable public static func -= (lhs: inout _Concurrency.ContinuousClock.Instant, rhs: Swift.Duration) { lhs = lhs.advanced(by: .zero - rhs) } @_alwaysEmitIntoClient @inlinable public static func - (lhs: _Concurrency.ContinuousClock.Instant, rhs: _Concurrency.ContinuousClock.Instant) -> Swift.Duration { rhs.duration(to: lhs) } @available(iOS 16.0, tvOS 16.0, watchOS 9.0, macOS 13.0, *) public typealias Duration = Swift.Duration public var hashValue: Swift.Int { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withDiscardingTaskGroup(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any _Concurrency.Actor)? = #isolation, body: (inout _Concurrency.DiscardingTaskGroup) async -> GroupResult) async -> GroupResult { let flags = taskGroupCreateFlags( discardResults: true ) let _group = Builtin.createTaskGroupWithFlags(flags, Void.self) var group = DiscardingTaskGroup(group: _group) defer { Builtin.destroyTaskGroup(_group) } let result = await body(&group) try! await group.awaitAllRemainingTasks() return result } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_silgen_name("$ss23withDiscardingTaskGroup9returning4bodyxxm_xs0bcD0VzYaXEtYalF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withDiscardingTaskGroup(returning returnType: GroupResult.Type = GroupResult.self, body: (inout _Concurrency.DiscardingTaskGroup) async -> GroupResult) async -> GroupResult @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @frozen public struct DiscardingTaskGroup { @usableFromInline internal let _group: Builtin.RawPointer @inlinable internal init(group: Builtin.RawPointer) { self._group = group } @usableFromInline internal mutating func awaitAllRemainingTasks() async throws public var isEmpty: Swift.Bool { get } public func cancelAll() public var isCancelled: Swift.Bool { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @available(*, unavailable) extension _Concurrency.DiscardingTaskGroup : Swift.Sendable { } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withThrowingDiscardingTaskGroup(returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any _Concurrency.Actor)? = #isolation, body: (inout _Concurrency.ThrowingDiscardingTaskGroup) async throws -> GroupResult) async throws -> GroupResult { let flags = taskGroupCreateFlags( discardResults: true ) let _group = Builtin.createTaskGroupWithFlags(flags, Void.self) var group = ThrowingDiscardingTaskGroup(group: _group) defer { Builtin.destroyTaskGroup(_group) } let result: GroupResult do { result = try await body(&group) } catch { group.cancelAll() try await group.awaitAllRemainingTasks(bodyError: error) throw error } try await group.awaitAllRemainingTasks(bodyError: nil) return result } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_silgen_name("$ss31withThrowingDiscardingTaskGroup9returning4bodyxxm_xs0bcdE0Vys5Error_pGzYaKXEtYaKlF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withThrowingDiscardingTaskGroup(returning returnType: GroupResult.Type = GroupResult.self, body: (inout _Concurrency.ThrowingDiscardingTaskGroup) async throws -> GroupResult) async throws -> GroupResult @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @frozen public struct ThrowingDiscardingTaskGroup where Failure : Swift.Error { @usableFromInline internal let _group: Builtin.RawPointer @inlinable internal init(group: Builtin.RawPointer) { self._group = group } @usableFromInline internal mutating func awaitAllRemainingTasks(bodyError: (any Swift.Error)?) async throws public var isEmpty: Swift.Bool { get } public func cancelAll() public var isCancelled: Swift.Bool { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @available(*, unavailable) extension _Concurrency.ThrowingDiscardingTaskGroup : Swift.Sendable { } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @usableFromInline @discardableResult @_silgen_name("swift_taskGroup_waitAll") internal func _taskGroupWaitAll(group: Builtin.RawPointer, bodyError: (any Swift.Error)?) async throws -> T? @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_deletedAsyncMethodError") @usableFromInline internal func swift_deletedAsyncMethodError() async @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol Executor : AnyObject, Swift.Sendable { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) func enqueue(_ job: _Concurrency.UnownedJob) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @available(*, deprecated, message: "Implement 'enqueue(_: consuming ExecutorJob)' instead") func enqueue(_ job: consuming _Concurrency.Job) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) func enqueue(_ job: consuming _Concurrency.ExecutorJob) } extension _Concurrency.Actor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient nonisolated public func withSerialExecutor(_ operation: (any _Concurrency.SerialExecutor) throws(E) -> T) throws(E) -> T where E : Swift.Error, T : ~Copyable { try operation(unsafeBitCast(self.unownedExecutor, to: (any SerialExecutor).self)) } #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient nonisolated public func withSerialExecutor(_ operation: nonisolated(nonsending) (any _Concurrency.SerialExecutor) async throws(E) -> T) async throws(E) -> T where E : Swift.Error, T : ~Copyable { try await operation(unsafeBitCast(self.unownedExecutor, to: (any SerialExecutor).self)) } #endif } extension _Concurrency.Executor { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @usableFromInline internal var _isComplexEquality: Swift.Bool { get } } extension _Concurrency.Executor where Self : Swift.Equatable { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @usableFromInline internal var _isComplexEquality: Swift.Bool { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol SerialExecutor : _Concurrency.Executor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "Implement 'enqueue(_: consuming ExecutorJob)' instead") @_nonoverride func enqueue(_ job: _Concurrency.UnownedJob) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @available(*, deprecated, message: "Implement 'enqueue(_: consuming ExecutorJob)' instead") @_nonoverride func enqueue(_ job: consuming _Concurrency.Job) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_nonoverride func enqueue(_ job: consuming _Concurrency.ExecutorJob) @unsafe func asUnownedSerialExecutor() -> _Concurrency.UnownedSerialExecutor @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) func isSameExclusiveExecutionContext(other: Self) -> Swift.Bool @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) func checkIsolated() @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) func isIsolatingCurrentContext() -> Swift.Bool? } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.SerialExecutor { @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) public var isMainExecutor: Swift.Bool { get } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public func checkIsolated() } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.SerialExecutor { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func isIsolatingCurrentContext() -> Swift.Bool? } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public protocol TaskExecutor : _Concurrency.Executor { @_nonoverride func enqueue(_ job: _Concurrency.UnownedJob) @available(*, deprecated, message: "Implement 'enqueue(_: consuming ExecutorJob)' instead") @_nonoverride func enqueue(_ job: consuming _Concurrency.Job) @_nonoverride func enqueue(_ job: consuming _Concurrency.ExecutorJob) func asUnownedTaskExecutor() -> _Concurrency.UnownedTaskExecutor } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.TaskExecutor { public func asUnownedTaskExecutor() -> _Concurrency.UnownedTaskExecutor } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.Executor { public func enqueue(_ job: _Concurrency.UnownedJob) public func enqueue(_ job: consuming _Concurrency.ExecutorJob) public func enqueue(_ job: consuming _Concurrency.Job) } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.SerialExecutor { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public func asUnownedSerialExecutor() -> _Concurrency.UnownedSerialExecutor } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.SerialExecutor { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public func isSameExclusiveExecutionContext(other: Self) -> Swift.Bool } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) extension _Concurrency.SerialExecutor where Self : Swift.Equatable { @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) public func isSameExclusiveExecutionContext(other: Self) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @unsafe @frozen public struct UnownedSerialExecutor : Swift.Sendable { @usableFromInline internal var executor: Builtin.Executor @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public var _executor: Builtin.Executor { get } @inlinable public init(_ executor: Builtin.Executor) { self.executor = executor } @inlinable public init(ordinary executor: __shared E) where E : _Concurrency.SerialExecutor { self.executor = Builtin.buildOrdinarySerialExecutorRef(executor) } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @inlinable public init(complexEquality executor: __shared E) where E : _Concurrency.SerialExecutor { self.executor = Builtin.buildComplexEqualitySerialExecutorRef(executor) } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) @inlinable public init(_ executor: __shared E) where E : _Concurrency.SerialExecutor { if executor._isComplexEquality { self.executor = Builtin.buildComplexEqualitySerialExecutorRef(executor) } else { self.executor = Builtin.buildOrdinarySerialExecutorRef(executor) } } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) public func asSerialExecutor() -> (any _Concurrency.SerialExecutor)? } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @unsafe @frozen public struct UnownedTaskExecutor : Swift.Sendable { @usableFromInline internal var executor: Builtin.Executor @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public var _executor: Builtin.Executor { get } @inlinable public init(_ executor: Builtin.Executor) { self.executor = executor } @inlinable public init(ordinary executor: __shared E) where E : _Concurrency.TaskExecutor { self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor) } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) @inlinable public init(_ executor: __shared E) where E : _Concurrency.TaskExecutor { self.executor = Builtin.buildOrdinaryTaskExecutorRef(executor) } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) public func asTaskExecutor() -> (any _Concurrency.TaskExecutor)? } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.UnownedTaskExecutor : Swift.Equatable { @inlinable public static func == (lhs: _Concurrency.UnownedTaskExecutor, rhs: _Concurrency.UnownedTaskExecutor) -> Swift.Bool { unsafeBitCast(lhs.executor, to: (Int, Int).self) == unsafeBitCast(rhs.executor, to: (Int, Int).self) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_transparent public 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(macOS 15.4, iOS 18.4, watchOS 11.4, tvOS 18.4, visionOS 2.4, *) @_silgen_name("swift_task_deinitOnExecutor") @usableFromInline internal func _deinitOnExecutor(_ object: __owned Swift.AnyObject, _ work: @escaping @convention(thin) (__owned Swift.AnyObject) -> Swift.Void, _ executor: Builtin.Executor, _ flags: Builtin.Word) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.SerialExecutor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public func preconditionIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { guard _isDebugAssertConfiguration() || _isReleaseAssertConfiguration() else { return } let expectationCheck = _taskIsCurrentExecutor(self.asUnownedSerialExecutor().executor) precondition(expectationCheck, "Incorrect actor executor assumption; Expected '\(self)' executor. \(message())", file: file, line: line) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Actor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) nonisolated public func preconditionIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { guard _isDebugAssertConfiguration() || _isReleaseAssertConfiguration() else { return } let expectationCheck = _taskIsCurrentExecutor(self.unownedExecutor.executor) precondition(expectationCheck, "Incorrect actor executor assumption; Expected '\(self.unownedExecutor)' executor. \(message())", file: file, line: line) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.GlobalActor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public static func preconditionIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { Self.shared.preconditionIsolated(message(), file: file, line: line) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.SerialExecutor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public func assertIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { guard _isDebugAssertConfiguration() else { return } guard _taskIsCurrentExecutor(self.asUnownedSerialExecutor().executor) else { let msg = "Incorrect actor executor assumption; Expected '\(self)' executor. \(message())" assertionFailure(msg, file: file, line: line) return } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Actor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) nonisolated public func assertIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { guard _isDebugAssertConfiguration() else { return } guard _taskIsCurrentExecutor(self.unownedExecutor.executor) else { let msg = "Incorrect actor executor assumption; Expected '\(self.unownedExecutor)' executor. \(message())" assertionFailure(msg, file: file, line: line) return } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.GlobalActor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0) public static func assertIsolated(_ message: @autoclosure () -> Swift.String = String(), file: Swift.StaticString = #fileID, line: Swift.UInt = #line) { Self.shared.assertIsolated(message(), file: file, line: line) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Actor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @_unavailableFromAsync(message: "express the closure as an explicit function declared on the specified 'actor' instead") nonisolated public func assumeIsolated(_ operation: (isolated Self) throws -> T, file: Swift.StaticString = #fileID, line: Swift.UInt = #line) rethrows -> T where T : Swift.Sendable { typealias YesActor = (isolated Self) throws -> T typealias NoActor = (Self) throws -> T let executor: Builtin.Executor = self.unownedExecutor.executor guard _taskIsCurrentExecutor(executor) else { fatalError("Incorrect actor executor assumption; Expected same executor as \(self).", file: file, line: line) } return try withoutActuallyEscaping(operation) { (_ fn: @escaping YesActor) throws -> T in let rawFn = unsafeBitCast(fn, to: NoActor.self) return try rawFn(self) } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @usableFromInline @_silgen_name("$sScAsE14assumeIsolated_4file4lineqd__qd__xYiKXE_s12StaticStringVSutKlF") nonisolated internal func __abi__assumeIsolated(_ operation: (isolated Self) throws -> T, _ file: Swift.StaticString, _ line: Swift.UInt) rethrows -> T where T : Swift.Sendable } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public protocol GlobalActor { associatedtype ActorType : _Concurrency.Actor static var shared: Self.ActorType { get } static var sharedUnownedExecutor: _Concurrency.UnownedSerialExecutor { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.GlobalActor { public static var sharedUnownedExecutor: _Concurrency.UnownedSerialExecutor { get } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public var globalConcurrentExecutor: any _Concurrency.TaskExecutor { get } @_hasMissingDesignatedInitializers @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @globalActor final public actor MainActor : _Concurrency.GlobalActor { public static let shared: _Concurrency.MainActor @inlinable nonisolated final public var unownedExecutor: _Concurrency.UnownedSerialExecutor { get { return UnownedSerialExecutor(Builtin.buildMainActorExecutorRef()) } } @inlinable public static var sharedUnownedExecutor: _Concurrency.UnownedSerialExecutor { get { return UnownedSerialExecutor(Builtin.buildMainActorExecutorRef()) } } @inlinable nonisolated final public func enqueue(_ job: _Concurrency.UnownedJob) { _enqueueOnMain(job) } @available(iOS 13.0, tvOS 13.0, watchOS 6.0, macOS 10.15, *) public typealias ActorType = _Concurrency.MainActor @objc deinit } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.MainActor { @usableFromInline internal static func run(resultType: T.Type = T.self, body: @_Concurrency.MainActor @Sendable () throws -> T) async rethrows -> T @_alwaysEmitIntoClient public static func run(resultType: T.Type = T.self, body: @_Concurrency.MainActor @Sendable () throws -> T) async rethrows -> T where T : Swift.Sendable { return try await body() } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.MainActor { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @_unavailableFromAsync(message: "await the call to the @MainActor closure directly") public static func assumeIsolated(_ operation: @_Concurrency.MainActor () throws -> T, file: Swift.StaticString = #fileID, line: Swift.UInt = #line) rethrows -> T where T : Swift.Sendable { typealias YesActor = @MainActor () throws -> T typealias NoActor = () throws -> T let executor: Builtin.Executor = Self.shared.unownedExecutor.executor guard _taskIsCurrentExecutor(executor) else { #if !$Embedded fatalError("Incorrect actor executor assumption; Expected same executor as \(self).", file: file, line: line) #else Builtin.int_trap() #endif } return try withoutActuallyEscaping(operation) { (_ fn: @escaping YesActor) throws -> T in let rawFn = unsafeBitCast(fn, to: NoActor.self) return try rawFn() } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @usableFromInline @_silgen_name("$sScM14assumeIsolated_4file4linexxyKScMYcXE_s12StaticStringVSutKlFZ") internal static func __abi__assumeIsolated(_ operation: @_Concurrency.MainActor () throws -> T, _ file: Swift.StaticString, _ line: Swift.UInt) rethrows -> T where T : Swift.Sendable } @usableFromInline @_extern(c, "pthread_main_np") internal func pthread_main_np() -> Swift.CInt @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_deinitOnExecutorMainActorBackDeploy") @_alwaysEmitIntoClient public func _deinitOnExecutorMainActorBackDeploy(_ object: __owned Swift.AnyObject, _ work: @escaping @convention(thin) (__owned Swift.AnyObject) -> Swift.Void, _ executor: Builtin.Executor, _ flags: Builtin.Word) { if #available(macOS 15.4, iOS 18.4, watchOS 11.4, tvOS 18.4, visionOS 2.4, *) { _deinitOnExecutor(object, work, executor, flags) } else if pthread_main_np() == 1 { work(consume object) } else { var stolenObject: AnyObject? = consume object Task.detached { @MainActor in work(stolenObject.take()!) } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_job_run") @usableFromInline internal func _swiftJobRun(_ job: _Concurrency.UnownedJob, _ executor: _Concurrency.UnownedSerialExecutor) @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_silgen_name("swift_job_run_on_task_executor") @usableFromInline internal func _swiftJobRunOnTaskExecutor(_ job: _Concurrency.UnownedJob, _ executor: _Concurrency.UnownedTaskExecutor) @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_silgen_name("swift_job_run_on_serial_and_task_executor") @usableFromInline internal func _swiftJobRunOnTaskExecutor(_ job: _Concurrency.UnownedJob, _ serialExecutor: _Concurrency.UnownedSerialExecutor, _ taskExecutor: _Concurrency.UnownedTaskExecutor) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @frozen public struct UnownedJob : Swift.Sendable { private var context: Builtin.Job @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @usableFromInline internal init(context: Builtin.Job) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public init(_ job: __owned _Concurrency.Job) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public init(_ job: __owned _Concurrency.ExecutorJob) @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public var priority: _Concurrency.JobPriority { get } @available(*, deprecated, renamed: "ExecutorJob.runSynchronously(on:)") @_alwaysEmitIntoClient @inlinable public func _runSynchronously(on executor: _Concurrency.UnownedSerialExecutor) { _swiftJobRun(self, executor) } @_alwaysEmitIntoClient @inlinable public func runSynchronously(on executor: _Concurrency.UnownedSerialExecutor) { _swiftJobRun(self, executor) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient @inlinable public func runSynchronously(on executor: _Concurrency.UnownedTaskExecutor) { _swiftJobRunOnTaskExecutor(self, executor) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient @inlinable public func runSynchronously(isolatedTo serialExecutor: _Concurrency.UnownedSerialExecutor, taskExecutor: _Concurrency.UnownedTaskExecutor) { _swiftJobRunOnTaskExecutor(self, serialExecutor, taskExecutor) } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.UnownedJob : Swift.CustomStringConvertible { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public var description: Swift.String { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @available(*, deprecated, renamed: "ExecutorJob") @frozen public struct Job : Swift.Sendable, ~Swift.Copyable { internal var context: Builtin.Job @usableFromInline internal init(context: __owned Builtin.Job) public init(_ job: _Concurrency.UnownedJob) public init(_ job: __owned _Concurrency.ExecutorJob) public var priority: _Concurrency.JobPriority { get } public var description: Swift.String { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.Job { @_alwaysEmitIntoClient @inlinable public __consuming func runSynchronously(on executor: _Concurrency.UnownedSerialExecutor) { _swiftJobRun(UnownedJob(self), executor) } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @frozen public struct ExecutorJob : Swift.Sendable, ~Swift.Copyable { internal var context: Builtin.Job @usableFromInline internal init(context: __owned Builtin.Job) public init(_ job: _Concurrency.UnownedJob) public init(_ job: __owned _Concurrency.Job) public var priority: _Concurrency.JobPriority { get } public var description: Swift.String { get } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ExecutorJob { @_alwaysEmitIntoClient @inlinable public __consuming func runSynchronously(on executor: _Concurrency.UnownedSerialExecutor) { _swiftJobRun(UnownedJob(self), executor) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient @inlinable public __consuming func runSynchronously(on executor: _Concurrency.UnownedTaskExecutor) { _swiftJobRunOnTaskExecutor(UnownedJob(self), executor) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient @inlinable public __consuming func runSynchronously(isolatedTo serialExecutor: _Concurrency.UnownedSerialExecutor, taskExecutor: _Concurrency.UnownedTaskExecutor) { _swiftJobRunOnTaskExecutor(UnownedJob(self), serialExecutor, taskExecutor) } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @frozen public struct JobPriority : Swift.Sendable { public typealias RawValue = Swift.UInt8 public var rawValue: _Concurrency.JobPriority.RawValue public init(rawValue: _Concurrency.JobPriority.RawValue) public init(_ p: _Concurrency.TaskPriority) } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.TaskPriority { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public init?(_ p: _Concurrency.JobPriority) } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.JobPriority : Swift.Equatable { public static func == (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool public static func != (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.JobPriority : Swift.Comparable { public static func < (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool public static func <= (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool public static func > (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool public static func >= (lhs: _Concurrency.JobPriority, rhs: _Concurrency.JobPriority) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @frozen @unsafe public struct UnsafeContinuation : Swift.Sendable where E : Swift.Error { @usableFromInline internal var context: Builtin.RawUnsafeContinuation @_alwaysEmitIntoClient internal init(_ context: Builtin.RawUnsafeContinuation) { self.context = context } @_alwaysEmitIntoClient public func resume(returning value: sending T) where E == Swift.Never { #if compiler(>=5.5) && $BuiltinContinuation Builtin.resumeNonThrowingContinuationReturning(context, value) #else fatalError("Swift compiler is incompatible with this SDK version") #endif } @_alwaysEmitIntoClient public func resume(returning value: sending T) { #if compiler(>=5.5) && $BuiltinContinuation Builtin.resumeThrowingContinuationReturning(context, value) #else fatalError("Swift compiler is incompatible with this SDK version") #endif } @_alwaysEmitIntoClient public func resume(throwing error: consuming E) { #if compiler(>=5.5) && $BuiltinContinuation Builtin.resumeThrowingContinuationThrowing(context, error) #else fatalError("Swift compiler is incompatible with this SDK version") #endif } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnsafeContinuation { @_alwaysEmitIntoClient public func resume(with result: __shared sending Swift.Result) where E == any Swift.Error, Er : Swift.Error { switch result { case .success(let val): self.resume(returning: val) case .failure(let err): self.resume(throwing: err) } } @_alwaysEmitIntoClient public func resume(with result: __shared sending Swift.Result) { switch result { case .success(let val): self.resume(returning: val) case .failure(let err): self.resume(throwing: err) } } @_alwaysEmitIntoClient public func resume() where T == () { self.resume(returning: ()) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeUnsafeContinuation(_ continuation: _Concurrency.UnsafeContinuation, _ value: sending T) { continuation.resume(returning: value) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeUnsafeThrowingContinuation(_ continuation: _Concurrency.UnsafeContinuation, _ value: sending T) { continuation.resume(returning: value) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func _resumeUnsafeThrowingContinuationWithError(_ continuation: _Concurrency.UnsafeContinuation, _ error: consuming any Swift.Error) { continuation.resume(throwing: error) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @unsafe public func withUnsafeContinuation(isolation: isolated (any _Concurrency.Actor)? = #isolation, _ fn: (_Concurrency.UnsafeContinuation) -> Swift.Void) async -> sending T { return await Builtin.withUnsafeContinuation { fn(UnsafeContinuation($0)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @unsafe public func withUnsafeThrowingContinuation(isolation: isolated (any _Concurrency.Actor)? = #isolation, _ fn: (_Concurrency.UnsafeContinuation) -> Swift.Void) async throws -> sending T { return try await Builtin.withUnsafeThrowingContinuation { fn(UnsafeContinuation($0)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @_unsafeInheritExecutor public func _unsafeInheritExecutor_withUnsafeContinuation(_ fn: (_Concurrency.UnsafeContinuation) -> Swift.Void) async -> sending T { return await Builtin.withUnsafeContinuation { fn(UnsafeContinuation($0)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient @_unsafeInheritExecutor public func _unsafeInheritExecutor_withUnsafeThrowingContinuation(_ fn: (_Concurrency.UnsafeContinuation) -> Swift.Void) async throws -> sending T { return try await Builtin.withUnsafeThrowingContinuation { fn(UnsafeContinuation($0)) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public func _abiEnableAwaitContinuation() { fatalError("never use this function") } @available(macOS 26.4, iOS 26.4, watchOS 26.4, tvOS 26.4, visionOS 26.4, *) @_silgen_name("_swift_createJobForTestingOnly") public func _swift_createJobForTestingOnly(priority: _Concurrency.TaskPriority = TaskPriority.medium, _ body: @escaping () -> ()) -> _Concurrency.ExecutorJob @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(*, deprecated, message: "Task.Priority has been removed; use TaskPriority") public typealias Priority = _Concurrency.TaskPriority @available(*, deprecated, message: "Task.Handle has been removed; use Task") public typealias Handle = _Concurrency.Task @available(*, deprecated, message: "Task.CancellationError has been removed; use CancellationError") @_alwaysEmitIntoClient public static func CancellationError() -> _Concurrency.CancellationError { return _Concurrency.CancellationError() } @available(*, deprecated, renamed: "yield()") @_alwaysEmitIntoClient public static func suspend() async { await yield() } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskPriority { @available(*, deprecated, message: "unspecified priority will be removed; use nil") @_alwaysEmitIntoClient public static var unspecified: _Concurrency.TaskPriority { get { .init(rawValue: 0x00) } } @available(*, deprecated, message: "userInteractive priority will be removed") @_alwaysEmitIntoClient public static var userInteractive: _Concurrency.TaskPriority { get { .init(rawValue: 0x21) } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, renamed: "withTaskCancellationHandler(operation:onCancel:)") @_alwaysEmitIntoClient public func withTaskCancellationHandler(handler: @Sendable () -> Swift.Void, operation: () async throws -> T) async rethrows -> T { try await withTaskCancellationHandler(operation: operation, onCancel: handler) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, renamed: "withTaskCancellationHandler(operation:onCancel:)") @_alwaysEmitIntoClient @_unsafeInheritExecutor public func _unsafeInheritExecutor_withTaskCancellationHandler(handler: @Sendable () -> Swift.Void, operation: () async throws -> T) async rethrows -> T { try await withTaskCancellationHandler(operation: operation, onCancel: handler) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(*, deprecated, message: "`Task.withCancellationHandler` has been replaced by `withTaskCancellationHandler` and will be removed shortly.") @_alwaysEmitIntoClient public static func withCancellationHandler(handler: @Sendable () -> Swift.Void, operation: () async throws -> T) async rethrows -> T { try await withTaskCancellationHandler(operation: operation, onCancel: handler) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(*, deprecated, message: "`Task.Group` was replaced by `ThrowingTaskGroup` and `TaskGroup` and will be removed shortly.") public typealias Group = _Concurrency.ThrowingTaskGroup where TaskResult : Swift.Sendable @available(*, deprecated, message: "`Task.withGroup` was replaced by `withThrowingTaskGroup` and `withTaskGroup` and will be removed shortly.") @_alwaysEmitIntoClient public static func withGroup(resultType: TaskResult.Type, returning returnType: BodyResult.Type = BodyResult.self, body: (inout _Concurrency.Task.Group) async throws -> BodyResult) async rethrows -> BodyResult where TaskResult : Swift.Sendable { try await withThrowingTaskGroup(of: resultType) { group in try await body(&group) } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task { @available(*, deprecated, message: "get() has been replaced by .value") @_alwaysEmitIntoClient public func get() async throws -> Success { return try await value } @available(*, deprecated, message: "getResult() has been replaced by .result") @_alwaysEmitIntoClient public func getResult() async -> Swift.Result { return await result } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Failure == Swift.Never { @available(*, deprecated, message: "get() has been replaced by .value") @_alwaysEmitIntoClient public func get() async -> Success { return await value } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup { @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func add(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async -> ChildTaskResult) async -> Swift.Bool { return self.addTaskUnlessCancelled(priority: priority) { await operation() } } @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func spawn(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async -> ChildTaskResult) { addTask(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTaskUnlessCancelled(priority:operation:)") @_alwaysEmitIntoClient public mutating func spawnUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async -> ChildTaskResult) -> Swift.Bool { addTaskUnlessCancelled(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func async(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async -> ChildTaskResult) { addTask(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTaskUnlessCancelled(priority:operation:)") @_alwaysEmitIntoClient public mutating func asyncUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async -> ChildTaskResult) -> Swift.Bool { addTaskUnlessCancelled(priority: priority, operation: operation) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup { @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func add(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async throws -> ChildTaskResult) async -> Swift.Bool { return self.addTaskUnlessCancelled(priority: priority) { try await operation() } } @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func spawn(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async throws -> ChildTaskResult) { addTask(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTaskUnlessCancelled(priority:operation:)") @_alwaysEmitIntoClient public mutating func spawnUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async throws -> ChildTaskResult) -> Swift.Bool { addTaskUnlessCancelled(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTask(priority:operation:)") @_alwaysEmitIntoClient public mutating func async(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async throws -> ChildTaskResult) { addTask(priority: priority, operation: operation) } @available(*, deprecated, renamed: "addTaskUnlessCancelled(priority:operation:)") @_alwaysEmitIntoClient public mutating func asyncUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: __owned @escaping @Sendable () async throws -> ChildTaskResult) -> Swift.Bool { addTaskUnlessCancelled(priority: priority, operation: operation) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "please use UnsafeContinuation<..., Error>") public typealias UnsafeThrowingContinuation = _Concurrency.UnsafeContinuation @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, renamed: "UnownedJob") public typealias PartialAsyncTask = _Concurrency.UnownedJob @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public struct SuspendingClock : Swift.Sendable { public struct Instant : Swift.Sendable { } public init() } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.SuspendingClock.Instant : Swift.Codable { public func encode(to encoder: any Swift.Encoder) throws public init(from decoder: any Swift.Decoder) throws } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.Clock where Self == _Concurrency.SuspendingClock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public static var suspending: _Concurrency.SuspendingClock { get } } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.SuspendingClock : _Concurrency.Clock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public var now: _Concurrency.SuspendingClock.Instant { get } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public static var now: _Concurrency.SuspendingClock.Instant { get } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public var minimumResolution: Swift.Duration { get } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public func sleep(until deadline: _Concurrency.SuspendingClock.Instant, tolerance: Swift.Duration? = nil) async throws @available(iOS 16.0, tvOS 16.0, watchOS 9.0, macOS 13.0, *) public typealias Duration = Swift.Duration } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.SuspendingClock { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_alwaysEmitIntoClient public var systemEpoch: _Concurrency.SuspendingClock.Instant { get { unsafeBitCast(Duration.seconds(0), to: Instant.self) } } } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.SuspendingClock.Instant : Swift.InstantProtocol { public static var now: _Concurrency.SuspendingClock.Instant { get } public func advanced(by duration: Swift.Duration) -> _Concurrency.SuspendingClock.Instant public func duration(to other: _Concurrency.SuspendingClock.Instant) -> Swift.Duration public func hash(into hasher: inout Swift.Hasher) public static func == (lhs: _Concurrency.SuspendingClock.Instant, rhs: _Concurrency.SuspendingClock.Instant) -> Swift.Bool public static func < (lhs: _Concurrency.SuspendingClock.Instant, rhs: _Concurrency.SuspendingClock.Instant) -> Swift.Bool public static func + (lhs: _Concurrency.SuspendingClock.Instant, rhs: Swift.Duration) -> _Concurrency.SuspendingClock.Instant public static func += (lhs: inout _Concurrency.SuspendingClock.Instant, rhs: Swift.Duration) public static func - (lhs: _Concurrency.SuspendingClock.Instant, rhs: Swift.Duration) -> _Concurrency.SuspendingClock.Instant public static func -= (lhs: inout _Concurrency.SuspendingClock.Instant, rhs: Swift.Duration) public static func - (lhs: _Concurrency.SuspendingClock.Instant, rhs: _Concurrency.SuspendingClock.Instant) -> Swift.Duration @available(iOS 16.0, tvOS 16.0, watchOS 9.0, macOS 13.0, *) public typealias Duration = Swift.Duration public var hashValue: Swift.Int { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @frozen public struct Task : Swift.Sendable where Success : Swift.Sendable, Failure : Swift.Error { @usableFromInline internal let _task: Builtin.NativeObject @_alwaysEmitIntoClient internal init(_ task: Builtin.NativeObject) { self._task = task } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task { public var value: Success { get async throws } public var result: Swift.Result { get async } public func cancel() } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Failure == Swift.Never { public var value: Success { get async } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task : Swift.Hashable { public func hash(into hasher: inout Swift.Hasher) public var hashValue: Swift.Int { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task : Swift.Equatable { public static func == (lhs: _Concurrency.Task, rhs: _Concurrency.Task) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct TaskPriority : Swift.RawRepresentable, Swift.Sendable { public typealias RawValue = Swift.UInt8 public var rawValue: Swift.UInt8 public init(rawValue: Swift.UInt8) public static let high: _Concurrency.TaskPriority @_alwaysEmitIntoClient public static var medium: _Concurrency.TaskPriority { get { .init(rawValue: 0x15) } } public static let low: _Concurrency.TaskPriority public static let userInitiated: _Concurrency.TaskPriority public static let utility: _Concurrency.TaskPriority public static let background: _Concurrency.TaskPriority @available(*, deprecated, renamed: "medium") public static let `default`: _Concurrency.TaskPriority } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskPriority : Swift.Equatable { public static func == (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool public static func != (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskPriority : Swift.Comparable { public static func < (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool public static func <= (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool public static func > (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool public static func >= (lhs: _Concurrency.TaskPriority, rhs: _Concurrency.TaskPriority) -> Swift.Bool } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.TaskPriority : Swift.CustomStringConvertible { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public var description: Swift.String { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskPriority : Swift.Codable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { public static var currentPriority: _Concurrency.TaskPriority { get } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public static var basePriority: _Concurrency.TaskPriority? { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient internal func taskCreateFlags(priority: _Concurrency.TaskPriority?, isChildTask: Swift.Bool, copyTaskLocals: Swift.Bool, inheritContext: Swift.Bool, enqueueJob: Swift.Bool, addPendingGroupTaskUnconditionally: Swift.Bool, isDiscardingTask: Swift.Bool, isSynchronousStart: Swift.Bool) -> Swift.Int { var bits = 0 bits |= (bits & ~0xFF) | Int(priority?.rawValue ?? 0) if isChildTask { bits |= 1 << 8 } if copyTaskLocals { bits |= 1 << 10 } if inheritContext { bits |= 1 << 11 } if enqueueJob { bits |= 1 << 12 } if addPendingGroupTaskUnconditionally { bits |= 1 << 13 } if isDiscardingTask { bits |= 1 << 14 } if isSynchronousStart { bits |= 1 << 16 } return bits } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public static var name: Swift.String? { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { public static func yield() async } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public func withUnsafeCurrentTask(body: (_Concurrency.UnsafeCurrentTask?) throws -> T) rethrows -> T @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public func withUnsafeCurrentTask(body: (_Concurrency.UnsafeCurrentTask?) async throws -> T) async rethrows -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @unsafe public struct UnsafeCurrentTask { public var isCancelled: Swift.Bool { get } public var priority: _Concurrency.TaskPriority { get } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) public var basePriority: _Concurrency.TaskPriority { get } public func cancel() } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, unavailable) extension _Concurrency.UnsafeCurrentTask : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnsafeCurrentTask : @unsafe Swift.Hashable { public func hash(into hasher: inout Swift.Hasher) public var hashValue: Swift.Int { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnsafeCurrentTask : Swift.Equatable { public static func == (lhs: _Concurrency.UnsafeCurrentTask, rhs: _Concurrency.UnsafeCurrentTask) -> Swift.Bool } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_getCurrent") public func _getCurrentAsyncTask() -> Builtin.NativeObject? @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_enqueueGlobal") @usableFromInline internal func _enqueueJobGlobal(_ task: Builtin.Job) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_enqueueGlobalWithDelay") @usableFromInline internal func _enqueueJobGlobalWithDelay(_ delay: Swift.UInt64, _ task: Builtin.Job) @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_silgen_name("swift_task_enqueueGlobalWithDeadline") @usableFromInline internal func _enqueueJobGlobalWithDeadline(_ seconds: Swift.Int64, _ nanoseconds: Swift.Int64, _ toleranceSec: Swift.Int64, _ toleranceNSec: Swift.Int64, _ clock: Swift.Int32, _ task: _Concurrency.UnownedJob) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_asyncMainDrainQueue") internal func _asyncMainDrainQueue() -> Swift.Never @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_getMainExecutor") internal func _getMainExecutor() -> Builtin.Executor @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @usableFromInline internal func _getGenericSerialExecutor() -> Builtin.Executor @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @preconcurrency internal func _runAsyncMain(_ asyncFun: @escaping @Sendable () async throws -> ()) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_future_wait") public func _taskFutureGet(_ task: Builtin.NativeObject) async -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_future_wait_throwing") public func _taskFutureGetThrowing(_ task: Builtin.NativeObject) async throws -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_cancel") public func _taskCancel(_ task: Builtin.NativeObject) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_task_isCancelled") @usableFromInline internal func _taskIsCancelled(_ task: Builtin.NativeObject) -> Swift.Bool @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_isCurrentExecutor") internal func _taskIsCurrentExecutor(_ executor: Builtin.Executor) -> Swift.Bool @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_silgen_name("swift_task_isCurrentExecutorWithFlags") @usableFromInline internal func _taskIsCurrentExecutor(executor: Builtin.Executor, flags: Swift.UInt64) -> Swift.Bool @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_reportUnexpectedExecutor") internal func _reportUnexpectedExecutor(_ _filenameStart: Builtin.RawPointer, _ _filenameLength: Builtin.Word, _ _filenameIsASCII: Builtin.Int1, _ _line: Builtin.Word, _ _executor: Builtin.Executor) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_alwaysEmitIntoClient internal func _runTaskForBridgedAsyncMethod(@_inheritActorContext _ body: __owned @escaping @Sendable () async -> Swift.Void) { #if compiler(>=5.6) Task(operation: body) #else Task { await body() return 0 } #endif } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func escalatePriority(to newPriority: _Concurrency.TaskPriority) } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.UnsafeCurrentTask { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func escalatePriority(to newPriority: _Concurrency.TaskPriority) } #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient nonisolated(nonsending) public func withTaskPriorityEscalationHandler(operation: nonisolated(nonsending) () async throws(E) -> T, onPriorityEscalated handler: @Sendable (_Concurrency.TaskPriority, _Concurrency.TaskPriority) -> Swift.Void) async throws(E) -> T where E : Swift.Error { return try await __withTaskPriorityEscalationHandler0( operation: operation, onPriorityEscalated: { handler(TaskPriority(rawValue: $0), TaskPriority(rawValue: $1)) }) } #endif #if compiler(>=5.3) && $ABIAttributeSE0479 @abi(func withTaskPriorityEscalationHandler(operation: () async throws(E) -> T, onPriorityEscalated handler: @Sendable (_Concurrency.TaskPriority, _Concurrency.TaskPriority) -> Swift.Void, isolation: isolated (any _Concurrency.Actor)?) async throws(E) -> T where E : Swift.Error) @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func _isolatedParameter_withTaskPriorityEscalationHandler(operation: () async throws(E) -> T, onPriorityEscalated handler: @Sendable (_Concurrency.TaskPriority, _Concurrency.TaskPriority) -> Swift.Void, isolation: isolated (any _Concurrency.Actor)? = #isolation) async throws(E) -> T where E : Swift.Error #else @_silgen_name("$ss33withTaskPriorityEscalationHandler9operation02onC9Escalated9isolationxxyYaq_YKXE_yScP_ScPtYbXEScA_pSgYitYaq_YKs5ErrorR_r0_lF") @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) public func _isolatedParameter_withTaskPriorityEscalationHandler(operation: () async throws(E) -> T, onPriorityEscalated handler: @Sendable (_Concurrency.TaskPriority, _Concurrency.TaskPriority) -> Swift.Void, isolation: isolated (any _Concurrency.Actor)? = #isolation) async throws(E) -> T where E : Swift.Error #endif #if compiler(>=5.3) && $AsyncExecutionBehaviorAttributes @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient nonisolated(nonsending) internal func __withTaskPriorityEscalationHandler0(operation: nonisolated(nonsending) () async throws(E) -> T, onPriorityEscalated handler0: @Sendable (Swift.UInt8, Swift.UInt8) -> Swift.Void) async throws(E) -> T where E : Swift.Error { #if $BuiltinConcurrencyStackNesting let record = Builtin.taskAddPriorityEscalationHandler(handler: handler0) defer { Builtin.taskRemovePriorityEscalationHandler(record: record) } #else let record = _taskAddPriorityEscalationHandler(handler: handler0) defer { _taskRemovePriorityEscalationHandler(record: record) } #endif return try await operation() } #endif @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @usableFromInline @_silgen_name("swift_task_addPriorityEscalationHandler") internal func _taskAddPriorityEscalationHandler(handler: (Swift.UInt8, Swift.UInt8) -> Swift.Void) -> Swift.UnsafeRawPointer @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @usableFromInline @_silgen_name("swift_task_removePriorityEscalationHandler") internal func _taskRemovePriorityEscalationHandler(record: Swift.UnsafeRawPointer) @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public func withTaskExecutorPreference(_ taskExecutor: (any _Concurrency.TaskExecutor)?, isolation: isolated (any _Concurrency.Actor)? = #isolation, operation: () async throws(Failure) -> T) async throws(Failure) -> T where Failure : Swift.Error @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_silgen_name("$ss26withTaskExecutorPreference_9operationxSch_pSg_xyYaYbKXEtYaKs8SendableRzlF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withTaskExecutorPreference(_ taskExecutor: (any _Concurrency.TaskExecutor)?, operation: @Sendable () async throws -> T) async rethrows -> T where T : Swift.Sendable @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.UnsafeCurrentTask { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public var unownedTaskExecutor: _Concurrency.UnownedTaskExecutor? { get } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @usableFromInline internal func _getUndefinedTaskExecutor() -> Builtin.Executor @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) public func withTaskCancellationHandler(operation: () async throws -> T, onCancel handler: @Sendable () -> Swift.Void, isolation: isolated (any _Concurrency.Actor)? = #isolation) async rethrows -> T { #if $BuiltinConcurrencyStackNesting let record = Builtin.taskAddCancellationHandler(handler: handler) defer { Builtin.taskRemoveCancellationHandler(record: record) } #else let record = _taskAddCancellationHandler(handler: handler) defer { _taskRemoveCancellationHandler(record: record) } #endif return try await operation() } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss27withTaskCancellationHandler9operation8onCancelxxyYaKXE_yyYbXEtYaKlF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withTaskCancellationHandler(operation: () async throws -> T, onCancel handler: @Sendable () -> Swift.Void) async rethrows -> T @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task { @_transparent public var isCancelled: Swift.Bool { @_transparent get { _taskIsCancelled(_task) } } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { public static var isCancelled: Swift.Bool { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { public static func checkCancellation() throws } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct CancellationError : Swift.Error { public init() } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_addCancellationHandler") internal func _taskAddCancellationHandler(handler: () -> Swift.Void) -> Swift.UnsafeRawPointer @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_removeCancellationHandler") internal func _taskRemoveCancellationHandler(record: Swift.UnsafeRawPointer) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withTaskGroup(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any _Concurrency.Actor)? = #isolation, body: (inout _Concurrency.TaskGroup) async -> GroupResult) async -> GroupResult where ChildTaskResult : Swift.Sendable { #if compiler(>=5.5) && $BuiltinTaskGroupWithArgument let _group = Builtin.createTaskGroup(ChildTaskResult.self) var group = TaskGroup(group: _group) let result = await body(&group) await group.awaitAllRemainingTasks() Builtin.destroyTaskGroup(_group) return result #else fatalError("Swift compiler is incompatible with this SDK version") #endif } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss13withTaskGroup2of9returning4bodyq_xm_q_mq_ScGyxGzYaXEtYar0_lF") @_unsafeInheritExecutor @inlinable public func _unsafeInheritExecutor_withTaskGroup(of childTaskResultType: ChildTaskResult.Type, returning returnType: GroupResult.Type = GroupResult.self, body: (inout _Concurrency.TaskGroup) async -> GroupResult) async -> GroupResult where ChildTaskResult : Swift.Sendable { #if compiler(>=5.5) && $BuiltinTaskGroupWithArgument let _group = Builtin.createTaskGroup(ChildTaskResult.self) var group = TaskGroup(group: _group) let result = await body(&group) await group.awaitAllRemainingTasks() Builtin.destroyTaskGroup(_group) return result #else fatalError("Swift compiler is incompatible with this SDK version") #endif } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @inlinable public func withThrowingTaskGroup(of childTaskResultType: ChildTaskResult.Type = ChildTaskResult.self, returning returnType: GroupResult.Type = GroupResult.self, isolation: isolated (any _Concurrency.Actor)? = #isolation, body: (inout _Concurrency.ThrowingTaskGroup) async throws -> GroupResult) async rethrows -> GroupResult where ChildTaskResult : Swift.Sendable { #if compiler(>=5.5) && $BuiltinTaskGroupWithArgument let _group = Builtin.createTaskGroup(ChildTaskResult.self) var group = ThrowingTaskGroup(group: _group) do { let result = try await body(&group) await group.awaitAllRemainingTasks() Builtin.destroyTaskGroup(_group) return result } catch { group.cancelAll() await group.awaitAllRemainingTasks() Builtin.destroyTaskGroup(_group) throw error } #else fatalError("Swift compiler is incompatible with this SDK version") #endif } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss21withThrowingTaskGroup2of9returning4bodyq_xm_q_mq_Scgyxs5Error_pGzYaKXEtYaKr0_lF") @_unsafeInheritExecutor public func _unsafeInheritExecutor_withThrowingTaskGroup(of childTaskResultType: ChildTaskResult.Type, returning returnType: GroupResult.Type = GroupResult.self, body: (inout _Concurrency.ThrowingTaskGroup) async throws -> GroupResult) async rethrows -> GroupResult where ChildTaskResult : Swift.Sendable @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @frozen public struct TaskGroup where ChildTaskResult : Swift.Sendable { @usableFromInline internal let _group: Builtin.RawPointer @inlinable internal init(group: Builtin.RawPointer) { self._group = group } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) public mutating func next(isolation: isolated (any _Concurrency.Actor)? = #isolation) async -> ChildTaskResult? { return try! await _taskGroupWaitNext(group: _group) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_disfavoredOverload public mutating func next() async -> ChildTaskResult? @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @usableFromInline internal mutating func awaitAllRemainingTasks(isolation: isolated (any _Concurrency.Actor)? = #isolation) async { while let _ = await next(isolation: isolation) {} } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline internal mutating func awaitAllRemainingTasks() async @_alwaysEmitIntoClient public mutating func waitForAll(isolation: isolated (any _Concurrency.Actor)? = #isolation) async { await awaitAllRemainingTasks(isolation: isolation) } public var isEmpty: Swift.Bool { get } public func cancelAll() public var isCancelled: Swift.Bool { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, unavailable) extension _Concurrency.TaskGroup : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @frozen public struct ThrowingTaskGroup where ChildTaskResult : Swift.Sendable, Failure : Swift.Error { @usableFromInline internal let _group: Builtin.RawPointer @inlinable internal init(group: Builtin.RawPointer) { self._group = group } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @usableFromInline internal mutating func awaitAllRemainingTasks(isolation: isolated (any _Concurrency.Actor)? = #isolation) async { while true { do { guard let _ = try await next(isolation: isolation) else { return } } catch {} } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline internal mutating func awaitAllRemainingTasks() async @usableFromInline internal mutating func _waitForAll() async throws @_alwaysEmitIntoClient public mutating func waitForAll(isolation: isolated (any _Concurrency.Actor)? = #isolation) async throws { var firstError: Error? = nil while !isEmpty { do { while let _ = try await next() {} } catch { if firstError == nil { firstError = error } } } if let firstError { throw firstError } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) public mutating func next(isolation: isolated (any _Concurrency.Actor)? = #isolation) async throws -> ChildTaskResult? { return try await _taskGroupWaitNext(group: _group) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_disfavoredOverload public mutating func next() async throws -> ChildTaskResult? @_silgen_name("$sScg10nextResults0B0Oyxq_GSgyYaKF") @usableFromInline internal mutating func nextResultForABI() async throws -> Swift.Result? @_alwaysEmitIntoClient public mutating func nextResult(isolation: isolated (any _Concurrency.Actor)? = #isolation) async -> Swift.Result? { return try! await nextResultForABI() } public var isEmpty: Swift.Bool { get } public func cancelAll() public var isCancelled: Swift.Bool { get } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, unavailable) extension _Concurrency.ThrowingTaskGroup : Swift.Sendable { } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup : _Concurrency.AsyncSequence { public typealias AsyncIterator = _Concurrency.TaskGroup.Iterator public typealias Element = ChildTaskResult public func makeAsyncIterator() -> _Concurrency.TaskGroup.Iterator @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct Iterator : _Concurrency.AsyncIteratorProtocol { public typealias Element = ChildTaskResult @usableFromInline internal var group: _Concurrency.TaskGroup @usableFromInline internal var finished: Swift.Bool public mutating func next() async -> _Concurrency.TaskGroup.Iterator.Element? @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async -> _Concurrency.TaskGroup.Iterator.Element? public mutating func cancel() @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = Swift.Never } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = Swift.Never } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup : _Concurrency.AsyncSequence { public typealias AsyncIterator = _Concurrency.ThrowingTaskGroup.Iterator public typealias Element = ChildTaskResult public func makeAsyncIterator() -> _Concurrency.ThrowingTaskGroup.Iterator @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) public struct Iterator : _Concurrency.AsyncIteratorProtocol { public typealias Element = ChildTaskResult @usableFromInline internal var group: _Concurrency.ThrowingTaskGroup @usableFromInline internal var finished: Swift.Bool public mutating func next() async throws -> _Concurrency.ThrowingTaskGroup.Iterator.Element? @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) public mutating func next(isolation actor: isolated (any _Concurrency.Actor)?) async throws(Failure) -> _Concurrency.ThrowingTaskGroup.Iterator.Element? public mutating func cancel() @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncIteratorProtocol, Failure) public typealias __AsyncIteratorProtocol_Failure = Failure } @available(iOS 18.0, tvOS 18.0, watchOS 11.0, visionOS 2.0, macOS 15.0, *) @_implements(_Concurrency.AsyncSequence, Failure) public typealias __AsyncSequence_Failure = Failure } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_taskGroup_addPending") @usableFromInline internal func _taskGroupAddPendingTask(group: Builtin.RawPointer, unconditionally: Swift.Bool) -> Swift.Bool @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("swift_taskGroup_wait_next_throwing") public func _taskGroupWaitNext(group: Builtin.RawPointer) async throws -> T? @available(macOS 13.3, iOS 16.4, watchOS 9.4, tvOS 16.4, *) @_alwaysEmitIntoClient internal func taskGroupCreateFlags(discardResults: Swift.Bool) -> Swift.Int { var bits = 0 if discardResults { bits |= 1 << 8 } return bits } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @attached(accessor) @attached(peer, names: prefixed(`$`)) public macro TaskLocal() = #externalMacro(module: "SwiftMacros", type: "TaskLocalMacro") @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) final public class TaskLocal : Swift.Sendable, Swift.CustomStringConvertible where Value : Swift.Sendable { public init(wrappedValue defaultValue: Value) @_alwaysEmitIntoClient final internal var key: Builtin.RawPointer { get { unsafeBitCast(self, to: Builtin.RawPointer.self) } } final public func get() -> Value @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @discardableResult @inlinable final public func withValue(_ valueDuringOperation: Value, operation: () async throws -> R, isolation: isolated (any _Concurrency.Actor)? = #isolation, file: Swift.String = #fileID, line: Swift.UInt = #line) async rethrows -> R { return try await withValueImpl( valueDuringOperation, operation: operation, isolation: isolation, file: file, line: line) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @discardableResult @_silgen_name("$ss9TaskLocalC9withValue_9operation4file4lineqd__x_qd__yYaKXESSSutYaKlF") @_unsafeInheritExecutor final public func _unsafeInheritExecutor_withValue(_ valueDuringOperation: Value, operation: () async throws -> R, file: Swift.String = #fileID, line: Swift.UInt = #line) async rethrows -> R @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @backDeployed(before: macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0) @discardableResult @inlinable final internal func withValueImpl(_ valueDuringOperation: __owned Value, operation: () async throws -> R, isolation: isolated (any _Concurrency.Actor)?, file: Swift.String = #fileID, line: Swift.UInt = #line) async rethrows -> R { #if $BuiltinConcurrencyStackNesting Builtin.taskLocalValuePush(key, consume valueDuringOperation) defer { Builtin.taskLocalValuePop() } #else _taskLocalValuePush(key: key, value: consume valueDuringOperation) defer { _taskLocalValuePop() } #endif return try await operation() } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_silgen_name("$ss9TaskLocalC13withValueImpl_9operation4file4lineqd__xn_qd__yYaKXESSSutYaKlF") @discardableResult @inlinable @_unsafeInheritExecutor final internal func _unsafeInheritExecutor_withValueImpl(_ valueDuringOperation: __owned Value, operation: () async throws -> R, file: Swift.String = #fileID, line: Swift.UInt = #line) async rethrows -> R { #if $BuiltinConcurrencyStackNesting Builtin.taskLocalValuePush(key, consume valueDuringOperation) defer { Builtin.taskLocalValuePop() } #else _taskLocalValuePush(key: key, value: consume valueDuringOperation) defer { _taskLocalValuePop() } #endif return try await operation() } @discardableResult @inlinable final public func withValue(_ valueDuringOperation: Value, operation: () throws -> R, file: Swift.String = #fileID, line: Swift.UInt = #line) rethrows -> R { #if $BuiltinConcurrencyStackNesting Builtin.taskLocalValuePush(key, valueDuringOperation) defer { Builtin.taskLocalValuePop() } #else _taskLocalValuePush(key: key, value: valueDuringOperation) defer { _taskLocalValuePop() } #endif return try operation() } final public var projectedValue: _Concurrency.TaskLocal { get @available(*, unavailable, message: "use '$myTaskLocal.withValue(_:do:)' instead") set } @available(*, unavailable, message: "property wrappers cannot be instance members") public static subscript(_enclosingInstance object: Swift.Never, wrapped wrappedKeyPath: Swift.ReferenceWritableKeyPath, storage storageKeyPath: Swift.ReferenceWritableKeyPath>) -> Value { get } final public var wrappedValue: Value { get } final public var description: Swift.String { get } @objc deinit } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_localValuePush") internal func _taskLocalValuePush(key: Builtin.RawPointer, value: __owned Value) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @_silgen_name("swift_task_localValuePop") internal func _taskLocalValuePop() @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @available(*, deprecated, message: "The situation diagnosed by this is not handled gracefully rather than by crashing") internal func _checkIllegalTaskLocalBindingWithinWithTaskGroup(file: Swift.String, line: Swift.UInt) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @usableFromInline @available(*, deprecated, message: "The situation diagnosed by this is not handled gracefully rather than by crashing") @_silgen_name("swift_task_reportIllegalTaskLocalBindingWithinWithTaskGroup") internal func _reportIllegalTaskLocalBindingWithinWithTaskGroup(_ _filenameStart: Swift.UnsafePointer, _ _filenameLength: Swift.Int, _ _filenameIsASCII: Swift.Bool, _ _line: Swift.UInt) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(*, deprecated, renamed: "Task.sleep(nanoseconds:)") public static func sleep(_ duration: Swift.UInt64) async public static func sleep(nanoseconds duration: Swift.UInt64) async throws } @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) extension _Concurrency.Task where Success == Swift.Never, Failure == Swift.Never { @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) public static func sleep(until deadline: C.Instant, tolerance: C.Instant.Duration? = nil, clock: C = .continuous) async throws where C : _Concurrency.Clock @available(macOS 13.0, iOS 16.0, watchOS 9.0, tvOS 16.0, *) @_alwaysEmitIntoClient public static func sleep(for duration: C.Instant.Duration, tolerance: C.Instant.Duration? = nil, clock: C = .continuous) async throws where C : _Concurrency.Clock { try await clock.sleep(for: duration, tolerance: tolerance) } } extension _Concurrency.Task where Failure == Swift.Never { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @discardableResult @_alwaysEmitIntoClient public init(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async -> Success) { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } self._task = task! } } extension _Concurrency.Task where Failure == any Swift.Error { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @discardableResult @_alwaysEmitIntoClient public init(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async throws -> Success) { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } self._task = task! } } extension _Concurrency.Task where Failure == Swift.Never { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @discardableResult @_alwaysEmitIntoClient public static func detached(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } } extension _Concurrency.Task where Failure == any Swift.Error { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @discardableResult @_alwaysEmitIntoClient public static func detached(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } } extension _Concurrency.Task where Failure == Swift.Never { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @discardableResult @_alwaysEmitIntoClient public init(name: Swift.String? = nil, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping () async -> Success) { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, operation: operation).0 } self._task = task! } } extension _Concurrency.Task where Failure == any Swift.Error { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @discardableResult @_alwaysEmitIntoClient public init(name: Swift.String? = nil, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping () async throws -> Success) { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, operation: operation).0 } self._task = task! } } extension _Concurrency.Task where Failure == Swift.Never { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @discardableResult @_alwaysEmitIntoClient public static func detached(name: Swift.String? = nil, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping () async -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, operation: operation).0 } return Task(task!) } } extension _Concurrency.Task where Failure == any Swift.Error { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @discardableResult @_alwaysEmitIntoClient public static func detached(name: Swift.String? = nil, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping () async throws -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, operation: operation).0 } return Task(task!) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`detach` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func detach(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`detach` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func detach(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async throws -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } extension _Concurrency.Task where Failure == Swift.Never { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`Task.runDetached` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public static func runDetached(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } } extension _Concurrency.Task where Failure == any Swift.Error { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`Task.runDetached` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public static func runDetached(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async throws -> Success) -> _Concurrency.Task { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`asyncDetached` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func asyncDetached(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`asyncDetached` was replaced by `Task.detached` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func asyncDetached(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async throws -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`async` was replaced by `Task.init` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func async(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @available(*, deprecated, message: "`async` was replaced by `Task.init` and will be removed shortly.") @discardableResult @_alwaysEmitIntoClient public func async(priority: _Concurrency.TaskPriority? = nil, @_inheritActorContext @_implicitSelfCapture operation: __owned @escaping @isolated(any) @Sendable () async throws -> Success) -> _Concurrency.Task where Success : Swift.Sendable { let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } return Task(task!) } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.TaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.TaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTask(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(name: Swift.String?, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.TaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.TaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTask(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(executorPreference taskExecutor: (any _Concurrency.TaskExecutor)? = nil, priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTask(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTask(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTask(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTask(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") } } @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) @_alwaysEmitIntoClient public mutating func addTaskUnlessCancelled(priority: _Concurrency.TaskPriority? = nil, operation: sending @escaping @isolated(any) () async throws -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: true, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: false ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") return true } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task where Failure == any Swift.Error { #if compiler(>=5.3) && $AlwaysInheritActorContext @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @discardableResult @_alwaysEmitIntoClient public static func immediate(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_implicitSelfCapture @_inheritActorContext(always) operation: sending @escaping @isolated(any) () async throws -> Success) -> _Concurrency.Task { let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor let flagsMustNotCrash: UInt64 = 0 let canRunSynchronously: Bool = if let builtinSerialExecutor { _taskIsCurrentExecutor(executor: builtinSerialExecutor, flags: flagsMustNotCrash) } else { true } let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: !canRunSynchronously, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } if canRunSynchronously { _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } return Task(task!) } #endif } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task where Failure == Swift.Never { #if compiler(>=5.3) && $AlwaysInheritActorContext @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @discardableResult @_alwaysEmitIntoClient public static func immediate(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_implicitSelfCapture @_inheritActorContext(always) operation: sending @escaping @isolated(any) () async -> Success) -> _Concurrency.Task { let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor let flagsMustNotCrash: UInt64 = 0 let canRunSynchronously: Bool = if let builtinSerialExecutor { _taskIsCurrentExecutor(executor: builtinSerialExecutor, flags: flagsMustNotCrash) } else { true } let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: true, inheritContext: true, enqueueJob: !canRunSynchronously, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } if canRunSynchronously { _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } return Task(task!) } #endif } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task where Failure == any Swift.Error { #if compiler(>=5.3) && $AlwaysInheritActorContext @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @discardableResult @_alwaysEmitIntoClient public static func immediateDetached(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_implicitSelfCapture @_inheritActorContext(always) operation: sending @escaping @isolated(any) () async throws -> Success) -> _Concurrency.Task { let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor let flagsMustNotCrash: UInt64 = 0 let canRunSynchronously: Bool = if let builtinSerialExecutor { _taskIsCurrentExecutor(executor: builtinSerialExecutor, flags: flagsMustNotCrash) } else { true } let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: !canRunSynchronously, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } if canRunSynchronously { _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } return Task(task!) } #endif } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.Task where Failure == Swift.Never { #if compiler(>=5.3) && $AlwaysInheritActorContext @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @discardableResult @_alwaysEmitIntoClient public static func immediateDetached(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_implicitSelfCapture @_inheritActorContext(always) operation: sending @escaping @isolated(any) () async -> Success) -> _Concurrency.Task { let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor let flagsMustNotCrash: UInt64 = 0 let canRunSynchronously: Bool = if let builtinSerialExecutor { _taskIsCurrentExecutor(executor: builtinSerialExecutor, flags: flagsMustNotCrash) } else { true } let flags = taskCreateFlags( priority: priority, isChildTask: false, copyTaskLocals: false , inheritContext: false , enqueueJob: !canRunSynchronously, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #else task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } #endif } #endif if task == nil { assert(name == nil) #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, operation: operation).0 } if canRunSynchronously { _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } return Task(task!) } #endif } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.TaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTask(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.TaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTaskUnlessCancelled(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) return true } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTask(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: true, isDiscardingTask: false, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.ThrowingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTaskUnlessCancelled(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async throws -> ChildTaskResult) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: false, isDiscardingTask: false, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) return true } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTask(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.DiscardingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTaskUnlessCancelled(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) return true } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTask(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async throws -> Swift.Void) { let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: true, isDiscardingTask: true, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup { @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_alwaysEmitIntoClient public mutating func addImmediateTaskUnlessCancelled(name: Swift.String? = nil, priority: _Concurrency.TaskPriority? = nil, executorPreference taskExecutor: consuming (any _Concurrency.TaskExecutor)? = nil, @_inheritActorContext @_implicitSelfCapture operation: sending @escaping @isolated(any) () async throws -> Swift.Void) -> Swift.Bool { let canAdd = _taskGroupAddPendingTask(group: _group, unconditionally: false) guard canAdd else { return false } let flags = taskCreateFlags( priority: priority, isChildTask: true, copyTaskLocals: false, inheritContext: false, enqueueJob: false, addPendingGroupTaskUnconditionally: false, isDiscardingTask: true, isSynchronousStart: true ) let builtinSerialExecutor = Builtin.extractFunctionIsolation(operation)?.unownedExecutor.executor var task: Builtin.NativeObject? #if $BuiltinCreateAsyncTaskName if let name { task = name.utf8CString.withUnsafeBufferPointer { nameBytes in Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, taskName: nameBytes.baseAddress!._rawValue, operation: operation).0 } } #endif if task == nil, let taskExecutor { #if $BuiltinCreateAsyncTaskOwnedTaskExecutor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutorConsuming: taskExecutor, operation: operation).0 #else let executorBuiltin: Builtin.Executor = taskExecutor.asUnownedTaskExecutor().executor task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, initialTaskExecutor: executorBuiltin, operation: operation).0 #endif } if task == nil { task = Builtin.createDiscardingTask( flags: flags, initialSerialExecutor: builtinSerialExecutor, taskGroup: _group, operation: operation).0 } assert(task != nil, "Expected task to be created!") _startTaskImmediately(task!, targetExecutor: builtinSerialExecutor) return true } } @available(macOS 26.0, iOS 26.0, watchOS 26.0, tvOS 26.0, visionOS 26.0, *) @_silgen_name("swift_task_immediate") @usableFromInline internal func _startTaskImmediately(_ task: Builtin.NativeObject, targetExecutor: Builtin.Executor?) @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream.Continuation.Termination : Swift.Equatable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.AsyncStream.Continuation.Termination : Swift.Hashable {} @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.DiscardingTaskGroup : Swift.BitwiseCopyable {} @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.ThrowingDiscardingTaskGroup : Swift.BitwiseCopyable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnownedSerialExecutor : Swift.BitwiseCopyable {} @available(macOS 15.0, iOS 18.0, watchOS 11.0, tvOS 18.0, visionOS 2.0, *) extension _Concurrency.UnownedTaskExecutor : Swift.BitwiseCopyable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnownedJob : Swift.BitwiseCopyable {} @available(macOS 14.0, iOS 17.0, watchOS 10.0, tvOS 17.0, *) extension _Concurrency.JobPriority : Swift.BitwiseCopyable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.UnsafeContinuation : Swift.BitwiseCopyable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.TaskGroup : Swift.BitwiseCopyable {} @available(macOS 10.15, iOS 13.0, watchOS 6.0, tvOS 13.0, *) extension _Concurrency.ThrowingTaskGroup : Swift.BitwiseCopyable {}