fixup: Refactor how conformance works and add support for pipe channels

Author: simonjbeaumont

Sources/NIOCore/BSDSocketAPI.swift

@@ -129,6 +129,16 @@ public enum NIOBSDSocket: Sendable {
     #else
     public typealias Handle = CInt
     #endif
+    public struct PipeHandle {
+        public var input: Handle
+        public var output: Handle
+
+        @inlinable
+        public init(input: Handle, output: Handle) {
+            self.input = input
+            self.output = output
+        }
+    }
 }
 
 extension NIOBSDSocket {

Sources/NIOPosix/BaseSocketChannel+AccessibleTransport.swift

@@ -0,0 +1,45 @@
+//===----------------------------------------------------------------------===//
+//
+// This source file is part of the SwiftNIO open source project
+//
+// Copyright (c) 2026 Apple Inc. and the SwiftNIO project authors
+// Licensed under Apache License v2.0
+//
+// See LICENSE.txt for license information
+// See CONTRIBUTORS.txt for the list of SwiftNIO project authors
+//
+// SPDX-License-Identifier: Apache-2.0
+//
+//===----------------------------------------------------------------------===//
+
+import NIOCore
+
+extension BaseSocketChannel where SocketType: BaseSocket {
+    /// The underlying transport type backing this channel.
+    typealias Transport = NIOBSDSocket.Handle
+
+    /// Provides scoped access to the socket file handle.
+    func withUnsafeTransport<Result>(_ body: (_ transport: NIOBSDSocket.Handle) throws -> Result) throws -> Result {
+        try self.socket.withUnsafeHandle(body)
+    }
+}
+
+extension BaseSocketChannel where SocketType: PipePair {
+    /// The underlying transport type backing this channel.
+    typealias Transport = NIOBSDSocket.PipeHandle
+
+    /// Provides scoped access to the pipe file descriptors.
+    func withUnsafeTransport<Result>(_ body: (_ transport: NIOBSDSocket.PipeHandle) throws -> Result) throws -> Result {
+        try body(
+            NIOBSDSocket.PipeHandle(
+                input: self.socket.input?.fileDescriptor ?? NIOBSDSocket.invalidHandle,
+                output: self.socket.output?.fileDescriptor ?? NIOBSDSocket.invalidHandle
+            )
+        )
+    }
+}
+
+extension SocketChannel: NIOTransportAccessibleChannelCore {}
+extension ServerSocketChannel: NIOTransportAccessibleChannelCore {}
+extension DatagramChannel: NIOTransportAccessibleChannelCore {}
+extension PipeChannel: NIOTransportAccessibleChannelCore {}

Sources/NIOPosix/BaseSocketChannel.swift

@@ -1479,16 +1479,6 @@ extension BaseSocketChannel {
     }
 }
 
-extension BaseSocketChannel: NIOTransportAccessibleChannelCore where SocketType: BaseSocket {
-    /// The underlying transport which is a BSD socket file handle.
-    typealias Transport = NIOBSDSocket.Handle
-
-    /// Provides scoped access to the BSD socket file handle.
-    func withUnsafeTransport<Result>(_ body: (_ transport: NIOBSDSocket.Handle) throws -> Result) throws -> Result {
-        try self.socket.withUnsafeHandle(body)
-    }
-}
-
 /// Execute the given function and synchronously complete the given `EventLoopPromise` (if not `nil`).
 func executeAndComplete<Value: Sendable>(_ promise: EventLoopPromise<Value>?, _ body: () throws -> Value) {
     do {

Tests/NIOPosixTests/NIOTransportAccessibleChannelCoreTests.swift

@@ -13,6 +13,7 @@
 //===----------------------------------------------------------------------===//
 
 import NIOCore  // NOTE: Not @testable import here -- testing public API surface.
+import NIOEmbedded
 import NIOPosix  // NOTE: Not @testable import here -- testing public API surface.
 import Testing
 
@@ -63,21 +64,50 @@ import Testing
     @Test func testUnderlyingTransportForUnsupportedChannels() throws {
         let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
         defer { #expect(throws: Never.self) { try group.syncShutdownGracefully() } }
-
-        // Right now pipe channels do not expose their underlying transport, so we'll use this to test API behaviour.
-        let channel = try NIOPipeBootstrap(group: group).takingOwnershipOfDescriptor(output: STDOUT_FILENO).wait()
+        let channel = EmbeddedChannel()
         defer { #expect(throws: Never.self) { try channel.close().wait() } }
 
         #expect(channel is any NIOTransportAccessibleChannelCore == false)
 
-        try channel.eventLoop.submit {
-            let syncOps = channel.pipeline.syncOperations
+        // Calling the public API will never run the closure -- we cannot specify a type to pass the runtime check.
+        let syncOps = channel.pipeline.syncOperations
+        try #expect(syncOps.withUnsafeTransportIfAvailable { 42 } == nil)
+        try #expect(syncOps.withUnsafeTransportIfAvailable(of: Any.self) { _ in 42 } == nil)
+        try #expect(syncOps.withUnsafeTransportIfAvailable(of: CInt.self) { _ in 42 } == nil)
+        try #expect(syncOps.withUnsafeTransportIfAvailable(of: type(of: STDOUT_FILENO).self) { _ in 42 } == nil)
+    }
 
-            // Calling the public API will never run the closure -- we cannot specify a type to pass the runtime check.
-            try #expect(syncOps.withUnsafeTransportIfAvailable { 42 } == nil)
-            try #expect(syncOps.withUnsafeTransportIfAvailable(of: Any.self) { _ in 42 } == nil)
-            try #expect(syncOps.withUnsafeTransportIfAvailable(of: CInt.self) { _ in 42 } == nil)
-            try #expect(syncOps.withUnsafeTransportIfAvailable(of: type(of: STDOUT_FILENO).self) { _ in 42 } == nil)
-        }.wait()
+    @Test func testUnderlyingTransportConformanceForExpectedChannels() throws {
+        let group = MultiThreadedEventLoopGroup(numberOfThreads: 1)
+        defer { #expect(throws: Never.self) { try group.syncShutdownGracefully() } }
+
+        // SeverSocketChannel -- yep.
+        let serverChannel = try ServerBootstrap(group: group).bind(host: "127.0.0.1", port: 0).wait()
+        defer { #expect(throws: Never.self) { try serverChannel.close().wait() } }
+        #expect(serverChannel is any NIOTransportAccessibleChannelCore)
+        #expect(serverChannel is any NIOTransportAccessibleChannelCore<NIOBSDSocket.Handle>)
+
+        // SocketChannel -- yep.
+        let clientChannel = try ClientBootstrap(group: group).connect(to: serverChannel.localAddress!).wait()
+        defer { #expect(throws: Never.self) { try clientChannel.close().wait() } }
+        #expect(clientChannel is any NIOTransportAccessibleChannelCore)
+        #expect(clientChannel is any NIOTransportAccessibleChannelCore<NIOBSDSocket.Handle>)
+
+        // DatagramChannel -- yep.
+        let datagramChannel = try DatagramBootstrap(group: group).bind(host: "127.0.0.1", port: 0).wait()
+        defer { #expect(throws: Never.self) { try datagramChannel.close().wait() } }
+        #expect(datagramChannel is any NIOTransportAccessibleChannelCore)
+        #expect(datagramChannel is any NIOTransportAccessibleChannelCore<NIOBSDSocket.Handle>)
+
+        // PipeChannel -- yep.
+        let pipeChannel = try NIOPipeBootstrap(group: group).takingOwnershipOfDescriptor(output: STDOUT_FILENO).wait()
+        defer { #expect(throws: Never.self) { try pipeChannel.close().wait() } }
+        #expect(pipeChannel is any NIOTransportAccessibleChannelCore)
+        #expect(pipeChannel is any NIOTransportAccessibleChannelCore<NIOBSDSocket.PipeHandle>)
+
+        // EmbeddedChannel -- nope.
+        let embeddedChannel = EmbeddedChannel()
+        defer { #expect(throws: Never.self) { try embeddedChannel.close().wait() } }
+        #expect(embeddedChannel is any NIOTransportAccessibleChannelCore == false)
     }
 }