Why can't we declare a top-level delegate returning a value-tuple?

[Odepax]

In the following Program.cs listing, only the second to last delegate, I() gives off compile errors.

System.Console.WriteLine("Hello");

delegate int F(int x);
delegate int G((int, int) x);
delegate System.ValueTuple<int, int> H(int x);
delegate (int, int) I(int x);
class _ {
   delegate (int, int) J(int x);
}

As if to compensate for its uniqueness, it gives off tons of errors, actually:

 1: error CS8803: Top-level statements must precede namespace and type declarations.
14: error CS1001: Identifier expected
19: error CS1001: Identifier expected
21: error CS1514: { expected
21: error CS1002: ; expected
23: error CS1525: Invalid expression term 'int'
27: error CS1003: Syntax error, ',' expected

... But not one that would help me understand how I angered the compiler.

Just wondering. 😗

[bernd5]

It seems to be a roslyn bug.

delegate (int, int) I(int x);

it is parsed as anonymous method expression with some missing parts.
See: https://roslynquoter.azurewebsites.net/

CompilationUnit()
.WithMembers(
    List<MemberDeclarationSyntax>(
        new MemberDeclarationSyntax[]{
            GlobalStatement(
                ExpressionStatement(
                    AnonymousMethodExpression()
                    .WithParameterList(
                        ParameterList(
                            SeparatedList<ParameterSyntax>(
                                new SyntaxNodeOrToken[]{
                                    Parameter(
                                        MissingToken(SyntaxKind.IdentifierToken))
                                    .WithType(
                                        PredefinedType(
                                            Token(SyntaxKind.IntKeyword))),
                                    Token(SyntaxKind.CommaToken),
                                    Parameter(
                                        MissingToken(SyntaxKind.IdentifierToken))
                                    .WithType(
                                        PredefinedType(
                                            Token(SyntaxKind.IntKeyword)))})))
                    .WithBlock(
                        Block()
                        .WithOpenBraceToken(
                            MissingToken(SyntaxKind.OpenBraceToken))
                        .WithCloseBraceToken(
                            MissingToken(SyntaxKind.CloseBraceToken))))
                .WithSemicolonToken(
                    MissingToken(SyntaxKind.SemicolonToken))),
            GlobalStatement(
                ExpressionStatement(
                    InvocationExpression(
                        IdentifierName("I"))
                    .WithArgumentList(
                        ArgumentList(
                            SeparatedList<ArgumentSyntax>(
                                new SyntaxNodeOrToken[]{
                                    Argument(
                                        PredefinedType(
                                            Token(SyntaxKind.IntKeyword))),
                                    MissingToken(SyntaxKind.CommaToken),
                                    Argument(
                                        IdentifierName("x"))})))))}))
.NormalizeWhitespace()

[bernd5]

I think I found the actual bug - which is here:

https://github.com/dotnet/roslyn/blob/4731920a020c7433aead8999cda309165b43e727/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs#L2203

There we forgot valuetuple return types to disambiguate expression vs. member declarations

Please open an issue in the roslyn repo and link it here

[Odepax]

Just opened issue 67311.
Thanks for helping.