Implement FileDescriptor.Pipe()

Sources/System/FileOperations.swift

@@ -370,4 +370,37 @@ extension FileDescriptor {
   public func dup2() throws -> FileDescriptor {
     fatalError("Not implemented")
   }
+
+  /// A pair of `FileDescriptor` values represening a pipe.
+  ///
+  /// A pipe enables data written to `output` to be read from `input`.
+  /// You are responsible for managing the lifetime and validity
+  /// of the `output` and `input` `FileDescriptor` values.
+  public typealias Pipe = (output: FileDescriptor, input: FileDescriptor)
+
+  /// Create a pipe, a uniderctional data channel which can be used for interprocess communication.
+  ///
+  /// - Parameters:
+  ///   - retryOnInterrupt: Whether to retry the write operation
+  ///      if it throws ``Errno/interrupted``. The default is `true`.
+  ///      Pass `false` to try only once and throw an error upon interruption.
+  /// - Returns: The new file descriptor.
+  ///
+  /// The corresponding C function is `pipe`.
+  @_alwaysEmitIntoClient
+  // @available(macOS 9999, iOS 9999, watchOS 9999, tvOS 9999, *)
+  public static func pipe(retryOnInterrupt: Bool = true) throws -> Pipe {
+    try _pipe(retryOnInterrupt: retryOnInterrupt).get()
+  }
+
+  @usableFromInline
+  internal static func _pipe(retryOnInterrupt: Bool) -> Result<Pipe, Errno> {
+    var fds: (Int32, Int32) = (-1, -1)
+    return withUnsafeMutableBytes(of: &fds) { bytes in
+      let fds = bytes.bindMemory(to: Int32.self)
+      return valueOrErrno(retryOnInterrupt: retryOnInterrupt) {
+        system_pipe(fds.baseAddress!)
+      }.map { _ in (FileDescriptor(rawValue: fds[0]), FileDescriptor(rawValue: fds[1])) }
+    }
+  }
 }

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.input.closeAfter {
+      try pipe.output.closeAfter {
+        var abc = "abc"
+        try abc.withUTF8 {
+          _ = try pipe.input.write(UnsafeRawBufferPointer($0))
+        }
+        let readLen = 3
+        let readBytes = try Array<UInt8>(unsafeUninitializedCapacity: readLen) { buf, count in
+          count = try pipe.output.read(into: UnsafeMutableRawBufferPointer(buf))
+        }
+        XCTAssertEqual(readBytes, Array(abc.utf8))
+      }
+    }
+  }
 
   func testAdHocOpen() {
     // Ad-hoc test touching a file system.