Update AsyncProcess with bug fixes

Package.swift

@@ -76,9 +76,22 @@ let package = Package(
       ]
     ),
     .systemLibrary(name: "SystemSQLite", pkgConfig: "sqlite3"),
+
+    // `AsyncProcess` modules and dependencies
+
+    .target(name: "CProcessSpawnSync"),
+    .target(
+      name: "ProcessSpawnSync",
+      dependencies: [
+        "CProcessSpawnSync",
+        .product(name: "Atomics", package: "swift-atomics"),
+        .product(name: "NIOConcurrencyHelpers", package: "swift-nio"),
+      ]
+    ),
     .target(
       name: "AsyncProcess",
       dependencies: [
+        "ProcessSpawnSync",
         .product(name: "Atomics", package: "swift-atomics"),
         .product(name: "AsyncAlgorithms", package: "swift-async-algorithms"),
         .product(name: "Logging", package: "swift-log"),

Sources/AsyncProcess/ChunkSequence.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -33,17 +33,17 @@ public struct ChunkSequence: AsyncSequence & Sendable {
 
   public func makeAsyncIterator() -> AsyncIterator {
     // This will close the file handle.
-    AsyncIterator(try! self.fileHandle?.fileContentStream(eventLoop: self.group.any()))
+    return AsyncIterator(try! self.fileHandle?.fileContentStream(eventLoop: group.any()))
   }
 
   public typealias Element = ByteBuffer
   public struct AsyncIterator: AsyncIteratorProtocol {
     public typealias Element = ByteBuffer
-    typealias UnderlyingSequence = FileContentStream
+    internal typealias UnderlyingSequence = FileContentStream
 
     private var underlyingIterator: UnderlyingSequence.AsyncIterator?
 
-    init(_ underlyingSequence: UnderlyingSequence?) {
+    internal init(_ underlyingSequence: UnderlyingSequence?) {
       self.underlyingIterator = underlyingSequence?.makeAsyncIterator()
     }
 

Sources/AsyncProcess/EOFSequence.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -15,13 +15,13 @@ public struct EOFSequence<Element>: AsyncSequence & Sendable {
 
   public struct AsyncIterator: AsyncIteratorProtocol {
     public mutating func next() async throws -> Element? {
-      nil
+      return nil
     }
   }
 
   public init(of type: Element.Type = Element.self) {}
 
   public func makeAsyncIterator() -> AsyncIterator {
-    AsyncIterator()
+    return AsyncIterator()
   }
 }

Sources/AsyncProcess/FileContentStream.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information
@@ -19,12 +19,13 @@ import NIO
 // - Known issues:
 //   - no tests
 //   - most configurations have never run
-struct FileContentStream: AsyncSequence {
+internal typealias FileContentStream = _FileContentStream
+public struct _FileContentStream: AsyncSequence & Sendable {
   public typealias Element = ByteBuffer
   typealias Underlying = AsyncThrowingChannel<Element, Error>
 
   public func makeAsyncIterator() -> AsyncIterator {
-    AsyncIterator(underlying: self.asyncChannel.makeAsyncIterator())
+    return AsyncIterator(underlying: self.asyncChannel.makeAsyncIterator())
   }
 
   public struct AsyncIterator: AsyncIteratorProtocol {
@@ -33,21 +34,31 @@ struct FileContentStream: AsyncSequence {
     var underlying: Underlying.AsyncIterator
 
     public mutating func next() async throws -> ByteBuffer? {
-      try await self.underlying.next()
+      return try await self.underlying.next()
     }
   }
 
   public struct IOError: Error {
     public var errnoValue: CInt
 
     public static func makeFromErrnoGlobal() -> IOError {
-      IOError(errnoValue: errno)
+      return IOError(errnoValue: errno)
     }
   }
 
   private let asyncChannel: AsyncThrowingChannel<ByteBuffer, Error>
 
-  public init(
+  public static func makeReader(
+    fileDescriptor: CInt,
+    eventLoop: EventLoop = MultiThreadedEventLoopGroup.singleton.any(),
+    blockingPool: NIOThreadPool = .singleton
+  ) async throws -> _FileContentStream {
+    return try await eventLoop.submit {
+      try FileContentStream(fileDescriptor: fileDescriptor, eventLoop: eventLoop, blockingPool: blockingPool)
+    }.get()
+  }
+
+  internal init(
     fileDescriptor: CInt,
     eventLoop: EventLoop,
     blockingPool: NIOThreadPool? = nil
@@ -64,7 +75,7 @@ struct FileContentStream: AsyncSequence {
 
     switch statInfo.st_mode & S_IFMT {
     case S_IFREG:
-      guard let blockingPool else {
+      guard let blockingPool = blockingPool else {
         throw IOError(errnoValue: EINVAL)
       }
       let fileHandle = NIOLoopBound(
@@ -86,7 +97,7 @@ struct FileContentStream: AsyncSequence {
         .whenComplete { result in
           try! fileHandle.value.close()
           switch result {
-          case let .failure(error):
+          case .failure(let error):
             asyncChannel.fail(error)
           case .success:
             asyncChannel.finish()
@@ -140,7 +151,7 @@ private final class ReadIntoAsyncChannelHandler: ChannelDuplexHandler {
         return data
       case .error:
         return nil
-      case var .sending(queue):
+      case .sending(var queue):
         queue.append(data)
         self = .sending(queue)
         return nil
@@ -153,7 +164,7 @@ private final class ReadIntoAsyncChannelHandler: ChannelDuplexHandler {
         preconditionFailure("didSendOne during .idle")
       case .error:
         return nil
-      case var .sending(queue):
+      case .sending(var queue):
         if queue.isEmpty {
           self = .idle
           return nil
@@ -212,7 +223,7 @@ private final class ReadIntoAsyncChannelHandler: ChannelDuplexHandler {
     eventLoop.makeFutureWithTask {
       // note: We're _not_ on an EventLoop thread here
       switch data {
-      case let .chunk(data):
+      case .chunk(let data):
         await sink.send(data)
       case .finish:
         sink.finish()
@@ -255,18 +266,15 @@ private final class ReadIntoAsyncChannelHandler: ChannelDuplexHandler {
 
 extension FileHandle {
   func fileContentStream(eventLoop: EventLoop) throws -> FileContentStream {
-    let asyncBytes = try FileContentStream(
-      fileDescriptor: self.fileDescriptor,
-      eventLoop: eventLoop
-    )
+    let asyncBytes = try FileContentStream(fileDescriptor: self.fileDescriptor, eventLoop: eventLoop)
     try self.close()
     return asyncBytes
   }
 }
 
 extension FileContentStream {
   var lines: AsyncByteBufferLineSequence<FileContentStream> {
-    AsyncByteBufferLineSequence(
+    return AsyncByteBufferLineSequence(
       self,
       dropTerminator: true,
       maximumAllowableBufferSize: 1024 * 1024,
@@ -281,7 +289,7 @@ extension AsyncSequence where Element == ByteBuffer, Self: Sendable {
     maximumAllowableBufferSize: Int = 1024 * 1024,
     dropLastChunkIfNoNewline: Bool = false
   ) -> AsyncByteBufferLineSequence<Self> {
-    AsyncByteBufferLineSequence(
+    return AsyncByteBufferLineSequence(
       self,
       dropTerminator: dropTerminator,
       maximumAllowableBufferSize: maximumAllowableBufferSize,
@@ -290,7 +298,7 @@ extension AsyncSequence where Element == ByteBuffer, Self: Sendable {
   }
 
   public var strings: AsyncMapSequence<Self, String> {
-    self.map { String(buffer: $0) }
+    return self.map { String(buffer: $0) }
   }
 }
 
@@ -312,28 +320,26 @@ where Base: AsyncSequence, Base.Element == ByteBuffer {
 
     struct Buffer {
       private var buffer: [ByteBuffer] = []
-      private(set) var byteCount: Int = 0
+      internal private(set) var byteCount: Int = 0
 
       mutating func append(_ buffer: ByteBuffer) {
         self.buffer.append(buffer)
         self.byteCount += buffer.readableBytes
       }
 
       func allButLast() -> ArraySlice<ByteBuffer> {
-        self.buffer.dropLast()
+        return self.buffer.dropLast()
       }
 
       var byteCountButLast: Int {
-        self.byteCount - (self.buffer.last?.readableBytes ?? 0)
+        return self.byteCount - (self.buffer.last?.readableBytes ?? 0)
       }
 
       var lastChunkView: ByteBufferView? {
-        self.buffer.last?.readableBytesView
+        return self.buffer.last?.readableBytesView
       }
 
-      mutating func concatenateEverything(upToLastChunkLengthToConsume lastLength: Int)
-        -> ByteBuffer
-      {
+      mutating func concatenateEverything(upToLastChunkLengthToConsume lastLength: Int) -> ByteBuffer {
         var output = ByteBuffer()
         output.reserveCapacity(lastLength + self.byteCountButLast)
 
@@ -359,7 +365,7 @@ where Base: AsyncSequence, Base.Element == ByteBuffer {
       }
     }
 
-    init(
+    internal init(
       underlying: Base.AsyncIterator,
       dropTerminator: Bool,
       maximumAllowableBufferSize: Int,
@@ -446,7 +452,7 @@ where Base: AsyncSequence, Base.Element == ByteBuffer {
   }
 
   public func makeAsyncIterator() -> AsyncIterator {
-    AsyncIterator(
+    return AsyncIterator(
       underlying: self.underlying.makeAsyncIterator(),
       dropTerminator: self.dropTerminator,
       maximumAllowableBufferSize: self.maximumAllowableBufferSize,

Sources/AsyncProcess/NIOAsyncPipeWriter.swift

@@ -2,7 +2,7 @@
 //
 // This source file is part of the Swift open source project
 //
-// Copyright (c) 2022-2023 Apple Inc. and the Swift project authors
+// Copyright (c) 2022-2025 Apple Inc. and the Swift project authors
 // Licensed under Apache License v2.0 with Runtime Library Exception
 //
 // See https://swift.org/LICENSE.txt for license information