Implement FileDescriptor.Pipe()

Sources/System/FileHelpers.swift

@@ -123,3 +123,34 @@ extension FileDescriptor {
     }
   }
 }
+
+extension FileDescriptor.Pipe {
+  /// Runs a closure and then closes both ends of this pipe, even if an error occurs.
+  ///
+  /// - Parameter body: The closure to run.
+  ///   If the closure throws an error,
+  ///   this method closes both ends of this pipe before it rethrows that error.
+  ///
+  /// - Returns: The value returned by the closure.
+  ///
+  /// If `body` throws an error
+  /// or an error occurs while closing the file descriptor,
+  /// this method rethrows that error.
+  public func closeAfter<R>(_ body: () throws -> R) throws -> R {
+    try fileDescriptorForReading.closeAfter {
+      try fileDescriptorForWriting.closeAfter {
+        try body()
+      }
+    }
+  }
+
+  /// Closes both ends of a Pipe
+  ///
+  /// If both ends fail to close, the error from the read end is thrown.
+  @_alwaysEmitIntoClient
+  public func close() throws {
+    try fileDescriptorForWriting.closeAfter {
+      try fileDescriptorForReading.close()
+    }
+  }
+}

Sources/System/FileOperations.swift

@@ -370,4 +370,52 @@ extension FileDescriptor {
   public func dup2() throws -> FileDescriptor {
     fatalError("Not implemented")
   }
+
+  /// A pair of `FileDescriptor` values represening a pipe.
+  ///
+  /// You are responsible for managing the lifetime and validity
+  /// of the `read` and `write` `FileDescriptor` values,
+  /// which can be closed independently or via helper methods on `Pipe`, but not both.
+  public struct Pipe {
+    /// The file descriptor for reading from this pipe
+    public let fileDescriptorForReading: FileDescriptor
+
+    /// The file descriptor for writing to this pipe
+    public let fileDescriptorForWriting: FileDescriptor
+
+    /// Create a pipe, a uniderctional data channel which can be used for interprocess communication.
+    ///
+    /// - Returns: A `Pipe` value representing the read and write ends of the created `Pipe`.
+    ///
+    /// The corresponding C function is `pipe`.
+    @_alwaysEmitIntoClient
+    // @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+    public init(
+      retryOnInterrupt: Bool = true
+    ) throws {
+      self = try Self._create(retryOnInterrupt: retryOnInterrupt).get()
+    }
+
+    // @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+    @usableFromInline
+    internal static func _create(
+      retryOnInterrupt: Bool
+    ) -> Result<Pipe, Errno> {
+      var fds: [Int32] = [-1, -1]
+      return valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+        system_pipe(&fds)
+      }.map { _ in Pipe(fds: fds) }
+    }
+
+    private init(fds: [Int32]) {
+      fileDescriptorForReading = FileDescriptor(rawValue: fds[0])
+      fileDescriptorForWriting = FileDescriptor(rawValue: fds[1])
+    }
+  }
+
+  @_alwaysEmitIntoClient
+  @available(*, unavailable, renamed: "FileDescriptor.Pipe()")
+  public func pipe() throws -> FileDescriptor {
+    fatalError("Not implemented")
+  }
 }

Sources/System/Internals/Syscalls.swift

@@ -115,3 +115,11 @@ internal func system_dup2(_ fd: Int32, _ fd2: Int32) -> Int32 {
   #endif
   return dup2(fd, fd2)
 }
+
+// write
+internal func system_pipe(_ fds: UnsafeMutablePointer<Int32>) -> CInt {
+#if ENABLE_MOCKING
+  if mockingEnabled { return _mock(fds) }
+#endif
+  return pipe(fds)
+}

Tests/SystemTests/FileOperationsTest.swift

@@ -89,6 +89,25 @@ final class FileOperationsTest: XCTestCase {
   func testHelpers() {
     // TODO: Test writeAll, writeAll(toAbsoluteOffset), closeAfter
   }
+
+  func testAdHocPipe() throws {
+    // Ad-hoc test testing `Pipe` functionality.
+    // We cannot test `Pipe` using `MockTestCase` because it calls `pipe` with a pointer to an array local to the `Pipe`, the address of which we do not know prior to invoking `Pipe`.
+    let pipe = try FileDescriptor.Pipe()
+    try pipe.fileDescriptorForWriting.closeAfter {
+      try pipe.fileDescriptorForReading.closeAfter {
+        var abc = "abc"
+        try abc.withUTF8 {
+          _ = try pipe.fileDescriptorForWriting.write(UnsafeRawBufferPointer($0))
+        }
+        let readLen = 3
+        let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
+          count = try pipe.fileDescriptorForReading.read(into: UnsafeMutableRawBufferPointer(buf))
+        }
+        XCTAssertEqual(readBytes, Array(abc.utf8))
+      }
+    }
+  }
 
   func testAdHocOpen() {
     // Ad-hoc test touching a file system.