         }
     }
 
-    @inlinable public func reentrantChannelReception(_ element: Any) {
+    public func reentrantChannelReception(_ element: Any) {
         #if DEBUG_CHANNELZ
             //print("ChannelZ reentrant channel short-circuit; break on \(#function) to debug", type(of: element))
             ChannelZReentrantReceptions.increment()

#if !(os(Linux))
/// A `Lock` implementation that uses an `os_unfair_lock`
@available(macOS 10.12, iOS 10.0, *)
public final class UnfairLock : Lock {
    public var unfairLock = os_unfair_lock_s()

    @inlinable public init() {
    }

    @inlinable public var isReentrant: Bool {
        return false
    }

    @inlinable public func lock() {
        os_unfair_lock_lock(&unfairLock)
    }

    @inlinable public func unlock() {
        os_unfair_lock_unlock(&unfairLock)
    }

    @inlinable public func withLock<T>(_ f: () throws -> T) rethrows -> T {
        os_unfair_lock_lock(&unfairLock)
        defer { os_unfair_lock_unlock(&unfairLock) }
        return try f()
    }

    @inlinable public func tryLock<T>(_ f: () throws -> T) rethrows -> T? {
        if !os_unfair_lock_trylock(&unfairLock) { return nil }
        defer { os_unfair_lock_unlock(&unfairLock) }
        return try f()

}

/// A no-op `Lock` implementation
final class NoLock : Lock {
    init() {
    }

    func lock() {
    }

    func unlock() {
    }

    func withLock<T>(_ f: () throws -> T) rethrows -> T {
        return try f()
    }

    var isReentrant: Bool { return true }
}

/// A `Lock` implementation that uses a `pthread_mutex_t`
final class ReentrantLock : Lock {
    var mutex = pthread_mutex_t()
    var mutexAttr = pthread_mutexattr_t()

    #if os(Linux)
    typealias PTHREAD_ATTR_TYPE = Int
    #else
    typealias PTHREAD_ATTR_TYPE = Int32
    #endif

    convenience init() {
        self.init(attr: PTHREAD_MUTEX_RECURSIVE)
    }

    var isReentrant: Bool {
        var attr: Int32 = 0
        assertSuccess(pthread_mutexattr_gettype(&mutexAttr, &attr))
        return attr == PTHREAD_MUTEX_RECURSIVE
    }

    init(attr: PTHREAD_ATTR_TYPE = PTHREAD_MUTEX_RECURSIVE) {
        assertSuccess(pthread_mutexattr_init(&mutexAttr))
        assertSuccess(pthread_mutexattr_settype(&mutexAttr, Int32(attr)))
        assertSuccess(pthread_mutex_init(&mutex, &mutexAttr))
