为什么包装 os_log() 会导致无法正确记录双打？

Question

考虑以下示例：

import Foundation
import os.log

class OSLogWrapper {

    func logDefault(_ message: StaticString, _ args: CVarArg...) {
        os_log(message, type: .default, args)
    }

    func testWrapper() {
        logDefault("WTF: %f", 1.2345)
    }
}

如果我创建一个新的OSLogWrapper实例并调用testWrapper()

let logger = OSLogWrapper()
logger.testWrapper()

我在 Xcode 控制台中得到以下输出：

2018-06-19 18:21:08.327979-0400 WrapperWTF[50240:548958] WTF: 0.000000

我已经检查了所有我能想到的东西，我无法弄清楚这里出了什么问题。 查看文档并没有产生任何有用的东西。

Answer 1

编译器通过将每个参数转换为声明的可变参数类型，将它们打包成该类型的Array ，并将该数组传递给可变参数函数来实现可变参数参数。 在testWrapper的情况下，声明的可变参数类型是CVarArg ，所以当testWrapper调用logDefault ，这就是logDefault发生的事情： testWrapper将1.2345转换为CVarArg ，创建一个Array<CVarArg> ，并将其作为args传递给logDefault 。

然后logDefault调用os_log ，将Array<CVarArg>作为参数传递给它。 这是您代码中的错误。 该错误非常微妙。 问题是os_log不接受Array<CVarArg>参数； os_log本身就是对CVarArg可变参数。 因此，Swift 将args （一个Array<CVarArg> ）转换为CVarArg ，并将CVarArg转换为另一个Array<CVarArg> 。 结构如下所示：

Array<CVarArg> created in `logDefault`
  |
  +--> CVarArg (element at index 0)
         |
         +--> Array<CVarArg> (created in `testWrapper`)
                |
                +--> CVarArg (element at index 0)
                       |
                       +--> 1.2345 (a Double)

然后logDefault将这个新的Array<CVarArg>传递给os_log 。 所以你要求os_log格式化它的第一个元素，它是（有点）一个Array<CVarArg> ，使用%f ，这是无稽之谈，你碰巧得到0.000000作为输出。 （我说“有点”是因为这里有一些微妙之处，我稍后会解释。）

因此， logDefault将其传入的Array<CVarArg>作为潜在的许多可变参数之一传递给os_log ，但您实际上希望logDefault做的是将传入的Array<CVarArg>作为整个可变参数集传递给os_log ，而无需重新 -包裹它。 这在其他语言中有时被称为“争论”。

对你来说可悲的是，Swift 还没有任何用于参数 splatting 的语法。 它在 Swift-Evolution 中已经讨论过不止一次（ 例如， 在这个线程中），但目前还没有一个解决方案。

这个问题的通常解决方案是寻找一个伴随函数，它将已经捆绑的可变参数作为单个参数。 通常，同伴会在函数名称中添加一个v 。 例子：

• printf （可变参数）和vprintf （采用va_list ，C 的等效于Array<CVarArg> ）
• NSLog (variadic) 和NSLogv (需要一个va_list )
• -[NSString initWithFormat:] (variadic) 和-[NSString WithFormat:arguments:] (需要一个va_list )

所以你可能会去寻找一个os_logv 。 可悲的是，你不会找到一个。 os_log没有记录os_log预捆绑参数的伴侣。

此时您有两个选择：

• 放弃将os_log包装在您自己的可变参数包装器中，因为根本没有好的方法可以做到，或者

• 接受 Kamran 的建议（在他对您的问题的评论中）并使用%@而不是%f 。 但请注意，您的消息字符串中只能有一个%@ （并且没有其他格式说明符），因为您只将一个参数传递给os_log 。 输出如下所示：

   2018-06-20 02:22:56.132704-0500 test[39313:6086331] WTF: ( "1.2345" )

您还可以在https://bugreport.apple.com 上提交增强请求雷达，要求提供os_logv功能，但您不应期望它会很快实现。

就是这样了。 做这两件事之一，也许提交雷达，然后继续你的生活。 严重地。 停止阅读这里。 这条线之后就没有什么好东西了。

---

好的，你继续阅读。 让我们来看看os_log 。 事实证明，Swift os_log函数的实现是公共 Swift 源代码的一部分：

 @_exported import os @_exported import os.log import _SwiftOSOverlayShims @available(macOS 10.14, iOS 12.0, watchOS 5.0, tvOS 12.0, *) public func os_log( _ type: OSLogType, dso: UnsafeRawPointer = #dsohandle, log: OSLog = .default, _ message: StaticString, _ args: CVarArg...) { guard log.isEnabled(type: type) else { return } let ra = _swift_os_log_return_address() message.withUTF8Buffer { (buf: UnsafeBufferPointer<UInt8>) in // Since dladdr is in libc, it is safe to unsafeBitCast // the cstring argument type. buf.baseAddress!.withMemoryRebound( to: CChar.self, capacity: buf.count ) { str in withVaList(args) { valist in _swift_os_log(dso, ra, log, type, str, valist) } } } }

因此，原来有一个版本的os_log ，叫_swift_os_log ，这需要预先绑定的参数。 Swift 包装器使用withVaList （已记录）将Array<CVarArg>转换为va_list并将其传递给_swift_os_log ，它本身也是公共 Swift 源代码的一部分。 我不会在这里引用它的代码，因为它很长，我们实际上不需要查看它。

无论如何，即使没有记录，我们实际上可以调用_swift_os_log 。 我们基本上可以复制os_log的源代码并将其转换为您的logDefault函数：

func logDefaultHack(_ message: StaticString, dso: UnsafeRawPointer = #dsohandle, _ args: CVarArg...) {
    let ra = _swift_os_log_return_address()
    message.withUTF8Buffer { (buf: UnsafeBufferPointer<UInt8>) in
        buf.baseAddress!.withMemoryRebound(to: CChar.self, capacity: buf.count) { str in
            withVaList(args) { valist in
                _swift_os_log(dso, ra, .default, .default, str, valist)
            }
        }
    }
}

它有效。 测试代码：

func testWrapper() {
    logDefault("WTF: %f", 1.2345)
    logDefault("WTF: %@", 1.2345)
    logDefaultHack("Hack: %f", 1.2345)
}

输出：

2018-06-20 02:22:56.131875-0500 test[39313:6086331] WTF: 0.000000
2018-06-20 02:22:56.132704-0500 test[39313:6086331] WTF: (
    "1.2345"
)
2018-06-20 02:22:56.132807-0500 test[39313:6086331] Hack: 1.234500

我会推荐这个解决方案吗？ 不，地狱不。 os_log的内部是一个实现细节，可能会在 Swift 的未来版本中发生变化。 所以不要像这样依赖他们。 但无论如何，看看幕后是很有趣的。

---

最后一件事。 为什么编译器不抱怨将Array<CVarArg>转换为CVarArg ？ 为什么 Kamran 的建议（使用%@ ）有效？

事实证明，这些问题有相同的答案：这是因为Array可以“桥接”到 Objective-C 对象。 具体来说：

• Foundation（在 Apple 平台上）使Array符合_ObjectiveCBridgeable协议。 它通过返回一个NSArray来实现Array到 Objective-C 的桥接。

• Foundation 还使Array符合CVarArg协议。

• withVaList函数要求每个CVarArg 将自身转换为它的_cVarArgEncoding 。

• 对于同时符合_ObjectiveCBridgeable和CVarArg的类型， _cVarArgEncoding的默认实现返回桥接的 Objective-C 对象。

• Array与CVarArg的一致性意味着编译器不会抱怨（默默地）将Array<CVarArg>转换为CVarArg并将其粘贴到另一个Array<CVarArg> 。

这种无声转换通常是一个错误（就像您的情况一样），因此编译器警告它是合理的，并允许您使用显式args as CVarArg （例如args as CVarArg ）使警告静音。 如果需要，您可以在https://bugs.swift.org提交错误报告。

Answer 2

正如我在上面对 Rob Mayoff 的回答的评论中提到的，对于任何遇到os_signpost()相同问题的人，这里是我围绕它制作的包装类：

import Foundation
import os
import _SwiftOSOverlayShims

public final class Signpost {

    private final let log: OSLog

    public init(log: OSLog) {
        self.log = log
    }

    public final func begin(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil) {
        if #available(iOS 12.0, *) {
            signpost(.begin, dso: dso, name: name, idObject: idObject)
        }
    }

    public final func begin(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil, _ format: StaticString, _ arguments: CVarArg...) {
        if #available(iOS 12.0, *) {
            signpost(.begin, dso: dso, name: name, idObject: idObject, format, arguments)
        }
    }

    public final func event(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil) {
        if #available(iOS 12.0, *) {
            signpost(.event, dso: dso, name: name, idObject: idObject)
        }
    }

    public final func event(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil, _ format: StaticString, _ arguments: CVarArg...) {
        if #available(iOS 12.0, *) {
            signpost(.event, dso: dso, name: name, idObject: idObject, format, arguments)
        }
    }

    public final func end(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil) {
        if #available(iOS 12.0, *) {
            signpost(.end, dso: dso, name: name, idObject: idObject)
        }
    }

    public final func end(name: StaticString, dso: UnsafeRawPointer = #dsohandle, idObject: AnyObject? = nil, _ format: StaticString, _ arguments: CVarArg...) {
        if #available(iOS 12.0, *) {
            signpost(.end, dso: dso, name: name, idObject: idObject, format, arguments)
        }
    }

    @available(iOS 12.0, *)
    private final func signpost(_ type: OSSignpostType, dso: UnsafeRawPointer = #dsohandle, name: StaticString, idObject: AnyObject? = nil) {
        guard log.signpostsEnabled else { return }
        let signpostID = getSignpostId(forObject: idObject)
        os_signpost(type, dso: dso, log: log, name: name, signpostID: signpostID)
    }

    @available(iOS 12.0, *)
    private final func signpost(
        _ type: OSSignpostType,
        dso: UnsafeRawPointer,
        name: StaticString,
        idObject: AnyObject? = nil,
        _ format: StaticString,
        _ arguments: [CVarArg])
    {
        // This crazy mess is because [CVarArg] gets treated as a single CVarArg and repassing a CVarArg... actually passes a [CVarArg]
        // This was copied from the publicly available Swift source code at https://github.com/apple/swift/blob/master/stdlib/public/Darwin/os/os_signpost.swift#L40
        // THIS IS A HACK
        guard log.signpostsEnabled else { return }
        let signpostID = getSignpostId(forObject: idObject)
        guard signpostID != .invalid && signpostID != .null else { return }
        let ra = _swift_os_log_return_address()
        name.withUTF8Buffer { (nameBuf: UnsafeBufferPointer<UInt8>) in
            // Since dladdr is in libc, it is safe to unsafeBitCast
            // the cstring argument type.
            nameBuf.baseAddress!.withMemoryRebound(to: CChar.self, capacity: nameBuf.count) { nameStr in
                format.withUTF8Buffer { (formatBuf: UnsafeBufferPointer<UInt8>) in
                    // Since dladdr is in libc, it is safe to unsafeBitCast
                    // the cstring argument type.
                    formatBuf.baseAddress!.withMemoryRebound(to: CChar.self, capacity: formatBuf.count) { formatStr in
                        withVaList(arguments) { valist in
                            _swift_os_signpost_with_format(dso, ra, log, type, nameStr, signpostID.rawValue, formatStr, valist)
                        }
                    }
                }
            }
        }
    }

    @available(iOS 12.0, *)
    private final func getSignpostId(forObject idObject: AnyObject?) -> OSSignpostID {
        if let idObject = idObject {
            return OSSignpostID(log: log, object: idObject)
        }
        return .exclusive
    }
}