Collection-Expression-Cast to non generic type is not recognized as cast but as ParenthesizedExpression

[bernd5]

Version Used: https://github.com/bernd5/roslyn/tree/d83425fde733763cd45c010209ce8ce2ae1185d3

Steps to Reproduce:

Try to compile the following code:

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;

ObjectList o = [1, 2];
var x = (ObjectList)[3, 4]; //<-- this fails to compile

class CustomListBuilder
{
    public static ObjectList Create(ReadOnlySpan<object> span)
    {
        var list = new ObjectList();
        foreach (var l in span)
        {
            list.Add(l);
        }
        return list;
    }
}

[CollectionBuilder(typeof(CustomListBuilder), "Create")]
class ObjectList : IEnumerable<object>
{
    private readonly List<object> _list = new();

    public IEnumerator<object> GetEnumerator()
    {
        return _list.GetEnumerator();
    }
    IEnumerator IEnumerable.GetEnumerator()
    {
        return _list.GetEnumerator();
    }

    public void Add(object item) => _list.Add(item);
    //and more...
}

Diagnostic Id:

// /Program.cs(7,10): error CS0119: 'ObjectList' is a type, which is not valid in the given context
// var x = (ObjectList)[3, 4];
Diagnostic(ErrorCode.ERR_BadSKunknown, "ObjectList").WithArguments("ObjectList", "type").WithLocation(7, 10),
// /Program.cs(7,10): error CS0119: 'ObjectList' is a type, which is not valid in the given context
// var x = (ObjectList)[3, 4];
Diagnostic(ErrorCode.ERR_BadSKunknown, "ObjectList").WithArguments("ObjectList", "type").WithLocation(7, 10)

Expected Behavior:
Should compile fine (like it does with generic types or global-qualified types)

Actual Behavior:
Fails to parse the cast which causes the error.

See the syntax tree:

LocalDeclarationStatement(
    VariableDeclaration(
        IdentifierName(
            Identifier(
                TriviaList(),
                SyntaxKind.VarKeyword,
                "var",
                "var",
                TriviaList())))
    .WithVariables(
        SingletonSeparatedList<VariableDeclaratorSyntax>(
            VariableDeclarator(
                Identifier("x"))
            .WithInitializer(
                EqualsValueClause(
                    ElementAccessExpression(
                        ParenthesizedExpression(
                            IdentifierName("ObjectList")))
                    .WithArgumentList(
                        BracketedArgumentList(
                            SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[]{
                                    Argument(
                                        LiteralExpression(
                                            SyntaxKind.NumericLiteralExpression,
                                            Literal(3))),
                                    Token(SyntaxKind.CommaToken),
                                    Argument(
                                        LiteralExpression(
                                            SyntaxKind.NumericLiteralExpression,
                                            Literal(4)))}))))))))
.NormalizeWhitespace()

It should be:

LocalDeclarationStatement(
    VariableDeclaration(
        IdentifierName(
            Identifier(
                TriviaList(),
                SyntaxKind.VarKeyword,
                "var",
                "var",
                TriviaList())))
    .WithVariables(
        SingletonSeparatedList<VariableDeclaratorSyntax>(
            VariableDeclarator(
                Identifier("x"))
            .WithInitializer(
                EqualsValueClause(
                    CastExpression(
                        IdentifierName("ObjectList"),
                        CollectionExpression(
                            SeparatedList<CollectionElementSyntax>(
                                new SyntaxNodeOrToken[]{
                                    ExpressionElement(
                                        LiteralExpression(
                                            SyntaxKind.NumericLiteralExpression,
                                            Literal(3))),
                                    Token(SyntaxKind.CommaToken),
                                    ExpressionElement(
                                        LiteralExpression(
                                            SyntaxKind.NumericLiteralExpression,
                                            Literal(4)))}))))))))

[bernd5]

Not sure if it can be handled while parsing (I assume not) – e.g. code like this must still work:

class App{

    public static void Main(){

        var x = (SomeArray)[0,0,0];
        System.Console.WriteLine(x);
    }

    public static int[,,] SomeArray = new int[1, 1, 1]{{{42}}};
}

[CyrusNajmabadi]

This is by design. As you saw, this is legal code that has to preserve meaning. If you want this to compile, do (SomeArray)([0,0,0])

[bernd5]

Can't we simply check it in the binding phase and do a fallback if it can not be parsed as an expression? Usually parentheses have no meaning in C# (single exception is stackalloc AFAIK)...
If not – I think it should be mentioned in the spec (https://github.com/dotnet/csharplang/blob/main/proposals/csharp-12.0/collection-expressions.md#syntax-ambiguities)

[CyrusNajmabadi]

Can't we simply check it in the binding phase

No. These entities are parsed entirely differently. A collection expression is not the same as an indexer argument list.

Usually parentheses have no meaning in C#

That's not true at all. Parentheses often have meaning. Especially in the context of cast expressions. For example: (A)-B is a subtraction expression. Whereas (A)(-B) is a cast expression. This has been part and parcel of the language since V1.

If not – I think it should be mentioned in the spec (dotnet/csharplang@main/proposals/csharp-12.0/collection-expressions.md#syntax-ambiguities)

Def open a suggestion on csharplang. This is by design for the feature though, and explicitly coded and tested for.

[bernd5]

Okay – thanks