Hiding a base class member produces CS0109 but shouldn't

[YohDeadfall]

In the example below the Derived type hides a base class member, and there is used keyword new to suppress potential CS0108, but as the result CS0109 is produced by the compiler:

public class Base
{
    public Task DoSomething() => Task.CompletedTask;
}

public class Derived : Base
{
    public new Task DoSomething(CancellationToken token = default) // CS0109 
        => Task.CompletedTask;
}

It might seem that expression new Derived().DoSomething() calls Base.DoSomethig(), but actually the compiler recognizes that the new method should be invoked and generates the correct output.

Another example is:

public class Base
{
    public Task DoSomething(int x) => Task.CompletedTask;
    public Task DoSomething(int x, CancellationToken token) => Task.CompletedTask;
}

public class Derived : Base
{
    // Hides both base methods
    // Without new the compiler generates CS0108
    public new Task DoSomething(int x, CancellationToken token = default)
        => Task.CompletedTask;
}

Derived.DoSomething will be used instead of base class members, but no warning.

Language version: 8.0
Compiler version: 3.3.1-beta3-19423-01 (8cf35ae6)

[jcouv]

This seems by-design. The signatures of the two methods are different (one has no parameter and the other does). The new is unnecessary.

https://github.com/dotnet/csharplang/blob/master/spec/classes.md#the-new-modifier

[YohDeadfall]

I hope it's not by design because there is a bug one way or another. Let's see.

public class Program
{
    public static void Main() => new Derived().DoSomething();
}

public class Base
{
    public Task DoSomething() => Task.CompletedTask;
}

public class Derived : Base
{
    public Task DoSomething(CancellationToken token = default) => Task.CompletedTask;
}

This code is translated into (on SharpLab):

    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 21 (0x15)
        .maxstack 2
        .locals init (
            [0] valuetype [mscorlib]System.Threading.CancellationToken
        )

        IL_0000: newobj instance void Derived::.ctor()
        IL_0005: ldloca.s 0
        IL_0007: initobj [mscorlib]System.Threading.CancellationToken
        IL_000d: ldloc.0
        IL_000e: call instance class [mscorlib]System.Threading.Tasks.Task Derived::DoSomething(valuetype [mscorlib]System.Threading.CancellationToken)
        IL_0013: pop
        IL_0014: ret
    } // end of method Program::Main

So if Derived.DoSomething hides nothing why does the compiler uses it instead of Base.DoSomething? If it's a correct behavior, then the new keyword must be required and CS0109 must be raised in case when there is no new.

Speaking about the second code snippet, the compiler still prefers the method from the derived class, but no warnings are shown (on SharpLab):

public class Program
{
    public static void Main() => new Derived().DoSomething(42);
}

public class Base
{
    public Task DoSomething(int x) => Task.CompletedTask;
}

public class Derived : Base
{
    public Task DoSomething(int x, CancellationToken token = default) => Task.CompletedTask;
}

    .method public hidebysig static 
        void Main () cil managed 
    {
        // Method begins at RVA 0x2050
        // Code size 23 (0x17)
        .maxstack 3
        .locals init (
            [0] valuetype [mscorlib]System.Threading.CancellationToken
        )

        IL_0000: newobj instance void Derived::.ctor()
        IL_0005: ldc.i4.s 42
        IL_0007: ldloca.s 0
        IL_0009: initobj [mscorlib]System.Threading.CancellationToken
        IL_000f: ldloc.0
        IL_0010: call instance class [mscorlib]System.Threading.Tasks.Task Derived::DoSomething(int32, valuetype [mscorlib]System.Threading.CancellationToken)
        IL_0015: pop
        IL_0016: ret
    } // end of method Program::Main

[RikkiGibson]

It does seem like a scenario the original spec for the 'new' modifier didn't account for. This scenario doesn't meet the definition of 'hiding' used in the spec, but it can make it impossible to call the base member without casting to the base type.

[gafter]

The compiler is indeed behaving according to spec. Moving to csharplang for the LDM's consideration.

[gafter]

This is a question for the LDM: should we do anything about this?

[gafter]

We would like to do this as follows:

• Permit new when a method effectively hides another as in this example. We'd need to spec that concept.
• Give a new warning (in a warning wave) when you don't put new for those situations.

Because the latter requires a warning wave, this depends on that compiler feature.