Create platform specific AsyncIO

Sources/Subprocess/AsyncBufferSequence.swift

@@ -23,10 +23,10 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
     public typealias Failure = any Swift.Error
     public typealias Element = Buffer
 
-    #if os(Windows)
-    internal typealias DiskIO = FileDescriptor
-    #else
+    #if canImport(Darwin)
     internal typealias DiskIO = DispatchIO
+    #else
+    internal typealias DiskIO = FileDescriptor
     #endif
 
     @_nonSendable
@@ -47,15 +47,16 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
                 return self.buffer.removeFirst()
             }
             // Read more data
-            let data = try await self.diskIO.read(
-                upToLength: readBufferSize
+            let data = try await AsyncIO.shared.read(
+                from: self.diskIO,
+                upTo: readBufferSize
             )
             guard let data else {
                 // We finished reading. Close the file descriptor now
-                #if os(Windows)
-                try self.diskIO.close()
-                #else
+                #if canImport(Darwin)
                 self.diskIO.close()
+                #else
+                try self.diskIO.close()
                 #endif
                 return nil
             }
@@ -132,17 +133,7 @@ extension AsyncBufferSequence {
                         self.eofReached = true
                         return nil
                     }
-                    #if os(Windows)
-                    // Cast data to CodeUnit type
-                    let result = buffer.withUnsafeBytes { ptr in
-                        return Array(
-                            UnsafeBufferPointer<Encoding.CodeUnit>(
-                                start: ptr.bindMemory(to: Encoding.CodeUnit.self).baseAddress!,
-                                count: ptr.count / MemoryLayout<Encoding.CodeUnit>.size
-                            )
-                        )
-                    }
-                    #else
+                    #if canImport(Darwin)
                     // Unfortunately here we _have to_ copy the bytes out because
                     // DispatchIO (rightfully) reuses buffer, which means `buffer.data`
                     // has the same address on all iterations, therefore we can't directly
@@ -157,7 +148,13 @@ extension AsyncBufferSequence {
                             UnsafeBufferPointer(start: ptr.baseAddress?.assumingMemoryBound(to: Encoding.CodeUnit.self), count: elementCount)
                         )
                     }
-
+                    #else
+                    // Cast data to CodeUnitg type
+                    let result = buffer.withUnsafeBytes { ptr in
+                        return ptr.withMemoryRebound(to: Encoding.CodeUnit.self) { codeUnitPtr in
+                            return Array(codeUnitPtr)
+                        }
+                    }
                     #endif
                     return result.isEmpty ? nil : result
                 }

Sources/Subprocess/Buffer.swift

@@ -17,18 +17,8 @@
 extension AsyncBufferSequence {
     /// A immutable collection of bytes
     public struct Buffer: Sendable {
-        #if os(Windows)
-        internal let data: [UInt8]
-
-        internal init(data: [UInt8]) {
-            self.data = data
-        }
-
-        internal static func createFrom(_ data: [UInt8]) -> [Buffer] {
-            return [.init(data: data)]
-        }
-        #else
-        // We need to keep the backingData alive while _ContiguousBufferView is alive
+        #if canImport(Darwin)
+        // We need to keep the backingData alive while Slice is alive
         internal let backingData: DispatchData
         internal let data: DispatchData._ContiguousBufferView
 
@@ -45,7 +35,17 @@ extension AsyncBufferSequence {
             }
             return slices.map{ .init(data: $0, backingData: data) }
         }
-        #endif
+        #else
+        internal let data: [UInt8]
+
+        internal init(data: [UInt8]) {
+            self.data = data
+        }
+
+        internal static func createFrom(_ data: [UInt8]) -> [Buffer] {
+            return [.init(data: data)]
+        }
+        #endif // canImport(Darwin)
     }
 }
 
@@ -92,26 +92,23 @@ extension AsyncBufferSequence.Buffer {
 
 // MARK: - Hashable, Equatable
 extension AsyncBufferSequence.Buffer: Equatable, Hashable {
-    #if os(Windows)
-    // Compiler generated conformances
-    #else
+    #if canImport(Darwin)
     public static func == (lhs: AsyncBufferSequence.Buffer, rhs: AsyncBufferSequence.Buffer) -> Bool {
-        return lhs.data.elementsEqual(rhs.data)
+        return lhs.data == rhs.data
     }
 
     public func hash(into hasher: inout Hasher) {
-        self.data.withUnsafeBytes { ptr in
-            hasher.combine(bytes: ptr)
-        }
+        hasher.combine(self.data)
     }
     #endif
+    // else Compiler generated conformances
 }
 
 // MARK: - DispatchData.Block
 #if canImport(Darwin) || canImport(Glibc) || canImport(Android) || canImport(Musl)
 extension DispatchData {
     /// Unfortunately `DispatchData.Region` is not available on Linux, hence our own wrapper
-    internal struct _ContiguousBufferView: @unchecked Sendable, RandomAccessCollection {
+    internal struct _ContiguousBufferView: @unchecked Sendable, RandomAccessCollection, Hashable {
         typealias Element = UInt8
 
         internal let bytes: UnsafeBufferPointer<UInt8>
@@ -127,6 +124,14 @@ extension DispatchData {
             return try body(UnsafeRawBufferPointer(self.bytes))
         }
 
+        internal func hash(into hasher: inout Hasher) {
+            hasher.combine(bytes: UnsafeRawBufferPointer(self.bytes))
+        }
+
+        internal static func == (lhs: DispatchData._ContiguousBufferView, rhs: DispatchData._ContiguousBufferView) -> Bool {
+            return lhs.bytes.elementsEqual(rhs.bytes)
+        }
+
         subscript(position: Int) -> UInt8 {
             _read {
                 yield self.bytes[position]

Sources/Subprocess/CMakeLists.txt

@@ -17,6 +17,7 @@ target_sources(Subprocess PRIVATE
   Result.swift
   IO/Output.swift
   IO/Input.swift
+  IO/AsyncIO.swift
   Span+Subprocess.swift
   AsyncBufferSequence.swift
   API.swift

Sources/Subprocess/Configuration.swift

@@ -595,15 +595,13 @@ internal struct TrackedFileDescriptor: ~Copyable {
         self.closeWhenDone = closeWhenDone
     }
 
-    #if os(Windows)
     consuming func consumeDiskIO() -> FileDescriptor {
         let result = self.fileDescriptor
         // Transfer the ownership out and therefor
         // don't perform close on deinit
         self.closeWhenDone = false
         return result
     }
-    #endif
 
     internal mutating func safelyClose() throws {
         guard self.closeWhenDone else {

Sources/Subprocess/Error.swift

@@ -41,6 +41,7 @@ extension SubprocessError {
             case failedToWriteToSubprocess
             case failedToMonitorProcess
             case streamOutputExceedsLimit(Int)
+            case asyncIOFailed(String)
             // Signal
             case failedToSendSignal(Int32)
             // Windows Only
@@ -67,18 +68,20 @@ extension SubprocessError {
                 return 5
             case .streamOutputExceedsLimit(_):
                 return 6
-            case .failedToSendSignal(_):
+            case .asyncIOFailed(_):
                 return 7
-            case .failedToTerminate:
+            case .failedToSendSignal(_):
                 return 8
-            case .failedToSuspend:
+            case .failedToTerminate:
                 return 9
-            case .failedToResume:
+            case .failedToSuspend:
                 return 10
-            case .failedToCreatePipe:
+            case .failedToResume:
                 return 11
-            case .invalidWindowsPath(_):
+            case .failedToCreatePipe:
                 return 12
+            case .invalidWindowsPath(_):
+                return 13
             }
         }
 
@@ -108,6 +111,8 @@ extension SubprocessError: CustomStringConvertible, CustomDebugStringConvertible
             return "Failed to monitor the state of child process with underlying error: \(self.underlyingError!)"
         case .streamOutputExceedsLimit(let limit):
             return "Failed to create output from current buffer because the output limit (\(limit)) was reached."
+        case .asyncIOFailed(let reason):
+            return "An error occurred within the AsyncIO subsystem: \(reason). Underlying error: \(self.underlyingError!)"
         case .failedToSendSignal(let signal):
             return "Failed to send signal \(signal) to the child process."
         case .failedToTerminate: