allow using ?. on certain expressions returning a ref struct

[YairHalberstadt]

Currently an expression such as myString?.AsSpan() ?? throw new ArgumentNullException() are illegal. This is because the specification defines myString?.AsSpan() as returning a Nullable<ReadOnlySpan<Char>>, and ref structs cannot be used as type parameters.

This is over-limiting for a couple of reasons:

a)

There's really no reason not to allow a nullable ref struct. Ideally we would like to be able to express conditional ref structness - i.e. Nullable<T> is a ref struct if and only if T is a ref struct.

Whilst I don't think it's worth adding this construct to the type system, the language and runtime might be able to specialise Nullable<T>.

b)

In many cases the compiler optimises away the temporary nullable anyway, even in debug. For example int M(string s) => s?.Length ?? 0; becomes:

        IL_0000: ldarg.1
        IL_0001: brtrue.s IL_0005

        IL_0003: ldc.i4.0
        IL_0004: ret

        IL_0005: ldarg.1
        IL_0006: call instance int32 [System.Private.CoreLib]System.String::get_Length()
        IL_000b: ret

Which is equivalent to:

        if (s == null)
        {
            return 0;
        }
        return s.Length;

It would be nice if we could formalize this in the specification, and thus allow ref structs to be part of such ?. expressions.

Here is an attempt at doing so:

Given an expression of form: subexpression1?.subexpression2 ?? subexpression3

where subExpressions can be any expression.

This is equivalent to: (subExpression1 is {} temp) ? temp.subexpression2 : subexpression3

[Leemyy]

I actually came across this whilst working on the specification for #2883.
In that case it would be impossible to use - or even construct - the value of a conditional assignment expression, if the type of the member being assigned to is a ref struct.

At first sight, I find the idea of ref struct generic arguments 'infecting' the generic type interesting. This way a lot of generic types would be able to be used with ref structs without any extra work. I am not sure, though, whether a ref-infected class could be done, so we might have to restict that behaviour to structs. Still an interesting idea worth exploring, imo.