Null conditional spec seems to no longer disallow `obj?.MethodGroup`

[jnm2]

The original wording of the spec seems to disallow obj?.MethodGroup due to the combination of the following (thanks to @RikkiGibson for finding this):

https://github.com/dotnet/csharplang/blob/main/spec/expressions.md#null-conditional-operator

If E0 is classified as nothing, then E is classified as nothing. Otherwise E is classified as a value.

https://github.com/dotnet/csharplang/blob/main/spec/expressions.md#expression-classifications

Expression classifications

An expression is classified as one of the following:

• A value. Every value has an associated type.
• ...
• A method group, which is a set of overloaded methods resulting from a member lookup (Member lookup)...A method group is permitted in an invocation_expression (Invocation expressions) , a delegate_creation_expression (Delegate creation expressions) and as the left hand side of an is operator, and can be implicitly converted to a compatible delegate type (Method group conversions). In any other context, an expression classified as a method group causes a compile-time error.

This is also the current behavior of the compiler (SharpLab):

using System;
using System.Collections.Generic;

class C
{
    // ❌ CS8978 'method group' cannot be made nullable.
    // (Older compiler: ❌ CS0023 Operator '?' cannot be applied to operand of type 'method group')
    //                             ↓
    Action<int> M(List<int> p) => p?.Add;
}

However, the current spec doesn't contain wording that seems to disallow this. I saw no statement that resembles the one in the original spec:

If E0 is classified as nothing, then E is classified as nothing. Otherwise E is classified as a value.

And reading the entire section as well as the member_access section didn't seem to speak on this at all.

https://github.com/dotnet/csharpstandard/blob/standard-v6/standard/expressions.md#1177-null-conditional-member-access

Rather, the spec says the null-conditional expression has the same meaning as ((object)P == null) ? null : P.A except that P is evaluated once. That conditional expression works for method groups.

[jnm2]

The conditional expression which obj?.MethodGroup is translated to, ((object)obj == null) ? null : obj.MethodGroup, doesn't work under the old compiler (C# 5):

error CS0173: Type of conditional expression cannot be determined because there is no implicit conversion between '' and 'method group'

Something has changed since to make the conditional expression begin to work. Perhaps this indirectly means the new spec is correct (for at least some versions of C#), and the compiler should now be updated to allow obj?.MethodGroup?

[RikkiGibson]

I think what we're trying to determine as part of this issue is:

1. From the old spec in csharplang to the new standard in csharpstandard, did we change from disallowing null-conditional method group to allowing it?
2. If the answer to (1) is yes, then was the change intentional?

[jskeet]

Assigned to @gafter and @Nigel-Ecma who've done the most work in this area.

[The-Futurist]

So why is this not allowed then?

var attributes_func = context.declarationBody()?.typeInfo()?.attribute;

The last element attribute is a method just like declarationBody and typeInfo.

This generates CS8978

[RikkiGibson]

Was there an opportunity to discuss this issue in meeting yet?

So why is this not allowed then?

I think it's not allowed by the compiler for the same reason as the original example. If the original example turns out to be allowed by the standard, then I think your example is too, and the compiler should be changed to allow both.

[gafter]

From the specification at https://github.com/dotnet/csharpstandard/blob/standard-v6/standard/expressions.md#1177-null-conditional-member-access, the type of P?.A is the type of P.A when that type is neither a type parameter (blah blah) nor a non-nullable value type. Well, there is no such type in this context. So how is it classified? There is no classification that fits.

The null-conditional invocation expression, on the other hand, was intended to be permitted. There is a hint here:

Unlike the syntactically equivalent null_conditional_member_access or null_conditional_element_access, a null_conditional_invocation_expression may be classified as nothing.

Oh, so tell me where it says the former cannot be classified as nothing? I think a constraint is missing. It says that the result cannot be void; is that the same thing? In any case, I believe it was intended not to be permitted.

While the null-conditional method group was not intended to be permitted, the null-conditional invocation expression was explicitly permitted.

[gafter]

Also, if the left-hand-side has an explicitly declared type, then the conditional expression works because we added target-typed conditional expressions in 8.0: https://github.com/dotnet/csharplang/blob/main/proposals/csharp-9.0/target-typed-conditional-expression.md . If the left-hand-side is declared with var, that won't work.