Nullability checks and optional parameters with default value

[thomaslevesque]

Sorry if a similar issue has already been raised, but if it exists, I couldn't find it...

In the following code, with nullability enabled, shouldn't T value = default cause a warning?

    internal class Foo<T>
    {
        public T Bar(T value = default)
        {
            return value;
        }
    }

If T is a non-nullable reference type, then default isn't a valid value for it.

Even if I add a notnull constraint on T, I still get no warning.

A warning is emitted only if I add a class constraint.

[thomaslevesque]

Also: if I call this method by explicitly passing default as an argument, I get a warning. But if I don't pass the argument (which is equivalent to passing default), no warning is emitted. That seems inconsistent...

var foo = new Foo<string>();
foo.Bar(default); // warning
foo.Bar(); // no warning

[spydacarnage]

I assume this is because if T is a value type, such as an int, its
default is 0, not null.

Adding the class constraint, however, confirms it won't be a value type,
and thus it can warn.

[thomaslevesque]

I assume this is because if T is a value type, such as an int, its
default is 0, not null.

Yes, I thought of that, but it doesn't seem like a valid argument to me. Just because there are cases where it would be valid, doesn't mean it should be allowed. The more important argument, IMO, is that there are cases where it would not be valid, so it shouldn't be allowed.

[huoyaoyuan]

Passing the same constant of default parameter should definitely provide same result if there's no overloads.

default(string) produces warning now just because it self.
default(T) produces no warning.
I think default should behaves like [MaybeNull]: converts TRef to TRef?, and warnings when assinged to TRef.

[YairHalberstadt]

See this proposal: https://github.com/dotnet/csharplang/pull/4101/files