为什么 Swift 在这里调用太浅

Question

有点学术，但看这段代码

// Some protocol
protocol R : Equatable
{
}

// Some class
class E : R
{
    // Default implementation
    static func == ( lhs : E, rhs : E ) -> Bool
    {
        print ( "Comparing E ===" )
        return lhs === rhs
    }
}

// Some class with a string
class F : E
{
    let f : String

    init ( f : String )
    {
        self.f = f
    }

    // Copare strings
    static func == ( lhs : F, rhs : F ) -> Bool
    {
        print ( "Comparing F ==" )
        return lhs.f == rhs.f
    }
}

// Some generic container type
class G < T : R > : R
{
    let g : T

    init ( g : T )
    {
        self.g = g
    }

    // Compare
    static func == ( lhs : G, rhs : G ) -> Bool
    {
        print ( "Comparing G ==" )
        return lhs.g == rhs.g
    }
}

let f1 = F ( f : "abc" )
let f2 = F ( f : "abc" )

print ( "f1 == f2 ? \( f1 == f2 ) (expect true)" )

let g1 = G < F > ( g : f1 )
let g2 = G < F > ( g : f2 )

print ( "g1 == g2 ? \( g1 == g2 ) (expect true)" )

这给了

Comparing F ==
f1 == f2 ? true (expect true)
Comparing G ==
Comparing E ===
g1 == g2 ? false (expect true)

代码定义了一些协议，然后是一个实现它并提供通用比较器的类E。接下来是F，它会覆盖这个比较器来比较它所包含的字符串f。最后是一些容器类G，其中包含实现协议的东西。

到目前为止一切顺利。现在让我们比较一下东西。与 F 的实例进行比较，因为使用了正确的比较器。然而，比较两个容器类是行不通的，而且看起来 Swift 调用太浅了。它调用E 中提供的通用实现，而不是F 中覆盖的更深层次的实现。如果这是 Objective-C，即使 lhs 和 rhs 是不同的类，它也会进行更深入的调用，然后它通常会崩溃。 Swift 不允许这样做，这很容易通过创建另一个类来查看，例如包含 Int 而不是 String 但同时它似乎没有使用正确的比较器。

编辑

这使情况变得更糟。下面的变化是f1、f2 和g1 和g2 被更一般地定义为（或包含）超类类型E。即使F 覆盖了比较器，它也不会在任何比较中使用。

let f1 : E = F ( f : "abc" )
let f2 : E = F ( f : "abc" )

print ( "f1 == f2 ? \( f1 == f2 ) (expect true)" )

let g1 = G < E > ( g : f1 )
let g2 = G < E > ( g : f2 )

print ( "g1 == g2 ? \( g1 == g2 ) (expect true)" )

我怀疑这与运算符重载与函数重载有关......但任何光线都会受到赞赏。

编辑 2

玩弄了一点some，想如果我使用它，也许它可以让它按我想要的方式工作，但目前不允许some 用作函数参数。

Answer 1

我查看了上述精简版本的编译输出：

class E: Equatable {
  static func ==(lhs: E, rhs: E) -> Bool { return false }
}

class F: E {
  static func ==(lhs: F, rhs: F) -> Bool { return false }
}

class G <T: Equatable>: Equatable {
  let g: T

  init(_ g: T) {
    self.g = g
  }

  static func ==(lhs: G, rhs: G) -> Bool {
    return lhs.g == rhs.g
  }
}

并且缺少的链接是继承类没有协议见证。协议见证的使用详解here。

如果你看一下符号表：

$ nm main | swift demangle | grep 'protocol witness'
00000001000024a0 t protocol witness for static Swift.Equatable.== infix(A, A) -> Swift.Bool in conformance main.E : Swift.Equatable in main
00000001000028e0 t protocol witness for static Swift.Equatable.== infix(A, A) -> Swift.Bool in conformance main.G<A> : Swift.Equatable in main

您可以看到 E 和 G 的一个，但不是 F。

如果您修改代码以添加与Equatable 的一致性，那么您会毫不意外地获得额外的协议见证：

$ nm main | swift demangle | grep 'protocol witness'
00000001000024a0 t protocol witness for static Swift.Equatable.== infix(A, A) -> Swift.Bool in conformance main.E : Swift.Equatable in main
00000001000025a0 t protocol witness for static Swift.Equatable.== infix(A, A) -> Swift.Bool in conformance main.F : Swift.Equatable in main
00000001000028d0 t protocol witness for static Swift.Equatable.== infix(A, A) -> Swift.Bool in conformance main.G<A> : Swift.Equatable in main

所以，是的，可以非常强烈地支持这是一个错误，但正如相关的 bug report 中所述，事情就是这样，所以如果没有重要的仪式和流程，不太可能改变。

Answer 2

@msbit 很好地解释了幕后发生的事情，我会尝试从另一个角度解决这个问题。

我们看一下协议声明：

public protocol Equatable {
    static func == (lhs: Self, rhs: Self) -> Bool
}

一旦协议在其声明中使用Self，或具有关联类型，它就会离开动态调度世界，并进入静态调度世界。而且这种静态调度通过继承进入了动态方法解析的方式。

另一方面是== 方法是static 要求，当涉及到类时，static 成员接收静态调度，而不是动态调度。这意味着当通过对基类的引用来引用派生类时，方法调用将始终分派给基类。

您需要使用class func 才能进行动态调度，但是协议声明不允许将要求指定为class func，即使协议是类类型之一。

因此，在这种情况下，运行时行为是正确的，甚至不是预期的，因为它遵循语言设计。我看到的问题是编译器允许您在不覆盖静态方法（在这种情况下为==）的情况下重新实现，因为常规、非运算符、静态方法不允许这样做。

class Base {
    static func sayMyName() {
        print("My name is Base")
    }

    static func ==(lhs: Base, rhs: Base) -> Bool {
        true
    }

    static func >>(lhs: Base, rhs: Base) -> Bool {
        true
    }
}

class Derived: Base {
    // this not allowed by the compiler
    static func sayMyName() {
        print("My name is Derived")
    }

    // this override is allowed, though `Base` doesn't conform
    // to Equatable
    static func ==(lhs: Derived, rhs: Derived) -> Bool {
        true
    }

    // Other operator-like static overrides are also allowed
    static func >>(lhs: Derived, rhs: Derived) -> Bool {
        true
    }
}