Is a member binding expression really an expression in C#?

A member binding expression looks like this:

.something

This is a valid expression according to the grammar, but I don’t think it is.

It’s used in conditional access expression (a?.b). The grammer pretends that any expression can follow the ?, but only a member access or array access can.

So presumably, the same is true for array access. [1] would be a valid statement according to this grammar, while I think it shouldn’t be.

[damieng]

Okay, I have a fix incoming for this that also solves #131. It doesn’t add any new conflict rules and actually drops the Roslyn file parsing issues from 27 files to 25 and does not introduce any new example failures. PR in a few minutes.

[Sjord]

I now better understand how conditional access expressions (a?.b) are parsed in Roslyn, and why a member binding expression (.something) was an expression. Of course .something is not a valid expression in itself, but it is used in many things that take an expression.

a?.b() only performs the invocation on b if a is not null, so it’s parsed like a?(.b()). This means that the parse tree looks like this:

• conditional_access_expression
  • identifier
  • invocation_expression
    • member_binding_expression
    • argument_list

As you see, the member_binding_expression is moved down into the invocation_expression. invocation_expression consists of an invocation on any expression, and here it invokes a member_binding_expression, so member_binding_expression should be a type of expression.

This also means that (in Roslyn), the right part of the conditional_access_expression can be many things, not only a member_binding_expression. So that is why the right arm of the conditional_access_expression could contain any expression.