Split CreatedPipe to InputPipe and OutputPipe to avoid runtime casting

Author: iCharlesHu

Sources/Subprocess/AsyncBufferSequence.swift

@@ -26,12 +26,12 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
     public struct Iterator: AsyncIteratorProtocol {
         public typealias Element = SequenceOutput.Buffer
 
-        private let diskIO: DiskIO
+        private let diskIO: TrackedPlatformDiskIO
         private var buffer: [UInt8]
         private var currentPosition: Int
         private var finished: Bool
 
-        internal init(diskIO: DiskIO) {
+        internal init(diskIO: TrackedPlatformDiskIO) {
             self.diskIO = diskIO
             self.buffer = []
             self.currentPosition = 0
@@ -51,9 +51,9 @@ public struct AsyncBufferSequence: AsyncSequence, Sendable {
         }
     }
 
-    private let diskIO: DiskIO
+    private let diskIO: TrackedPlatformDiskIO
 
-    internal init(diskIO: DiskIO) {
+    internal init(diskIO: TrackedPlatformDiskIO) {
         self.diskIO = diskIO
     }
 

Sources/Subprocess/Configuration.swift

@@ -101,7 +101,7 @@ public struct Configuration: Sendable {
             // Body runs in the same isolation
             let result = try await body(
                 execution,
-                .init(fileDescriptor: execution.inputPipe.writeFileDescriptor!)
+                .init(diskIO: execution.inputPipe.writeEnd!)
             )
             return ExecutionResult(
                 terminationStatus: try await waitingStatus,
@@ -165,7 +165,7 @@ public struct Configuration: Sendable {
                 standardError
             ) = try await execution.captureIOs()
             // Write input in the same scope
-            guard let writeFd = execution.inputPipe.writeFileDescriptor else {
+            guard let writeFd = execution.inputPipe.writeEnd else {
                 fatalError("Trying to write to an input that has been closed")
             }
             try await withCheckedThrowingContinuation { (continuation: CheckedContinuation<Void, any Swift.Error>) in
@@ -256,8 +256,8 @@ public struct Configuration: Sendable {
                 returning: ExecutionResult.self
             ) { group in
                 group.addTask {
-                    if let writeFd = execution.inputPipe.writeFileDescriptor {
-                        let writer = StandardInputWriter(fileDescriptor: writeFd)
+                    if let writeFd = execution.inputPipe.writeEnd {
+                        let writer = StandardInputWriter(diskIO: writeFd)
                         try await input.write(with: writer)
                         try await writer.finish()
                     }
@@ -363,25 +363,25 @@ extension Configuration {
 
         if childSide {
             inputError = captureError {
-                try execution.inputPipe.readFileDescriptor?.safelyClose()
+                try execution.inputPipe.readEnd?.safelyClose()
             }
             outputError = captureError {
-                try execution.outputPipe.writeFileDescriptor?.safelyClose()
+                try execution.outputPipe.writeEnd?.safelyClose()
             }
             errorError = captureError {
-                try execution.errorPipe.writeFileDescriptor?.safelyClose()
+                try execution.errorPipe.writeEnd?.safelyClose()
             }
         }
 
         if parentSide {
             inputError = captureError {
-                try execution.inputPipe.writeFileDescriptor?.safelyClose()
+                try execution.inputPipe.writeEnd?.safelyClose()
             }
             outputError = captureError {
-                try execution.outputPipe.readFileDescriptor?.safelyClose()
+                try execution.outputPipe.readEnd?.safelyClose()
             }
             errorError = captureError {
-                try execution.errorPipe.readFileDescriptor?.safelyClose()
+                try execution.errorPipe.readEnd?.safelyClose()
             }
         }
 
@@ -802,50 +802,26 @@ internal enum StringOrRawBytes: Sendable, Hashable {
 }
 
 /// A wrapped `FileDescriptor` or `DispatchIO` and
-/// whether it should beeddsw closed automactially when done.
-internal struct DiskIO {
-    internal enum Storage {
-        case fileDescriptor(FileDescriptor)
-        #if !os(Windows) // Darwin and Linux
-        case dispatchIO(DispatchIO)
-        #endif
-    }
-
+/// whether it should be closed automactially when done.
+internal struct TrackedFileDescriptor {
     internal let closeWhenDone: Bool
-    internal let storage: Storage
+    internal let fileDescriptor: FileDescriptor
 
     internal init(
         _ fileDescriptor: FileDescriptor,
         closeWhenDone: Bool
     ) {
-        self.storage = .fileDescriptor(fileDescriptor)
-        self.closeWhenDone = closeWhenDone
-    }
-
-    #if !os(Windows)
-    internal init(
-        _ dispatchIO: DispatchIO,
-        closeWhenDone: Bool
-    ) {
-        self.storage = .dispatchIO(dispatchIO)
+        self.fileDescriptor = fileDescriptor
         self.closeWhenDone = closeWhenDone
     }
-    #endif
 
     internal func safelyClose() throws {
         guard self.closeWhenDone else {
             return
         }
 
         do {
-            switch self.storage {
-            case .fileDescriptor(let fileDescriptor):
-                try fileDescriptor.close()
-            #if !os(Windows)
-            case .dispatchIO(let dispatchIO):
-                dispatchIO.close()
-            #endif
-            }
+            try fileDescriptor.close()
         } catch {
             guard let errno: Errno = error as? Errno else {
                 throw error
@@ -857,38 +833,50 @@ internal struct DiskIO {
     }
 
     internal var platformDescriptor: PlatformFileDescriptor {
-        switch self.storage {
-        case .fileDescriptor(let fileDescriptor):
-            return fileDescriptor.platformDescriptor
-        #if !os(Windows)
-        case .dispatchIO(let dispatchIO):
-            return dispatchIO.fileDescriptor
-        #endif // !os(Windows)
-        }
+        return self.fileDescriptor.platformDescriptor
     }
 }
 
-internal struct CreatedPipe {
-    internal enum PipeEnd {
-        case readEnd
-        case writeEnd
+#if !os(Windows)
+internal struct TrackedDispatchIO {
+    internal let closeWhenDone: Bool
+    internal let dispatchIO: DispatchIO
+
+    internal init(
+        _ dispatchIO: DispatchIO,
+        closeWhenDone: Bool
+    ) {
+        self.dispatchIO = dispatchIO
+        self.closeWhenDone = closeWhenDone
     }
 
-    internal let readFileDescriptor: DiskIO?
-    internal let writeFileDescriptor: DiskIO?
-    internal let parentEnd: PipeEnd
+    internal func safelyClose() throws {
+        guard self.closeWhenDone else {
+            return
+        }
+
+        dispatchIO.close()
+    }
+
+    internal var platformDescriptor: PlatformFileDescriptor {
+        return self.dispatchIO.fileDescriptor
+    }
+}
+#endif
+
+internal struct CreatedPipe {
+    internal let readFileDescriptor: TrackedFileDescriptor?
+    internal let writeFileDescriptor: TrackedFileDescriptor?
 
     internal init(
-        readFileDescriptor: DiskIO?,
-        writeFileDescriptor: DiskIO?,
-        parentEnd: PipeEnd
+        readFileDescriptor: TrackedFileDescriptor?,
+        writeFileDescriptor: TrackedFileDescriptor?,
     ) {
         self.readFileDescriptor = readFileDescriptor
         self.writeFileDescriptor = writeFileDescriptor
-        self.parentEnd = parentEnd
     }
 
-    internal init(closeWhenDone: Bool, parentEnd: PipeEnd) throws {
+    internal init(closeWhenDone: Bool) throws {
         let pipe = try FileDescriptor.ssp_pipe()
         self.readFileDescriptor = .init(
             pipe.readEnd,
@@ -898,7 +886,6 @@ internal struct CreatedPipe {
             pipe.writeEnd,
             closeWhenDone: closeWhenDone
         )
-        self.parentEnd = parentEnd
     }
 }
 

Sources/Subprocess/Execution.swift

@@ -42,9 +42,9 @@ public final class Execution<
 
     internal let output: Output
     internal let error: Error
-    internal let inputPipe: CreatedPipe
-    internal let outputPipe: CreatedPipe
-    internal let errorPipe: CreatedPipe
+    internal let inputPipe: InputPipe
+    internal let outputPipe: OutputPipe
+    internal let errorPipe: OutputPipe
     internal let outputConsumptionState: AtomicBox
 
     #if os(Windows)
@@ -54,9 +54,9 @@ public final class Execution<
         processIdentifier: ProcessIdentifier,
         output: Output,
         error: Error,
-        inputPipe: CreatedPipe,
-        outputPipe: CreatedPipe,
-        errorPipe: CreatedPipe,
+        inputPipe: InputPipe,
+        outputPipe: OutputPipe,
+        errorPipe: OutputPipe,
         consoleBehavior: PlatformOptions.ConsoleBehavior
     ) {
         self.processIdentifier = processIdentifier
@@ -73,9 +73,9 @@ public final class Execution<
         processIdentifier: ProcessIdentifier,
         output: Output,
         error: Error,
-        inputPipe: CreatedPipe,
-        outputPipe: CreatedPipe,
-        errorPipe: CreatedPipe
+        inputPipe: InputPipe,
+        outputPipe: OutputPipe,
+        errorPipe: OutputPipe
     ) {
         self.processIdentifier = processIdentifier
         self.output = output
@@ -103,7 +103,7 @@ extension Execution where Output == SequenceOutput {
         )
 
         guard consumptionState.contains(.standardOutputConsumed),
-            let readFd = self.outputPipe.readFileDescriptor
+            let readFd = self.outputPipe.readEnd
         else {
             fatalError("The standard output has already been consumed")
         }
@@ -126,7 +126,7 @@ extension Execution where Error == SequenceOutput {
         )
 
         guard consumptionState.contains(.standardErrorConsumed),
-            let readFd = self.errorPipe.readFileDescriptor
+            let readFd = self.errorPipe.readEnd
         else {
             fatalError("The standard output has already been consumed")
         }
@@ -170,13 +170,13 @@ extension Execution {
         ) { group in
             group.addTask {
                 let stdout = try await self.output.captureOutput(
-                    from: self.outputPipe.readFileDescriptor
+                    from: self.outputPipe.readEnd
                 )
                 return .standardOutputCaptured(stdout)
             }
             group.addTask {
                 let stderr = try await self.error.captureOutput(
-                    from: self.errorPipe.readFileDescriptor
+                    from: self.errorPipe.readEnd
                 )
                 return .standardErrorCaptured(stderr)
             }

Sources/Subprocess/IO/Input.swift

@@ -50,15 +50,13 @@ public struct NoInput: InputProtocol {
         // to signal no input
         return CreatedPipe(
             readFileDescriptor: nil,
-            writeFileDescriptor: nil,
-            parentEnd: .writeEnd
+            writeFileDescriptor: nil
         )
         #else
         let devnull: FileDescriptor = try .openDevNull(withAcessMode: .readOnly)
         return CreatedPipe(
             readFileDescriptor: .init(devnull, closeWhenDone: true),
-            writeFileDescriptor: nil,
-            parentEnd: .writeEnd
+            writeFileDescriptor: nil
         )
         #endif
     }
@@ -85,8 +83,7 @@ public struct FileDescriptorInput: InputProtocol {
                 self.fileDescriptor,
                 closeWhenDone: self.closeAfterSpawningProcess
             ),
-            writeFileDescriptor: nil,
-            parentEnd: .writeEnd
+            writeFileDescriptor: nil
         )
     }
 
@@ -206,7 +203,7 @@ extension InputProtocol {
             return try fdInput.createPipe()
         }
         // Base implementation
-        return try CreatedPipe(closeWhenDone: true, parentEnd: .writeEnd)
+        return try CreatedPipe(closeWhenDone: true)
     }
 }
 
@@ -215,10 +212,10 @@ extension InputProtocol {
 /// A writer that writes to the standard input of the subprocess.
 public final actor StandardInputWriter: Sendable {
 
-    internal let diskIO: DiskIO
+    internal let diskIO: TrackedPlatformDiskIO
 
-    init(fileDescriptor: DiskIO) {
-        self.diskIO = fileDescriptor
+    init(diskIO: TrackedPlatformDiskIO) {
+        self.diskIO = diskIO
     }
 
     /// Write an array of UInt8 to the standard input of the subprocess.
@@ -261,6 +258,23 @@ public final actor StandardInputWriter: Sendable {
     }
 }
 
+
+// MARK: - InputPipe
+internal struct InputPipe {
+    // On Darwin and Linux, parent end (write end) should be
+    // wrapped as `DispatchIO` for writing
+    internal let readEnd: TrackedFileDescriptor?
+    internal let writeEnd: TrackedPlatformDiskIO?
+
+    internal init(
+        readEnd: TrackedFileDescriptor?,
+        writeEnd: TrackedPlatformDiskIO?
+    ) {
+        self.readEnd = readEnd
+        self.writeEnd = writeEnd
+    }
+}
+
 extension StringProtocol {
     #if SubprocessFoundation
     private func convertEncoding<Encoding: Unicode.Encoding>(