为什么Swift不能通过扩展泛型where子句调用函数？

Question

If I call function (eg funcB) from a class that have extension where clause directly all works as expected.

But if I call some another function (eg funcA) of a class and called function use funcB inside I see a result from original funcB not from extension.

Code sample:

class Bar {

}

class Foo<T> {

    func funcA() {
        funcB()
    }

    func funcB() {
        print("Parent without clause")
    }

}

extension Foo where T: Bar {

    func funcB() {
        print("Parent + clause")
    }

}

Foo<Any>().funcB()

Foo<Bar>().funcB()

print("--")

Foo<Any>().funcA()

Foo<Bar>().funcA()

Output:

Parent without clause

Parent + clause

--

Parent without clause

Parent without clause

I want to call different implementation depending on parent of T and send T to a second class.

If T is child of Bar, use Class<T: Bar> else return nil.

Answer 1

To have some kind of "abstract" class behavior, you can use a protocol instead of generic class.

Something like this:

class Bar: FooProtocol {
}

class Foo: FooProtocol {
}

protocol FooProtocol {
    func funcA()
    func funcB()
}

extension FooProtocol {
    func funcA() {
        funcB()
    }

    func funcB() {
        print("Parent without clause")
    }
}

extension FooProtocol where Self: Bar {
    func funcB() {
        print("Parent + clause")
    }
}

Here I have used a default implementation for the FooProtocol but you can define the functions int the Foo class and Bar class depending on what you want. Then you will have this result:

    let bar = Bar()
    bar.funcA() // Parent + clause
    bar.funcB() // Parent + clause

    let foo = Foo()
    foo.funcA() // Parent without clause
    foo.funcB() // Parent without clause

Answer 2

This is a correct behaviour for current Swift implementation.

https://bugs.swift.org/browse/SR-10549