Repository: apple/swift-nio
File: Sources/NIOCore/AsyncChannel/AsyncChannel.swift (Swift)

Code before:
        // assertionFailure to guide bad Channel implementations that are incorrectly failing this
        // future to stop failing it.
        do {
            try await self.channel.closeFuture.get()
        } catch {
            assertionFailure(
                """
                The channel's closeFuture should never be failed, but it was failed with error: \(error).
                This is an error in the channel's implementation.
                Refer to `Channel/closeFuture`'s documentation for more information.
                """
            )
        }
        return result
    }

    #if compiler(>=6.0)
    /// Provides scoped access to the inbound side of the underlying ``Channel``.
    ///
    /// - Important: After this method returned the underlying ``Channel`` will be closed.
    ///
    /// - Parameters:
    ///     - actor: actor where this function should be isolated to
    ///     - body: A closure that gets scoped access to the inbound.
    public func executeThenClose<Result>(
        isolatedTo actor: isolated (any Actor)? = #isolation,
        _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>) async throws -> Result
    ) async throws -> Result where Outbound == Never, Result: Sendable {
        try await self.executeThenClose { inbound, _ in
            try await body(inbound)
        }
    }
    #endif
}

extension Channel {
    @available(macOS 10.15, iOS 13, tvOS 13, watchOS 6, *)
    @inlinable
    func _syncAddAsyncHandlers<Inbound: Sendable, Outbound: Sendable>(
        backPressureStrategy: NIOAsyncSequenceProducerBackPressureStrategies.HighLowWatermark?,
        isOutboundHalfClosureEnabled: Bool,
        closeOnDeinit: Bool
    ) throws -> (NIOAsyncChannelInboundStream<Inbound>, NIOAsyncChannelOutboundWriter<Outbound>) {
        self.eventLoop.assertInEventLoop()

        let handler = NIOAsyncChannelHandler<Inbound, Inbound, Outbound>(
            eventLoop: self.eventLoop,
            transformation: .syncWrapping { $0 },
            isOutboundHalfClosureEnabled: isOutboundHalfClosureEnabled
        )


Review comment (suggestion):
```suggestion
        isolation actor: isolated (any Actor)? = #isolation,
```

Code after:
        // assertionFailure to guide bad Channel implementations that are incorrectly failing this
        // future to stop failing it.
        do {
            try await self.channel.closeFuture.get()
        } catch {
            assertionFailure(
                """
                The channel's closeFuture should never be failed, but it was failed with error: \(error).
                This is an error in the channel's implementation.
                Refer to `Channel/closeFuture`'s documentation for more information.
                """
            )
        }
        return result
    }

    #if compiler(>=6.0)
    /// Provides scoped access to the inbound side of the underlying ``Channel``.
    ///
    /// - Important: After this method returned the underlying ``Channel`` will be closed.
    ///
    /// - Parameters:
    ///     - actor: actor where this function should be isolated to
    ///     - body: A closure that gets scoped access to the inbound.
    public func executeThenClose<Result>(
        isolation actor: isolated (any Actor)? = #isolation,
        _ body: (_ inbound: NIOAsyncChannelInboundStream<Inbound>) async throws -> sending Result
    ) async throws -> sending Result where Outbound == Never {
        let result: Result
        do {
            result = try await body(self._inbound)
        } catch let bodyError {
            do {
                self._outbound.finish()
                try await self.channel.close().get()
                throw bodyError
            } catch {
                throw bodyError
            }
        }

        self._outbound.finish()
        // We ignore errors from close, since all we care about is that the channel has been closed
        // at this point.
        self.channel.close(promise: nil)
        // `closeFuture` should never be failed, so we could ignore the error. However, do an
        // assertionFailure to guide bad Channel implementations that are incorrectly failing this
        // future to stop failing it.
        do {
            try await self.channel.closeFuture.get()
        } catch {