8.2.5 Grammar ambiguities

[gafter]

The resolution we took in https://github.com/ECMA-TC49-TG2/spec/issues/880 does not appear to be correct. The current spec now says that the example

x = y is C<T> && z;

does not trigger disambiguation: "the tokens C<T> are interpreted as a namespace-or-type-name with a type-argument-list due to being on the right-hand side of the is operator (§13.11.1). Because C<T> parses as a namespace-or-type-name, not a simple-name, member-access, or pointer-member-access, the above rule does not apply, and it is considered to have a type-argument-list regardless of the token that follows."

As I show below, the token that follows needs to matter.

It is true that the disambiguation rules don't handle this case, but that still leaves the question as to why the right-hand-side of the is expression is the type C<T> rather than the type C followed by less-than operator. The following program demonstrates that this could be a valid parse:

public class Example
{
    public static void Main()
    {
    }
    static bool M(object y, C c, T t, Z z)
    {
        // return ((y is C) < t) > z;
        return y is C < t > z;
    }
}

class C
{
}

class T
{
    public static bool operator <(bool left, T right) => true;
    public static bool operator >(bool left, T right) => false;
}

class Z
{
    public static bool operator <(bool left, Z right) => true;
    public static bool operator >(bool left, Z right) => false;
}

Similarly, we may need to handle an expression such as F(e is G<A, B>7).

We might consider modifying the precedence of the is and as operators to forbid this. I believe existing compilers won't parse these examples.

[gafter]

While existing compilers cannot parse

        return y is C < t > z;

they can parse

        return y is C > t > z;

The addition of pattern-matching in C# 7 takes advantage of this to give a new meaning to the former.

[jskeet]

This is probably worth including in our discussion of ANTLR grammars tomorrow.

[RexJaeschke]

Just an FYI, we'll also touch this section to address a separate issue re adding support for out variables in V7. See #44, which might or might not impact how we deal with this issue now.

[gafter]

Disambiguating these kind of examples is explicitly handled in the PR for pattern-matching.