Introduce custom initializers to initialize String, Data, and Array from AsyncBufferSequence.Buffer

iCharlesHu · iCharlesHu · commit 0712fdb9ee97 · 2025-06-05T10:21:33.000-07:00
diff --git a/Sources/Subprocess/API.swift b/Sources/Subprocess/API.swift
@@ -168,7 +168,7 @@ public func run<Result, Input: InputProtocol, Error: OutputProtocol>(
     workingDirectory: FilePath? = nil,
     platformOptions: PlatformOptions = PlatformOptions(),
     input: Input = .none,
-    error: Error,
+    error: Error = .discarded,
     isolation: isolated (any Actor)? = #isolation,
     body: ((Execution, AsyncBufferSequence) async throws -> Result)
 ) async throws -> ExecutionResult<Result> where Error.OutputType == Void {
@@ -267,7 +267,7 @@ public func run<Result, Error: OutputProtocol>(
     environment: Environment = .inherit,
     workingDirectory: FilePath? = nil,
     platformOptions: PlatformOptions = PlatformOptions(),
-    error: Error,
+    error: Error = .discarded,
     isolation: isolated (any Actor)? = #isolation,
     body: ((Execution, StandardInputWriter, AsyncBufferSequence) async throws -> Result)
 ) async throws -> ExecutionResult<Result> where Error.OutputType == Void {
diff --git a/Sources/Subprocess/Buffer.swift b/Sources/Subprocess/Buffer.swift
@@ -18,13 +18,13 @@ extension AsyncBufferSequence {
     /// A immutable collection of bytes
     public struct Buffer: Sendable {
         #if os(Windows)
-        private var data: [UInt8]
+        internal var data: [UInt8]
 
         internal init(data: [UInt8]) {
             self.data = data
         }
         #else
-        private var data: DispatchData
+        internal var data: DispatchData
 
         internal init(data: DispatchData) {
             self.data = data
@@ -54,7 +54,6 @@ extension AsyncBufferSequence.Buffer {
 @available(SubprocessSpan, *)
 #endif
 extension AsyncBufferSequence.Buffer {
-    #if !SubprocessSpan
     /// Access the raw bytes stored in this buffer
     /// - Parameter body: A closure with an `UnsafeRawBufferPointer` parameter that
     ///   points to the contiguous storage for the type. If no such storage exists,
@@ -64,13 +63,6 @@ extension AsyncBufferSequence.Buffer {
     /// - Returns: The return value, if any, of the body closure parameter.
     public func withUnsafeBytes<ResultType>(
         _ body: (UnsafeRawBufferPointer) throws -> ResultType
-    ) rethrows -> ResultType {
-        return try self._withUnsafeBytes(body)
-    }
-    #endif  // !SubprocessSpan
-
-    internal func _withUnsafeBytes<ResultType>(
-        _ body: (UnsafeRawBufferPointer) throws -> ResultType
     ) rethrows -> ResultType {
         #if os(Windows)
         return try self.data.withUnsafeBytes(body)
@@ -88,44 +80,46 @@ extension AsyncBufferSequence.Buffer {
     #if SubprocessSpan
     // Access the storge backing this Buffer
     public var bytes: RawSpan {
-        var backing: SpanBacking?
-        #if os(Windows)
-        self.data.withUnsafeBufferPointer {
-            backing = .pointer($0)
-        }
-        #else
-        self.data.enumerateBytes { buffer, byteIndex, stop in
-            if _fastPath(backing == nil) {
-                // In practice, almost all `DispatchData` is contiguous
-                backing = .pointer(buffer)
-            } else {
-                // This DispatchData is not contiguous. We need to copy
-                // the bytes out
-                let contents = Array(buffer)
-                switch backing! {
-                case .pointer(let ptr):
-                    // Convert the ptr to array
-                    let existing = Array(ptr)
-                    backing = .array(existing + contents)
-                case .array(let array):
-                    backing = .array(array + contents)
+        @lifetime(borrow self)
+        borrowing get {
+            var backing: SpanBacking?
+            #if os(Windows)
+            self.data.withUnsafeBufferPointer {
+                backing = .pointer($0)
+            }
+            #else
+            self.data.enumerateBytes { buffer, byteIndex, stop in
+                if _fastPath(backing == nil) {
+                    // In practice, almost all `DispatchData` is contiguous
+                    backing = .pointer(buffer)
+                } else {
+                    // This DispatchData is not contiguous. We need to copy
+                    // the bytes out
+                    let contents = Array(buffer)
+                    switch backing! {
+                    case .pointer(let ptr):
+                        // Convert the ptr to array
+                        let existing = Array(ptr)
+                        backing = .array(existing + contents)
+                    case .array(let array):
+                        backing = .array(array + contents)
+                    }
                 }
             }
-        }
-        #endif
-        guard let backing = backing else {
-            let empty = UnsafeRawBufferPointer(start: nil, count: 0)
-            let span = RawSpan(_unsafeBytes: empty)
-            return _overrideLifetime(of: span, to: self)
-        }
-        switch backing {
-        case .pointer(let ptr):
-            let span = RawSpan(_unsafeElements: ptr)
-            return _overrideLifetime(of: span, to: self)
-        case .array(let array):
-            let ptr = array.withUnsafeBytes { $0 }
-            let span = RawSpan(_unsafeBytes: ptr)
-            return _overrideLifetime(of: span, to: self)
+            #endif
+            guard let backing = backing else {
+                let empty = UnsafeRawBufferPointer(start: nil, count: 0)
+                let span = RawSpan(_unsafeBytes: empty)
+                return _overrideLifetime(of: span, to: self)
+            }
+            switch backing {
+            case .pointer(let ptr):
+                let span = RawSpan(_unsafeElements: ptr)
+                return _overrideLifetime(of: span, to: self)
+            case .array(let array):
+                let span = array.bytes
+                return _overrideLifetime(of: span, to: self)
+            }
         }
     }
     #endif  // SubprocessSpan
@@ -159,3 +153,42 @@ extension AsyncBufferSequence.Buffer: Equatable, Hashable {
     }
     #endif
 }
+
+// MARK: - Initializers
+#if SubprocessSpan
+@available(SubprocessSpan, *)
+#endif
+extension String {
+    /// Create a String with the given encoding from `Buffer`.
+    /// - Parameters:
+    ///   - buffer: the buffer to copy from
+    ///   - encoding: the encoding to encode Self with
+    public init?<Encoding: _UnicodeEncoding>(buffer: AsyncBufferSequence.Buffer, as encoding: Encoding.Type) {
+#if os(Windows)
+        let source = buffer.data.map { Encoding.CodeUnit($0) }
+        self = String(decoding: source, as: encoding)
+#else
+        self = buffer.withUnsafeBytes { ptr in
+            return String(
+                decoding: ptr.bindMemory(to: Encoding.CodeUnit.self).lazy.map { $0 },
+                as: encoding
+            )
+        }
+#endif
+    }
+}
+
+#if SubprocessSpan
+@available(SubprocessSpan, *)
+#endif
+extension Array where Element == UInt8 {
+    /// Create an Array from `Buffer`
+    /// - Parameter buffer: the buffer to copy from
+    public init(buffer: AsyncBufferSequence.Buffer) {
+#if os(Windows)
+        self = buffer.data
+#else
+        self = Array(buffer.data)
+#endif
+    }
+}
diff --git a/Sources/Subprocess/SubprocessFoundation/Output+Foundation.swift b/Sources/Subprocess/SubprocessFoundation/Output+Foundation.swift
@@ -61,6 +61,17 @@ extension OutputProtocol where Self == DataOutput {
     }
 }
 
+#if SubprocessSpan
+@available(SubprocessSpan, *)
+#endif
+extension Data {
+    /// Create a `Data` from `Buffer`
+    /// - Parameter buffer: buffer to copy from
+    public init(buffer: AsyncBufferSequence.Buffer) {
+        self = Data(buffer.data)
+    }
+}
+
 // MARK: - Workarounds
 #if SubprocessSpan
 @available(SubprocessSpan, *)
diff --git a/Tests/SubprocessTests/SubprocessTests+Unix.swift b/Tests/SubprocessTests/SubprocessTests+Unix.swift
@@ -433,7 +433,7 @@ extension SubprocessUnixTests {
         ) { execution, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
@@ -472,7 +472,7 @@ extension SubprocessUnixTests {
         ) { execution, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
@@ -620,7 +620,7 @@ extension SubprocessUnixTests {
         ) { execution, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
@@ -828,7 +828,7 @@ extension SubprocessUnixTests {
                 group.addTask {
                     var outputs: [String] = []
                     for try await bit in standardOutput {
-                        let bitString = bit._withUnsafeBytes { ptr in
+                        let bitString = bit.withUnsafeBytes { ptr in
                             return String(decoding: ptr, as: UTF8.self)
                         }.trimmingCharacters(in: .whitespacesAndNewlines)
                         if bitString.contains("\n") {
diff --git a/Tests/SubprocessTests/SubprocessTests+Windows.swift b/Tests/SubprocessTests/SubprocessTests+Windows.swift
@@ -367,7 +367,7 @@ extension SubprocessWindowsTests {
         ) { execution, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
@@ -407,7 +407,7 @@ extension SubprocessWindowsTests {
         ) { execution, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
@@ -504,7 +504,7 @@ extension SubprocessWindowsTests {
         ) { subprocess, standardOutput in
             var buffer = Data()
             for try await chunk in standardOutput {
-                let currentChunk = chunk._withUnsafeBytes { Data($0) }
+                let currentChunk = chunk.withUnsafeBytes { Data($0) }
                 buffer += currentChunk
             }
             return buffer
