Refactor captureOutput() to minimize force unwrap

Author: iCharlesHu

Sources/Subprocess/IO/AsyncIO.swift

@@ -352,8 +352,14 @@ extension AsyncIO {
         )
         var readLength: Int = 0
         let signalStream = self.registerFileDescriptor(fileDescriptor, for: .read)
+        /// Outer loop: every iteration signals we are ready to read more data
         for try await _ in signalStream {
-            // Every iteration signals we are ready to read more data
+            /// Inner loop: repeatedly call `.read()` and read more data until:
+            /// 1. We reached EOF (read length is 0), in which case return the result
+            /// 2. We read `maxLength` bytes, in which case return the result
+            /// 3. `read()` returns -1 and sets `errno` to `EAGAIN` or `EWOULDBLOCK`. In
+            ///     this case we `break` out of the inner loop and wait `.read()` to be
+            ///     ready by `await`ing the next signal in the outer loop.
             while true {
                 let bytesRead = resultBuffer.withUnsafeMutableBufferPointer { bufferPointer in
                     // Get a pointer to the memory at the specified offset
@@ -417,7 +423,13 @@ extension AsyncIO {
         let fileDescriptor = diskIO.fileDescriptor
         let signalStream = self.registerFileDescriptor(fileDescriptor, for: .write)
         var writtenLength: Int = 0
+        /// Outer loop: every iteration signals we are ready to read more data
         for try await _ in signalStream {
+            /// Inner loop: repeatedly call `.write()` and write more data until:
+            /// 1. We've written bytes.count bytes.
+            /// 3. `.write()` returns -1 and sets `errno` to `EAGAIN` or `EWOULDBLOCK`. In
+            ///     this case we `break` out of the inner loop and wait `.write()` to be
+            ///     ready by `await`ing the next signal in the outer loop.
             while true {
                 let written = bytes.withUnsafeBytes { ptr in
                     let remainingLength = ptr.count - writtenLength
@@ -454,7 +466,13 @@ extension AsyncIO {
         let fileDescriptor = diskIO.fileDescriptor
         let signalStream = self.registerFileDescriptor(fileDescriptor, for: .write)
         var writtenLength: Int = 0
+        /// Outer loop: every iteration signals we are ready to read more data
         for try await _ in signalStream {
+            /// Inner loop: repeatedly call `.write()` and write more data until:
+            /// 1. We've written bytes.count bytes.
+            /// 3. `.write()` returns -1 and sets `errno` to `EAGAIN` or `EWOULDBLOCK`. In
+            ///     this case we `break` out of the inner loop and wait `.write()` to be
+            ///     ready by `await`ing the next signal in the outer loop.
             while true {
                 let written = span.withUnsafeBytes { ptr in
                     let remainingLength = ptr.count - writtenLength

Sources/Subprocess/IO/Output.swift

@@ -140,10 +140,10 @@ public struct BytesOutput: OutputProtocol {
     public let maxSize: Int
 
     internal func captureOutput(
-        from diskIO: consuming TrackedPlatformDiskIO?
+        from diskIO: consuming TrackedPlatformDiskIO
     ) async throws -> [UInt8] {
-        let result = try await AsyncIO.shared.read(from: diskIO!, upTo: self.maxSize)
-        try diskIO?.safelyClose()
+        let result = try await AsyncIO.shared.read(from: diskIO, upTo: self.maxSize)
+        try diskIO.safelyClose()
         #if canImport(Darwin)
         return result?.array() ?? []
         #else
@@ -255,17 +255,26 @@ extension OutputProtocol {
     internal func captureOutput(
         from diskIO: consuming TrackedPlatformDiskIO?
     ) async throws -> OutputType {
-        if let bytesOutput = self as? BytesOutput {
-            return try await bytesOutput.captureOutput(from: diskIO) as! Self.OutputType
-        }
-
         if OutputType.self == Void.self {
             return () as! OutputType
         }
+        // `diskIO` is only `nil` for any types that conform to `OutputProtocol`
+        // and have `Void` as ``OutputType` (i.e. `DiscardedOutput`). Since we
+        // made sure `OutputType` is not `Void` on the line above, `diskIO`
+        // must not be nil; otherwise, this is a programmer error.
+        guard var diskIO else {
+            fatalError(
+                "Internal Inconsistency Error: diskIO must not be nil when OutputType is not Void"
+            )
+        }
+
+        if let bytesOutput = self as? BytesOutput {
+            return try await bytesOutput.captureOutput(from: diskIO) as! Self.OutputType
+        }
         // Force unwrap is safe here because only `OutputType.self == Void` would
         // have nil `TrackedPlatformDiskIO`
-        let result = try await AsyncIO.shared.read(from: diskIO!, upTo: self.maxSize)
-        try diskIO?.safelyClose()
+        let result = try await AsyncIO.shared.read(from: diskIO, upTo: self.maxSize)
+        try diskIO.safelyClose()
         #if canImport(Darwin)
         return try self.output(from: result ?? .empty)
         #else