Virtual Generic Method Bug?

[TonyValenti]

This seems like a bug to me. Shouldn't this compile?

public class Foo1 : Foo {
    protected override T? Serialization_Remove<T>(string Value) {
        return base.Serialization_Remove<T>(Value);
    }
}

public class Foo {
    protected virtual T? Serialization_Remove<T>(string Value) {
        return default;
    }
}

[333fred]

No. This does, though:

#nullable enable

public class Foo1 : Foo {
    protected override T? Serialization_Remove<T>(string Value) where T : default { // Note the new where clause here
        return base.Serialization_Remove<T>(Value);
    }
}

public class Foo {
    protected virtual T? Serialization_Remove<T>(string Value) {
        return default;
    }
}

From the docs:

The addition of nullable reference types introduces a potential ambiguity in the meaning of T? in generic methods. If T is a struct, T? is the same as System.Nullable. However, if T is a reference type, T? means that null is a valid value. The ambiguity arises because overriding methods can't include constraints. The new default constraint resolves this ambiguity. You'll add it when a base class or interface declares two overloads of a method, one that specifies the struct constraint, and one that doesn't have either the struct or class constraint applied:

[TonyValenti]

@333fred Thanks!

[TonyValenti]

@333fred - Also, why is the where T : default even necessary? The docs seem to indicate that the constraint is necessary to disambiguate two overloads of a method, but in my situation above, there aren't any overloads at all.

[CyrusNajmabadi]

because when we see the override we have to match it to a method. The override has a T? which we don't know if we should match against normal reference types, or if it should match against nullable structs. You could say: hey... exist in a super position where you might be either, and then go lookup the original, and hten if there is only one, then decide which you are.

This is especially problematic as prior to NRT then T? in an override was always a Nullable struct. And we'd like to keep that being nice and simple and true.

But that's a lot of complexity. We want to know up front what you meant so that we don't have to add all these caveats about when/if you might need this. So the rule is: you always have to tell us if your T? doesn't mean nullable-struct in an override. It then makes everything else simple as the meaning is defined properly at the declaration point, and not an outcome of some stitching together point that involves inheritance and whatnot.

[TonyValenti]

@333fred - When I'm coding in VS and I go into an empty Foo1 and use the override autocomplete, it generates the code that I used which doesn't work. Where would I report a bug in the autocompleter? Roslyn?

[333fred]

Yes, that would be a report on roslyn.