json - 为什么 Swift 不使用更具体的类型调用我的重载方法？

Question

我使用 Decodable从 JSON 解码一个简单的结构。这通过遵守 Decodable 协议(protocol)来实现:

extension BackendServerID: Decodable {

    static func decode(_ json: Any) throws -> BackendServerID {
        return try BackendServerID(
            id: json => "id",
            name: json => "name"
        )
    }
}

不过，我希望能够使用 String 调用 decode，所以我添加了一个扩展:

extension Decodable {

    static func decode(_ string: String) throws -> Self {
        let jsonData = string.data(using: .utf8)!
        let jsonObject = try JSONSerialization.jsonObject(with: jsonData, options: [])
        return try decode(jsonObject)
    }
}

然后我想像这样解码对象:

XCTAssertNoThrow(try BackendServerID.decode("{\"id\": \"foo\", \"name\": \"bar\"}"))

但这并没有像预期的那样工作，因为不知何故 decode(Any) 方法被调用而不是 decode(String)。我究竟做错了什么？ (当我通过将自定义方法重命名为 decodeString 来澄清调用时，它可以正常工作。)

Answer 1

我同意这种行为令人惊讶，您可能很想 file a bug over it .

通过快速浏览 CSRanking.cpp 的来源，这是类型检查器实现的一部分，它处理重载决议时不同声明的“排名”——我们可以在以下实现中看到:

/// \brief Determine whether the first declaration is as "specialized" as
/// the second declaration.
///
/// "Specialized" is essentially a form of subtyping, defined below.
static bool isDeclAsSpecializedAs(TypeChecker &tc, DeclContext *dc,
                                  ValueDecl *decl1, ValueDecl *decl2) {

类型检查器认为具体类型中的重载比协议(protocol)扩展中的重载(source)更“专业”:

  // Members of protocol extensions have special overloading rules.
  ProtocolDecl *inProtocolExtension1 = outerDC1
                                         ->getAsProtocolExtensionContext();
  ProtocolDecl *inProtocolExtension2 = outerDC2
                                         ->getAsProtocolExtensionContext();
  if (inProtocolExtension1 && inProtocolExtension2) {
    // Both members are in protocol extensions.
    // Determine whether the 'Self' type from the first protocol extension
    // satisfies all of the requirements of the second protocol extension.
    bool better1 = isProtocolExtensionAsSpecializedAs(tc, outerDC1, outerDC2);
    bool better2 = isProtocolExtensionAsSpecializedAs(tc, outerDC2, outerDC1);
    if (better1 != better2) {
      return better1;
    }
  } else if (inProtocolExtension1 || inProtocolExtension2) {
    // One member is in a protocol extension, the other is in a concrete type.
    // Prefer the member in the concrete type.
    return inProtocolExtension2;
  }

并且在执行重载决议时，类型检查器将跟踪每个潜在重载的“分数”，选择最高的一个。当一个给定的重载被认为比另一个更“专业”时，它的分数就会增加，因此意味着它会受到青睐。还有其他因素会影响过载的分数，但 isDeclAsSpecializedAs 似乎是这种特殊情况下的决定因素。

所以，如果我们考虑一个最小的例子，类似于 @Sulthan gives :

protocol Decodable {
    static func decode(_ json: Any) throws -> Self
}

struct BackendServerID {}

extension Decodable {
    static func decode(_ string: String) throws -> Self {
        return try decode(string as Any)
    }
}

extension BackendServerID : Decodable {
    static func decode(_ json: Any) throws -> BackendServerID {
        return BackendServerID()
    }
}

let str = try BackendServerID.decode("foo")

当调用 BackendServerID.decode("foo") 时，具体类型 BackendServerID 中的重载比协议(protocol)中的重载优先扩展(BackendServerID 重载在具体类型的扩展中的事实在这里没有区别)。在这种情况下，这与函数签名本身是否更专业无关。 位置更为重要。

^{(尽管如果涉及泛型，函数签名确实很重要——参见下面的切线)}

值得注意的是，在这种情况下，我们可以通过在调用时转换方法来强制 Swift 使用我们想要的重载:

let str = try (BackendServerID.decode as (String) throws -> BackendServerID)("foo")

这将调用协议(protocol)扩展中的重载。

如果重载都在 BackendServerID 中定义:

extension BackendServerID : Decodable {
    static func decode(_ json: Any) throws -> BackendServerID {
        return BackendServerID()
    }

    static func decode(_ string: String) throws -> BackendServerID {
        return try decode(string as Any)
    }
}

let str = try BackendServerID.decode("foo")

类型检查器实现中的上述条件不会被触发，因为在协议(protocol)扩展中也不会触发 - 因此当涉及到重载解析时，更“专业”的重载将完全基于签名。因此，将为 String 参数调用 String 重载。

---

(关于通用重载的轻微切线...)

值得注意的是，类型检查器中还有(很多)其他规则来判断一个重载是否被认为比另一个更“专业”。其中之一是更喜欢非通用重载而不是通用重载 (source):

  // A non-generic declaration is more specialized than a generic declaration.
  if (auto func1 = dyn_cast<AbstractFunctionDecl>(decl1)) {
    auto func2 = cast<AbstractFunctionDecl>(decl2);
    if (func1->isGeneric() != func2->isGeneric())
      return func2->isGeneric();
  }

此条件的实现高于协议(protocol)扩展条件——因此，如果您要更改协议(protocol)中的decode(_:) 要求，使其使用通用占位符:

protocol Decodable {
    static func decode<T>(_ json: T) throws -> Self
}

struct BackendServerID {}

extension Decodable {
    static func decode(_ string: String) throws -> Self {
        return try decode(string as Any)
    }
}

extension BackendServerID : Decodable {
    static func decode<T>(_ json: T) throws -> BackendServerID {
        return BackendServerID()
    }
}

let str = try BackendServerID.decode("foo")

尽管在协议(protocol)扩展中，现在将调用 String 重载而不是通用重载。

---

真的，如您所见，有很多复杂因素决定调用哪个重载。在这种情况下，真正最好的解决方案，正如其他人已经说过的，是通过给你的 String 重载一个参数标签来明确地消除重载的歧义:

extension Decodable {
    static func decode(jsonString: String) throws -> Self {
        // ...
    }
}

// ...

let str = try BackendServerID.decode(jsonString: "{\"id\": \"foo\", \"name\": \"bar\"}")

这不仅清除了重载决议，还使 API 更加清晰。仅使用 decode("someString")，并不清楚字符串的确切格式(XML？CSV？)。现在很明显，它需要一个 JSON 字符串。