src/Compilers/CSharp/Test/Syntax/Parsing/ExpressionParsingTests.cs - main - githubmirror/roslyn

src/Compilers/CSharp/Test/Syntax/Parsing/ExpressionParsingTests.cs
9 381 строка404 KB
Jan Jones
Unsafe evolution: unsafe expressions (#84012)
16 июн 2026, 18:53
16 июн 2026, 18:53610e1e1
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
// See the LICENSE file in the project root for more information.

#nullable disable

using System.Linq;
using Microsoft.CodeAnalysis.CSharp.Syntax;
using Microsoft.CodeAnalysis.CSharp.Test.Utilities;
using Roslyn.Test.Utilities;
using Xunit;
using Xunit.Abstractions;

namespace Microsoft.CodeAnalysis.CSharp.UnitTests
{
    public class ExpressionParsingTests : ParsingTests
    {
        public ExpressionParsingTests(ITestOutputHelper output) : base(output) { }

        protected override SyntaxTree ParseTree(string text, CSharpParseOptions options)
        {
            return SyntaxFactory.ParseSyntaxTree(text, options: options);
        }

        private ExpressionSyntax ParseExpression(string text, ParseOptions options = null)
        {
            return SyntaxFactory.ParseExpression(text, options: options);
        }

        [Fact]
        public void TestEmptyString()
        {
            var text = string.Empty;
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.IdentifierName, expr.Kind());
            Assert.True(((IdentifierNameSyntax)expr).Identifier.IsMissing);
            Assert.Equal(text, expr.ToString());
            Assert.Equal(1, expr.Errors().Length);
            Assert.Equal((int)ErrorCode.ERR_ExpressionExpected, expr.Errors()[0].Code);
        }

        [Fact]
        public void TestInterpolatedVerbatimString()
        {
            UsingExpression(@"$@""hello""");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestInterpolatedSingleLineRawString1()
        {
            UsingExpression(@"$""""""{1 + 1}""""""");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedSingleLineRawStringStartToken);
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.AddExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        N(SyntaxKind.PlusToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedRawStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestInterpolatedSingleLineRawString2()
        {
            UsingExpression(@"$$""""""{{{1 + 1}}}""""""");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedSingleLineRawStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.AddExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        N(SyntaxKind.PlusToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedRawStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestInterpolatedMultiLineRawString1()
        {
            UsingExpression(@"$""""""
    {1 + 1}
    """"""");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedMultiLineRawStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.AddExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        N(SyntaxKind.PlusToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedRawStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestInterpolatedMultiLineRawString2()
        {
            UsingExpression(@"$$""""""
    {{{1 + 1}}}
    """"""");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedMultiLineRawStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.AddExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        N(SyntaxKind.PlusToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedRawStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestAltInterpolatedVerbatimString_CSharp73()
        {
            var text = @"@$""hello""";
            CreateCompilation($@"
class C
{{
    void M()
    {{
        var v = {text};
    }}
}}", parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)).VerifyDiagnostics(
                // (6,17): error CS8370: Feature 'alternative interpolated verbatim strings' is not available in C# 7.3. Please use language version 8.0 or greater.
                //         var v = @$"hello";
                Diagnostic(ErrorCode.ERR_AltInterpolatedVerbatimStringsNotAvailable, @"@$""").WithArguments("8.0").WithLocation(6, 17));

            UsingExpression(text, TestOptions.Regular7_3);

            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestAltInterpolatedVerbatimString_CSharp8()
        {
            var text = @"@$""hello""";
            CreateCompilation($@"
class C
{{
    void M()
    {{
        var v = {text};
    }}
}}", parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp8)).VerifyDiagnostics();

            UsingExpression(text, TestOptions.Regular8);
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestNestedAltInterpolatedVerbatimString_CSharp73()
        {
            var text = "$@\"aaa{@$\"bbb\nccc\"}ddd\"";
            CreateCompilation($@"
class C
{{
    void M()
    {{
        var v = {text};
    }}
}}", parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp7_3)).VerifyDiagnostics(
                // (6, 24): error CS8401: To use '@$' instead of '$@' for an interpolated verbatim string, please use language version '8.0' or greater.
                // $@"aaa{@$"bbb
                Diagnostic(ErrorCode.ERR_AltInterpolatedVerbatimStringsNotAvailable, @"@$""").WithArguments("8.0").WithLocation(6, 24));

            UsingExpression(text, TestOptions.Regular7_3);

            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken, "aaa");
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.InterpolatedStringExpression);
                    {
                        N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                        N(SyntaxKind.InterpolatedStringText);
                        {
                            N(SyntaxKind.InterpolatedStringTextToken, "bbb\nccc");
                        }
                        N(SyntaxKind.InterpolatedStringEndToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken, "ddd");
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestNestedAltInterpolatedVerbatimString_CSharp8()
        {
            var text = "$@\"aaa{@$\"bbb\nccc\"}ddd\"";

            CreateCompilation($@"
class C
{{
    void M()
    {{
        var v = {text};
    }}
}}", parseOptions: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp8)).VerifyDiagnostics();

            UsingExpression(text, TestOptions.Regular8);

            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken, "aaa");
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.InterpolatedStringExpression);
                    {
                        N(SyntaxKind.InterpolatedVerbatimStringStartToken);
                        N(SyntaxKind.InterpolatedStringText);
                        {
                            N(SyntaxKind.InterpolatedStringTextToken, "bbb\nccc");
                        }
                        N(SyntaxKind.InterpolatedStringEndToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken, "ddd");
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void TestInterpolatedStringWithNewLinesInExpression()
        {
            var text = @"$""Text with {
    new[] {
        1, 2, 3
    }[2]
} parts and new line expressions!""";

            UsingExpression(text, TestOptions.RegularPreview);

            var expr = (InterpolatedStringExpressionSyntax)N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.ElementAccessExpression);
                    {
                        N(SyntaxKind.ImplicitArrayCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.CloseBracketToken);
                            N(SyntaxKind.ArrayInitializerExpression);
                            {
                                N(SyntaxKind.OpenBraceToken);
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "1");
                                }
                                N(SyntaxKind.CommaToken);
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "2");
                                }
                                N(SyntaxKind.CommaToken);
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "3");
                                }
                                N(SyntaxKind.CloseBraceToken);
                            }
                        }
                        N(SyntaxKind.BracketedArgumentList);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.Argument);
                            {
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "2");
                                }
                            }
                            N(SyntaxKind.CloseBracketToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();

            Assert.Equal("Text with ", expr.Contents[0].ToString());
            Assert.Equal(" parts and new line expressions!", expr.Contents[2].ToString());
        }

        [Fact]
        public void TestName()
        {
            var text = "goo";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.IdentifierName, expr.Kind());
            Assert.False(((IdentifierNameSyntax)expr).Identifier.IsMissing);
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
        }

        [Fact]
        public void TestParenthesizedExpression()
        {
            var text = "(goo)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
        }

        private void TestLiteralExpression(SyntaxKind kind)
        {
            var text = SyntaxFacts.GetText(kind);
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetLiteralExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            var us = (LiteralExpressionSyntax)expr;
            Assert.NotEqual(default, us.Token);
            Assert.Equal(kind, us.Token.Kind());
        }

        [Fact]
        public void TestPrimaryExpressions()
        {
            TestLiteralExpression(SyntaxKind.NullKeyword);
            TestLiteralExpression(SyntaxKind.TrueKeyword);
            TestLiteralExpression(SyntaxKind.FalseKeyword);
            TestLiteralExpression(SyntaxKind.ArgListKeyword);
        }

        private void TestInstanceExpression(SyntaxKind kind)
        {
            var text = SyntaxFacts.GetText(kind);
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetInstanceExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            SyntaxToken token;
            switch (expr.Kind())
            {
                case SyntaxKind.ThisExpression:
                    token = ((ThisExpressionSyntax)expr).Token;
                    Assert.NotEqual(default, token);
                    Assert.Equal(kind, token.Kind());
                    break;
                case SyntaxKind.BaseExpression:
                    token = ((BaseExpressionSyntax)expr).Token;
                    Assert.NotEqual(default, token);
                    Assert.Equal(kind, token.Kind());
                    break;
            }
        }

        [Fact]
        public void TestInstanceExpressions()
        {
            TestInstanceExpression(SyntaxKind.ThisKeyword);
            TestInstanceExpression(SyntaxKind.BaseKeyword);
        }

        [Fact]
        public void TestStringLiteralExpression()
        {
            var text = "\"stuff\"";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.StringLiteralExpression, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            var us = (LiteralExpressionSyntax)expr;
            Assert.NotEqual(default, us.Token);
            Assert.Equal(SyntaxKind.StringLiteralToken, us.Token.Kind());
        }

        [WorkItem(540379, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/540379")]
        [Fact]
        public void TestVerbatimLiteralExpression()
        {
            var text = "@\"\"\"stuff\"\"\"";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.StringLiteralExpression, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            var us = (LiteralExpressionSyntax)expr;
            Assert.NotEqual(default, us.Token);
            Assert.Equal(SyntaxKind.StringLiteralToken, us.Token.Kind());
            Assert.Equal("\"stuff\"", us.Token.ValueText);
        }

        [Fact]
        public void TestCharacterLiteralExpression()
        {
            var text = "'c'";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.CharacterLiteralExpression, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            var us = (LiteralExpressionSyntax)expr;
            Assert.NotEqual(default, us.Token);
            Assert.Equal(SyntaxKind.CharacterLiteralToken, us.Token.Kind());
        }

        [Fact]
        public void TestNumericLiteralExpression()
        {
            var text = "0";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.NumericLiteralExpression, expr.Kind());
            Assert.Equal(0, expr.Errors().Length);
            var us = (LiteralExpressionSyntax)expr;
            Assert.NotEqual(default, us.Token);
            Assert.Equal(SyntaxKind.NumericLiteralToken, us.Token.Kind());
        }

        private void TestPrefixUnary(SyntaxKind kind)
        {
            var text = SyntaxFacts.GetText(kind) + "a";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetPrefixUnaryExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var us = (PrefixUnaryExpressionSyntax)expr;
            Assert.NotEqual(default, us.OperatorToken);
            Assert.Equal(kind, us.OperatorToken.Kind());
            Assert.NotNull(us.Operand);
            Assert.Equal(SyntaxKind.IdentifierName, us.Operand.Kind());
            Assert.Equal("a", us.Operand.ToString());
        }

        [Fact]
        public void TestPrefixUnaryOperators()
        {
            TestPrefixUnary(SyntaxKind.PlusToken);
            TestPrefixUnary(SyntaxKind.MinusToken);
            TestPrefixUnary(SyntaxKind.TildeToken);
            TestPrefixUnary(SyntaxKind.ExclamationToken);
            TestPrefixUnary(SyntaxKind.PlusPlusToken);
            TestPrefixUnary(SyntaxKind.MinusMinusToken);
            TestPrefixUnary(SyntaxKind.AmpersandToken);
            TestPrefixUnary(SyntaxKind.AsteriskToken);
        }

        private void TestPostfixUnary(SyntaxKind kind, ParseOptions options = null)
        {
            var text = "a" + SyntaxFacts.GetText(kind);
            var expr = this.ParseExpression(text, options: options);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetPostfixUnaryExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var us = (PostfixUnaryExpressionSyntax)expr;
            Assert.NotEqual(default, us.OperatorToken);
            Assert.Equal(kind, us.OperatorToken.Kind());
            Assert.NotNull(us.Operand);
            Assert.Equal(SyntaxKind.IdentifierName, us.Operand.Kind());
            Assert.Equal("a", us.Operand.ToString());
        }

        [Fact]
        public void TestPostfixUnaryOperators()
        {
            TestPostfixUnary(SyntaxKind.PlusPlusToken);
            TestPostfixUnary(SyntaxKind.MinusMinusToken);
            TestPostfixUnary(SyntaxKind.ExclamationToken, TestOptions.Regular8);
        }

        private void TestBinary(SyntaxKind kind)
        {
            var text = "(a) " + SyntaxFacts.GetText(kind) + " b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetBinaryExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var b = (BinaryExpressionSyntax)expr;
            Assert.NotEqual(default, b.OperatorToken);
            Assert.Equal(kind, b.OperatorToken.Kind());
            Assert.NotNull(b.Left);
            Assert.NotNull(b.Right);
            Assert.Equal("(a)", b.Left.ToString());
            Assert.Equal("b", b.Right.ToString());
        }

        [Fact]
        public void TestBinaryOperators()
        {
            TestBinary(SyntaxKind.PlusToken);
            TestBinary(SyntaxKind.MinusToken);
            TestBinary(SyntaxKind.AsteriskToken);
            TestBinary(SyntaxKind.SlashToken);
            TestBinary(SyntaxKind.PercentToken);
            TestBinary(SyntaxKind.EqualsEqualsToken);
            TestBinary(SyntaxKind.ExclamationEqualsToken);
            TestBinary(SyntaxKind.LessThanToken);
            TestBinary(SyntaxKind.LessThanEqualsToken);
            TestBinary(SyntaxKind.LessThanLessThanToken);
            TestBinary(SyntaxKind.GreaterThanToken);
            TestBinary(SyntaxKind.GreaterThanEqualsToken);
            TestBinary(SyntaxKind.GreaterThanGreaterThanToken);
            TestBinary(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
            TestBinary(SyntaxKind.AmpersandToken);
            TestBinary(SyntaxKind.AmpersandAmpersandToken);
            TestBinary(SyntaxKind.BarToken);
            TestBinary(SyntaxKind.BarBarToken);
            TestBinary(SyntaxKind.CaretToken);
            TestBinary(SyntaxKind.IsKeyword);
            TestBinary(SyntaxKind.AsKeyword);
            TestBinary(SyntaxKind.QuestionQuestionToken);
        }

        private void TestAssignment(SyntaxKind kind, ParseOptions options = null)
        {
            var text = "(a) " + SyntaxFacts.GetText(kind) + " b";
            var expr = this.ParseExpression(text, options);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetAssignmentExpression(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var a = (AssignmentExpressionSyntax)expr;
            Assert.NotEqual(default, a.OperatorToken);
            Assert.Equal(kind, a.OperatorToken.Kind());
            Assert.NotNull(a.Left);
            Assert.NotNull(a.Right);
            Assert.Equal("(a)", a.Left.ToString());
            Assert.Equal("b", a.Right.ToString());
        }

        [Fact]
        public void TestAssignmentOperators()
        {
            TestAssignment(SyntaxKind.PlusEqualsToken);
            TestAssignment(SyntaxKind.MinusEqualsToken);
            TestAssignment(SyntaxKind.AsteriskEqualsToken);
            TestAssignment(SyntaxKind.SlashEqualsToken);
            TestAssignment(SyntaxKind.PercentEqualsToken);
            TestAssignment(SyntaxKind.EqualsToken);
            TestAssignment(SyntaxKind.LessThanLessThanEqualsToken);
            TestAssignment(SyntaxKind.GreaterThanGreaterThanEqualsToken);
            TestAssignment(SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken);
            TestAssignment(SyntaxKind.AmpersandEqualsToken);
            TestAssignment(SyntaxKind.BarEqualsToken);
            TestAssignment(SyntaxKind.CaretEqualsToken);
            TestAssignment(SyntaxKind.QuestionQuestionEqualsToken, options: TestOptions.Regular8);
        }

        private void TestMemberAccess(SyntaxKind kind)
        {
            var text = "(a)" + SyntaxFacts.GetText(kind) + " b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var e = (MemberAccessExpressionSyntax)expr;
            Assert.NotEqual(default, e.OperatorToken);
            Assert.Equal(kind, e.OperatorToken.Kind());
            Assert.NotNull(e.Expression);
            Assert.NotNull(e.Name);
            Assert.Equal("(a)", e.Expression.ToString());
            Assert.Equal("b", e.Name.ToString());
        }

        [Fact]
        public void TestMemberAccessTokens()
        {
            TestMemberAccess(SyntaxKind.DotToken);
            TestMemberAccess(SyntaxKind.MinusGreaterThanToken);
        }

        [Fact]
        public void TestConditionalAccessNotVersion5()
        {
            var text = "a.b?.c.d?[1]?.e()?.f";
            var expr = this.ParseExpression(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp5));

            Assert.NotNull(expr);
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var e = (ConditionalAccessExpressionSyntax)expr;
            Assert.Equal("a.b", e.Expression.ToString());
            Assert.Equal(".c.d?[1]?.e()?.f", e.WhenNotNull.ToString());

            var testWithStatement = @$"class C {{ void M() {{ var v = {text}; }} }}";
            CreateCompilation(testWithStatement, parseOptions: TestOptions.Regular5).VerifyDiagnostics(
                // (1,30): error CS0103: The name 'a' does not exist in the current context
                // class C { void M() { var v = a.b?.c.d?[1]?.e()?.f; } }
                Diagnostic(ErrorCode.ERR_NameNotInContext, "a").WithArguments("a").WithLocation(1, 30),
                // (1,33): error CS8026: Feature 'null propagating operator' is not available in C# 5. Please use language version 6 or greater.
                // class C { void M() { var v = a.b?.c.d?[1]?.e()?.f; } }
                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "?").WithArguments("null propagating operator", "6").WithLocation(1, 33),
                // (1,38): error CS8026: Feature 'null propagating operator' is not available in C# 5. Please use language version 6 or greater.
                // class C { void M() { var v = a.b?.c.d?[1]?.e()?.f; } }
                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "?").WithArguments("null propagating operator", "6").WithLocation(1, 38),
                // (1,42): error CS8026: Feature 'null propagating operator' is not available in C# 5. Please use language version 6 or greater.
                // class C { void M() { var v = a.b?.c.d?[1]?.e()?.f; } }
                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "?").WithArguments("null propagating operator", "6").WithLocation(1, 42),
                // (1,47): error CS8026: Feature 'null propagating operator' is not available in C# 5. Please use language version 6 or greater.
                // class C { void M() { var v = a.b?.c.d?[1]?.e()?.f; } }
                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion5, "?").WithArguments("null propagating operator", "6").WithLocation(1, 47));
        }

        [Fact]
        public void TestConditionalAccess()
        {
            var text = "a.b?.c.d?[1]?.e()?.f";
            var expr = this.ParseExpression(text, options: CSharpParseOptions.Default.WithLanguageVersion(LanguageVersion.CSharp6));

            Assert.NotNull(expr);
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var e = (ConditionalAccessExpressionSyntax)expr;
            Assert.Equal("a.b", e.Expression.ToString());
            var cons = e.WhenNotNull;
            Assert.Equal(".c.d?[1]?.e()?.f", cons.ToString());
            Assert.Equal(SyntaxKind.ConditionalAccessExpression, cons.Kind());

            e = e.WhenNotNull as ConditionalAccessExpressionSyntax;
            Assert.Equal(".c.d", e.Expression.ToString());
            cons = e.WhenNotNull;
            Assert.Equal("[1]?.e()?.f", cons.ToString());
            Assert.Equal(SyntaxKind.ConditionalAccessExpression, cons.Kind());

            e = e.WhenNotNull as ConditionalAccessExpressionSyntax;
            Assert.Equal("[1]", e.Expression.ToString());
            cons = e.WhenNotNull;
            Assert.Equal(".e()?.f", cons.ToString());
            Assert.Equal(SyntaxKind.ConditionalAccessExpression, cons.Kind());

            e = e.WhenNotNull as ConditionalAccessExpressionSyntax;
            Assert.Equal(".e()", e.Expression.ToString());
            cons = e.WhenNotNull;
            Assert.Equal(".f", cons.ToString());
            Assert.Equal(SyntaxKind.MemberBindingExpression, cons.Kind());
        }

        private void TestFunctionKeyword(SyntaxKind kind, SyntaxToken keyword)
        {
            Assert.NotEqual(default, keyword);
            Assert.Equal(kind, keyword.Kind());
        }

        private void TestParenthesizedArgument(SyntaxToken openParen, CSharpSyntaxNode arg, SyntaxToken closeParen)
        {
            Assert.NotEqual(default, openParen);
            Assert.False(openParen.IsMissing);
            Assert.NotEqual(default, closeParen);
            Assert.False(closeParen.IsMissing);
            Assert.Equal("a", arg.ToString());
        }

        private void TestSingleParamFunctionalOperator(SyntaxKind kind)
        {
            var text = SyntaxFacts.GetText(kind) + "(a)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            var opKind = SyntaxFacts.GetPrimaryFunction(kind);
            Assert.Equal(opKind, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            switch (opKind)
            {
                case SyntaxKind.MakeRefExpression:
                    var makeRefSyntax = (MakeRefExpressionSyntax)expr;
                    TestFunctionKeyword(kind, makeRefSyntax.Keyword);
                    TestParenthesizedArgument(makeRefSyntax.OpenParenToken, makeRefSyntax.Expression, makeRefSyntax.CloseParenToken);
                    break;

                case SyntaxKind.RefTypeExpression:
                    var refTypeSyntax = (RefTypeExpressionSyntax)expr;
                    TestFunctionKeyword(kind, refTypeSyntax.Keyword);
                    TestParenthesizedArgument(refTypeSyntax.OpenParenToken, refTypeSyntax.Expression, refTypeSyntax.CloseParenToken);
                    break;

                case SyntaxKind.CheckedExpression:
                case SyntaxKind.UncheckedExpression:
                    var checkedSyntax = (CheckedExpressionSyntax)expr;
                    TestFunctionKeyword(kind, checkedSyntax.Keyword);
                    TestParenthesizedArgument(checkedSyntax.OpenParenToken, checkedSyntax.Expression, checkedSyntax.CloseParenToken);
                    break;

                case SyntaxKind.UnsafeExpression:
                    var unsafeSyntax = (UnsafeExpressionSyntax)expr;
                    TestFunctionKeyword(kind, unsafeSyntax.Keyword);
                    TestParenthesizedArgument(unsafeSyntax.OpenParenToken, unsafeSyntax.Expression, unsafeSyntax.CloseParenToken);
                    break;

                case SyntaxKind.TypeOfExpression:
                    var typeOfSyntax = (TypeOfExpressionSyntax)expr;
                    TestFunctionKeyword(kind, typeOfSyntax.Keyword);
                    TestParenthesizedArgument(typeOfSyntax.OpenParenToken, typeOfSyntax.Type, typeOfSyntax.CloseParenToken);
                    break;

                case SyntaxKind.SizeOfExpression:
                    var sizeOfSyntax = (SizeOfExpressionSyntax)expr;
                    TestFunctionKeyword(kind, sizeOfSyntax.Keyword);
                    TestParenthesizedArgument(sizeOfSyntax.OpenParenToken, sizeOfSyntax.Type, sizeOfSyntax.CloseParenToken);
                    break;

                case SyntaxKind.DefaultExpression:
                    var defaultSyntax = (DefaultExpressionSyntax)expr;
                    TestFunctionKeyword(kind, defaultSyntax.Keyword);
                    TestParenthesizedArgument(defaultSyntax.OpenParenToken, defaultSyntax.Type, defaultSyntax.CloseParenToken);
                    break;
            }
        }

        [Fact]
        public void TestFunctionOperators()
        {
            TestSingleParamFunctionalOperator(SyntaxKind.MakeRefKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.RefTypeKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.CheckedKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.UncheckedKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.UnsafeKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.SizeOfKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.TypeOfKeyword);
            TestSingleParamFunctionalOperator(SyntaxKind.DefaultKeyword);
        }

        [Fact]
        public void TestRefValue()
        {
            var text = SyntaxFacts.GetText(SyntaxKind.RefValueKeyword) + "(a, b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.RefValueExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var fs = (RefValueExpressionSyntax)expr;
            Assert.NotEqual(default, fs.Keyword);
            Assert.Equal(SyntaxKind.RefValueKeyword, fs.Keyword.Kind());
            Assert.NotEqual(default, fs.OpenParenToken);
            Assert.False(fs.OpenParenToken.IsMissing);
            Assert.NotEqual(default, fs.CloseParenToken);
            Assert.False(fs.CloseParenToken.IsMissing);
            Assert.Equal("a", fs.Expression.ToString());
            Assert.Equal("b", fs.Type.ToString());
        }

        [Fact]
        public void TestConditional()
        {
            var text = "a ? b : c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ConditionalExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ts = (ConditionalExpressionSyntax)expr;
            Assert.NotEqual(default, ts.QuestionToken);
            Assert.NotEqual(default, ts.ColonToken);
            Assert.Equal(SyntaxKind.QuestionToken, ts.QuestionToken.Kind());
            Assert.Equal(SyntaxKind.ColonToken, ts.ColonToken.Kind());
            Assert.Equal("a", ts.Condition.ToString());
            Assert.Equal("b", ts.WhenTrue.ToString());
            Assert.Equal("c", ts.WhenFalse.ToString());
        }

        [Fact]
        public void TestConditional02()
        {
            // ensure that ?: has lower precedence than assignment.
            var text = "a ? b=c : d=e";
            var expr = this.ParseExpression(text);
            Assert.Equal(SyntaxKind.ConditionalExpression, expr.Kind());
            Assert.False(expr.HasErrors);
        }

        [Fact]
        public void TestCast()
        {
            var text = "(a) b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.CastExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var cs = (CastExpressionSyntax)expr;
            Assert.NotEqual(default, cs.OpenParenToken);
            Assert.NotEqual(default, cs.CloseParenToken);
            Assert.False(cs.OpenParenToken.IsMissing);
            Assert.False(cs.CloseParenToken.IsMissing);
            Assert.NotNull(cs.Type);
            Assert.NotNull(cs.Expression);
            Assert.Equal("a", cs.Type.ToString());
            Assert.Equal("b", cs.Expression.ToString());
        }

        [Fact]
        public void TestCall()
        {
            var text = "a(b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.InvocationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var cs = (InvocationExpressionSyntax)expr;
            Assert.NotEqual(default, cs.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, cs.ArgumentList.CloseParenToken);
            Assert.False(cs.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(cs.ArgumentList.CloseParenToken.IsMissing);
            Assert.NotNull(cs.Expression);
            Assert.Equal(1, cs.ArgumentList.Arguments.Count);
            Assert.Equal("a", cs.Expression.ToString());
            Assert.Equal("b", cs.ArgumentList.Arguments[0].ToString());
        }

        [Fact]
        public void TestCallWithRef()
        {
            var text = "a(ref b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.InvocationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var cs = (InvocationExpressionSyntax)expr;
            Assert.NotEqual(default, cs.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, cs.ArgumentList.CloseParenToken);
            Assert.False(cs.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(cs.ArgumentList.CloseParenToken.IsMissing);
            Assert.NotNull(cs.Expression);
            Assert.Equal(1, cs.ArgumentList.Arguments.Count);
            Assert.Equal("a", cs.Expression.ToString());
            Assert.Equal("ref b", cs.ArgumentList.Arguments[0].ToString());
            Assert.NotEqual(default, cs.ArgumentList.Arguments[0].RefOrOutKeyword);
            Assert.Equal(SyntaxKind.RefKeyword, cs.ArgumentList.Arguments[0].RefOrOutKeyword.Kind());
            Assert.NotNull(cs.ArgumentList.Arguments[0].Expression);
            Assert.Equal("b", cs.ArgumentList.Arguments[0].Expression.ToString());
        }

        [Fact]
        public void TestCallWithOut()
        {
            var text = "a(out b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.InvocationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var cs = (InvocationExpressionSyntax)expr;
            Assert.NotEqual(default, cs.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, cs.ArgumentList.CloseParenToken);
            Assert.False(cs.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(cs.ArgumentList.CloseParenToken.IsMissing);
            Assert.NotNull(cs.Expression);
            Assert.Equal(1, cs.ArgumentList.Arguments.Count);
            Assert.Equal("a", cs.Expression.ToString());
            Assert.Equal("out b", cs.ArgumentList.Arguments[0].ToString());
            Assert.NotEqual(default, cs.ArgumentList.Arguments[0].RefOrOutKeyword);
            Assert.Equal(SyntaxKind.OutKeyword, cs.ArgumentList.Arguments[0].RefOrOutKeyword.Kind());
            Assert.NotNull(cs.ArgumentList.Arguments[0].Expression);
            Assert.Equal("b", cs.ArgumentList.Arguments[0].Expression.ToString());
        }

        [Fact]
        public void TestCallWithNamedArgument()
        {
            var text = "a(B: b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.InvocationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var cs = (InvocationExpressionSyntax)expr;
            Assert.NotEqual(default, cs.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, cs.ArgumentList.CloseParenToken);
            Assert.False(cs.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(cs.ArgumentList.CloseParenToken.IsMissing);
            Assert.NotNull(cs.Expression);
            Assert.Equal(1, cs.ArgumentList.Arguments.Count);
            Assert.Equal("a", cs.Expression.ToString());
            Assert.Equal("B: b", cs.ArgumentList.Arguments[0].ToString());
            Assert.NotNull(cs.ArgumentList.Arguments[0].NameColon);
            Assert.Equal("B", cs.ArgumentList.Arguments[0].NameColon.Name.ToString());
            Assert.NotEqual(default, cs.ArgumentList.Arguments[0].NameColon.ColonToken);
            Assert.Equal("b", cs.ArgumentList.Arguments[0].Expression.ToString());
        }

        [Fact]
        public void TestIndex()
        {
            var text = "a[b]";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ElementAccessExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ea = (ElementAccessExpressionSyntax)expr;
            Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken);
            Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken);
            Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing);
            Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing);
            Assert.NotNull(ea.Expression);
            Assert.Equal(1, ea.ArgumentList.Arguments.Count);
            Assert.Equal("a", ea.Expression.ToString());
            Assert.Equal("b", ea.ArgumentList.Arguments[0].ToString());
        }

        [Fact]
        public void TestIndexWithRef()
        {
            var text = "a[ref b]";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ElementAccessExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ea = (ElementAccessExpressionSyntax)expr;
            Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken);
            Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken);
            Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing);
            Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing);
            Assert.NotNull(ea.Expression);
            Assert.Equal(1, ea.ArgumentList.Arguments.Count);
            Assert.Equal("a", ea.Expression.ToString());
            Assert.Equal("ref b", ea.ArgumentList.Arguments[0].ToString());
            Assert.NotEqual(default, ea.ArgumentList.Arguments[0].RefOrOutKeyword);
            Assert.Equal(SyntaxKind.RefKeyword, ea.ArgumentList.Arguments[0].RefOrOutKeyword.Kind());
            Assert.NotNull(ea.ArgumentList.Arguments[0].Expression);
            Assert.Equal("b", ea.ArgumentList.Arguments[0].Expression.ToString());
        }

        [Fact]
        public void TestIndexWithOut()
        {
            var text = "a[out b]";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ElementAccessExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ea = (ElementAccessExpressionSyntax)expr;
            Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken);
            Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken);
            Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing);
            Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing);
            Assert.NotNull(ea.Expression);
            Assert.Equal(1, ea.ArgumentList.Arguments.Count);
            Assert.Equal("a", ea.Expression.ToString());
            Assert.Equal("out b", ea.ArgumentList.Arguments[0].ToString());
            Assert.NotEqual(default, ea.ArgumentList.Arguments[0].RefOrOutKeyword);
            Assert.Equal(SyntaxKind.OutKeyword, ea.ArgumentList.Arguments[0].RefOrOutKeyword.Kind());
            Assert.NotNull(ea.ArgumentList.Arguments[0].Expression);
            Assert.Equal("b", ea.ArgumentList.Arguments[0].Expression.ToString());
        }

        [Fact]
        public void TestIndexWithNamedArgument()
        {
            var text = "a[B: b]";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ElementAccessExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ea = (ElementAccessExpressionSyntax)expr;
            Assert.NotEqual(default, ea.ArgumentList.OpenBracketToken);
            Assert.NotEqual(default, ea.ArgumentList.CloseBracketToken);
            Assert.False(ea.ArgumentList.OpenBracketToken.IsMissing);
            Assert.False(ea.ArgumentList.CloseBracketToken.IsMissing);
            Assert.NotNull(ea.Expression);
            Assert.Equal(1, ea.ArgumentList.Arguments.Count);
            Assert.Equal("a", ea.Expression.ToString());
            Assert.Equal("B: b", ea.ArgumentList.Arguments[0].ToString());
        }

        [Fact]
        public void TestNew()
        {
            var text = "new a()";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.NotNull(oc.ArgumentList);
            Assert.NotEqual(default, oc.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, oc.ArgumentList.CloseParenToken);
            Assert.False(oc.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(oc.ArgumentList.CloseParenToken.IsMissing);
            Assert.Equal(0, oc.ArgumentList.Arguments.Count);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());
            Assert.Null(oc.Initializer);
        }

        [Fact]
        public void TestNewWithArgument()
        {
            var text = "new a(b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.NotNull(oc.ArgumentList);
            Assert.NotEqual(default, oc.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, oc.ArgumentList.CloseParenToken);
            Assert.False(oc.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(oc.ArgumentList.CloseParenToken.IsMissing);
            Assert.Equal(1, oc.ArgumentList.Arguments.Count);
            Assert.Equal("b", oc.ArgumentList.Arguments[0].ToString());
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());
            Assert.Null(oc.Initializer);
        }

        [Fact]
        public void TestNewWithNamedArgument()
        {
            var text = "new a(B: b)";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.NotNull(oc.ArgumentList);
            Assert.NotEqual(default, oc.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, oc.ArgumentList.CloseParenToken);
            Assert.False(oc.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(oc.ArgumentList.CloseParenToken.IsMissing);
            Assert.Equal(1, oc.ArgumentList.Arguments.Count);
            Assert.Equal("B: b", oc.ArgumentList.Arguments[0].ToString());
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());
            Assert.Null(oc.Initializer);
        }

        [Fact]
        public void TestNewWithEmptyInitializer()
        {
            var text = "new a() { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.NotNull(oc.ArgumentList);
            Assert.NotEqual(default, oc.ArgumentList.OpenParenToken);
            Assert.NotEqual(default, oc.ArgumentList.CloseParenToken);
            Assert.False(oc.ArgumentList.OpenParenToken.IsMissing);
            Assert.False(oc.ArgumentList.CloseParenToken.IsMissing);
            Assert.Equal(0, oc.ArgumentList.Arguments.Count);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(0, oc.Initializer.Expressions.Count);
        }

        [Fact]
        public void TestNewWithNoArgumentsAndEmptyInitializer()
        {
            var text = "new a { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.Null(oc.ArgumentList);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(0, oc.Initializer.Expressions.Count);
        }

        [Fact]
        public void TestNewWithNoArgumentsAndInitializer()
        {
            var text = "new a { b }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.Null(oc.ArgumentList);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, oc.Initializer.Expressions.Count);
            Assert.Equal("b", oc.Initializer.Expressions[0].ToString());
        }

        [Fact]
        public void TestNewWithNoArgumentsAndInitializers()
        {
            var text = "new a { b, c, d }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.Null(oc.ArgumentList);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(3, oc.Initializer.Expressions.Count);
            Assert.Equal("b", oc.Initializer.Expressions[0].ToString());
            Assert.Equal("c", oc.Initializer.Expressions[1].ToString());
            Assert.Equal("d", oc.Initializer.Expressions[2].ToString());
        }

        [Fact]
        public void TestNewWithNoArgumentsAndAssignmentInitializer()
        {
            var text = "new a { B = b }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.Null(oc.ArgumentList);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, oc.Initializer.Expressions.Count);
            Assert.Equal("B = b", oc.Initializer.Expressions[0].ToString());
        }

        [Fact]
        public void TestNewWithNoArgumentsAndNestedAssignmentInitializer()
        {
            var text = "new a { B = { X = x } }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var oc = (ObjectCreationExpressionSyntax)expr;
            Assert.Null(oc.ArgumentList);
            Assert.NotNull(oc.Type);
            Assert.Equal("a", oc.Type.ToString());

            Assert.NotNull(oc.Initializer);
            Assert.NotEqual(default, oc.Initializer.OpenBraceToken);
            Assert.NotEqual(default, oc.Initializer.CloseBraceToken);
            Assert.False(oc.Initializer.OpenBraceToken.IsMissing);
            Assert.False(oc.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, oc.Initializer.Expressions.Count);
            Assert.Equal("B = { X = x }", oc.Initializer.Expressions[0].ToString());
            Assert.Equal(SyntaxKind.SimpleAssignmentExpression, oc.Initializer.Expressions[0].Kind());
            var b = (AssignmentExpressionSyntax)oc.Initializer.Expressions[0];
            Assert.Equal("B", b.Left.ToString());
            Assert.Equal(SyntaxKind.ObjectInitializerExpression, b.Right.Kind());
        }

        [Fact]
        public void TestNewArray()
        {
            var text = "new a[1]";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ArrayCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (ArrayCreationExpressionSyntax)expr;
            Assert.NotNull(ac.Type);
            Assert.Equal("a[1]", ac.Type.ToString());
            Assert.Null(ac.Initializer);
        }

        [Fact]
        public void TopLevel_NewPartialArray_Incomplete()
        {
            UsingTree("new partial[",
                // (1,13): error CS1003: Syntax error, ']' expected
                // new partial[
                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(1, 13),
                // (1,13): error CS1002: ; expected
                // new partial[
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(1, 13));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ArrayCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.ArrayType);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "partial");
                                }
                                N(SyntaxKind.ArrayRankSpecifier);
                                {
                                    N(SyntaxKind.OpenBracketToken);
                                    N(SyntaxKind.OmittedArraySizeExpression);
                                    {
                                        N(SyntaxKind.OmittedArraySizeExpressionToken);
                                    }
                                    M(SyntaxKind.CloseBracketToken);
                                }
                            }
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Theory]
        [InlineData("file")]
        [InlineData("required")]
        [InlineData("async")]
        [InlineData("closed")]
        public void TopLevel_NewContextualKeywordArray_Incomplete(string keyword)
        {
            UsingTree($"""
                new {keyword}
                [
                """,
                // (2,2): error CS1003: Syntax error, ']' expected
                // [
                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("]").WithLocation(2, 2));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.IncompleteMember);
                {
                    N(SyntaxKind.NewKeyword);
                    N(SyntaxKind.ArrayType);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, keyword);
                        }
                        N(SyntaxKind.ArrayRankSpecifier);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.OmittedArraySizeExpression);
                            {
                                N(SyntaxKind.OmittedArraySizeExpressionToken);
                            }
                            M(SyntaxKind.CloseBracketToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_NewScopedArray()
        {
            UsingTree($"""
                new scoped[1];
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ArrayCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.ArrayType);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "scoped");
                                }
                                N(SyntaxKind.ArrayRankSpecifier);
                                {
                                    N(SyntaxKind.OpenBracketToken);
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "1");
                                    }
                                    N(SyntaxKind.CloseBracketToken);
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Theory]
        [InlineData("file")]
        [InlineData("required")]
        [InlineData("async")]
        [InlineData("closed")]
        public void TopLevel_NewContextualKeywordArray(string keyword)
        {
            UsingTree($"""
                new {keyword}[1
                ];
                """,
                // (2,1): error CS0116: A namespace cannot directly contain members such as fields, methods or statements
                // ];
                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, "]").WithLocation(2, 1));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.IncompleteMember);
                {
                    N(SyntaxKind.NewKeyword);
                    N(SyntaxKind.ArrayType);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, keyword);
                        }
                        N(SyntaxKind.ArrayRankSpecifier);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.NumericLiteralExpression);
                            {
                                N(SyntaxKind.NumericLiteralToken, "1");
                            }
                            N(SyntaxKind.CloseBracketToken);
                        }
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.EmptyStatement);
                    {
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_ScopedObjectCreation_Incomplete()
        {
            UsingTree($"""
                new scoped
                (
                """,
                // (2,2): error CS1026: ) expected
                // (
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(2, 2),
                // (2,2): error CS1002: ; expected
                // (
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(2, 2));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ObjectCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "scoped");
                            }
                            N(SyntaxKind.ArgumentList);
                            {
                                N(SyntaxKind.OpenParenToken);
                                M(SyntaxKind.CloseParenToken);
                            }
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Theory]
        [InlineData("file")]
        [InlineData("required")]
        [InlineData("async")]
        [InlineData("closed")]
        public void TopLevel_ContextualKeywordObjectCreation_Incomplete(string keyword)
        {
            UsingTree($"""
                new {keyword}
                (
                """,
                // (1,5): error CS0116: A namespace cannot directly contain members such as fields, methods or statements
                // new {keyword}
                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, keyword).WithLocation(1, 5),
                // (2,2): error CS1733: Expected expression
                // (
                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(2, 2),
                // (2,2): error CS1026: ) expected
                // (
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(2, 2),
                // (2,2): error CS1002: ; expected
                // (
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(2, 2));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.IncompleteMember);
                {
                    N(SyntaxKind.NewKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, keyword);
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ParenthesizedExpression);
                        {
                            N(SyntaxKind.OpenParenToken);
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                            M(SyntaxKind.CloseParenToken);
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_ScopedObjectCreation()
        {
            UsingTree($"new scoped();");

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ObjectCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "scoped");
                            }
                            N(SyntaxKind.ArgumentList);
                            {
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.CloseParenToken);
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Theory]
        [InlineData("file")]
        [InlineData("required")]
        [InlineData("async")]
        [InlineData("closed")]
        public void TopLevel_ContextualModifierObjectCreation(string keyword)
        {
            UsingTree($"""
                new {keyword}
                ();
                """,
                // (1,5): error CS0116: A namespace cannot directly contain members such as fields, methods or statements
                // new {keyword}
                Diagnostic(ErrorCode.ERR_NamespaceUnexpected, keyword).WithLocation(1, 5),
                // (2,2): error CS1525: Invalid expression term ')'
                // ();
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(2, 2));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.IncompleteMember);
                {
                    N(SyntaxKind.NewKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, keyword);
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ParenthesizedExpression);
                        {
                            N(SyntaxKind.OpenParenToken);
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_NewPartialArray()
        {
            UsingTree($"new partial[1];");

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ArrayCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.ArrayType);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "partial");
                                }
                                N(SyntaxKind.ArrayRankSpecifier);
                                {
                                    N(SyntaxKind.OpenBracketToken);
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "1");
                                    }
                                    N(SyntaxKind.CloseBracketToken);
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_PartialObjectCreation_Incomplete()
        {
            UsingTree($"""
                new partial
                (
                """,
                // (2,2): error CS1026: ) expected
                // (
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(2, 2),
                // (2,2): error CS1002: ; expected
                // (
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(2, 2));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ObjectCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "partial");
                            }
                            N(SyntaxKind.ArgumentList);
                            {
                                N(SyntaxKind.OpenParenToken);
                                M(SyntaxKind.CloseParenToken);
                            }
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TopLevel_PartialObjectCreation()
        {
            UsingTree($"new partial();");

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.ObjectCreationExpression);
                        {
                            N(SyntaxKind.NewKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "partial");
                            }
                            N(SyntaxKind.ArgumentList);
                            {
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.CloseParenToken);
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TestNewArrayWithInitializer()
        {
            var text = "new a[] {b}";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ArrayCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (ArrayCreationExpressionSyntax)expr;
            Assert.NotNull(ac.Type);
            Assert.Equal("a[]", ac.Type.ToString());
            Assert.NotNull(ac.Initializer);
            Assert.NotEqual(default, ac.Initializer.OpenBraceToken);
            Assert.NotEqual(default, ac.Initializer.CloseBraceToken);
            Assert.False(ac.Initializer.OpenBraceToken.IsMissing);
            Assert.False(ac.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, ac.Initializer.Expressions.Count);
            Assert.Equal("b", ac.Initializer.Expressions[0].ToString());
        }

        [Fact]
        public void TestNewArrayWithInitializers()
        {
            var text = "new a[] {b, c, d}";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ArrayCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (ArrayCreationExpressionSyntax)expr;
            Assert.NotNull(ac.Type);
            Assert.Equal("a[]", ac.Type.ToString());
            Assert.NotNull(ac.Initializer);
            Assert.NotEqual(default, ac.Initializer.OpenBraceToken);
            Assert.NotEqual(default, ac.Initializer.CloseBraceToken);
            Assert.False(ac.Initializer.OpenBraceToken.IsMissing);
            Assert.False(ac.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(3, ac.Initializer.Expressions.Count);
            Assert.Equal("b", ac.Initializer.Expressions[0].ToString());
            Assert.Equal("c", ac.Initializer.Expressions[1].ToString());
            Assert.Equal("d", ac.Initializer.Expressions[2].ToString());
        }

        [Fact]
        public void TestNewMultiDimensionalArrayWithInitializer()
        {
            var text = "new a[][,][,,] {b}";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ArrayCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (ArrayCreationExpressionSyntax)expr;
            Assert.NotNull(ac.Type);
            Assert.Equal("a[][,][,,]", ac.Type.ToString());
            Assert.NotNull(ac.Initializer);
            Assert.NotEqual(default, ac.Initializer.OpenBraceToken);
            Assert.NotEqual(default, ac.Initializer.CloseBraceToken);
            Assert.False(ac.Initializer.OpenBraceToken.IsMissing);
            Assert.False(ac.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, ac.Initializer.Expressions.Count);
            Assert.Equal("b", ac.Initializer.Expressions[0].ToString());
        }

        [Fact]
        public void TestImplicitArrayCreation()
        {
            var text = "new [] {b}";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ImplicitArrayCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (ImplicitArrayCreationExpressionSyntax)expr;
            Assert.NotNull(ac.Initializer);
            Assert.NotEqual(default, ac.Initializer.OpenBraceToken);
            Assert.NotEqual(default, ac.Initializer.CloseBraceToken);
            Assert.False(ac.Initializer.OpenBraceToken.IsMissing);
            Assert.False(ac.Initializer.CloseBraceToken.IsMissing);
            Assert.Equal(1, ac.Initializer.Expressions.Count);
            Assert.Equal("b", ac.Initializer.Expressions[0].ToString());
        }

        [Fact]
        public void TestAnonymousObjectCreation()
        {
            var text = "new {a, b}";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.AnonymousObjectCreationExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var ac = (AnonymousObjectCreationExpressionSyntax)expr;
            Assert.NotEqual(default, ac.NewKeyword);
            Assert.NotEqual(default, ac.OpenBraceToken);
            Assert.NotEqual(default, ac.CloseBraceToken);
            Assert.False(ac.OpenBraceToken.IsMissing);
            Assert.False(ac.CloseBraceToken.IsMissing);
            Assert.Equal(2, ac.Initializers.Count);
            Assert.Equal("a", ac.Initializers[0].ToString());
            Assert.Equal("b", ac.Initializers[1].ToString());
        }

        [Fact]
        public void TestAnonymousMethod()
        {
            var text = "delegate (int a) { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.AnonymousMethodExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var am = (AnonymousMethodExpressionSyntax)expr;

            Assert.NotEqual(default, am.DelegateKeyword);
            Assert.False(am.DelegateKeyword.IsMissing);

            Assert.NotNull(am.ParameterList);
            Assert.NotEqual(default, am.ParameterList.OpenParenToken);
            Assert.NotEqual(default, am.ParameterList.CloseParenToken);
            Assert.False(am.ParameterList.OpenParenToken.IsMissing);
            Assert.False(am.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(1, am.ParameterList.Parameters.Count);
            Assert.Equal("int a", am.ParameterList.Parameters[0].ToString());

            Assert.NotNull(am.Block);
            Assert.NotEqual(default, am.Block.OpenBraceToken);
            Assert.NotEqual(default, am.Block.CloseBraceToken);
            Assert.False(am.Block.OpenBraceToken.IsMissing);
            Assert.False(am.Block.CloseBraceToken.IsMissing);
            Assert.Equal(0, am.Block.Statements.Count);
        }

        [Fact]
        public void TestAnonymousMethodWithNoArguments()
        {
            var text = "delegate () { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.AnonymousMethodExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var am = (AnonymousMethodExpressionSyntax)expr;

            Assert.NotEqual(default, am.DelegateKeyword);
            Assert.False(am.DelegateKeyword.IsMissing);

            Assert.NotNull(am.ParameterList);
            Assert.NotEqual(default, am.ParameterList.OpenParenToken);
            Assert.NotEqual(default, am.ParameterList.CloseParenToken);
            Assert.False(am.ParameterList.OpenParenToken.IsMissing);
            Assert.False(am.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(0, am.ParameterList.Parameters.Count);

            Assert.NotNull(am.Block);
            Assert.NotEqual(default, am.Block.OpenBraceToken);
            Assert.NotEqual(default, am.Block.CloseBraceToken);
            Assert.False(am.Block.OpenBraceToken.IsMissing);
            Assert.False(am.Block.CloseBraceToken.IsMissing);
            Assert.Equal(0, am.Block.Statements.Count);
        }

        [Fact]
        public void TestAnonymousMethodWithNoArgumentList()
        {
            var text = "delegate { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.AnonymousMethodExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var am = (AnonymousMethodExpressionSyntax)expr;

            Assert.NotEqual(default, am.DelegateKeyword);
            Assert.False(am.DelegateKeyword.IsMissing);

            Assert.Null(am.ParameterList);

            Assert.NotNull(am.Block);
            Assert.NotEqual(default, am.Block.OpenBraceToken);
            Assert.NotEqual(default, am.Block.CloseBraceToken);
            Assert.False(am.Block.OpenBraceToken.IsMissing);
            Assert.False(am.Block.CloseBraceToken.IsMissing);
            Assert.Equal(0, am.Block.Statements.Count);
        }

        [Fact]
        public void TestSimpleLambda()
        {
            var text = "a => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.SimpleLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (SimpleLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.Parameter.Identifier);
            Assert.False(lambda.Parameter.Identifier.IsMissing);
            Assert.Equal("a", lambda.Parameter.Identifier.ToString());
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestSimpleLambdaWithRefReturn()
        {
            var text = "a => ref b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.SimpleLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (SimpleLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.Parameter.Identifier);
            Assert.False(lambda.Parameter.Identifier.IsMissing);
            Assert.Equal("a", lambda.Parameter.Identifier.ToString());
            Assert.Equal(SyntaxKind.RefExpression, lambda.Body.Kind());
            Assert.Equal("ref b", lambda.Body.ToString());
        }

        [Fact]
        public void TestSimpleLambdaWithBlock()
        {
            var text = "a => { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.SimpleLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (SimpleLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.Parameter.Identifier);
            Assert.False(lambda.Parameter.Identifier.IsMissing);
            Assert.Equal("a", lambda.Parameter.Identifier.ToString());
            Assert.NotNull(lambda.Body);
            Assert.Equal(SyntaxKind.Block, lambda.Body.Kind());
            var b = (BlockSyntax)lambda.Body;
            Assert.Equal("{ }", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithNoParameters()
        {
            var text = "() => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(0, lambda.ParameterList.Parameters.Count);
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithNoParametersAndRefReturn()
        {
            var text = "() => ref b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(0, lambda.ParameterList.Parameters.Count);
            Assert.Equal(SyntaxKind.RefExpression, lambda.Body.Kind());
            Assert.Equal("ref b", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithNoParametersAndBlock()
        {
            var text = "() => { }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(0, lambda.ParameterList.Parameters.Count);
            Assert.NotNull(lambda.Body);
            Assert.Equal(SyntaxKind.Block, lambda.Body.Kind());
            var b = (BlockSyntax)lambda.Body;
            Assert.Equal("{ }", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithOneParameter()
        {
            var text = "(a) => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(1, lambda.ParameterList.Parameters.Count);
            Assert.Equal(SyntaxKind.Parameter, lambda.ParameterList.Parameters[0].Kind());
            var ps = (ParameterSyntax)lambda.ParameterList.Parameters[0];
            Assert.Null(ps.Type);
            Assert.Equal("a", ps.Identifier.ToString());
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithTwoParameters()
        {
            var text = "(a, a2) => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(2, lambda.ParameterList.Parameters.Count);
            Assert.Equal(SyntaxKind.Parameter, lambda.ParameterList.Parameters[0].Kind());
            var ps = (ParameterSyntax)lambda.ParameterList.Parameters[0];
            Assert.Null(ps.Type);
            Assert.Equal("a", ps.Identifier.ToString());
            var ps2 = (ParameterSyntax)lambda.ParameterList.Parameters[1];
            Assert.Null(ps2.Type);
            Assert.Equal("a2", ps2.Identifier.ToString());
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithOneTypedParameter()
        {
            var text = "(T a) => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(1, lambda.ParameterList.Parameters.Count);
            Assert.Equal(SyntaxKind.Parameter, lambda.ParameterList.Parameters[0].Kind());
            var ps = (ParameterSyntax)lambda.ParameterList.Parameters[0];
            Assert.NotNull(ps.Type);
            Assert.Equal("T", ps.Type.ToString());
            Assert.Equal("a", ps.Identifier.ToString());
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestLambdaWithOneRefParameter()
        {
            var text = "(ref T a) => b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedLambdaExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var lambda = (ParenthesizedLambdaExpressionSyntax)expr;
            Assert.NotEqual(default, lambda.ParameterList.OpenParenToken);
            Assert.NotEqual(default, lambda.ParameterList.CloseParenToken);
            Assert.False(lambda.ParameterList.OpenParenToken.IsMissing);
            Assert.False(lambda.ParameterList.CloseParenToken.IsMissing);
            Assert.Equal(1, lambda.ParameterList.Parameters.Count);
            Assert.Equal(SyntaxKind.Parameter, lambda.ParameterList.Parameters[0].Kind());
            var ps = (ParameterSyntax)lambda.ParameterList.Parameters[0];
            Assert.NotNull(ps.Type);
            Assert.Equal("T", ps.Type.ToString());
            Assert.Equal("a", ps.Identifier.ToString());
            Assert.Equal(1, ps.Modifiers.Count);
            Assert.Equal(SyntaxKind.RefKeyword, ps.Modifiers[0].Kind());
            Assert.NotNull(lambda.Body);
            Assert.Equal("b", lambda.Body.ToString());
        }

        [Fact]
        public void TestTupleWithTwoArguments()
        {
            var text = "(a, a2)";
            var expr = this.ParseExpression(text, options: TestOptions.Regular);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.TupleExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var tuple = (TupleExpressionSyntax)expr;
            Assert.NotEqual(default, tuple.OpenParenToken);
            Assert.NotEqual(default, tuple.CloseParenToken);
            Assert.False(tuple.OpenParenToken.IsMissing);
            Assert.False(tuple.CloseParenToken.IsMissing);
            Assert.Equal(2, tuple.Arguments.Count);
            Assert.Equal(SyntaxKind.IdentifierName, tuple.Arguments[0].Expression.Kind());
            Assert.Null(tuple.Arguments[1].NameColon);
        }

        [Fact]
        public void TestTupleWithTwoNamedArguments()
        {
            var text = "(arg1: (a, a2), arg2: a2)";
            var expr = this.ParseExpression(text, options: TestOptions.Regular);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.TupleExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
            var tuple = (TupleExpressionSyntax)expr;
            Assert.NotEqual(default, tuple.OpenParenToken);
            Assert.NotEqual(default, tuple.CloseParenToken);
            Assert.False(tuple.OpenParenToken.IsMissing);
            Assert.False(tuple.CloseParenToken.IsMissing);
            Assert.Equal(2, tuple.Arguments.Count);
            Assert.Equal(SyntaxKind.TupleExpression, tuple.Arguments[0].Expression.Kind());
            Assert.NotNull(tuple.Arguments[0].NameColon.Name);
            Assert.Equal("arg2", tuple.Arguments[1].NameColon.Name.ToString());
        }

        [Fact]
        public void TestFromSelect()
        {
            var text = "from a in A select b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(0, qs.Body.Clauses.Count);

            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.Equal(SyntaxKind.FromKeyword, fs.FromKeyword.Kind());
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.Equal(SyntaxKind.SelectKeyword, ss.SelectKeyword.Kind());
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("b", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromWithType()
        {
            var text = "from T a in A select b";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(0, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.NotNull(fs.Type);
            Assert.Equal("T", fs.Type.ToString());
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("b", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromSelectIntoSelect()
        {
            var text = "from a in A select b into c select d";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(0, qs.Body.Clauses.Count);
            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("b", ss.Expression.ToString());

            Assert.NotNull(qs.Body.Continuation);
            Assert.Equal(SyntaxKind.QueryContinuation, qs.Body.Continuation.Kind());
            Assert.NotEqual(default, qs.Body.Continuation.IntoKeyword);
            Assert.Equal(SyntaxKind.IntoKeyword, qs.Body.Continuation.IntoKeyword.Kind());
            Assert.False(qs.Body.Continuation.IntoKeyword.IsMissing);
            Assert.Equal("c", qs.Body.Continuation.Identifier.ToString());

            Assert.NotNull(qs.Body.Continuation.Body);
            Assert.Equal(0, qs.Body.Continuation.Body.Clauses.Count);
            Assert.NotNull(qs.Body.Continuation.Body.SelectOrGroup);

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.Continuation.Body.SelectOrGroup.Kind());
            ss = (SelectClauseSyntax)qs.Body.Continuation.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("d", ss.Expression.ToString());

            Assert.Null(qs.Body.Continuation.Body.Continuation);
        }

        [Fact]
        public void TestFromWhereSelect()
        {
            var text = "from a in A where b select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.WhereClause, qs.Body.Clauses[0].Kind());
            var ws = (WhereClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, ws.WhereKeyword);
            Assert.Equal(SyntaxKind.WhereKeyword, ws.WhereKeyword.Kind());
            Assert.False(ws.WhereKeyword.IsMissing);
            Assert.NotNull(ws.Condition);
            Assert.Equal("b", ws.Condition.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromFromSelect()
        {
            var text = "from a in A from b in B select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.FromClause, qs.Body.Clauses[0].Kind());
            fs = (FromClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("b", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("B", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromLetSelect()
        {
            var text = "from a in A let b = B select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.LetClause, qs.Body.Clauses[0].Kind());
            var ls = (LetClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, ls.LetKeyword);
            Assert.Equal(SyntaxKind.LetKeyword, ls.LetKeyword.Kind());
            Assert.False(ls.LetKeyword.IsMissing);
            Assert.NotEqual(default, ls.Identifier);
            Assert.Equal("b", ls.Identifier.ToString());
            Assert.NotEqual(default, ls.EqualsToken);
            Assert.False(ls.EqualsToken.IsMissing);
            Assert.NotNull(ls.Expression);
            Assert.Equal("B", ls.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromOrderBySelect()
        {
            var text = "from a in A orderby b select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.OrderByClause, qs.Body.Clauses[0].Kind());
            var obs = (OrderByClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, obs.OrderByKeyword);
            Assert.Equal(SyntaxKind.OrderByKeyword, obs.OrderByKeyword.Kind());
            Assert.False(obs.OrderByKeyword.IsMissing);
            Assert.Equal(1, obs.Orderings.Count);

            var os = (OrderingSyntax)obs.Orderings[0];
            Assert.Equal(SyntaxKind.None, os.AscendingOrDescendingKeyword.Kind());
            Assert.NotNull(os.Expression);
            Assert.Equal("b", os.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromOrderBy2Select()
        {
            var text = "from a in A orderby b, b2 select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.OrderByClause, qs.Body.Clauses[0].Kind());
            var obs = (OrderByClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, obs.OrderByKeyword);
            Assert.False(obs.OrderByKeyword.IsMissing);
            Assert.Equal(2, obs.Orderings.Count);

            var os = (OrderingSyntax)obs.Orderings[0];
            Assert.Equal(SyntaxKind.None, os.AscendingOrDescendingKeyword.Kind());
            Assert.NotNull(os.Expression);
            Assert.Equal("b", os.Expression.ToString());

            os = (OrderingSyntax)obs.Orderings[1];
            Assert.Equal(SyntaxKind.None, os.AscendingOrDescendingKeyword.Kind());
            Assert.NotNull(os.Expression);
            Assert.Equal("b2", os.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromOrderByAscendingSelect()
        {
            var text = "from a in A orderby b ascending select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.OrderByClause, qs.Body.Clauses[0].Kind());
            var obs = (OrderByClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, obs.OrderByKeyword);
            Assert.False(obs.OrderByKeyword.IsMissing);
            Assert.Equal(1, obs.Orderings.Count);

            var os = (OrderingSyntax)obs.Orderings[0];
            Assert.NotEqual(default, os.AscendingOrDescendingKeyword);
            Assert.Equal(SyntaxKind.AscendingKeyword, os.AscendingOrDescendingKeyword.Kind());
            Assert.False(os.AscendingOrDescendingKeyword.IsMissing);
            Assert.Equal(SyntaxKind.AscendingKeyword, os.AscendingOrDescendingKeyword.ContextualKind());

            Assert.NotNull(os.Expression);
            Assert.Equal("b", os.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromOrderByDescendingSelect()
        {
            var text = "from a in A orderby b descending select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());
            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());

            Assert.Equal(SyntaxKind.OrderByClause, qs.Body.Clauses[0].Kind());
            var obs = (OrderByClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, obs.OrderByKeyword);
            Assert.False(obs.OrderByKeyword.IsMissing);
            Assert.Equal(1, obs.Orderings.Count);

            var os = (OrderingSyntax)obs.Orderings[0];
            Assert.NotEqual(default, os.AscendingOrDescendingKeyword);
            Assert.Equal(SyntaxKind.DescendingKeyword, os.AscendingOrDescendingKeyword.Kind());
            Assert.False(os.AscendingOrDescendingKeyword.IsMissing);
            Assert.Equal(SyntaxKind.DescendingKeyword, os.AscendingOrDescendingKeyword.ContextualKind());

            Assert.NotNull(os.Expression);
            Assert.Equal("b", os.Expression.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromGroupBy()
        {
            var text = "from a in A group b by c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(0, qs.Body.Clauses.Count);

            var fs = qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.GroupClause, qs.Body.SelectOrGroup.Kind());
            var gbs = (GroupClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, gbs.GroupKeyword);
            Assert.Equal(SyntaxKind.GroupKeyword, gbs.GroupKeyword.Kind());
            Assert.False(gbs.GroupKeyword.IsMissing);
            Assert.NotNull(gbs.GroupExpression);
            Assert.Equal("b", gbs.GroupExpression.ToString());
            Assert.NotEqual(default, gbs.ByKeyword);
            Assert.Equal(SyntaxKind.ByKeyword, gbs.ByKeyword.Kind());
            Assert.False(gbs.ByKeyword.IsMissing);
            Assert.NotNull(gbs.ByExpression);
            Assert.Equal("c", gbs.ByExpression.ToString());

            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromGroupByIntoSelect()
        {
            var text = "from a in A group b by c into d select e";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(0, qs.Body.Clauses.Count);

            var fs = qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.GroupClause, qs.Body.SelectOrGroup.Kind());
            var gbs = (GroupClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, gbs.GroupKeyword);
            Assert.False(gbs.GroupKeyword.IsMissing);
            Assert.NotNull(gbs.GroupExpression);
            Assert.Equal("b", gbs.GroupExpression.ToString());
            Assert.NotEqual(default, gbs.ByKeyword);
            Assert.False(gbs.ByKeyword.IsMissing);
            Assert.NotNull(gbs.ByExpression);
            Assert.Equal("c", gbs.ByExpression.ToString());

            Assert.NotNull(qs.Body.Continuation);
            Assert.Equal(SyntaxKind.QueryContinuation, qs.Body.Continuation.Kind());
            Assert.NotEqual(default, qs.Body.Continuation.IntoKeyword);
            Assert.False(qs.Body.Continuation.IntoKeyword.IsMissing);
            Assert.Equal("d", qs.Body.Continuation.Identifier.ToString());

            Assert.NotNull(qs.Body.Continuation);
            Assert.Equal(0, qs.Body.Continuation.Body.Clauses.Count);
            Assert.NotNull(qs.Body.Continuation.Body.SelectOrGroup);

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.Continuation.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.Continuation.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("e", ss.Expression.ToString());

            Assert.Null(qs.Body.Continuation.Body.Continuation);
        }

        [Fact]
        public void TestFromJoinSelect()
        {
            var text = "from a in A join b in B on a equals b select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.JoinClause, qs.Body.Clauses[0].Kind());
            var js = (JoinClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, js.JoinKeyword);
            Assert.Equal(SyntaxKind.JoinKeyword, js.JoinKeyword.Kind());
            Assert.False(js.JoinKeyword.IsMissing);
            Assert.Null(js.Type);
            Assert.NotEqual(default, js.Identifier);
            Assert.Equal("b", js.Identifier.ToString());
            Assert.NotEqual(default, js.InKeyword);
            Assert.False(js.InKeyword.IsMissing);
            Assert.NotNull(js.InExpression);
            Assert.Equal("B", js.InExpression.ToString());
            Assert.NotEqual(default, js.OnKeyword);
            Assert.Equal(SyntaxKind.OnKeyword, js.OnKeyword.Kind());
            Assert.False(js.OnKeyword.IsMissing);
            Assert.NotNull(js.LeftExpression);
            Assert.Equal("a", js.LeftExpression.ToString());
            Assert.NotEqual(default, js.EqualsKeyword);
            Assert.Equal(SyntaxKind.EqualsKeyword, js.EqualsKeyword.Kind());
            Assert.False(js.EqualsKeyword.IsMissing);
            Assert.NotNull(js.RightExpression);
            Assert.Equal("b", js.RightExpression.ToString());
            Assert.Null(js.Into);

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromJoinWithTypesSelect()
        {
            var text = "from Ta a in A join Tb b in B on a equals b select c";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.NotNull(fs.Type);
            Assert.Equal("Ta", fs.Type.ToString());
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.JoinClause, qs.Body.Clauses[0].Kind());
            var js = (JoinClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, js.JoinKeyword);
            Assert.False(js.JoinKeyword.IsMissing);
            Assert.NotNull(js.Type);
            Assert.Equal("Tb", js.Type.ToString());
            Assert.NotEqual(default, js.Identifier);
            Assert.Equal("b", js.Identifier.ToString());
            Assert.NotEqual(default, js.InKeyword);
            Assert.False(js.InKeyword.IsMissing);
            Assert.NotNull(js.InExpression);
            Assert.Equal("B", js.InExpression.ToString());
            Assert.NotEqual(default, js.OnKeyword);
            Assert.False(js.OnKeyword.IsMissing);
            Assert.NotNull(js.LeftExpression);
            Assert.Equal("a", js.LeftExpression.ToString());
            Assert.NotEqual(default, js.EqualsKeyword);
            Assert.False(js.EqualsKeyword.IsMissing);
            Assert.NotNull(js.RightExpression);
            Assert.Equal("b", js.RightExpression.ToString());
            Assert.Null(js.Into);

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("c", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromJoinIntoSelect()
        {
            var text = "from a in A join b in B on a equals b into c select d";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.Equal(1, qs.Body.Clauses.Count);

            Assert.Equal(SyntaxKind.FromClause, qs.FromClause.Kind());
            var fs = (FromClauseSyntax)qs.FromClause;
            Assert.NotEqual(default, fs.FromKeyword);
            Assert.False(fs.FromKeyword.IsMissing);
            Assert.Null(fs.Type);
            Assert.Equal("a", fs.Identifier.ToString());
            Assert.NotEqual(default, fs.InKeyword);
            Assert.False(fs.InKeyword.IsMissing);
            Assert.Equal("A", fs.Expression.ToString());

            Assert.Equal(SyntaxKind.JoinClause, qs.Body.Clauses[0].Kind());
            var js = (JoinClauseSyntax)qs.Body.Clauses[0];
            Assert.NotEqual(default, js.JoinKeyword);
            Assert.False(js.JoinKeyword.IsMissing);
            Assert.Null(js.Type);
            Assert.NotEqual(default, js.Identifier);
            Assert.Equal("b", js.Identifier.ToString());
            Assert.NotEqual(default, js.InKeyword);
            Assert.False(js.InKeyword.IsMissing);
            Assert.NotNull(js.InExpression);
            Assert.Equal("B", js.InExpression.ToString());
            Assert.NotEqual(default, js.OnKeyword);
            Assert.False(js.OnKeyword.IsMissing);
            Assert.NotNull(js.LeftExpression);
            Assert.Equal("a", js.LeftExpression.ToString());
            Assert.NotEqual(default, js.EqualsKeyword);
            Assert.False(js.EqualsKeyword.IsMissing);
            Assert.NotNull(js.RightExpression);
            Assert.Equal("b", js.RightExpression.ToString());
            Assert.NotNull(js.Into);
            Assert.NotEqual(default, js.Into.IntoKeyword);
            Assert.False(js.Into.IntoKeyword.IsMissing);
            Assert.NotEqual(default, js.Into.Identifier);
            Assert.Equal("c", js.Into.Identifier.ToString());

            Assert.Equal(SyntaxKind.SelectClause, qs.Body.SelectOrGroup.Kind());
            var ss = (SelectClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotEqual(default, ss.SelectKeyword);
            Assert.False(ss.SelectKeyword.IsMissing);
            Assert.Equal("d", ss.Expression.ToString());
            Assert.Null(qs.Body.Continuation);
        }

        [Fact]
        public void TestFromGroupBy1()
        {
            var text = "from it in goo group x by y";
            var expr = SyntaxFactory.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);

            var qs = (QueryExpressionSyntax)expr;
            Assert.NotNull(qs.Body.SelectOrGroup);
            Assert.IsType<GroupClauseSyntax>(qs.Body.SelectOrGroup);

            var gs = (GroupClauseSyntax)qs.Body.SelectOrGroup;
            Assert.NotNull(gs.GroupExpression);
            Assert.Equal("x", gs.GroupExpression.ToString());
            Assert.Equal("y", gs.ByExpression.ToString());
        }

        [WorkItem(543075, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543075")]
        [Fact]
        public void UnterminatedRankSpecifier()
        {
            var text = "new int[";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ArrayCreationExpression, expr.Kind());

            var arrayCreation = (ArrayCreationExpressionSyntax)expr;
            Assert.Equal(1, arrayCreation.Type.RankSpecifiers.Single().Rank);
        }

        [WorkItem(543075, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543075")]
        [Fact]
        public void UnterminatedTypeArgumentList()
        {
            var text = "new C<";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ObjectCreationExpression, expr.Kind());

            var objectCreation = (ObjectCreationExpressionSyntax)expr;
            Assert.Equal(1, ((NameSyntax)objectCreation.Type).Arity);
        }

        [WorkItem(675602, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/675602")]
        [Fact]
        public void QueryKeywordInObjectInitializer()
        {
            //'on' is a keyword here
            var text = "from elem in aRay select new Result { A = on = true }";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.QueryExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.NotEqual(0, expr.Errors().Length);
        }

        [Fact]
        public void IndexingExpressionInParens()
        {
            var text = "(aRay[i,j])";
            var expr = this.ParseExpression(text);

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.ParenthesizedExpression, expr.Kind());

            var parenExp = (ParenthesizedExpressionSyntax)expr;
            Assert.Equal(SyntaxKind.ElementAccessExpression, parenExp.Expression.Kind());
        }

        [WorkItem(543993, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/543993")]
        [Fact]
        public void ShiftOperator()
        {
            UsingTree(@"
class C
{
    int x = 1 << 2 << 3;
}
");
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken);
                    N(SyntaxKind.OpenBraceToken);

                    N(SyntaxKind.FieldDeclaration);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.PredefinedType); N(SyntaxKind.IntKeyword);
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken);
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    // NB: left associative
                                    N(SyntaxKind.LeftShiftExpression);
                                    {
                                        N(SyntaxKind.LeftShiftExpression);
                                        {
                                            N(SyntaxKind.NumericLiteralExpression); N(SyntaxKind.NumericLiteralToken);
                                            N(SyntaxKind.LessThanLessThanToken);
                                            N(SyntaxKind.NumericLiteralExpression); N(SyntaxKind.NumericLiteralToken);
                                        }
                                        N(SyntaxKind.LessThanLessThanToken);
                                        N(SyntaxKind.NumericLiteralExpression); N(SyntaxKind.NumericLiteralToken);
                                    }
                                }
                            }
                            N(SyntaxKind.SemicolonToken);
                        }
                    }

                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
        }

        [WorkItem(1091974, "http://vstfdevdiv:8080/DevDiv2/DevDiv/_workitems/edit/1091974")]
        [Fact]
        public void ParseBigExpression()
        {
            var text = @"

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text.RegularExpressions;

namespace WB.Core.SharedKernels.DataCollection.Generated
{
   internal partial class QuestionnaireTopLevel
   {   
      private bool IsValid_a()
      {
            return (stackDepth == 100) || ((stackDepth == 200) || ((stackDepth == 300) || ((stackDepth == 400) || ((stackDepth == 501) || ((stackDepth == 502) || ((stackDepth == 600) || ((stackDepth = … [Строка слишком длинная. Вы можете скачать файл]
      }      
   }
}
";
            var root = SyntaxFactory.ParseSyntaxTree(text).GetRoot();

            Assert.NotNull(root);
            Assert.Equal(SyntaxKind.CompilationUnit, root.Kind());
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration1()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task.Delay();
    }
}
";
            UsingTree(text,
                // (6,14): error CS1001: Identifier expected
                //         Task.
                Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(6, 14),
                // (6,14): error CS1002: ; expected
                //         Task.
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 14));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.SimpleMemberAccessExpression);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                    N(SyntaxKind.DotToken);
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                }
                                M(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.AwaitExpression);
                                {
                                    N(SyntaxKind.AwaitKeyword);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.SimpleMemberAccessExpression);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "Task");
                                            }
                                            N(SyntaxKind.DotToken);
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "Delay");
                                            }
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration2()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.await Task.Delay();
    }
}
";
            UsingTree(text,
                // (6,14): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         Task.await Task.Delay();
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(6, 14),
                // (6,24): error CS1003: Syntax error, ',' expected
                //         Task.await Task.Delay();
                Diagnostic(ErrorCode.ERR_SyntaxError, ".").WithArguments(",").WithLocation(6, 24),
                // (6,25): error CS1002: ; expected
                //         Task.await Task.Delay();
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "Delay").WithLocation(6, 25));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.QualifiedName);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Task");
                                        }
                                        N(SyntaxKind.DotToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "await");
                                        }
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                }
                                M(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.InvocationExpression);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Delay");
                                    }
                                    N(SyntaxKind.ArgumentList);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration3()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task;
    }
}
";
            UsingTree(text,
                // (7,9): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         await Task;
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(7, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.QualifiedName);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Task");
                                        }
                                        N(SyntaxKind.DotToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "await");
                                        }
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration4()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task = 1;
    }
}
";
            UsingTree(text,
                // (7,9): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         await Task = 1;
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(7, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.QualifiedName);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Task");
                                        }
                                        N(SyntaxKind.DotToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "await");
                                        }
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.NumericLiteralExpression);
                                            {
                                                N(SyntaxKind.NumericLiteralToken, "1");
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration5()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task, Task2;
    }
}
";
            UsingTree(text,
                // (7,9): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         await Task, Task2;
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(7, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.QualifiedName);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Task");
                                        }
                                        N(SyntaxKind.DotToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "await");
                                        }
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                    N(SyntaxKind.CommaToken);
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task2");
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration6()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task();
    }
}
";
            UsingTree(text,
                // (7,9): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         await Task();
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(7, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalFunctionStatement);
                            {
                                N(SyntaxKind.QualifiedName);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                    N(SyntaxKind.DotToken);
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "await");
                                    }
                                }
                                N(SyntaxKind.IdentifierToken, "Task");
                                N(SyntaxKind.ParameterList);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration7()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task<T>();
    }
}
";
            UsingTree(text,
                // (7,9): error CS4003: 'await' cannot be used as an identifier within an async method or lambda expression
                //         await Task<T>();
                Diagnostic(ErrorCode.ERR_BadAwaitAsIdentifier, "await").WithLocation(7, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalFunctionStatement);
                            {
                                N(SyntaxKind.QualifiedName);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                    N(SyntaxKind.DotToken);
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "await");
                                    }
                                }
                                N(SyntaxKind.IdentifierToken, "Task");
                                N(SyntaxKind.TypeParameterList);
                                {
                                    N(SyntaxKind.LessThanToken);
                                    N(SyntaxKind.TypeParameter);
                                    {
                                        N(SyntaxKind.IdentifierToken, "T");
                                    }
                                    N(SyntaxKind.GreaterThanToken);
                                }
                                N(SyntaxKind.ParameterList);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(15885, "https://github.com/dotnet/roslyn/pull/15885")]
        public void InProgressLocalDeclaration8()
        {
            const string text = @"
class C
{
    async void M()
    {
        Task.
        await Task[1];
    }
}
";
            UsingTree(text,
                // (6,14): error CS1001: Identifier expected
                //         Task.
                Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(6, 14),
                // (6,14): error CS1002: ; expected
                //         Task.
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "").WithLocation(6, 14));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AsyncKeyword);
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.SimpleMemberAccessExpression);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "Task");
                                    }
                                    N(SyntaxKind.DotToken);
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                }
                                M(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.AwaitExpression);
                                {
                                    N(SyntaxKind.AwaitKeyword);
                                    N(SyntaxKind.ElementAccessExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Task");
                                        }
                                        N(SyntaxKind.BracketedArgumentList);
                                        {
                                            N(SyntaxKind.OpenBracketToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "1");
                                                }
                                            }
                                            N(SyntaxKind.CloseBracketToken);
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_01()
        {
            const string text = @"
class C
{
    void M()
    {
        //int a = 1;
        //int i = 1;
        var j = a < i >> 2;
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.LessThanExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "a");
                                                }
                                                N(SyntaxKind.LessThanToken);
                                                N(SyntaxKind.RightShiftExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                    N(SyntaxKind.GreaterThanGreaterThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_02()
        {
            const string text = @"
class C
{
    void M()
    {
        //const int a = 1;
        //const int i = 2;
        switch (false)
        {
            case a < i >> 2: break;
        }
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.SwitchStatement);
                            {
                                N(SyntaxKind.SwitchKeyword);
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.FalseLiteralExpression);
                                {
                                    N(SyntaxKind.FalseKeyword);
                                }
                                N(SyntaxKind.CloseParenToken);
                                N(SyntaxKind.OpenBraceToken);
                                N(SyntaxKind.SwitchSection);
                                {
                                    N(SyntaxKind.CaseSwitchLabel);
                                    {
                                        N(SyntaxKind.CaseKeyword);
                                        N(SyntaxKind.LessThanExpression);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "a");
                                            }
                                            N(SyntaxKind.LessThanToken);
                                            N(SyntaxKind.RightShiftExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "i");
                                                }
                                                N(SyntaxKind.GreaterThanGreaterThanToken);
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "2");
                                                }
                                            }
                                        }
                                        N(SyntaxKind.ColonToken);
                                    }
                                    N(SyntaxKind.BreakStatement);
                                    {
                                        N(SyntaxKind.BreakKeyword);
                                        N(SyntaxKind.SemicolonToken);
                                    }
                                }
                                N(SyntaxKind.CloseBraceToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_03()
        {
            const string text = @"
class C
{
    void M()
    {
        M(out a < i >> 2);
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.InvocationExpression);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "M");
                                    }
                                    N(SyntaxKind.ArgumentList);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.OutKeyword);
                                            N(SyntaxKind.LessThanExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "a");
                                                }
                                                N(SyntaxKind.LessThanToken);
                                                N(SyntaxKind.RightShiftExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                    N(SyntaxKind.GreaterThanGreaterThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_04()
        {
            const string text = @"
class C
{
    void M()
    {
        // (e is a<i>) > 2
        var j = e is a < i >> 2;
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.GreaterThanExpression);
                                            {
                                                N(SyntaxKind.IsExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "e");
                                                    }
                                                    N(SyntaxKind.IsKeyword);
                                                    N(SyntaxKind.GenericName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "a");
                                                        N(SyntaxKind.TypeArgumentList);
                                                        {
                                                            N(SyntaxKind.LessThanToken);
                                                            N(SyntaxKind.IdentifierName);
                                                            {
                                                                N(SyntaxKind.IdentifierToken, "i");
                                                            }
                                                            N(SyntaxKind.GreaterThanToken);
                                                        }
                                                    }
                                                }
                                                N(SyntaxKind.GreaterThanToken);
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "2");
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_05()
        {
            const string text = @"
class C
{
    void M()
    {
        var j = e is a < i >>> 2;
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.LessThanExpression);
                                            {
                                                N(SyntaxKind.IsExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "e");
                                                    }
                                                    N(SyntaxKind.IsKeyword);
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "a");
                                                    }
                                                }
                                                N(SyntaxKind.LessThanToken);
                                                N(SyntaxKind.UnsignedRightShiftExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                    N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_06()
        {
            const string text = @"
class C
{
    void M()
    {
        // syntax error
        var j = e is a < i > << 2;
    }
}
";
            var tree = UsingTree(text,
                // (7,30): error CS1525: Invalid expression term '<<'
                //         var j = e is a < i > << 2;
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "<<").WithArguments("<<").WithLocation(7, 30)
                );
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.GreaterThanExpression);
                                            {
                                                N(SyntaxKind.LessThanExpression);
                                                {
                                                    N(SyntaxKind.IsExpression);
                                                    {
                                                        N(SyntaxKind.IdentifierName);
                                                        {
                                                            N(SyntaxKind.IdentifierToken, "e");
                                                        }
                                                        N(SyntaxKind.IsKeyword);
                                                        N(SyntaxKind.IdentifierName);
                                                        {
                                                            N(SyntaxKind.IdentifierToken, "a");
                                                        }
                                                    }
                                                    N(SyntaxKind.LessThanToken);
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                }
                                                N(SyntaxKind.GreaterThanToken);
                                                N(SyntaxKind.LeftShiftExpression);
                                                {
                                                    M(SyntaxKind.IdentifierName);
                                                    {
                                                        M(SyntaxKind.IdentifierToken);
                                                    }
                                                    N(SyntaxKind.LessThanLessThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_07()
        {
            const string text = @"
class C
{
    void M()
    {
        // syntax error
        var j = e is a < i >>>> 2;
    }
}
";
            var tree = UsingTree(text,
                // (7,31): error CS1525: Invalid expression term '>'
                //         var j = e is a < i >>>> 2;
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(7, 31)
                );
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.GreaterThanExpression);
                                            {
                                                N(SyntaxKind.LessThanExpression);
                                                {
                                                    N(SyntaxKind.IsExpression);
                                                    {
                                                        N(SyntaxKind.IdentifierName);
                                                        {
                                                            N(SyntaxKind.IdentifierToken, "e");
                                                        }
                                                        N(SyntaxKind.IsKeyword);
                                                        N(SyntaxKind.IdentifierName);
                                                        {
                                                            N(SyntaxKind.IdentifierToken, "a");
                                                        }
                                                    }
                                                    N(SyntaxKind.LessThanToken);
                                                    N(SyntaxKind.UnsignedRightShiftExpression);
                                                    {
                                                        N(SyntaxKind.IdentifierName);
                                                        {
                                                            N(SyntaxKind.IdentifierToken, "i");
                                                        }
                                                        N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                                                        M(SyntaxKind.IdentifierName);
                                                        {
                                                            M(SyntaxKind.IdentifierToken);
                                                        }
                                                    }
                                                }
                                                N(SyntaxKind.GreaterThanToken);
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "2");
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_08()
        {
            const string text = @"
class C
{
    void M()
    {
        M(out a < i >>> 2);
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.InvocationExpression);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "M");
                                    }
                                    N(SyntaxKind.ArgumentList);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.OutKeyword);
                                            N(SyntaxKind.LessThanExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "a");
                                                }
                                                N(SyntaxKind.LessThanToken);
                                                N(SyntaxKind.UnsignedRightShiftExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                    N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_09()
        {
            const string text = @"
class C
{
    void M()
    {
        //const int a = 1;
        //const int i = 2;
        switch (false)
        {
            case a < i >>> 2: break;
        }
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.SwitchStatement);
                            {
                                N(SyntaxKind.SwitchKeyword);
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.FalseLiteralExpression);
                                {
                                    N(SyntaxKind.FalseKeyword);
                                }
                                N(SyntaxKind.CloseParenToken);
                                N(SyntaxKind.OpenBraceToken);
                                N(SyntaxKind.SwitchSection);
                                {
                                    N(SyntaxKind.CaseSwitchLabel);
                                    {
                                        N(SyntaxKind.CaseKeyword);
                                        N(SyntaxKind.LessThanExpression);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "a");
                                            }
                                            N(SyntaxKind.LessThanToken);
                                            N(SyntaxKind.UnsignedRightShiftExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "i");
                                                }
                                                N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "2");
                                                }
                                            }
                                        }
                                        N(SyntaxKind.ColonToken);
                                    }
                                    N(SyntaxKind.BreakStatement);
                                    {
                                        N(SyntaxKind.BreakKeyword);
                                        N(SyntaxKind.SemicolonToken);
                                    }
                                }
                                N(SyntaxKind.CloseBraceToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem(377556, "https://devdiv.visualstudio.com/DefaultCollection/DevDiv/_workitems?id=377556")]
        public void TypeArgumentShiftAmbiguity_10()
        {
            const string text = @"
class C
{
    void M()
    {
        //int a = 1;
        //int i = 1;
        var j = a < i >>> 2;
    }
}
";
            var tree = UsingTree(text);
            tree.GetDiagnostics().Verify();
            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalDeclarationStatement);
                            {
                                N(SyntaxKind.VariableDeclaration);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "var");
                                    }
                                    N(SyntaxKind.VariableDeclarator);
                                    {
                                        N(SyntaxKind.IdentifierToken, "j");
                                        N(SyntaxKind.EqualsValueClause);
                                        {
                                            N(SyntaxKind.EqualsToken);
                                            N(SyntaxKind.LessThanExpression);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "a");
                                                }
                                                N(SyntaxKind.LessThanToken);
                                                N(SyntaxKind.UnsignedRightShiftExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "i");
                                                    }
                                                    N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                                                    N(SyntaxKind.NumericLiteralExpression);
                                                    {
                                                        N(SyntaxKind.NumericLiteralToken, "2");
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void TestTargetTypedDefaultWithCSharp7_1()
        {
            var text = "default";
            var expr = this.ParseExpression(text, TestOptions.Regular.WithLanguageVersion(LanguageVersion.CSharp7_1));

            Assert.NotNull(expr);
            Assert.Equal(SyntaxKind.DefaultLiteralExpression, expr.Kind());
            Assert.Equal(text, expr.ToString());
            Assert.Equal(0, expr.Errors().Length);
        }

        [Fact, WorkItem(17683, "https://github.com/dotnet/roslyn/issues/17683")]
        public void Bug17683a()
        {
            var source =
@"from t in e
where
t == Int32.
MinValue
select t";
            UsingExpression(source);
            N(SyntaxKind.QueryExpression);
            {
                N(SyntaxKind.FromClause);
                {
                    N(SyntaxKind.FromKeyword);
                    N(SyntaxKind.IdentifierToken, "t");
                    N(SyntaxKind.InKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "e");
                    }
                }
                N(SyntaxKind.QueryBody);
                {
                    N(SyntaxKind.WhereClause);
                    {
                        N(SyntaxKind.WhereKeyword);
                        N(SyntaxKind.EqualsExpression);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "t");
                            }
                            N(SyntaxKind.EqualsEqualsToken);
                            N(SyntaxKind.SimpleMemberAccessExpression);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Int32");
                                }
                                N(SyntaxKind.DotToken);
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "MinValue");
                                }
                            }
                        }
                    }
                    N(SyntaxKind.SelectClause);
                    {
                        N(SyntaxKind.SelectKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "t");
                        }
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void Bug17683b()
        {
            var source =
@"switch (e)
{
    case Int32.
               MaxValue when true:
            break;
}";
            UsingStatement(source);
            N(SyntaxKind.SwitchStatement);
            {
                N(SyntaxKind.SwitchKeyword);
                N(SyntaxKind.OpenParenToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "e");
                }
                N(SyntaxKind.CloseParenToken);
                N(SyntaxKind.OpenBraceToken);
                N(SyntaxKind.SwitchSection);
                {
                    N(SyntaxKind.CasePatternSwitchLabel);
                    {
                        N(SyntaxKind.CaseKeyword);
                        N(SyntaxKind.ConstantPattern);
                        {
                            N(SyntaxKind.SimpleMemberAccessExpression);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Int32");
                                }
                                N(SyntaxKind.DotToken);
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "MaxValue");
                                }
                            }
                        }
                        N(SyntaxKind.WhenClause);
                        {
                            N(SyntaxKind.WhenKeyword);
                            N(SyntaxKind.TrueLiteralExpression);
                            {
                                N(SyntaxKind.TrueKeyword);
                            }
                        }
                        N(SyntaxKind.ColonToken);
                    }
                    N(SyntaxKind.BreakStatement);
                    {
                        N(SyntaxKind.BreakKeyword);
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.CloseBraceToken);
            }
            EOF();
        }

        [Fact, WorkItem(22830, "https://github.com/dotnet/roslyn/issues/22830")]
        public void TypeArgumentIndexerInitializer()
        {
            UsingExpression("new C { [0] = op1 < op2, [1] = true }");
            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "C");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.ImplicitElementAccess);
                        {
                            N(SyntaxKind.BracketedArgumentList);
                            {
                                N(SyntaxKind.OpenBracketToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "0");
                                    }
                                }
                                N(SyntaxKind.CloseBracketToken);
                            }
                        }
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.LessThanExpression);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "op1");
                            }
                            N(SyntaxKind.LessThanToken);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "op2");
                            }
                        }
                    }
                    N(SyntaxKind.CommaToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.ImplicitElementAccess);
                        {
                            N(SyntaxKind.BracketedArgumentList);
                            {
                                N(SyntaxKind.OpenBracketToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "1");
                                    }
                                }
                                N(SyntaxKind.CloseBracketToken);
                            }
                        }
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.TrueLiteralExpression);
                        {
                            N(SyntaxKind.TrueKeyword);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        public void InterpolatedStringExpressionSurroundedByCurlyBraces()
        {
            UsingExpression("$\"{{{12}}}\"");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "12");
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
        }

        [Fact]
        public void InterpolatedStringExpressionWithFormatClauseSurroundedByCurlyBraces()
        {
            UsingExpression("$\"{{{12:X}}}\"");
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedStringStartToken);
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "12");
                    }
                    N(SyntaxKind.InterpolationFormatClause);
                    {
                        N(SyntaxKind.ColonToken);
                        N(SyntaxKind.InterpolatedStringTextToken, "X");
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringText);
                {
                    N(SyntaxKind.InterpolatedStringTextToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
        }

        [Fact, WorkItem(12214, "https://github.com/dotnet/roslyn/issues/12214")]
        public void ConditionalExpressionInInterpolation()
        {
            UsingExpression("$\"{a ? b : d}\"",
                // (1,4): error CS8361: A conditional expression cannot be used directly in a string interpolation because the ':' ends the interpolation. Parenthesize the conditional expression.
                // $"{a ? b : d}"
                Diagnostic(ErrorCode.ERR_ConditionalInInterpolation, "a ? b ").WithLocation(1, 4)
                );
            N(SyntaxKind.InterpolatedStringExpression);
            {
                N(SyntaxKind.InterpolatedStringStartToken);
                N(SyntaxKind.Interpolation);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.ConditionalExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "a");
                        }
                        N(SyntaxKind.QuestionToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "b");
                        }
                        M(SyntaxKind.ColonToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.InterpolationFormatClause);
                    {
                        N(SyntaxKind.ColonToken);
                        N(SyntaxKind.InterpolatedStringTextToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.InterpolatedStringEndToken);
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentExpression()
        {
            UsingExpression("a ??= b");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentExpressionParenthesized()
        {
            UsingExpression("(a) ??= b");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.ParenthesizedExpression);
                {
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "a");
                    }
                    N(SyntaxKind.CloseParenToken);
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentExpressionInvocation()
        {
            UsingExpression("M(a) ??= b");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.InvocationExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "M");
                    }
                    N(SyntaxKind.ArgumentList);
                    {
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.Argument);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "a");
                            }
                        }
                        N(SyntaxKind.CloseParenToken);
                    }
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentExpressionAndCoalescingOperator()
        {
            UsingExpression("a ?? b ??= c");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.CoalesceExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "a");
                    }
                    N(SyntaxKind.QuestionQuestionToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "c");
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentExpressionNested()
        {
            UsingExpression("a ??= b ??= c");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.CoalesceAssignmentExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                    N(SyntaxKind.QuestionQuestionEqualsToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "c");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentParenthesizedNested()
        {
            UsingExpression("(a ??= b) ??= c");
            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.ParenthesizedExpression);
                {
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.CoalesceAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "a");
                        }
                        N(SyntaxKind.QuestionQuestionEqualsToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "b");
                        }
                    }
                    N(SyntaxKind.CloseParenToken);
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "c");
                }
            }
            EOF();
        }

        [Fact]
        public void NullCoalescingAssignmentCSharp7_3()
        {
            var test = "a ??= b";
            var testWithStatement = @$"class C {{ void M() {{ var v = {test}; }} }}";

            CreateCompilation(testWithStatement, parseOptions: TestOptions.Regular7_3).VerifyDiagnostics(
                // (1,30): error CS0103: The name 'a' does not exist in the current context
                // class C { void M() { var v = a ??= b; } }
                Diagnostic(ErrorCode.ERR_NameNotInContext, "a").WithArguments("a").WithLocation(1, 30),
                // (1,32): error CS8370: Feature 'coalescing assignment' is not available in C# 7.3. Please use language version 8.0 or greater.
                // class C { void M() { var v = a ??= b; } }
                Diagnostic(ErrorCode.ERR_FeatureNotAvailableInVersion7_3, "??=").WithArguments("coalescing assignment", "8.0").WithLocation(1, 32),
                // (1,36): error CS0103: The name 'b' does not exist in the current context
                // class C { void M() { var v = a ??= b; } }
                Diagnostic(ErrorCode.ERR_NameNotInContext, "b").WithArguments("b").WithLocation(1, 36));

            UsingExpression(test, TestOptions.Regular7_3);

            N(SyntaxKind.CoalesceAssignmentExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.QuestionQuestionEqualsToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void IndexExpression()
        {
            UsingExpression("^1");
            N(SyntaxKind.IndexExpression);
            {
                N(SyntaxKind.CaretToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_ThreeDots()
        {
            UsingExpression("1...2",
                // (1,2): error CS8635: Unexpected character sequence '...'
                // 1...2
                Diagnostic(ErrorCode.ERR_TripleDotNotAllowed, "").WithLocation(1, 2));

            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "2");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Binary()
        {
            UsingExpression("1..1");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Binary_WithIndexes()
        {
            UsingExpression("^5..^3");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.IndexExpression);
                {
                    N(SyntaxKind.CaretToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "5");
                    }
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.IndexExpression);
                {
                    N(SyntaxKind.CaretToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "3");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Binary_WithALowerPrecedenceOperator_01()
        {
            UsingExpression("1<<2..3>>4");
            N(SyntaxKind.RightShiftExpression);
            {
                N(SyntaxKind.LeftShiftExpression);
                {
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "1");
                    }
                    N(SyntaxKind.LessThanLessThanToken);
                    N(SyntaxKind.RangeExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "2");
                        }
                        N(SyntaxKind.DotDotToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "3");
                        }
                    }
                }
                N(SyntaxKind.GreaterThanGreaterThanToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "4");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Binary_WithALowerPrecedenceOperator_02()
        {
            UsingExpression("1<<2..3>>>4");
            N(SyntaxKind.UnsignedRightShiftExpression);
            {
                N(SyntaxKind.LeftShiftExpression);
                {
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "1");
                    }
                    N(SyntaxKind.LessThanLessThanToken);
                    N(SyntaxKind.RangeExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "2");
                        }
                        N(SyntaxKind.DotDotToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "3");
                        }
                    }
                }
                N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "4");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Binary_WithAHigherPrecedenceOperator()
        {
            UsingExpression("1+2..3-4");
            N(SyntaxKind.SubtractExpression);
            {
                N(SyntaxKind.AddExpression);
                {
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "1");
                    }
                    N(SyntaxKind.PlusToken);
                    N(SyntaxKind.RangeExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "2");
                        }
                        N(SyntaxKind.DotDotToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "3");
                        }
                    }
                }
                N(SyntaxKind.MinusToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "4");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_UnaryBadLeft()
        {
            UsingExpression("a*..b");
            N(SyntaxKind.MultiplyExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.AsteriskToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_BinaryLeftPlus()
        {
            UsingExpression("a + b..c");
            N(SyntaxKind.AddExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.PlusToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "c");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_UnaryLeftPlus()
        {
            UsingExpression("a + b..");
            N(SyntaxKind.AddExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.PlusToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                    N(SyntaxKind.DotDotToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_UnaryRightMult()
        {
            UsingExpression("a.. && b");
            N(SyntaxKind.LogicalAndExpression);
            {
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "a");
                    }
                    N(SyntaxKind.DotDotToken);
                }
                N(SyntaxKind.AmpersandAmpersandToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_UnaryRightMult2()
        {
            UsingExpression("..a && b");
            N(SyntaxKind.LogicalAndExpression);
            {
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "a");
                    }
                }
                N(SyntaxKind.AmpersandAmpersandToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "b");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Ambiguity1()
        {
            UsingExpression(".. ..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Ambiguity2()
        {
            UsingExpression(".. .. e");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "e");
                    }
                }
            }
            EOF();
        }

        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/36514")]
        public void RangeExpression_Ambiguity3()
        {
            UsingExpression(".. e ..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "e");
                    }
                    N(SyntaxKind.DotDotToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Ambiguity4()
        {
            UsingExpression("a .. .. b");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                }
            }
            EOF();
        }

        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/36514")]
        public void RangeExpression_Ambiguity5()
        {
            UsingExpression("a .. b ..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                    N(SyntaxKind.DotDotToken);
                }
            }
            EOF();
        }

        [Fact(Skip = "https://github.com/dotnet/roslyn/issues/36514")]
        public void RangeExpression_Ambiguity6()
        {
            UsingExpression("a .. b .. c");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "a");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                    N(SyntaxKind.DotDotToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem(36122, "https://github.com/dotnet/roslyn/issues/36122")]
        public void RangeExpression_NotCast()
        {
            UsingExpression("(Offset)..(Offset + Count)");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.ParenthesizedExpression);
                {
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "Offset");
                    }
                    N(SyntaxKind.CloseParenToken);
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.ParenthesizedExpression);
                {
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.AddExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Offset");
                        }
                        N(SyntaxKind.PlusToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Count");
                        }
                    }
                    N(SyntaxKind.CloseParenToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Right()
        {
            UsingExpression("..1");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Right_WithIndexes()
        {
            UsingExpression("..^3");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.IndexExpression);
                {
                    N(SyntaxKind.CaretToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "3");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Left()
        {
            UsingExpression("1..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotDotToken);
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_Left_WithIndexes()
        {
            UsingExpression("^5..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.IndexExpression);
                {
                    N(SyntaxKind.CaretToken);
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "5");
                    }
                }
                N(SyntaxKind.DotDotToken);
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_NoOperands()
        {
            UsingExpression("..");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_NoOperands_WithOtherOperators()
        {
            UsingExpression("1+..<<2");
            N(SyntaxKind.LeftShiftExpression);
            {
                N(SyntaxKind.AddExpression);
                {
                    N(SyntaxKind.NumericLiteralExpression);
                    {
                        N(SyntaxKind.NumericLiteralToken, "1");
                    }
                    N(SyntaxKind.PlusToken);
                    N(SyntaxKind.RangeExpression);
                    {
                        N(SyntaxKind.DotDotToken);
                    }
                }
                N(SyntaxKind.LessThanLessThanToken);
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "2");
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_DotSpaceDot()
        {
            UsingExpression("1. .2",
                // (1,1): error CS1073: Unexpected token '.2'
                // 1. .2
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "1. ").WithArguments(".2").WithLocation(1, 1),
                // (1,4): error CS1001: Identifier expected
                // 1. .2
                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".2").WithLocation(1, 4));

            N(SyntaxKind.SimpleMemberAccessExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotToken);
                M(SyntaxKind.IdentifierName);
                {
                    M(SyntaxKind.IdentifierToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_MethodInvocation_NoOperands()
        {
            UsingExpression(".. .ToString()",
                // (1,1): error CS1073: Unexpected token '.'
                // .. .ToString()
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "..").WithArguments(".").WithLocation(1, 1));

            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_MethodInvocation_LeftOperand()
        {
            UsingExpression("1.. .ToString()",
                // (1,1): error CS1073: Unexpected token '.'
                // 1.. .ToString()
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "1..").WithArguments(".").WithLocation(1, 1));

            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotDotToken);
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_MethodInvocation_RightOperand()
        {
            UsingExpression("..2 .ToString()");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.InvocationExpression);
                {
                    N(SyntaxKind.SimpleMemberAccessExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "2");
                        }
                        N(SyntaxKind.DotToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "ToString");
                        }
                        N(SyntaxKind.ArgumentList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_MethodInvocation_TwoOperands()
        {
            UsingExpression("1..2 .ToString()");
            N(SyntaxKind.RangeExpression);
            {
                N(SyntaxKind.NumericLiteralExpression);
                {
                    N(SyntaxKind.NumericLiteralToken, "1");
                }
                N(SyntaxKind.DotDotToken);
                N(SyntaxKind.InvocationExpression);
                {
                    N(SyntaxKind.SimpleMemberAccessExpression);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "2");
                        }
                        N(SyntaxKind.DotToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "ToString");
                        }
                        N(SyntaxKind.ArgumentList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_ConditionalAccessExpression_01()
        {
            UsingExpression("c?..b",
                // (1,6): error CS1003: Syntax error, ':' expected
                // c?..b
                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":").WithLocation(1, 6),
                // (1,6): error CS1733: Expected expression
                // c?..b
                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 6));

            N(SyntaxKind.ConditionalExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "c");
                }
                N(SyntaxKind.QuestionToken);
                N(SyntaxKind.RangeExpression);
                {
                    N(SyntaxKind.DotDotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "b");
                    }
                }
                M(SyntaxKind.ColonToken);
                M(SyntaxKind.IdentifierName);
                {
                    M(SyntaxKind.IdentifierToken);
                }
            }
            EOF();
        }

        [Fact]
        public void RangeExpression_ConditionalAccessExpression_02()
        {
            // It would also be reasonable to parse this as '(c?.b)..(a)', but a Range doesn't accept nullable operands, so the below parse is acceptable.
            UsingExpression("c?.b..a",
                // (1,6): error CS1001: Identifier expected
                // c?.b..a
                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(1, 6));

            N(SyntaxKind.ConditionalAccessExpression);
            {
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "c");
                }
                N(SyntaxKind.QuestionToken);
                N(SyntaxKind.SimpleMemberAccessExpression);
                {
                    N(SyntaxKind.SimpleMemberAccessExpression);
                    {
                        N(SyntaxKind.MemberBindingExpression);
                        {
                            N(SyntaxKind.DotToken);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "b");
                            }
                        }
                        N(SyntaxKind.DotToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.DotToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "a");
                    }
                }
            }
            EOF();
        }

        [Fact]
        public void BaseExpression_01()
        {
            UsingExpression("base");
            N(SyntaxKind.BaseExpression);
            {
                N(SyntaxKind.BaseKeyword);
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_BadRef()
        {
            UsingExpression("new[] { ref }",
                // (1,9): error CS1525: Invalid expression term 'ref'
                // new[] { ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref ").WithArguments("ref").WithLocation(1, 9),
                // (1,13): error CS1525: Invalid expression term '}'
                // new[] { ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "}").WithArguments("}").WithLocation(1, 13));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.RefExpression);
                    {
                        N(SyntaxKind.RefKeyword);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_BadRefExpression()
        {
            UsingExpression("new[] { ref obj }",
                // (1,9): error CS1525: Invalid expression term 'ref'
                // new[] { ref obj }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref obj").WithArguments("ref").WithLocation(1, 9));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.RefExpression);
                    {
                        N(SyntaxKind.RefKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "obj");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_BadRefElementAccess()
        {
            UsingExpression("new[] { ref[] }",
                // (1,9): error CS1525: Invalid expression term 'ref'
                // new[] { ref[] }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref[]").WithArguments("ref").WithLocation(1, 9));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.RefExpression);
                    {
                        N(SyntaxKind.RefKeyword);
                        N(SyntaxKind.CollectionExpression);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.CloseBracketToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void AnonymousObjectCreation_BadRef()
        {
            UsingExpression("new { ref }",
                // (1,7): error CS1525: Invalid expression term 'ref'
                // new { ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref ").WithArguments("ref").WithLocation(1, 7),
                // (1,11): error CS1525: Invalid expression term '}'
                // new { ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "}").WithArguments("}").WithLocation(1, 11));

            N(SyntaxKind.AnonymousObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBraceToken);
                N(SyntaxKind.AnonymousObjectMemberDeclarator);
                {
                    N(SyntaxKind.RefExpression);
                    {
                        N(SyntaxKind.RefKeyword);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                }
                N(SyntaxKind.CloseBraceToken);
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ObjectInitializer_BadRef()
        {
            UsingExpression("new C { P = ref }",
                // (1,17): error CS1525: Invalid expression term '}'
                // new C { P = ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "}").WithArguments("}").WithLocation(1, 17));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "C");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "P");
                        }
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.RefExpression);
                        {
                            N(SyntaxKind.RefKeyword);
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void CollectionInitializer_BadRef_01()
        {
            UsingExpression("new C { ref }",
                // (1,13): error CS1525: Invalid expression term '}'
                // new C { ref }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "}").WithArguments("}").WithLocation(1, 13));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "C");
                }
                N(SyntaxKind.CollectionInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.RefExpression);
                    {
                        N(SyntaxKind.RefKeyword);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void CollectionInitializer_BadRef_02()
        {
            UsingExpression("new C { { 0, ref } }",
                // (1,14): error CS1525: Invalid expression term 'ref'
                // new C { { 0, ref } }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref ").WithArguments("ref").WithLocation(1, 14),
                // (1,18): error CS1525: Invalid expression term '}'
                // new C { { 0, ref } }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "}").WithArguments("}").WithLocation(1, 18));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "C");
                }
                N(SyntaxKind.CollectionInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.ComplexElementInitializerExpression);
                    {
                        N(SyntaxKind.OpenBraceToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                        N(SyntaxKind.CommaToken);
                        N(SyntaxKind.RefExpression);
                        {
                            N(SyntaxKind.RefKeyword);
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                        }
                        N(SyntaxKind.CloseBraceToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void AttributeArgument_BadRef()
        {
            UsingTree("class C { [Attr(ref)] void M() { } }",
                // (1,17): error CS1525: Invalid expression term 'ref'
                // class C { [Attr(ref)] void M() { } }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref").WithArguments("ref").WithLocation(1, 17),
                // (1,20): error CS1525: Invalid expression term ')'
                // class C { [Attr(ref)] void M() { } }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(1, 20));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.ClassDeclaration);
                {
                    N(SyntaxKind.ClassKeyword);
                    N(SyntaxKind.IdentifierToken, "C");
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.MethodDeclaration);
                    {
                        N(SyntaxKind.AttributeList);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            N(SyntaxKind.Attribute);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Attr");
                                }
                                N(SyntaxKind.AttributeArgumentList);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.AttributeArgument);
                                    {
                                        N(SyntaxKind.RefExpression);
                                        {
                                            N(SyntaxKind.RefKeyword);
                                            M(SyntaxKind.IdentifierName);
                                            {
                                                M(SyntaxKind.IdentifierToken);
                                            }
                                        }
                                    }
                                    N(SyntaxKind.CloseParenToken);
                                }
                            }
                            N(SyntaxKind.CloseBracketToken);
                        }
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ForLoop_BadRefCondition()
        {
            UsingStatement("for (int i = 0; ref; i++) { }",
                // (1,17): error CS1525: Invalid expression term 'ref'
                // for (int i = 0; ref; i++) { }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "ref").WithArguments("ref").WithLocation(1, 17),
                // (1,20): error CS1525: Invalid expression term ';'
                // for (int i = 0; ref; i++) { }
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ";").WithArguments(";").WithLocation(1, 20));

            N(SyntaxKind.ForStatement);
            {
                N(SyntaxKind.ForKeyword);
                N(SyntaxKind.OpenParenToken);
                N(SyntaxKind.VariableDeclaration);
                {
                    N(SyntaxKind.PredefinedType);
                    {
                        N(SyntaxKind.IntKeyword);
                    }
                    N(SyntaxKind.VariableDeclarator);
                    {
                        N(SyntaxKind.IdentifierToken, "i");
                        N(SyntaxKind.EqualsValueClause);
                        {
                            N(SyntaxKind.EqualsToken);
                            N(SyntaxKind.NumericLiteralExpression);
                            {
                                N(SyntaxKind.NumericLiteralToken, "0");
                            }
                        }
                    }
                }
                N(SyntaxKind.SemicolonToken);
                N(SyntaxKind.RefExpression);
                {
                    N(SyntaxKind.RefKeyword);
                    M(SyntaxKind.IdentifierName);
                    {
                        M(SyntaxKind.IdentifierToken);
                    }
                }
                N(SyntaxKind.SemicolonToken);
                N(SyntaxKind.PostIncrementExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "i");
                    }
                    N(SyntaxKind.PlusPlusToken);
                }
                N(SyntaxKind.CloseParenToken);
                N(SyntaxKind.Block);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_BadInElementAccess()
        {
            UsingExpression("new[] { in[] }",
                // (1,9): error CS1041: Identifier expected; 'in' is a keyword
                // new[] { in[] }
                Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "in").WithArguments("", "in").WithLocation(1, 9));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.CollectionExpression);
                    {
                        N(SyntaxKind.OpenBracketToken);
                        N(SyntaxKind.CloseBracketToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_BadOutElementAccess()
        {
            UsingExpression("new[] { out[] }",
                // (1,9): error CS1041: Identifier expected; 'out' is a keyword
                // new[] { out[] }
                Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "out").WithArguments("", "out").WithLocation(1, 9));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.CollectionExpression);
                    {
                        N(SyntaxKind.OpenBracketToken);
                        N(SyntaxKind.CloseBracketToken);
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact]
        [WorkItem(39072, "https://github.com/dotnet/roslyn/issues/39072")]
        public void ArrayCreation_ElementAccess()
        {
            UsingExpression("new[] { obj[] }",
                // (1,13): error CS0443: Syntax error; value expected
                // new[] { obj[] }
                Diagnostic(ErrorCode.ERR_ValueExpected, "]").WithLocation(1, 13));

            N(SyntaxKind.ImplicitArrayCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.OpenBracketToken);
                N(SyntaxKind.CloseBracketToken);
                N(SyntaxKind.ArrayInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.ElementAccessExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "obj");
                        }
                        N(SyntaxKind.BracketedArgumentList);
                        {
                            N(SyntaxKind.OpenBracketToken);
                            M(SyntaxKind.Argument);
                            {
                                M(SyntaxKind.IdentifierName);
                                {
                                    M(SyntaxKind.IdentifierToken);
                                }
                            }
                            N(SyntaxKind.CloseBracketToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem(44789, "https://github.com/dotnet/roslyn/issues/44789")]
        public void MismatchedInterpolatedStringContents_01()
        {
            var text =
@"class A
{
    void M()
    {
        if (b)
        {
            A B = new C($@""{D(.E}"");
            N.O("""", P.Q);
            R.S(T);
            U.V(W.X, Y.Z);
        }
    }

    string M() => """";
}";
            var tree = ParseTree(text, TestOptions.Regular);
            // Note that the parser eventually syncs back up and stops producing diagnostics.
            tree.GetDiagnostics().Verify(
                // (7,31): error CS1001: Identifier expected
                //             A B = new C($@"{D(.E}");
                Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(7, 31),
                // (7,33): error CS1003: Syntax error, ')' expected
                //             A B = new C($@"{D(.E}");
                Diagnostic(ErrorCode.ERR_SyntaxError, "}").WithArguments(")").WithLocation(7, 33),
                // (7,33): error CS1003: Syntax error, ',' expected
                //             A B = new C($@"{D(.E}");
                Diagnostic(ErrorCode.ERR_SyntaxError, "}").WithArguments(",").WithLocation(7, 33),
                // (7,34): error CS1026: ) expected
                //             A B = new C($@"{D(.E}");
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(7, 34)
                );
        }

        [Fact, WorkItem(44789, "https://github.com/dotnet/roslyn/issues/44789")]
        public void MismatchedInterpolatedStringContents_02()
        {
            var text =
@"class A
{
    void M()
    {
        if (b)
        {
            A B = new C($@""{D(.E}\F\G{H}_{I.J.K(""L"")}.M"");
            N.O("""", P.Q);
            R.S(T);
            U.V(W.X, Y.Z);
        }
    }

    string M() => """";
}";
            var tree = ParseTree(text, TestOptions.Regular);
            // Note that the parser eventually syncs back up and stops producing diagnostics.
            tree.GetDiagnostics().Verify(
                    // (7,31): error CS1001: Identifier expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_IdentifierExpected, ".").WithLocation(7, 31),
                    // (7,33): error CS1003: Syntax error, ')' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "}").WithArguments(")").WithLocation(7, 33),
                    // (7,33): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "}").WithArguments(",").WithLocation(7, 33),
                    // (7,34): error CS1056: Unexpected character '\'
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_UnexpectedCharacter, "").WithArguments("\\").WithLocation(7, 34),
                    // (7,35): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "F").WithArguments(",").WithLocation(7, 35),
                    // (7,36): error CS1056: Unexpected character '\'
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_UnexpectedCharacter, "").WithArguments("\\").WithLocation(7, 36),
                    // (7,37): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "G").WithArguments(",").WithLocation(7, 37),
                    // (7,38): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments(",").WithLocation(7, 38),
                    // (7,39): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "H").WithArguments(",").WithLocation(7, 39),
                    // (7,40): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "}").WithArguments(",").WithLocation(7, 40),
                    // (7,41): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "_").WithArguments(",").WithLocation(7, 41),
                    // (7,42): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "{").WithArguments(",").WithLocation(7, 42),
                    // (7,43): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "I").WithArguments(",").WithLocation(7, 43),
                    // (7,49): error CS1026: ) expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(7, 49),
                    // (7,49): error CS1026: ) expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_CloseParenExpected, "").WithLocation(7, 49),
                    // (7,50): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, "L").WithArguments(",").WithLocation(7, 50),
                    // (7,51): error CS1003: Syntax error, ',' expected
                    //             A B = new C($@"{D(.E}\F\G{H}_{I.J.K("L")}.M");
                    Diagnostic(ErrorCode.ERR_SyntaxError, @""")}.M""").WithArguments(",").WithLocation(7, 51)
                );
        }

        [Fact]
        public void UnsignedRightShift_01()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x >>> y", options);

                N(SyntaxKind.UnsignedRightShiftExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShift_02()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x > >> y", options,
                    // (1,5): error CS1525: Invalid expression term '>'
                    // x > >> y
                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 5)
                    );

                N(SyntaxKind.GreaterThanExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.GreaterThanToken);
                    N(SyntaxKind.RightShiftExpression);
                    {
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                        N(SyntaxKind.GreaterThanGreaterThanToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "y");
                        }
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShift_03()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x >> > y", options,
                    // (1,6): error CS1525: Invalid expression term '>'
                    // x >> > y
                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 6)
                    );

                N(SyntaxKind.GreaterThanExpression);
                {
                    N(SyntaxKind.RightShiftExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "x");
                        }
                        N(SyntaxKind.GreaterThanGreaterThanToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.GreaterThanToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShiftAssignment_01()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x >>>= y", options);

                N(SyntaxKind.UnsignedRightShiftAssignmentExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShiftAssignment_02()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x > >>= y", options,
                    // (1,5): error CS1525: Invalid expression term '>'
                    // x > >>= y
                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">").WithArguments(">").WithLocation(1, 5)
                    );

                N(SyntaxKind.RightShiftAssignmentExpression);
                {
                    N(SyntaxKind.GreaterThanExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "x");
                        }
                        N(SyntaxKind.GreaterThanToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.GreaterThanGreaterThanEqualsToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShiftAssignment_03()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x >> >= y", options,
                    // (1,6): error CS1525: Invalid expression term '>='
                    // x >> >= y
                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, ">=").WithArguments(">=").WithLocation(1, 6)
                    );

                N(SyntaxKind.GreaterThanOrEqualExpression);
                {
                    N(SyntaxKind.RightShiftExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "x");
                        }
                        N(SyntaxKind.GreaterThanGreaterThanToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.GreaterThanEqualsToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact]
        public void UnsignedRightShiftAssignment_04()
        {
            foreach (var options in new[] { TestOptions.RegularPreview, TestOptions.Regular10, TestOptions.Regular11 })
            {
                UsingExpression("x >>> = y", options,
                    // (1,7): error CS1525: Invalid expression term '='
                    // x >>> = y
                    Diagnostic(ErrorCode.ERR_InvalidExprTerm, "=").WithArguments("=").WithLocation(1, 7)
                    );

                N(SyntaxKind.SimpleAssignmentExpression);
                {
                    N(SyntaxKind.UnsignedRightShiftExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "x");
                        }
                        N(SyntaxKind.GreaterThanGreaterThanGreaterThanToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.EqualsToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "y");
                    }
                }
                EOF();
            }
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/75074")]
        public void LinqQueryInConditionalExpression1()
        {
            var text = "x is X ? from item in collection select item : null";

            UsingExpression(text);
            N(SyntaxKind.ConditionalExpression);
            {
                N(SyntaxKind.IsExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.IsKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "X");
                    }
                }
                N(SyntaxKind.QuestionToken);
                N(SyntaxKind.QueryExpression);
                {
                    N(SyntaxKind.FromClause);
                    {
                        N(SyntaxKind.FromKeyword);
                        N(SyntaxKind.IdentifierToken, "item");
                        N(SyntaxKind.InKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "collection");
                        }
                    }
                    N(SyntaxKind.QueryBody);
                    {
                        N(SyntaxKind.SelectClause);
                        {
                            N(SyntaxKind.SelectKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "item");
                            }
                        }
                    }
                }
                N(SyntaxKind.ColonToken);
                N(SyntaxKind.NullLiteralExpression);
                {
                    N(SyntaxKind.NullKeyword);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/75074")]
        public void LinqQueryInConditionalExpression2()
        {
            var text = "x is X.Y ? from item in collection select item : null";

            UsingExpression(text);
            N(SyntaxKind.ConditionalExpression);
            {
                N(SyntaxKind.IsExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.IsKeyword);
                    N(SyntaxKind.QualifiedName);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        N(SyntaxKind.DotToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Y");
                        }
                    }
                }
                N(SyntaxKind.QuestionToken);
                N(SyntaxKind.QueryExpression);
                {
                    N(SyntaxKind.FromClause);
                    {
                        N(SyntaxKind.FromKeyword);
                        N(SyntaxKind.IdentifierToken, "item");
                        N(SyntaxKind.InKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "collection");
                        }
                    }
                    N(SyntaxKind.QueryBody);
                    {
                        N(SyntaxKind.SelectClause);
                        {
                            N(SyntaxKind.SelectKeyword);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "item");
                            }
                        }
                    }
                }
                N(SyntaxKind.ColonToken);
                N(SyntaxKind.NullLiteralExpression);
                {
                    N(SyntaxKind.NullKeyword);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/75074")]
        public void LinqQueryInConditionalExpression_Incomplete()
        {
            var text = "x is X.Y ? from item";

            UsingExpression(text,
                // (1,21): error CS1001: Identifier expected
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_IdentifierExpected, "").WithLocation(1, 21),
                // (1,21): error CS1003: Syntax error, 'in' expected
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments("in").WithLocation(1, 21),
                // (1,21): error CS1733: Expected expression
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 21),
                // (1,21): error CS0742: A query body must end with a select clause or a group clause
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_ExpectedSelectOrGroup, "").WithLocation(1, 21),
                // (1,21): error CS1003: Syntax error, ':' expected
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_SyntaxError, "").WithArguments(":").WithLocation(1, 21),
                // (1,21): error CS1733: Expected expression
                // x is X.Y ? from item
                Diagnostic(ErrorCode.ERR_ExpressionExpected, "").WithLocation(1, 21));

            N(SyntaxKind.ConditionalExpression);
            {
                N(SyntaxKind.IsExpression);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.IsKeyword);
                    N(SyntaxKind.QualifiedName);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        N(SyntaxKind.DotToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Y");
                        }
                    }
                }
                N(SyntaxKind.QuestionToken);
                N(SyntaxKind.QueryExpression);
                {
                    N(SyntaxKind.FromClause);
                    {
                        N(SyntaxKind.FromKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "item");
                        }
                        M(SyntaxKind.IdentifierToken);
                        M(SyntaxKind.InKeyword);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    M(SyntaxKind.QueryBody);
                    {
                        M(SyntaxKind.SelectClause);
                        {
                            M(SyntaxKind.SelectKeyword);
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                        }
                    }
                }
                M(SyntaxKind.ColonToken);
                M(SyntaxKind.IdentifierName);
                {
                    M(SyntaxKind.IdentifierToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80537")]
        public void ObjectInitializerWithColonInsteadOfEqualsSign()
        {
            UsingExpression("new Class1 { X: 0 }",
                // (1,15): error CS1003: Syntax error, '=' expected
                // new Class1 { X: 0 }
                Diagnostic(ErrorCode.ERR_SyntaxError, ":").WithArguments("=").WithLocation(1, 15));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "Class1");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        M(SyntaxKind.EqualsToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80537")]
        public void ImplicitObjectInitializerWithColonInsteadOfEqualsSign()
        {
            UsingStatement("Class1 c1 = new() { X: 0 };",
                // (1,22): error CS1003: Syntax error, '=' expected
                // Class1 c1 = new() { X: 0 };
                Diagnostic(ErrorCode.ERR_SyntaxError, ":").WithArguments("=").WithLocation(1, 22));

            N(SyntaxKind.LocalDeclarationStatement);
            {
                N(SyntaxKind.VariableDeclaration);
                {
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "Class1");
                    }
                    N(SyntaxKind.VariableDeclarator);
                    {
                        N(SyntaxKind.IdentifierToken, "c1");
                        N(SyntaxKind.EqualsValueClause);
                        {
                            N(SyntaxKind.EqualsToken);
                            N(SyntaxKind.ImplicitObjectCreationExpression);
                            {
                                N(SyntaxKind.NewKeyword);
                                N(SyntaxKind.ArgumentList);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.ObjectInitializerExpression);
                                {
                                    N(SyntaxKind.OpenBraceToken);
                                    N(SyntaxKind.SimpleAssignmentExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "X");
                                        }
                                        M(SyntaxKind.EqualsToken);
                                        N(SyntaxKind.NumericLiteralExpression);
                                        {
                                            N(SyntaxKind.NumericLiteralToken, "0");
                                        }
                                    }
                                    N(SyntaxKind.CloseBraceToken);
                                }
                            }
                        }
                    }
                }
                N(SyntaxKind.SemicolonToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80537")]
        public void ObjectInitializerWithColonInsteadOfEqualsSignInNestedInitialization()
        {
            UsingExpression("new Class1 { X = { Y: 0 } }",
                // (1,21): error CS1003: Syntax error, '=' expected
                // new Class1 { X = { Y: 0 } }
                Diagnostic(ErrorCode.ERR_SyntaxError, ":").WithArguments("=").WithLocation(1, 21));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "Class1");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.ObjectInitializerExpression);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.SimpleAssignmentExpression);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Y");
                                }
                                M(SyntaxKind.EqualsToken);
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "0");
                                }
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80537")]
        public void ObjectInitializerWithColonInsteadOfEqualsSignInCollectionInitializer()
        {
            UsingExpression("new Class1 { X = { [0] = { Y: 0 } } }",
                // (1,29): error CS1003: Syntax error, '=' expected
                // new Class1 { X = { [0] = { Y: 0 } } }
                Diagnostic(ErrorCode.ERR_SyntaxError, ":").WithArguments("=").WithLocation(1, 29));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "Class1");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.ObjectInitializerExpression);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.SimpleAssignmentExpression);
                            {
                                N(SyntaxKind.ImplicitElementAccess);
                                {
                                    N(SyntaxKind.BracketedArgumentList);
                                    {
                                        N(SyntaxKind.OpenBracketToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.NumericLiteralExpression);
                                            {
                                                N(SyntaxKind.NumericLiteralToken, "0");
                                            }
                                        }
                                        N(SyntaxKind.CloseBracketToken);
                                    }
                                }
                                N(SyntaxKind.EqualsToken);
                                N(SyntaxKind.ObjectInitializerExpression);
                                {
                                    N(SyntaxKind.OpenBraceToken);
                                    N(SyntaxKind.SimpleAssignmentExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Y");
                                        }
                                        M(SyntaxKind.EqualsToken);
                                        N(SyntaxKind.NumericLiteralExpression);
                                        {
                                            N(SyntaxKind.NumericLiteralToken, "0");
                                        }
                                    }
                                    N(SyntaxKind.CloseBraceToken);
                                }
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/80537")]
        public void ObjectInitializerWithColonAndDashInsteadOfEqualsSigns()
        {
            UsingExpression("new Class1 { X: 0, Y - 0 }",
                // (1,15): error CS1003: Syntax error, '=' expected
                // new Class1 { X: 0, Y - 0 }
                Diagnostic(ErrorCode.ERR_SyntaxError, ":").WithArguments("=").WithLocation(1, 15));

            N(SyntaxKind.ObjectCreationExpression);
            {
                N(SyntaxKind.NewKeyword);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "Class1");
                }
                N(SyntaxKind.ObjectInitializerExpression);
                {
                    N(SyntaxKind.OpenBraceToken);
                    N(SyntaxKind.SimpleAssignmentExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "X");
                        }
                        M(SyntaxKind.EqualsToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                    }
                    N(SyntaxKind.CommaToken);
                    N(SyntaxKind.SubtractExpression);
                    {
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Y");
                        }
                        N(SyntaxKind.MinusToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                    }
                    N(SyntaxKind.CloseBraceToken);
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11418")]
        public void LetClauseWithKeywordAsIdentifier1()
        {
            UsingExpression("from m in methods let params = 1 select m",
                // (1,23): error CS1041: Identifier expected; 'params' is a keyword
                // from m in methods let params = m.GetParameters() select m
                Diagnostic(ErrorCode.ERR_IdentifierExpectedKW, "params").WithArguments("", "params").WithLocation(1, 23));

            N(SyntaxKind.QueryExpression);
            {
                N(SyntaxKind.FromClause);
                {
                    N(SyntaxKind.FromKeyword);
                    N(SyntaxKind.IdentifierToken, "m");
                    N(SyntaxKind.InKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "methods");
                    }
                }
                N(SyntaxKind.QueryBody);
                {
                    N(SyntaxKind.LetClause);
                    {
                        N(SyntaxKind.LetKeyword);
                        M(SyntaxKind.IdentifierToken);
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.SelectClause);
                    {
                        N(SyntaxKind.SelectKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "m");
                        }
                    }
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11418")]
        public void LetClauseWithKeywordAsIdentifier2()
        {
            UsingExpression("from m in methods let and = 1 select m");

            N(SyntaxKind.QueryExpression);
            {
                N(SyntaxKind.FromClause);
                {
                    N(SyntaxKind.FromKeyword);
                    N(SyntaxKind.IdentifierToken, "m");
                    N(SyntaxKind.InKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "methods");
                    }
                }
                N(SyntaxKind.QueryBody);
                {
                    N(SyntaxKind.LetClause);
                    {
                        N(SyntaxKind.LetKeyword);
                        N(SyntaxKind.IdentifierToken, "and");
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.SelectClause);
                    {
                        N(SyntaxKind.SelectKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "m");
                        }
                    }
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/11418")]
        public void LetClauseWithKeywordAsIdentifier3()
        {
            UsingExpression("from m in methods let let = 1 select m",
                // (1,23): error CS1525: Invalid expression term 'let'
                // from m in methods let let = 1 select m
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "let").WithArguments("let").WithLocation(1, 23),
                // (1,23): error CS1003: Syntax error, '=' expected
                // from m in methods let let = 1 select m
                Diagnostic(ErrorCode.ERR_SyntaxError, "let").WithArguments("=").WithLocation(1, 23),
                // (1,23): error CS1525: Invalid expression term 'let'
                // from m in methods let let = 1 select m
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "let").WithArguments("let").WithLocation(1, 23),
                // (1,27): error CS1001: Identifier expected
                // from m in methods let let = 1 select m
                Diagnostic(ErrorCode.ERR_IdentifierExpected, "=").WithLocation(1, 27));

            N(SyntaxKind.QueryExpression);
            {
                N(SyntaxKind.FromClause);
                {
                    N(SyntaxKind.FromKeyword);
                    N(SyntaxKind.IdentifierToken, "m");
                    N(SyntaxKind.InKeyword);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "methods");
                    }
                }
                N(SyntaxKind.QueryBody);
                {
                    N(SyntaxKind.LetClause);
                    {
                        N(SyntaxKind.LetKeyword);
                        M(SyntaxKind.IdentifierToken);
                        M(SyntaxKind.EqualsToken);
                        M(SyntaxKind.IdentifierName);
                        {
                            M(SyntaxKind.IdentifierToken);
                        }
                    }
                    N(SyntaxKind.LetClause);
                    {
                        N(SyntaxKind.LetKeyword);
                        M(SyntaxKind.IdentifierToken);
                        N(SyntaxKind.EqualsToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                    }
                    N(SyntaxKind.SelectClause);
                    {
                        N(SyntaxKind.SelectKeyword);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "m");
                        }
                    }
                }
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInIfStatement1()
        {
            UsingTree("""
                if (Boo Quux())
                {
                }
                """,
                // (1,9): error CS1073: Unexpected token 'Quux'
                // if (Boo Quux())
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 9));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.IfStatement);
                    {
                        N(SyntaxKind.IfKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Boo");
                        }
                        N(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/4009")]
        public void InProgressMultipleExpressionsInIfStatement2()
        {
            UsingTree("""
                if (1 2)
                    return;
                """,
                // (1,7): error CS1073: Unexpected token '2'
                // if (1 2)
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "2").WithArguments("2").WithLocation(1, 7));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.IfStatement);
                    {
                        N(SyntaxKind.IfKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        N(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.ReturnStatement);
                        {
                            N(SyntaxKind.ReturnKeyword);
                            N(SyntaxKind.SemicolonToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/4009")]
        public void InProgressMultipleExpressionsInIfStatement3()
        {
            UsingTree("""
                if (1 2 3)
                    return;
                """,
                // (1,7): error CS1026: ) expected
                // if (1 2 3)
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "2").WithLocation(1, 7),
                // (1,9): error CS1002: ; expected
                // if (1 2 3)
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "3").WithLocation(1, 9),
                // (1,10): error CS1002: ; expected
                // if (1 2 3)
                Diagnostic(ErrorCode.ERR_SemicolonExpected, ")").WithLocation(1, 10),
                // (1,10): error CS1022: Type or namespace definition, or end-of-file expected
                // if (1 2 3)
                Diagnostic(ErrorCode.ERR_EOFExpected, ")").WithLocation(1, 10));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.IfStatement);
                    {
                        N(SyntaxKind.IfKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "1");
                        }
                        M(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.ExpressionStatement);
                        {
                            N(SyntaxKind.NumericLiteralExpression);
                            {
                                N(SyntaxKind.NumericLiteralToken, "2");
                            }
                            M(SyntaxKind.SemicolonToken);
                        }
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "3");
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ReturnStatement);
                    {
                        N(SyntaxKind.ReturnKeyword);
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInParenthesizedExpression()
        {
            UsingTree("""
                var v = (Boo Quux());
                """,
                // (1,14): error CS1073: Unexpected token 'Quux'
                // var v = (Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 14));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.ParenthesizedExpression);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInCatchFilter()
        {
            UsingTree("""
                try
                {
                }
                catch (Exception e) when (Boo Quux())
                {
                }
                """,
                // (4,31): error CS1073: Unexpected token 'Quux'
                // catch (Exception e) when (Boo Quux())
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(4, 31));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.TryStatement);
                    {
                        N(SyntaxKind.TryKeyword);
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                        N(SyntaxKind.CatchClause);
                        {
                            N(SyntaxKind.CatchKeyword);
                            N(SyntaxKind.CatchDeclaration);
                            {
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Exception");
                                }
                                N(SyntaxKind.IdentifierToken, "e");
                                N(SyntaxKind.CloseParenToken);
                            }
                            N(SyntaxKind.CatchFilterClause);
                            {
                                N(SyntaxKind.WhenKeyword);
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "Boo");
                                }
                                N(SyntaxKind.CloseParenToken);
                            }
                            N(SyntaxKind.Block);
                            {
                                N(SyntaxKind.OpenBraceToken);
                                N(SyntaxKind.CloseBraceToken);
                            }
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInDoStatement()
        {
            UsingTree("""
                do
                {
                }
                while (Boo Quux());
                """,
                // (4,12): error CS1073: Unexpected token 'Quux'
                // while (Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(4, 12));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.DoStatement);
                    {
                        N(SyntaxKind.DoKeyword);
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                        N(SyntaxKind.WhileKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Boo");
                        }
                        N(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInLockStatement()
        {
            UsingTree("""
                lock (Boo Quux())
                {
                }
                """,
                // (1,11): error CS1073: Unexpected token 'Quux'
                // lock (Boo Quux())
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 11));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LockStatement);
                    {
                        N(SyntaxKind.LockKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Boo");
                        }
                        N(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInWhileStatement()
        {
            UsingTree("""
                while (Boo Quux())
                {
                }
                """,
                // (1,12): error CS1073: Unexpected token 'Quux'
                // while (Boo Quux())
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 12));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.WhileStatement);
                    {
                        N(SyntaxKind.WhileKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.IdentifierName);
                        {
                            N(SyntaxKind.IdentifierToken, "Boo");
                        }
                        N(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInMakeRefExpression()
        {
            UsingTree("""
                var v = __makeref(Boo Quux());
                """,
                // (1,23): error CS1073: Unexpected token 'Quux'
                // var v = __makeref(Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 23));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.MakeRefExpression);
                                    {
                                        N(SyntaxKind.MakeRefKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInRefTypeExpression()
        {
            UsingTree("""
                var v = __reftype(Boo Quux());
                """,
                // (1,23): error CS1073: Unexpected token 'Quux'
                // var v = __reftype(Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 23));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.RefTypeExpression);
                                    {
                                        N(SyntaxKind.RefTypeKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInRefValueExpression()
        {
            UsingTree("""
                var v = __refvalue(Boo Quux);
                """,
                // (1,24): error CS1003: Syntax error, ',' expected
                // var v = __refvalue(Boo Quux);
                Diagnostic(ErrorCode.ERR_SyntaxError, "Quux").WithArguments(",").WithLocation(1, 24));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.RefValueExpression);
                                    {
                                        N(SyntaxKind.RefValueKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        M(SyntaxKind.CommaToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Quux");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInCheckedExpression()
        {
            UsingTree("""
                var v = checked(Boo Quux());
                """,
                // (1,21): error CS1073: Unexpected token 'Quux'
                // var v = checked(Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 21));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.CheckedExpression);
                                    {
                                        N(SyntaxKind.CheckedKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression()
        {
            UsingExpression("unsafe(x)");

            N(SyntaxKind.UnsafeExpression);
            {
                N(SyntaxKind.UnsafeKeyword);
                N(SyntaxKind.OpenParenToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "x");
                }
                N(SyntaxKind.CloseParenToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_PostfixMemberAccess()
        {
            UsingExpression("unsafe(x).M");

            N(SyntaxKind.SimpleMemberAccessExpression);
            {
                N(SyntaxKind.UnsafeExpression);
                {
                    N(SyntaxKind.UnsafeKeyword);
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.CloseParenToken);
                }
                N(SyntaxKind.DotToken);
                N(SyntaxKind.IdentifierName);
                {
                    N(SyntaxKind.IdentifierToken, "M");
                }
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_Indexer()
        {
            UsingExpression("unsafe(x)[0]");

            N(SyntaxKind.ElementAccessExpression);
            {
                N(SyntaxKind.UnsafeExpression);
                {
                    N(SyntaxKind.UnsafeKeyword);
                    N(SyntaxKind.OpenParenToken);
                    N(SyntaxKind.IdentifierName);
                    {
                        N(SyntaxKind.IdentifierToken, "x");
                    }
                    N(SyntaxKind.CloseParenToken);
                }
                N(SyntaxKind.BracketedArgumentList);
                {
                    N(SyntaxKind.OpenBracketToken);
                    N(SyntaxKind.Argument);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                    }
                    N(SyntaxKind.CloseBracketToken);
                }
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_Statement()
        {
            UsingTree("""
                unsafe(x);
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.UnsafeExpression);
                        {
                            N(SyntaxKind.UnsafeKeyword);
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "x");
                            }
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_AssignmentStatement()
        {
            UsingTree("""
                unsafe(x) = y;
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.SimpleAssignmentExpression);
                        {
                            N(SyntaxKind.UnsafeExpression);
                            {
                                N(SyntaxKind.UnsafeKeyword);
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "x");
                                }
                                N(SyntaxKind.CloseParenToken);
                            }
                            N(SyntaxKind.EqualsToken);
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "y");
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_PointerAssignmentStatement()
        {
            UsingTree("""
                unsafe(*p) = 2;
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.SimpleAssignmentExpression);
                        {
                            N(SyntaxKind.UnsafeExpression);
                            {
                                N(SyntaxKind.UnsafeKeyword);
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.PointerIndirectionExpression);
                                {
                                    N(SyntaxKind.AsteriskToken);
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "p");
                                    }
                                }
                                N(SyntaxKind.CloseParenToken);
                            }
                            N(SyntaxKind.EqualsToken);
                            N(SyntaxKind.NumericLiteralExpression);
                            {
                                N(SyntaxKind.NumericLiteralToken, "2");
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_ActuallyLocalFunction()
        {
            UsingTree("""
                unsafe (int, int) F() => (1, 2);
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.UnsafeKeyword);
                        N(SyntaxKind.TupleType);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.TupleElement);
                            {
                                N(SyntaxKind.PredefinedType);
                                {
                                    N(SyntaxKind.IntKeyword);
                                }
                            }
                            N(SyntaxKind.CommaToken);
                            N(SyntaxKind.TupleElement);
                            {
                                N(SyntaxKind.PredefinedType);
                                {
                                    N(SyntaxKind.IntKeyword);
                                }
                            }
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.IdentifierToken, "F");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.ArrowExpressionClause);
                        {
                            N(SyntaxKind.EqualsGreaterThanToken);
                            N(SyntaxKind.TupleExpression);
                            {
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "1");
                                    }
                                }
                                N(SyntaxKind.CommaToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.NumericLiteralExpression);
                                    {
                                        N(SyntaxKind.NumericLiteralToken, "2");
                                    }
                                }
                                N(SyntaxKind.CloseParenToken);
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_ActuallyLocalFunction_BlockBody()
        {
            UsingTree("""
                unsafe (int, int) F()
                {
                    return (1, 2);
                }
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.UnsafeKeyword);
                        N(SyntaxKind.TupleType);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.TupleElement);
                            {
                                N(SyntaxKind.PredefinedType);
                                {
                                    N(SyntaxKind.IntKeyword);
                                }
                            }
                            N(SyntaxKind.CommaToken);
                            N(SyntaxKind.TupleElement);
                            {
                                N(SyntaxKind.PredefinedType);
                                {
                                    N(SyntaxKind.IntKeyword);
                                }
                            }
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.IdentifierToken, "F");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ReturnStatement);
                            {
                                N(SyntaxKind.ReturnKeyword);
                                N(SyntaxKind.TupleExpression);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.Argument);
                                    {
                                        N(SyntaxKind.NumericLiteralExpression);
                                        {
                                            N(SyntaxKind.NumericLiteralToken, "1");
                                        }
                                    }
                                    N(SyntaxKind.CommaToken);
                                    N(SyntaxKind.Argument);
                                    {
                                        N(SyntaxKind.NumericLiteralExpression);
                                        {
                                            N(SyntaxKind.NumericLiteralToken, "2");
                                        }
                                    }
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact]
        public void UnsafeExpression_ActuallyLocalFunction_Nested()
        {
            UsingTree("""
                void M()
                {
                    unsafe (int, int) F() => (1, 2);
                }
                """);

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.LocalFunctionStatement);
                            {
                                N(SyntaxKind.UnsafeKeyword);
                                N(SyntaxKind.TupleType);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.TupleElement);
                                    {
                                        N(SyntaxKind.PredefinedType);
                                        {
                                            N(SyntaxKind.IntKeyword);
                                        }
                                    }
                                    N(SyntaxKind.CommaToken);
                                    N(SyntaxKind.TupleElement);
                                    {
                                        N(SyntaxKind.PredefinedType);
                                        {
                                            N(SyntaxKind.IntKeyword);
                                        }
                                    }
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.IdentifierToken, "F");
                                N(SyntaxKind.ParameterList);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.CloseParenToken);
                                }
                                N(SyntaxKind.ArrowExpressionClause);
                                {
                                    N(SyntaxKind.EqualsGreaterThanToken);
                                    N(SyntaxKind.TupleExpression);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.NumericLiteralExpression);
                                            {
                                                N(SyntaxKind.NumericLiteralToken, "1");
                                            }
                                        }
                                        N(SyntaxKind.CommaToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.NumericLiteralExpression);
                                            {
                                                N(SyntaxKind.NumericLiteralToken, "2");
                                            }
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInUncheckedExpression()
        {
            UsingTree("""
                var v = unchecked(Boo Quux());
                """,
                // (1,23): error CS1073: Unexpected token 'Quux'
                // var v = unchecked(Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 23));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.UncheckedExpression);
                                    {
                                        N(SyntaxKind.UncheckedKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInUnsafeExpression()
        {
            UsingTree("""
                var v = unsafe(Boo Quux());
                """,
                // (1,20): error CS1073: Unexpected token 'Quux'
                // var v = unsafe(Boo Quux());
                Diagnostic(ErrorCode.ERR_UnexpectedToken, "Quux").WithArguments("Quux").WithLocation(1, 20));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.UnsafeExpression);
                                    {
                                        N(SyntaxKind.UnsafeKeyword);
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Boo");
                                        }
                                        N(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInInvocationExpression1()
        {
            UsingTree("""
                var v = Goo(Boo Quux());
                """,
                // (1,17): error CS1003: Syntax error, ',' expected
                // var v = Goo(Boo Quux());
                Diagnostic(ErrorCode.ERR_SyntaxError, "Quux").WithArguments(",").WithLocation(1, 17));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Goo");
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "Boo");
                                                }
                                            }
                                            M(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.InvocationExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "Quux");
                                                    }
                                                    N(SyntaxKind.ArgumentList);
                                                    {
                                                        N(SyntaxKind.OpenParenToken);
                                                        N(SyntaxKind.CloseParenToken);
                                                    }
                                                }
                                            }
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInInvocationExpression2()
        {
            UsingTree("""
                var v = Goo(1, Boo Quux());
                """,
                // (1,20): error CS1003: Syntax error, ',' expected
                // var v = Goo(1, Boo Quux());
                Diagnostic(ErrorCode.ERR_SyntaxError, "Quux").WithArguments(",").WithLocation(1, 20));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Goo");
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "1");
                                                }
                                            }
                                            N(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "Boo");
                                                }
                                            }
                                            M(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.InvocationExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "Quux");
                                                    }
                                                    N(SyntaxKind.ArgumentList);
                                                    {
                                                        N(SyntaxKind.OpenParenToken);
                                                        N(SyntaxKind.CloseParenToken);
                                                    }
                                                }
                                            }
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInInvocationExpression3()
        {
            UsingTree("""
                var v = Goo(Boo Quux(), 1);
                """,
                // (1,17): error CS1003: Syntax error, ',' expected
                // var v = Goo(Boo Quux(), 1);
                Diagnostic(ErrorCode.ERR_SyntaxError, "Quux").WithArguments(",").WithLocation(1, 17));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Goo");
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "Boo");
                                                }
                                            }
                                            M(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.InvocationExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "Quux");
                                                    }
                                                    N(SyntaxKind.ArgumentList);
                                                    {
                                                        N(SyntaxKind.OpenParenToken);
                                                        N(SyntaxKind.CloseParenToken);
                                                    }
                                                }
                                            }
                                            N(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.NumericLiteralExpression);
                                                {
                                                    N(SyntaxKind.NumericLiteralToken, "1");
                                                }
                                            }
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInObjectCreationExpression1()
        {
            UsingTree("""
                var v = new Goo(Boo Quux());
                """,
                // (1,21): error CS1003: Syntax error, ',' expected
                // var v = new Goo(Boo Quux());
                Diagnostic(ErrorCode.ERR_SyntaxError, "Quux").WithArguments(",").WithLocation(1, 21));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.ObjectCreationExpression);
                                    {
                                        N(SyntaxKind.NewKeyword);
                                        N(SyntaxKind.IdentifierName);
                                        {
                                            N(SyntaxKind.IdentifierToken, "Goo");
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.IdentifierName);
                                                {
                                                    N(SyntaxKind.IdentifierToken, "Boo");
                                                }
                                            }
                                            M(SyntaxKind.CommaToken);
                                            N(SyntaxKind.Argument);
                                            {
                                                N(SyntaxKind.InvocationExpression);
                                                {
                                                    N(SyntaxKind.IdentifierName);
                                                    {
                                                        N(SyntaxKind.IdentifierToken, "Quux");
                                                    }
                                                    N(SyntaxKind.ArgumentList);
                                                    {
                                                        N(SyntaxKind.OpenParenToken);
                                                        N(SyntaxKind.CloseParenToken);
                                                    }
                                                }
                                            }
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInTupleExpression()
        {
            UsingTree("""
                var v = (a, b, 0 0);
                """,
                // (1,18): error CS1026: ) expected
                // var v = (a, b, 0 0);
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "0").WithLocation(1, 18),
                // (1,18): error CS1003: Syntax error, ',' expected
                // var v = (a, b, 0 0);
                Diagnostic(ErrorCode.ERR_SyntaxError, "0").WithArguments(",").WithLocation(1, 18));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalDeclarationStatement);
                    {
                        N(SyntaxKind.VariableDeclaration);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "var");
                            }
                            N(SyntaxKind.VariableDeclarator);
                            {
                                N(SyntaxKind.IdentifierToken, "v");
                                N(SyntaxKind.EqualsValueClause);
                                {
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.TupleExpression);
                                    {
                                        N(SyntaxKind.OpenParenToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "a");
                                            }
                                        }
                                        N(SyntaxKind.CommaToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "b");
                                            }
                                        }
                                        N(SyntaxKind.CommaToken);
                                        N(SyntaxKind.Argument);
                                        {
                                            N(SyntaxKind.NumericLiteralExpression);
                                            {
                                                N(SyntaxKind.NumericLiteralToken, "0");
                                            }
                                        }
                                        M(SyntaxKind.CloseParenToken);
                                    }
                                }
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void InProgressMultipleExpressionsInDeconstruction()
        {
            // Note: 'b c' is parsed as a declaration, which produces a binding error later.
            UsingTree("""
                (a, b, 0 0) = (a, b, c);
                """,
                // (1,10): error CS1026: ) expected
                // (a, b, 0 0) = (a, b, c);
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "0").WithLocation(1, 10),
                // (1,10): error CS1002: ; expected
                // (a, b, 0 0) = (a, b, c);
                Diagnostic(ErrorCode.ERR_SemicolonExpected, "0").WithLocation(1, 10),
                // (1,11): error CS1002: ; expected
                // (a, b, 0 0) = (a, b, c);
                Diagnostic(ErrorCode.ERR_SemicolonExpected, ")").WithLocation(1, 11),
                // (1,11): error CS1022: Type or namespace definition, or end-of-file expected
                // (a, b, 0 0) = (a, b, c);
                Diagnostic(ErrorCode.ERR_EOFExpected, ")").WithLocation(1, 11),
                // (1,13): error CS1525: Invalid expression term '='
                // (a, b, 0 0) = (a, b, c);
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "=").WithArguments("=").WithLocation(1, 13));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.TupleExpression);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.Argument);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "a");
                                }
                            }
                            N(SyntaxKind.CommaToken);
                            N(SyntaxKind.Argument);
                            {
                                N(SyntaxKind.IdentifierName);
                                {
                                    N(SyntaxKind.IdentifierToken, "b");
                                }
                            }
                            N(SyntaxKind.CommaToken);
                            N(SyntaxKind.Argument);
                            {
                                N(SyntaxKind.NumericLiteralExpression);
                                {
                                    N(SyntaxKind.NumericLiteralToken, "0");
                                }
                            }
                            M(SyntaxKind.CloseParenToken);
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.NumericLiteralExpression);
                        {
                            N(SyntaxKind.NumericLiteralToken, "0");
                        }
                        M(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.ExpressionStatement);
                    {
                        N(SyntaxKind.SimpleAssignmentExpression);
                        {
                            M(SyntaxKind.IdentifierName);
                            {
                                M(SyntaxKind.IdentifierToken);
                            }
                            N(SyntaxKind.EqualsToken);
                            N(SyntaxKind.TupleExpression);
                            {
                                N(SyntaxKind.OpenParenToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "a");
                                    }
                                }
                                N(SyntaxKind.CommaToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "b");
                                    }
                                }
                                N(SyntaxKind.CommaToken);
                                N(SyntaxKind.Argument);
                                {
                                    N(SyntaxKind.IdentifierName);
                                    {
                                        N(SyntaxKind.IdentifierToken, "c");
                                    }
                                }
                                N(SyntaxKind.CloseParenToken);
                            }
                        }
                        N(SyntaxKind.SemicolonToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/16595")]
        public void TestParenthesizedDefaultInIsExpression()
        {
            // We don't want to treat `!` as the start of a new 'missing' expression.
            UsingTree("""
                if (i is (default)!) {}
                """,
                // (1,19): error CS1026: ) expected
                // if (i is (default)!) {}
                Diagnostic(ErrorCode.ERR_CloseParenExpected, "!").WithLocation(1, 19),
                // (1,20): error CS1525: Invalid expression term ')'
                // if (i is (default)!) {}
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ")").WithArguments(")").WithLocation(1, 20),
                // (1,20): error CS1002: ; expected
                // if (i is (default)!) {}
                Diagnostic(ErrorCode.ERR_SemicolonExpected, ")").WithLocation(1, 20),
                // (1,20): error CS1022: Type or namespace definition, or end-of-file expected
                // if (i is (default)!) {}
                Diagnostic(ErrorCode.ERR_EOFExpected, ")").WithLocation(1, 20));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.IfStatement);
                    {
                        N(SyntaxKind.IfKeyword);
                        N(SyntaxKind.OpenParenToken);
                        N(SyntaxKind.IsPatternExpression);
                        {
                            N(SyntaxKind.IdentifierName);
                            {
                                N(SyntaxKind.IdentifierToken, "i");
                            }
                            N(SyntaxKind.IsKeyword);
                            N(SyntaxKind.ConstantPattern);
                            {
                                N(SyntaxKind.ParenthesizedExpression);
                                {
                                    N(SyntaxKind.OpenParenToken);
                                    N(SyntaxKind.DefaultLiteralExpression);
                                    {
                                        N(SyntaxKind.DefaultKeyword);
                                    }
                                    N(SyntaxKind.CloseParenToken);
                                }
                            }
                        }
                        M(SyntaxKind.CloseParenToken);
                        N(SyntaxKind.ExpressionStatement);
                        {
                            N(SyntaxKind.LogicalNotExpression);
                            {
                                N(SyntaxKind.ExclamationToken);
                                M(SyntaxKind.IdentifierName);
                                {
                                    M(SyntaxKind.IdentifierToken);
                                }
                            }
                            M(SyntaxKind.SemicolonToken);
                        }
                    }
                }
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.Block);
                    {
                        N(SyntaxKind.OpenBraceToken);
                        N(SyntaxKind.CloseBraceToken);
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/58298")]
        public void OperatorErrorLocation1()
        {
            UsingTree("""
                void M()
                {
                    <<;
                }
                """,
                // (3,5): error CS1525: Invalid expression term '<<'
                //     <<;
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "<<").WithArguments("<<").WithLocation(3, 5),
                // (3,7): error CS1525: Invalid expression term ';'
                //     <<;
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, ";").WithArguments(";").WithLocation(3, 7));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.LeftShiftExpression);
                                {
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                    N(SyntaxKind.LessThanLessThanToken);
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/31774")]
        public void OperatorErrorLocation2()
        {
            UsingTree("""
                void M()
                {
                    // comment
                    / Console.ReadKey();
                }
                """,
                // (4,5): error CS1525: Invalid expression term '/'
                //     / Console.ReadKey();
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "/").WithArguments("/").WithLocation(4, 5));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.DivideExpression);
                                {
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                    N(SyntaxKind.SlashToken);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.SimpleMemberAccessExpression);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "Console");
                                            }
                                            N(SyntaxKind.DotToken);
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "ReadKey");
                                            }
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }

        [Fact, WorkItem("https://github.com/dotnet/roslyn/issues/31774")]
        public void OperatorErrorLocation3()
        {
            UsingTree("""
                void M()
                {
                    // comment
                    = Console.ReadKey();
                }
                """,
                // (4,5): error CS1525: Invalid expression term '='
                //     = Console.ReadKey();
                Diagnostic(ErrorCode.ERR_InvalidExprTerm, "=").WithArguments("=").WithLocation(4, 5));

            N(SyntaxKind.CompilationUnit);
            {
                N(SyntaxKind.GlobalStatement);
                {
                    N(SyntaxKind.LocalFunctionStatement);
                    {
                        N(SyntaxKind.PredefinedType);
                        {
                            N(SyntaxKind.VoidKeyword);
                        }
                        N(SyntaxKind.IdentifierToken, "M");
                        N(SyntaxKind.ParameterList);
                        {
                            N(SyntaxKind.OpenParenToken);
                            N(SyntaxKind.CloseParenToken);
                        }
                        N(SyntaxKind.Block);
                        {
                            N(SyntaxKind.OpenBraceToken);
                            N(SyntaxKind.ExpressionStatement);
                            {
                                N(SyntaxKind.SimpleAssignmentExpression);
                                {
                                    M(SyntaxKind.IdentifierName);
                                    {
                                        M(SyntaxKind.IdentifierToken);
                                    }
                                    N(SyntaxKind.EqualsToken);
                                    N(SyntaxKind.InvocationExpression);
                                    {
                                        N(SyntaxKind.SimpleMemberAccessExpression);
                                        {
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "Console");
                                            }
                                            N(SyntaxKind.DotToken);
                                            N(SyntaxKind.IdentifierName);
                                            {
                                                N(SyntaxKind.IdentifierToken, "ReadKey");
                                            }
                                        }
                                        N(SyntaxKind.ArgumentList);
                                        {
                                            N(SyntaxKind.OpenParenToken);
                                            N(SyntaxKind.CloseParenToken);
                                        }
                                    }
                                }
                                N(SyntaxKind.SemicolonToken);
                            }
                            N(SyntaxKind.CloseBraceToken);
                        }
                    }
                }
                N(SyntaxKind.EndOfFileToken);
            }
            EOF();
        }
    }
}