SRTP doesn't handle calling member hiding inherited members

[vbfox]

When SRTP is used to call a member that is hiding an inherited member (C# new modifier) it fail to compile with the following error:

A unique overload for method 'Foo' could not be determined based on type information prior to this program point.
A type annotation may be needed. Candidates:

abstract member Base.Foo : unit -> unit,
member Derived.Foo : unit -> unit

Repro steps

The last line of this program should compile as the type is fully known and the correct Foo method can be chosen (The compiler does it correctly when the method is called directly without SRTP)

type Base() =
    abstract member Foo : unit -> unit
    default this.Foo() = printfn "Base"
    
type Derived() =
    inherit Base()
    member this.Foo() = printfn "Derived"
    
let inline callFoo< ^T when ^T : (member Foo: unit -> unit) > (t: ^T) =
    (^T : (member Foo: unit -> unit) (t))
    
let b = Base()
let d = Derived()
let bd = d :> Base

b.Foo()
bd.Foo()
d.Foo()

callFoo<Base> b
callFoo<Base> bd
callFoo<Base> d
// A unique overload for method 'Foo' could not be determined based on type information prior to this program point.
// A type annotation may be needed. Candidates:
//   abstract member Base.Foo : unit -> unit,
//   member Derived.Foo : unit -> unit
callFoo<Derived> d

Known workarounds

None AFAIK, if a library you use suddenly does it (Like Roslyn just did between 2.8.2 and 2.9.0) you must rewrite everything without SRTP.

Related information

Tested on SDK 2.1.300 & 2.1.400

[realvictorprm]

I've successfully looked into this and apparently there's definitely no check prior to filter out any methods which are higher in the object hirachy (if they're matching in signature).

[realvictorprm]

How should the compiler act for such an example:

type Base() =
    abstract member Foo : unit -> unit
    default this.Foo() = printfn "Base"
    
type Derived() =
    inherit Base()
    member this.Foo() = printfn "Derived"
    
type DerivedDerived() =
    inherit Derived()
    member this.Foo() = printfn "DerivedDerived"
    
let inline callFoo< ^T when ^T : (member Foo: unit -> unit) > (t: ^T) =
    (^T : (member Foo: unit -> unit) (t))
    
let b = Base()
let d = Derived()
let dd = DerivedDerived()
let bd = d :> Base
callFoo<Derived> d
callFoo<DerivedDerived> dd

Should callFoo<DerivedDerived> dd call Foo of DerivedDerived?

[zpodlovics]

If you are looking for overload resolution / late binding semantics corner cases, take a look at here and combine it with SRTPs:

eg.:

let inline callUpCv< ^T when ^T : (member Cv: Top -> unit) > (t: ^T) =
    (^T : (member Cv: Top -> unit) (t))

#3526

[vbfox]

@realvictorprm Compiler should have one single behavior. It's currently behaving one way when these methods are called without SRTP and should act exactly the same when SRTP is involved.

type Base() =
    abstract member Foo : unit -> unit
    default this.Foo() = printfn "Base"
    
type Derived() =
    inherit Base()
    member this.Foo() = printfn "Derived"
    
type DerivedDerived() =
    inherit Derived()
    member this.Foo() = printfn "DerivedDerived"
    
let inline callFoo< ^T when ^T : (member Foo: unit -> unit) > (t: ^T) =
    (^T : (member Foo: unit -> unit) (t))
    
let b = Base()
let d = Derived()
let dd = DerivedDerived()
let bd = d :> Base
d.Foo() //callFoo<Derived> d
dd.Foo() //callFoo<DerivedDerived> dd
bd.Foo() //callFoo<Base> bd

Prints:

Derived
DerivedDerived
Base

[realvictorprm]

OK great, I have the same opinion on this.