Swift Compiler lose its polymorphical context - swift

Question

First, I'm new to Swift language and have worked using python which is 'dynamic typed' language, so don't know exact compiler's perspective.
Below code is a simple code snippet to practice what Apple said POP(protocol oriented programming).
Snippet contains various ReturnClasses, RunnerClasses(each has different return type) and actual runner which just run RunnerClasses. Also has Selector enum to pretend dynamic dispatch.
protocol Return {
var value: Int { get set }
init(_ value: Int)
}
final class Return0: Return {
var value: Int
init(_ value: Int) {
print("return 0")
self.value = value
}
}
final class Return1: Return {
var value: Int
init(_ value: Int) {
print("return 1")
self.value = value + 50
}
}
final class Return2: Return {
var value: Int
init(_ value: Int) {
print("return 2")
self.value = value + 500
}
}
protocol FirstProtocol {
init()
func a() -> Return
func b() -> Return
}
extension FirstProtocol {
func a() -> Return {
print("protocol a hello")
return self.b()
}
func b() -> Return {
print("protocol b hello")
return Return0(5)
}
}
enum Selector {
case first, second
func cls() -> FirstProtocol{
switch self {
case .first:
return First1Class()
case .second:
return First2Class()
}
}
}
final class First1Class: FirstProtocol {
init() {
}
func b() -> Return1 {
print("first 1 class hello")
return Return1(3)
}
}
final class First2Class: FirstProtocol {
init() {
}
func b() -> Return2 {
print("first 2 class hello")
return Return2(5)
}
}
final class Runner {
var cls: FirstProtocol
var selector: Selector
init(_ selector: Selector) {
self.cls = selector.cls()
self.selector = selector
}
func createCls(cls: FirstProtocol.Type) -> FirstProtocol {
return cls.init()
}
func run(cls: FirstProtocol.Type) {
print("--- run 1 ---")
(self.createCls(cls: cls) as! First2Class).a()
}
func run2(t: Selector) -> Return {
print("--- run 2 ---")
print(t.cls())
return t.cls().b()
}
func run3() -> Return {
print("--- run 3 ---")
print(self.cls)
return self.cls.a()
}
}
final class Runner2 {
var runner: Runner
init(runner: Runner) {
self.runner = runner
}
func run() -> Return {
print("--- 2run 1 ---")
return self.runner.run2(t: .second)
}
}
var a = Runner2(runner: Runner(.second)).run()
print(type(of: a))
print(a.value)
And returns below result.
--- 2run 1 --- line 1
--- run 2 --- line 2
__lldb_expr_80.First2Class line 3
protocol b hello line 4
return 0 line 5
Return0 line 6
5 line 7
And here I have a question.
In line 3 which is result of Runner.run2, I think __lldb_expr_80.First2Class string means compiler exactly knows which class should be initiated. Therefore line 4 should be first 2 class hello not protocol b hello. Why protocol b hello is printed and how to make first 2 class hello is printed?

Answer 1

This is because the b in First2Class is not actually a witness for the b requirement in the FirstProtocol (same goes for First1Class). In other words, the reason why First2Class conforms to FirstProtocol is not the b method declared in it. The only witness for the protocol requirement is only the b in the protocol extension.
This is because the return types of these bs don't match the protocol requirement's return type:
// protocol requirement
func b() -> Return {
...
}
// First1Class
func b() -> Return1 {
...
}
// First2Class
func b() -> Return2 {
...
}
Return types must match exactly in order for a type to implement a protocol. See more discussions here.
When you call b on a protocol type, such as here:
return t.cls().b()
(t.cls() is of compile-time type FirstProtocol) because the bs are not the witness, your bs do not get considered when resolving the call. The call will only resolve to the only witness, which is the b in the protocol extension.
...means compiler exactly knows which class should be initiated.
That's not true. Remember that you only see the message printed at runtime. The compiler doesn't know which class is instantiated by cls.
Here is a shorter example that demonstrates this:
class A {}
class B : A {}
protocol Foo {
func foo() -> A
}
extension Foo {
func foo() -> A {
print("Foo")
return A()
}
}
class Bar : Foo {
func foo() -> B {
print("Bar")
return B()
}
}
let foo: Foo = Bar()
let bar = Bar()
foo.foo() // prints Foo
bar.foo() // prints Bar