From 399051e5e68455969647b11821ef0200b79057f1 Mon Sep 17 00:00:00 2001 From: Alex Date: Tue, 2 Apr 2024 19:31:56 +0300 Subject: [PATCH] Improve generic type argument list error recovery (#69734) * Improve error recovery on missing > in method * Add many more tests * Recovery on properties * Recovery on tuples and more tests * Adjust tests * Fix type argument list termination and tests * Move another test * Better recovery logic and another test * Adjust test after improvement * Apply review comments * Add more tests covering type arg list break * Revert test adjustment * More comments and improve tests * Recover removed test * Formatting expected diagnostics Co-authored-by: Cyrus Najmabadi * Review comments * Add a lot more tests * Add `this` and `operator` * Add comments for terminating tokens * Remove test failures for bad recoveries * Fix spelling * Handle pattern matching keywords + tests * Fix tests * Add more tests in method declarations * Review comments * Tests + nits --------- Co-authored-by: Cyrus Najmabadi --- .../CSharp/Portable/Parser/LanguageParser.cs | 103 +- .../Semantics/NullableReferenceTypesTests.cs | 25 +- .../Parsing/MemberDeclarationParsingTests.cs | 6907 ++++++++++++++++- .../Syntax/Parsing/PatternParsingTests2.cs | 416 + .../Test/Syntax/Parsing/ScriptParsingTests.cs | 38 +- .../CodeActions/AddUsing/AddUsingTests.cs | 50 + ...ingTestsWithAddImportDiagnosticProvider.cs | 20 +- 7 files changed, 7475 insertions(+), 84 deletions(-) diff --git a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs index 0d94193097554..6ee66aec39cd7 100644 --- a/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs +++ b/src/Compilers/CSharp/Portable/Parser/LanguageParser.cs @@ -5801,6 +5801,7 @@ private ScanTypeFlags ScanPossibleTypeArgumentList( } ScanTypeFlags result = ScanTypeFlags.GenericTypeOrExpression; + ScanTypeFlags lastScannedType; do { @@ -5819,7 +5820,8 @@ private ScanTypeFlags ScanPossibleTypeArgumentList( return result; } - switch (this.ScanType(out _)) + lastScannedType = this.ScanType(out _); + switch (lastScannedType) { case ScanTypeFlags.NotType: greaterThanToken = null; @@ -5918,6 +5920,25 @@ private ScanTypeFlags ScanPossibleTypeArgumentList( if (this.CurrentToken.Kind != SyntaxKind.GreaterThanToken) { + // Error recovery after missing > token: + + // In the case of an identifier, we assume that there could be a missing > token + // For example, we have reached C in X token between )( + // as the user probably wants to invoke X by X<(string, string)>() + if (lastScannedType is ScanTypeFlags.TupleType && this.CurrentToken.Kind is SyntaxKind.OpenParenToken) + { + greaterThanToken = this.EatToken(SyntaxKind.GreaterThanToken); + return result; + } + greaterThanToken = null; return ScanTypeFlags.NotType; } @@ -5968,7 +5989,34 @@ private void ParseTypeArgumentList(out SyntaxToken open, SeparatedSyntaxListBuil { break; } - else if (this.CurrentToken.Kind == SyntaxKind.CommaToken || this.IsPossibleType()) + + // We prefer early terminating the argument list over parsing until exhaustion + // for better error recovery + if (tokenBreaksTypeArgumentList(this.CurrentToken)) + { + break; + } + + // We are currently past parsing a type and we encounter an unexpected identifier token + // followed by tokens that are not part of a type argument list + // Example: List<(string a, string b) Method() { } + // current token: ^^^^^^ + if (this.CurrentToken.Kind is SyntaxKind.IdentifierToken && tokenBreaksTypeArgumentList(this.PeekToken(1))) + { + break; + } + + // This is for the case where we are in a this[] accessor, and the last one of the parameters in the parameter list + // is missing a > on its type + // Example: X this[IEnumerable + // current token: ^^^^^^^^^ + if (this.CurrentToken.Kind is SyntaxKind.IdentifierToken + && this.PeekToken(1).Kind is SyntaxKind.CloseBracketToken) + { + break; + } + + if (this.CurrentToken.Kind == SyntaxKind.CommaToken || this.IsPossibleType()) { types.AddSeparator(this.EatToken(SyntaxKind.CommaToken)); types.Add(this.ParseTypeArgument()); @@ -5980,6 +6028,57 @@ private void ParseTypeArgumentList(out SyntaxToken open, SeparatedSyntaxListBuil } close = this.EatToken(SyntaxKind.GreaterThanToken); + + static bool tokenBreaksTypeArgumentList(SyntaxToken token) + { + var contextualKind = SyntaxFacts.GetContextualKeywordKind(token.ValueText); + switch (contextualKind) + { + // Example: x is IEnumerable + case SyntaxKind.OrKeyword: + // Example: x is IEnumerable + // but since we do not look as far as possible to determine whether it is + // a tuple type or an argument list, we resort to considering it as an + // argument list + case SyntaxKind.OpenParenToken: + + // Example: IEnumerable() --- (< in ) + case SyntaxKind.LessThanToken: + // Example: Method(IEnumerable null; + case SyntaxKind.EqualsGreaterThanToken: + // Example: IEnumerable list, SyntaxKind expected) diff --git a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs index 89e53153226dc..81d33246c8d68 100644 --- a/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs +++ b/src/Compilers/CSharp/Test/Semantic/Semantics/NullableReferenceTypesTests.cs @@ -153546,27 +153546,18 @@ public override void M1(C x) class C {} "); comp.VerifyDiagnostics( - // (11,32): error CS0305: Using the generic type 'C' requires 1 type arguments + // (11,26): error CS0115: 'B.M1(C)': no suitable method found to override // public override void M1(C x) - Diagnostic(ErrorCode.ERR_BadArity, "C x").WithArguments("C", "type", "1").WithLocation(11, 32), - // (11,54): error CS1003: Syntax error, ',' expected + Diagnostic(ErrorCode.ERR_OverrideNotExpected, "M1").WithArguments("B.M1(C)").WithLocation(11, 26), + // (11,54): error CS1003: Syntax error, '>' expected // public override void M1(C x) - Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(",").WithLocation(11, 54), - // (11,54): error CS0246: The type or namespace name 'x' could not be found (are you missing a using directive or an assembly reference?) + Diagnostic(ErrorCode.ERR_SyntaxError, "x").WithArguments(">").WithLocation(11, 54), + // (11,54): error CS0453: The type 'T?' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable' // public override void M1(C x) - Diagnostic(ErrorCode.ERR_SingleTypeNameNotFound, "x").WithArguments("x").WithLocation(11, 54), - // (11,55): error CS1003: Syntax error, '>' expected + Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "x").WithArguments("System.Nullable", "T", "T?").WithLocation(11, 54), + // (11,54): error CS0453: The type 'T' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable' // public override void M1(C x) - Diagnostic(ErrorCode.ERR_SyntaxError, ")").WithArguments(">").WithLocation(11, 55), - // (11,55): error CS1001: Identifier expected - // public override void M1(C x) - Diagnostic(ErrorCode.ERR_IdentifierExpected, ")").WithLocation(11, 55), - // (11,55): error CS0453: The type 'T?' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable' - // public override void M1(C x) - Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "").WithArguments("System.Nullable", "T", "T?").WithLocation(11, 55), - // (11,55): error CS0453: The type 'T' must be a non-nullable value type in order to use it as parameter 'T' in the generic type or method 'Nullable' - // public override void M1(C x) - Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "").WithArguments("System.Nullable", "T", "T").WithLocation(11, 55) + Diagnostic(ErrorCode.ERR_ValConstraintNotSatisfied, "x").WithArguments("System.Nullable", "T", "T").WithLocation(11, 54) ); } diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs index 971eab148dc8e..6a8d436530645 100644 --- a/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs +++ b/src/Compilers/CSharp/Test/Syntax/Parsing/MemberDeclarationParsingTests.cs @@ -776,17 +776,12 @@ public void GenericAsyncTask_01() foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) { UsingDeclaration("async Task' expected // async Task' expected - // async Task").WithLocation(1, 41) + Diagnostic(ErrorCode.ERR_SyntaxError, "Method").WithArguments(">").WithLocation(1, 35) ); - N(SyntaxKind.IncompleteMember); + + N(SyntaxKind.MethodDeclaration); { N(SyntaxKind.AsyncKeyword); N(SyntaxKind.GenericName); @@ -807,14 +802,16 @@ public void GenericAsyncTask_01() N(SyntaxKind.IdentifierToken, "SomeType"); } } - M(SyntaxKind.CommaToken); - N(SyntaxKind.IdentifierName); - { - N(SyntaxKind.IdentifierToken, "Method"); - } M(SyntaxKind.GreaterThanToken); } } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); } EOF(); } @@ -827,17 +824,12 @@ public void GenericPublicTask_01() foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) { UsingDeclaration("public Task' expected + // (1,36): error CS1003: Syntax error, '>' expected // public Task").WithLocation(1, 42) + Diagnostic(ErrorCode.ERR_SyntaxError, "Method").WithArguments(">").WithLocation(1, 36) ); - N(SyntaxKind.IncompleteMember); + + N(SyntaxKind.MethodDeclaration); { N(SyntaxKind.PublicKeyword); N(SyntaxKind.GenericName); @@ -858,14 +850,16 @@ public void GenericPublicTask_01() N(SyntaxKind.IdentifierToken, "SomeType"); } } - M(SyntaxKind.CommaToken); - N(SyntaxKind.IdentifierName); - { - N(SyntaxKind.IdentifierToken, "Method"); - } M(SyntaxKind.GreaterThanToken); } } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); } EOF(); } @@ -10477,5 +10471,6862 @@ public class Class } EOF(); } + + #region Missing > after generic + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) GetAllValues(Type t) + { + if (!t.IsEnum) + throw new ArgumentException("no good"); + + return Enum.GetValues(t).Cast().Select(e => (e.ToString(), e.ToString())); + } + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) GetAllValues(Type t) + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.IfStatement); + { + N(SyntaxKind.IfKeyword); + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.LogicalNotExpression); + { + N(SyntaxKind.ExclamationToken); + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "IsEnum"); + } + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.ThrowStatement); + { + N(SyntaxKind.ThrowKeyword); + N(SyntaxKind.ObjectCreationExpression); + { + N(SyntaxKind.NewKeyword); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ArgumentException"); + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.StringLiteralExpression); + { + N(SyntaxKind.StringLiteralToken, "\"no good\""); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + } + N(SyntaxKind.ReturnStatement); + { + N(SyntaxKind.ReturnKeyword); + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Enum"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetValues"); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "t"); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Cast"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Enum"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Select"); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.SimpleLambdaExpression); + { + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierToken, "e"); + } + N(SyntaxKind.EqualsGreaterThanToken); + N(SyntaxKind.TupleExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "e"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ToString"); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "e"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ToString"); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + // Parser expects: + // static IEnumerable<(string Value, string Description)> A(Type t); + const string source = + """ + static IEnumerable<(string Value, string Description) A' expected + // static IEnumerable<(string Value, string Description) A").WithLocation(1, 55), + // (1,59): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A' expected + // static IEnumerable<(string Value, string Description) A").WithLocation(1, 71)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "A"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), int GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,60): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), int GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 60)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method04() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), A::X GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,61): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), A::X GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 61)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method05() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), X.Y GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,60): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), X.Y GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 60)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Y"); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method06() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), A' expected + // static IEnumerable<(string Value, string Description), A").WithLocation(1, 60), + // (1,60): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), A").WithLocation(1, 60)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "A"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method07() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), A GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,61): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), A GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 61)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "A"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + N(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method08() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), ref int GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,64): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), ref int GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 64)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.RefType); + { + N(SyntaxKind.RefKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method09() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), int* GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,61): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), int* GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 61)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.AsteriskToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method10() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), int[] GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,62): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), int[] GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 62)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method11() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), string[] GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,65): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), string[] GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 65)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method12() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), int*[] GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,63): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), int*[] GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 63)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method13() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description), (X[], Y.Z) GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,67): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description), (X[], Y.Z) GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 67)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Y"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Z"); + } + } + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method14() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A.GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) A.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) A.GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "A").WithArguments(",").WithLocation(1, 55), + // (1,69): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 69)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method15() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) A::GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "A").WithArguments(",").WithLocation(1, 55), + // (1,70): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 70)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method16() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) A::B.GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "A").WithArguments(",").WithLocation(1, 55), + // (1,72): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 72)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method17() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) GetAllValues' expected + // static IEnumerable<(string Value, string Description) GetAllValues").WithLocation(1, 55), + // (1,69): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) GetAllValues").WithLocation(1, 69)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method18() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method19() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) B.GetAllValues' expected + // static IEnumerable<(string Value, string Description) B.GetAllValues").WithLocation(1, 71), + // (1,71): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) B.GetAllValues").WithLocation(1, 71)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method20() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) B.GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) B.GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "B").WithArguments(",").WithLocation(1, 55), + // (1,72): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 72)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method21() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::B.GetAllValues' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues").WithLocation(1, 74), + // (1,74): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues").WithLocation(1, 74)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method22() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) A::B.GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "A").WithArguments(",").WithLocation(1, 55), + // (1,75): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::B.GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 75)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "B"); + } + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method23() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::GetAllValues' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues").WithLocation(1, 72), + // (1,72): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues").WithLocation(1, 72)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Method24() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IEnumerable<(string Value, string Description) A::GetAllValues").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, ',' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "A").WithArguments(",").WithLocation(1, 55), + // (1,73): error CS1003: Syntax error, '>' expected + // static IEnumerable<(string Value, string Description) A::GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 73)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) Type> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) Type> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "Type").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) int> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) int> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) Alias::X> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) Alias::X> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "Alias").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.AliasQualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Alias"); + } + N(SyntaxKind.ColonColonToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method04() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) Outer.Inner> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) Outer.Inner> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "Outer").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Outer"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Inner"); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method05() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + // Unfortunately in this case we expect: + // static IDictionary<(string Value, string Description)> IEnumerable<@T>(GetAllValues @p1, (Type t) @p2); + const string source = + """ + static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, '>' expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "IEnumerable").WithArguments(">").WithLocation(1, 55), + // (1,67): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, "string").WithLocation(1, 67), + // (1,67): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "string").WithArguments(",").WithLocation(1, 67), + // (1,75): error CS1003: Syntax error, '(' expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "GetAllValues").WithArguments("(").WithLocation(1, 75), + // (1,87): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 87), + // (1,87): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(",").WithLocation(1, 87), + // (1,94): error CS8124: Tuple must contain at least two elements. + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_TupleTooFewElements, ")").WithLocation(1, 94), + // (1,95): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 95), + // (1,95): error CS1026: ) expected + // static IDictionary<(string Value, string Description) IEnumerable GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(1, 95)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + M(SyntaxKind.TypeParameter); + { + M(SyntaxKind.IdentifierToken); + } + N(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + M(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + M(SyntaxKind.CommaToken); + M(SyntaxKind.TupleElement); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method06() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + // Unfortunately in this case we expect: + // static IDictionary<(string Value, string Description)> IEnumerable<@T>(GetAllValues @p1, (Type t) @p2); + const string source = + """ + static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, '>' expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "IEnumerable").WithArguments(">").WithLocation(1, 55), + // (1,67): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, "string").WithLocation(1, 67), + // (1,67): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "string").WithArguments(",").WithLocation(1, 67), + // (1,74): error CS1003: Syntax error, '(' expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, ">").WithArguments("(").WithLocation(1, 74), + // (1,74): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, ">").WithLocation(1, 74), + // (1,88): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, "(").WithLocation(1, 88), + // (1,88): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(",").WithLocation(1, 88), + // (1,95): error CS8124: Tuple must contain at least two elements. + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_TupleTooFewElements, ")").WithLocation(1, 95), + // (1,96): error CS1001: Identifier expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_IdentifierExpected, ";").WithLocation(1, 96), + // (1,96): error CS1026: ) expected + // static IDictionary<(string Value, string Description) IEnumerable> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_CloseParenExpected, ";").WithLocation(1, 96)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + M(SyntaxKind.TypeParameter); + { + M(SyntaxKind.IdentifierToken); + } + N(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + M(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "GetAllValues"); + } + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + M(SyntaxKind.CommaToken); + M(SyntaxKind.TupleElement); + { + M(SyntaxKind.IdentifierName); + { + M(SyntaxKind.IdentifierToken); + } + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.IdentifierToken); + } + M(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method07() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) (string, int)> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IDictionary<(string Value, string Description) (string, int)> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IDictionary<(string Value, string Description) ").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, '>' expected + // static IDictionary<(string Value, string Description) (string, int)> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method08() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) (X, X.X, X.X.X)> GetAllValues GetAllValues' expected + // static IDictionary<(string Value, string Description) (X, X.X, X.X.X)> GetAllValues").WithLocation(1, 55)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method09() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) (A GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IDictionary<(string Value, string Description) (A GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IDictionary<(string Value, string Description) ").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, '>' expected + // static IDictionary<(string Value, string Description) (A GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method10() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) (A, C.D)> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,1): error CS1073: Unexpected token '(' + // static IDictionary<(string Value, string Description) (A, C.D)> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_UnexpectedToken, "static IDictionary<(string Value, string Description) ").WithArguments("(").WithLocation(1, 1), + // (1,55): error CS1003: Syntax error, '>' expected + // static IDictionary<(string Value, string Description) (A, C.D)> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.IncompleteMember); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method11() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) int*> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) int*> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method12() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) void*> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) void*> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "void").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method13() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) String**> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) String**> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "String").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PointerType); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "String"); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method14() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) int[]> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) int[]> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method15() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static IDictionary<(string Value, string Description) int*[]> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) int*[]> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",").WithLocation(1, 55)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.ArrayType); + { + N(SyntaxKind.PointerType); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.AsteriskToken); + } + N(SyntaxKind.ArrayRankSpecifier); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.OmittedArraySizeExpression); + { + N(SyntaxKind.OmittedArraySizeExpressionToken); + } + N(SyntaxKind.CloseBracketToken); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingCommaIncludingAngleBracket_Method16() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + // We actually parse + // static IDictionary<(string Value, string Description), int> GetAllValues(Type t); + // and entirely ignore the ref, but provide the ',' expected error in both places + const string source = + """ + static IDictionary<(string Value, string Description) ref int> GetAllValues(Type t); + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) ref int> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "ref").WithArguments(",").WithLocation(1, 55), + // (1,59): error CS1003: Syntax error, ',' expected + // static IDictionary<(string Value, string Description) ref int> GetAllValues(Type t); + Diagnostic(ErrorCode.ERR_SyntaxError, "int").WithArguments(",").WithLocation(1, 59)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "GetAllValues"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Type"); + } + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method' expected + // static void Method").WithLocation(1, 21), + // (3,14): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 14)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "t"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method' expected + // static void Method").WithLocation(1, 21), + // (3,29): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 29), + // (3,29): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 29)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "t"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method)Method, (Action)Method' expected + // static void Method").WithLocation(1, 21)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.SimpleAssignmentExpression); + { + N(SyntaxKind.DeclarationExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "var"); + } + N(SyntaxKind.ParenthesizedVariableDesignation); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "u"); + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.EqualsToken); + N(SyntaxKind.TupleExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment04() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method)Method, (Action>)Method' expected + // static void Method").WithLocation(1, 21)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.SimpleAssignmentExpression); + { + N(SyntaxKind.DeclarationExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "var"); + } + N(SyntaxKind.ParenthesizedVariableDesignation); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "u"); + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.EqualsToken); + N(SyntaxKind.TupleExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment05() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method' expected + // static void Method").WithLocation(1, 24), + // (3,17): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 17)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "t"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "U"); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment06() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method' expected + // static void Method").WithLocation(1, 24), + // (3,32): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 32), + // (3,32): error CS1003: Syntax error, '>' expected + // Action").WithLocation(3, 32)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "t"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "U"); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment07() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method)Method, (Action)Method' expected + // static void Method").WithLocation(1, 24)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.SimpleAssignmentExpression); + { + N(SyntaxKind.DeclarationExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "var"); + } + N(SyntaxKind.ParenthesizedVariableDesignation); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "u"); + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.EqualsToken); + N(SyntaxKind.TupleExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_GenericDelegateAssignment08() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + static void Method)Method, (Action>)Method' expected + // static void Method").WithLocation(1, 24)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "U"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.Block); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.SimpleAssignmentExpression); + { + N(SyntaxKind.DeclarationExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "var"); + } + N(SyntaxKind.ParenthesizedVariableDesignation); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "t"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.SingleVariableDesignation); + { + N(SyntaxKind.IdentifierToken, "u"); + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.EqualsToken); + N(SyntaxKind.TupleExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Method"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.CastExpression); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Action"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Method"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "U"); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Property01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) Values { get; set; } + """; + + UsingDeclaration(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) Values { get; set; } + Diagnostic(ErrorCode.ERR_SyntaxError, "Values").WithArguments(">").WithLocation(1, 48)); + + N(SyntaxKind.PropertyDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Values"); + N(SyntaxKind.AccessorList); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.GetAccessorDeclaration); + { + N(SyntaxKind.GetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.SetAccessorDeclaration); + { + N(SyntaxKind.SetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Property02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) Values => null; + """; + + UsingDeclaration(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) Values => null; + Diagnostic(ErrorCode.ERR_SyntaxError, "Values").WithArguments(">").WithLocation(1, 48)); + + N(SyntaxKind.PropertyDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Values"); + N(SyntaxKind.ArrowExpressionClause); + { + N(SyntaxKind.EqualsGreaterThanToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Property03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + Dictionary' expected + // Dictionary").WithLocation(1, 24)); + + N(SyntaxKind.PropertyDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "Dictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Values"); + N(SyntaxKind.AccessorList); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.GetAccessorDeclaration); + { + N(SyntaxKind.GetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.SetAccessorDeclaration); + { + N(SyntaxKind.SetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Property04() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description Values { get; set; } + """; + + UsingDeclaration(source, options, + // (1,47): error CS1026: ) expected + // IEnumerable<(string Value, string Description Values { get; set; } + Diagnostic(ErrorCode.ERR_CloseParenExpected, "Values").WithLocation(1, 47), + // (1,47): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description Values { get; set; } + Diagnostic(ErrorCode.ERR_SyntaxError, "Values").WithArguments(">").WithLocation(1, 47)); + + N(SyntaxKind.PropertyDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + M(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Values"); + N(SyntaxKind.AccessorList); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.GetAccessorDeclaration); + { + N(SyntaxKind.GetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.SetAccessorDeclaration); + { + N(SyntaxKind.SetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Property05() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description Values => null; + """; + + UsingDeclaration(source, options, + // (1,47): error CS1026: ) expected + // IEnumerable<(string Value, string Description Values => null; + Diagnostic(ErrorCode.ERR_CloseParenExpected, "Values").WithLocation(1, 47), + // (1,47): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description Values => null; + Diagnostic(ErrorCode.ERR_SyntaxError, "Values").WithArguments(">").WithLocation(1, 47)); + + N(SyntaxKind.PropertyDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + M(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Values"); + N(SyntaxKind.ArrowExpressionClause); + { + N(SyntaxKind.EqualsGreaterThanToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Local01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) values; + """; + + UsingStatement(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) values; + Diagnostic(ErrorCode.ERR_SyntaxError, "values").WithArguments(">").WithLocation(1, 48)); + + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Local02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) values = null; + """; + + UsingStatement(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) values = null; + Diagnostic(ErrorCode.ERR_SyntaxError, "values").WithArguments(">").WithLocation(1, 48)); + + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Local03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) + values = null, + otherValues, + moreValues + ; + """; + + UsingStatement(source, options, + // (1,47): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(">").WithLocation(1, 47)); + + N(SyntaxKind.LocalDeclarationStatement); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "otherValues"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "moreValues"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Field01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) values; + """; + + UsingDeclaration(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) values; + Diagnostic(ErrorCode.ERR_SyntaxError, "values").WithArguments(">").WithLocation(1, 48) + ); + + N(SyntaxKind.FieldDeclaration); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Field02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) values = null; + """; + + UsingDeclaration(source, options, + // (1,48): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) values = null; + Diagnostic(ErrorCode.ERR_SyntaxError, "values").WithArguments(">").WithLocation(1, 48)); + + N(SyntaxKind.FieldDeclaration); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(24642, "https://github.com/dotnet/roslyn/issues/24642")] + public void MissingClosingAngleBracket_Field03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + IEnumerable<(string Value, string Description) + values = null, + otherValues, + moreValues + ; + """; + + UsingDeclaration(source, options, + // (1,47): error CS1003: Syntax error, '>' expected + // IEnumerable<(string Value, string Description) + Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(">").WithLocation(1, 47)); + + N(SyntaxKind.FieldDeclaration); + { + N(SyntaxKind.VariableDeclaration); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "values"); + N(SyntaxKind.EqualsValueClause); + { + N(SyntaxKind.EqualsToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "otherValues"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.VariableDeclarator); + { + N(SyntaxKind.IdentifierToken, "moreValues"); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodArgumentList01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public void M(ImmutableArray' expected + // public void M(ImmutableArray").WithLocation(1, 34)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "arr"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodArgumentList02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public void M(ImmutableArray another); + """; + + UsingDeclaration(source, options, + // (1,34): error CS1003: Syntax error, ',' expected + // public void M(ImmutableArray another); + Diagnostic(ErrorCode.ERR_SyntaxError, "arr").WithArguments(",").WithLocation(1, 34), + // (1,59): error CS1003: Syntax error, '>' expected + // public void M(ImmutableArray another); + Diagnostic(ErrorCode.ERR_SyntaxError, "another").WithArguments(">").WithLocation(1, 59)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "arr"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "another"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodArgumentList03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public ImmutableArray' expected + // public ImmutableArray").WithLocation(1, 27), + // (1,48): error CS1003: Syntax error, ',' expected + // public ImmutableArray' expected + // public ImmutableArray").WithLocation(1, 70), + // (1,70): error CS1003: Syntax error, '>' expected + // public ImmutableArray").WithLocation(1, 70)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "a"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "b"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodArgumentList04() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public ImmutableArray' expected + // public ImmutableArray").WithLocation(1, 25), + // (1,28): error CS1003: Syntax error, '>' expected + // public ImmutableArray").WithLocation(1, 28), + // (1,46): error CS1003: Syntax error, ',' expected + // public ImmutableArray' expected + // public ImmutableArray").WithLocation(1, 66), + // (1,66): error CS1003: Syntax error, '>' expected + // public ImmutableArray").WithLocation(1, 66)); + + N(SyntaxKind.MethodDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.CommaToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "a"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "b"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodInvocation01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + Invoke' expected + // Invoke").WithLocation(1, 43), + // (1,74): error CS1003: Syntax error, '>' expected + // Invoke").WithLocation(1, 74)); + + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Invoke"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "a"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "b"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.NumericLiteralExpression); + { + N(SyntaxKind.NumericLiteralToken, "31"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.DefaultExpression); + { + N(SyntaxKind.DefaultKeyword); + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodInvocation02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + Invoke(31, default(ImmutableArray' expected + // Invoke(31, default(ImmutableArray").WithLocation(1, 75)); + + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Invoke"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "a"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "b"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.NumericLiteralExpression); + { + N(SyntaxKind.NumericLiteralToken, "31"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.DefaultExpression); + { + N(SyntaxKind.DefaultKeyword); + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_MethodInvocation03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + Invoke(31, default(ImmutableArray)); + """; + + UsingStatement(source, options); + + N(SyntaxKind.ExpressionStatement); + { + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Invoke"); + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.InvocationExpression); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "a"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "b"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ArgumentList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.NumericLiteralExpression); + { + N(SyntaxKind.NumericLiteralToken, "31"); + } + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Argument); + { + N(SyntaxKind.DefaultExpression); + { + N(SyntaxKind.DefaultKeyword); + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + N(SyntaxKind.CloseParenToken); + } + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_RecordPrimaryConstructorArgumentList01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public record M(ImmutableArray' expected + // public record M(ImmutableArray").WithLocation(1, 36)); + + N(SyntaxKind.RecordDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.RecordKeyword); + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Array"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_RecordPrimaryConstructorArgumentList02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public record M' expected + // public record M").WithLocation(1, 18), + // (1,36): error CS1003: Syntax error, '>' expected + // public record M").WithLocation(1, 36)); + + N(SyntaxKind.RecordDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.RecordKeyword); + N(SyntaxKind.IdentifierToken, "M"); + N(SyntaxKind.TypeParameterList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TypeParameter); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "ImmutableArray"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "T"); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "Array"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_RecordPrimaryConstructorArgumentList03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public record M' expected + // public record M").WithLocation(1, 18), + // (1,36): error CS1003: Syntax error, '>' expected + // public record M").WithLocation(1, 36), + // (2,14): error CS1003: Syntax error, '>' expected + // : Other").WithLocation(2, 14), + // (2,33): error CS1003: Syntax error, ',' expected + // : Other' expected + // public IEnumerable<(string Value, string Description) this[string index] { get; } + Diagnostic(ErrorCode.ERR_SyntaxError, "this").WithArguments(">").WithLocation(1, 55)); + + N(SyntaxKind.IndexerDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ThisKeyword); + N(SyntaxKind.BracketedParameterList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "index"); + } + N(SyntaxKind.CloseBracketToken); + } + N(SyntaxKind.AccessorList); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.GetAccessorDeclaration); + { + N(SyntaxKind.GetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_ThisAccessor02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public IEnumerable<(string Value, string Description) this[IDictionary' expected + // public IEnumerable<(string Value, string Description) this[IDictionary").WithLocation(1, 55), + // (1,84): error CS1003: Syntax error, '>' expected + // public IEnumerable<(string Value, string Description) this[IDictionary").WithLocation(1, 84)); + + N(SyntaxKind.IndexerDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ThisKeyword); + N(SyntaxKind.BracketedParameterList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "keys"); + } + N(SyntaxKind.CloseBracketToken); + } + N(SyntaxKind.AccessorList); + { + N(SyntaxKind.OpenBraceToken); + N(SyntaxKind.GetAccessorDeclaration); + { + N(SyntaxKind.GetKeyword); + N(SyntaxKind.SemicolonToken); + } + N(SyntaxKind.CloseBraceToken); + } + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_ThisAccessor03() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public IEnumerable<(string Value, string Description) this[IDictionary null; + """; + + UsingDeclaration(source, options, + // (1,55): error CS1003: Syntax error, '>' expected + // public IEnumerable<(string Value, string Description) this[IDictionary null; + Diagnostic(ErrorCode.ERR_SyntaxError, "this").WithArguments(">").WithLocation(1, 55), + // (1,84): error CS1003: Syntax error, '>' expected + // public IEnumerable<(string Value, string Description) this[IDictionary null; + Diagnostic(ErrorCode.ERR_SyntaxError, "keys").WithArguments(">").WithLocation(1, 84)); + + N(SyntaxKind.IndexerDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ThisKeyword); + N(SyntaxKind.BracketedParameterList); + { + N(SyntaxKind.OpenBracketToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IDictionary"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.IntKeyword); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.IdentifierToken, "keys"); + } + N(SyntaxKind.CloseBracketToken); + } + N(SyntaxKind.ArrowExpressionClause); + { + N(SyntaxKind.EqualsGreaterThanToken); + N(SyntaxKind.NullLiteralExpression); + { + N(SyntaxKind.NullKeyword); + } + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_Operator01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public static IEnumerable<(string Value, string Description) operator +(X left, X right); + """; + + UsingDeclaration(source, options, + // (1,62): error CS1003: Syntax error, '>' expected + // public static IEnumerable<(string Value, string Description) operator +(X left, X right); + Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(">").WithLocation(1, 62)); + + N(SyntaxKind.OperatorDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.OperatorKeyword); + N(SyntaxKind.PlusToken); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "left"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "right"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_Operator02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public static IEnumerable<(string Value, string Description) operator checked +(X left, X right); + """; + + UsingDeclaration(source, options, + // (1,62): error CS1003: Syntax error, '>' expected + // public static IEnumerable<(string Value, string Description) operator checked +(X left, X right); + Diagnostic(ErrorCode.ERR_SyntaxError, "operator").WithArguments(">").WithLocation(1, 62)); + + N(SyntaxKind.OperatorDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.OperatorKeyword); + N(SyntaxKind.CheckedKeyword); + N(SyntaxKind.PlusToken); + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "left"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "right"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_ConversionOperator01() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public static implicit operator IEnumerable<(string Value, string Description)(X source); + """; + + UsingDeclaration(source, options, + // (1,79): error CS1003: Syntax error, '>' expected + // public static implicit operator IEnumerable<(string Value, string Description)(X source); + Diagnostic(ErrorCode.ERR_SyntaxError, "(").WithArguments(">").WithLocation(1, 79)); + + N(SyntaxKind.ConversionOperatorDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.ImplicitKeyword); + N(SyntaxKind.OperatorKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.TupleType); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Value"); + } + N(SyntaxKind.CommaToken); + N(SyntaxKind.TupleElement); + { + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + N(SyntaxKind.IdentifierToken, "Description"); + } + N(SyntaxKind.CloseParenToken); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "source"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + [Fact] + [WorkItem(48566, "https://github.com/dotnet/roslyn/issues/48566")] + public void MissingClosingAngleBracket_ConversionOperator02() + { + foreach (var options in new[] { TestOptions.Script, TestOptions.Regular }) + { + const string source = + """ + public static implicit operator IEnumerable' expected + // public static implicit operator IEnumerable").WithLocation(1, 51)); + + N(SyntaxKind.ConversionOperatorDeclaration); + { + N(SyntaxKind.PublicKeyword); + N(SyntaxKind.StaticKeyword); + N(SyntaxKind.ImplicitKeyword); + N(SyntaxKind.OperatorKeyword); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "IEnumerable"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.StringKeyword); + } + M(SyntaxKind.GreaterThanToken); + } + } + N(SyntaxKind.ParameterList); + { + N(SyntaxKind.OpenParenToken); + N(SyntaxKind.Parameter); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + N(SyntaxKind.IdentifierToken, "source"); + } + N(SyntaxKind.CloseParenToken); + } + N(SyntaxKind.SemicolonToken); + } + EOF(); + } + } + + #endregion } } diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs index 51fd79f19312e..ddc8174b9dbe3 100644 --- a/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs +++ b/src/Compilers/CSharp/Test/Syntax/Parsing/PatternParsingTests2.cs @@ -945,5 +945,421 @@ public void ExtendedPropertySubpattern_InPositionalPattern() } EOF(); } + + #region Missing > in type parameter list + + [Fact] + public void MissingClosingAngleBracket01() + { + UsingExpression(@"e is List' expected + // e is List").WithLocation(1, 15), + // (1,30): error CS1525: Invalid expression term 'int' + // e is List' expected + // e is not List").WithLocation(1, 19), + // (1,39): error CS1525: Invalid expression term 'int' + // e is not List' expected + // e is (not List").WithLocation(1, 20), + // (1,40): error CS1525: Invalid expression term 'int' + // e is (not List' expected + // e is (not List").WithLocation(1, 57), + // (1,77): error CS1525: Invalid expression term 'int' + // e is (not List' expected + // e is A.B").WithLocation(1, 12)); + + N(SyntaxKind.LessThanExpression); + { + N(SyntaxKind.IsPatternExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "e"); + } + N(SyntaxKind.IsKeyword); + N(SyntaxKind.OrPattern); + { + N(SyntaxKind.TypePattern); + { + N(SyntaxKind.QualifiedName); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "A"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.GenericName); + { + N(SyntaxKind.IdentifierToken, "B"); + N(SyntaxKind.TypeArgumentList); + { + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "X"); + } + M(SyntaxKind.GreaterThanToken); + } + } + } + } + N(SyntaxKind.OrKeyword); + N(SyntaxKind.ConstantPattern); + { + N(SyntaxKind.SimpleMemberAccessExpression); + { + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "C"); + } + N(SyntaxKind.DotToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "D"); + } + } + } + } + } + N(SyntaxKind.LessThanToken); + N(SyntaxKind.IdentifierName); + { + N(SyntaxKind.IdentifierToken, "Y"); + } + } + EOF(); + } + + #endregion } } diff --git a/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs b/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs index 17d12a4d447e1..18a55b0dd7804 100644 --- a/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs +++ b/src/Compilers/CSharp/Test/Syntax/Parsing/ScriptParsingTests.cs @@ -9236,38 +9236,34 @@ public void GlobalStatementSeparators_Comma2() a < b, void goo() { } ", - // (2,6): error CS1002: ; expected - // a < b, - Diagnostic(ErrorCode.ERR_SemicolonExpected, ",").WithLocation(2, 6), - // (2,6): error CS7017: Member definition, statement, or end-of-file expected - // a < b, - Diagnostic(ErrorCode.ERR_GlobalDefinitionOrStatementExpected, ",").WithLocation(2, 6)); + // (3,1): error CS1547: Keyword 'void' cannot be used in this context + // void goo() { } + Diagnostic(ErrorCode.ERR_NoVoidHere, "void").WithLocation(3, 1), + // (3,6): error CS1003: Syntax error, '>' expected + // void goo() { } + Diagnostic(ErrorCode.ERR_SyntaxError, "goo").WithArguments(">").WithLocation(3, 6)); + N(SyntaxKind.CompilationUnit); { - N(SyntaxKind.GlobalStatement); + N(SyntaxKind.MethodDeclaration); { - N(SyntaxKind.ExpressionStatement); + N(SyntaxKind.GenericName); { - N(SyntaxKind.LessThanExpression); + N(SyntaxKind.IdentifierToken, "a"); + N(SyntaxKind.TypeArgumentList); { - N(SyntaxKind.IdentifierName); - { - N(SyntaxKind.IdentifierToken, "a"); - } N(SyntaxKind.LessThanToken); N(SyntaxKind.IdentifierName); { N(SyntaxKind.IdentifierToken, "b"); } + N(SyntaxKind.CommaToken); + N(SyntaxKind.PredefinedType); + { + N(SyntaxKind.VoidKeyword); + } + M(SyntaxKind.GreaterThanToken); } - M(SyntaxKind.SemicolonToken); - } - } - N(SyntaxKind.MethodDeclaration); - { - N(SyntaxKind.PredefinedType); - { - N(SyntaxKind.VoidKeyword); } N(SyntaxKind.IdentifierToken, "goo"); N(SyntaxKind.ParameterList); diff --git a/src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AddUsingTests.cs b/src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AddUsingTests.cs index 01047342c26bf..c17cda9948689 100644 --- a/src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AddUsingTests.cs +++ b/src/EditorFeatures/CSharpTest/CodeActions/AddUsing/AddUsingTests.cs @@ -6527,5 +6527,55 @@ class Class index: 0, parameters: new TestParameters(options: Option(FormattingOptions2.NewLine, configuredNewLine), testHost: testHost)); } + + [Theory] + [CombinatorialData] + [WorkItem("https://github.com/dotnet/roslyn/issues/24642")] + public async Task TestAddUsingWithMalformedGeneric(TestHost testHost) + { + await TestInRegularAndScript1Async( + """ + class Class + { + [|List