20SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 21SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 22SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz *")); 30SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 31SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 32SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz "), 33SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 34SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); 42SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 43SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 44SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo Bar Baz "), 45SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 46SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); 52TestTokenizer("// Foo Bar Baz", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo Bar Baz")); 58TestTokenizer("// Foo Bar Baz\na", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo Bar Baz"), IgnoreRemaining); 64TestTokenizer("// Foo/*Bar*/ Baz\na", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo/*Bar*/ Baz"), IgnoreRemaining); 70TestTokenizer("/* Foo\nBar\nBaz */", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/* Foo\nBar\nBaz */")); 76TestTokenizer("/* Foo\nBar\nBaz */a", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/* Foo\nBar\nBaz */"), IgnoreRemaining); 82TestTokenizer("/* Foo\nBar\nBaz", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/* Foo\nBar\nBaz"), IgnoreRemaining); 88TestTokenizer("/* Foo/*\nBar\nBaz*/ */", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/* Foo/*\nBar\nBaz*/"), IgnoreRemaining); 94TestTokenizer("/* Foo\nBar\nBaz* */", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/* Foo\nBar\nBaz* */"), IgnoreRemaining);

16TestTokenizer("foo", SyntaxFactory.Token(SyntaxKind.Identifier, "foo")); 22TestTokenizer("_foo", SyntaxFactory.Token(SyntaxKind.Identifier, "_foo")); 28TestTokenizer("foo4", SyntaxFactory.Token(SyntaxKind.Identifier, "foo4")); 34TestTokenizer("ῼfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ῼfoo")); 40TestTokenizer("ᵊfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ᵊfoo")); 46TestTokenizer("ƻfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ƻfoo")); 52TestTokenizer("Ⅽool", SyntaxFactory.Token(SyntaxKind.Identifier, "Ⅽool")); 58TestTokenizer("foo\u0300", SyntaxFactory.Token(SyntaxKind.Identifier, "foo\u0300")); 64TestTokenizer("fooः", SyntaxFactory.Token(SyntaxKind.Identifier, "fooः")); 70TestTokenizer("foo١", SyntaxFactory.Token(SyntaxKind.Identifier, "foo١")); 76TestTokenizer("foo‿bar", SyntaxFactory.Token(SyntaxKind.Identifier, "foo‿bar")); 82TestTokenizer("foo؃bar", SyntaxFactory.Token(SyntaxKind.Identifier, "foo؃bar")); 170TestTokenizer(keyword, SyntaxFactory.Token(SyntaxKind.Keyword, keyword));

19TestSingleToken("01189998819991197253", SyntaxKind.IntegerLiteral); 25TestSingleToken("42U", SyntaxKind.IntegerLiteral); 26TestSingleToken("42u", SyntaxKind.IntegerLiteral); 28TestSingleToken("42L", SyntaxKind.IntegerLiteral); 29TestSingleToken("42l", SyntaxKind.IntegerLiteral); 31TestSingleToken("42UL", SyntaxKind.IntegerLiteral); 32TestSingleToken("42Ul", SyntaxKind.IntegerLiteral); 34TestSingleToken("42uL", SyntaxKind.IntegerLiteral); 35TestSingleToken("42ul", SyntaxKind.IntegerLiteral); 37TestSingleToken("42LU", SyntaxKind.IntegerLiteral); 38TestSingleToken("42Lu", SyntaxKind.IntegerLiteral); 40TestSingleToken("42lU", SyntaxKind.IntegerLiteral); 41TestSingleToken("42lu", SyntaxKind.IntegerLiteral); 47TestTokenizer("42a", SyntaxFactory.Token(SyntaxKind.IntegerLiteral, "42"), IgnoreRemaining); 53TestSingleToken("0x0123456789ABCDEF", SyntaxKind.IntegerLiteral); 59TestSingleToken("0xDEADBEEFU", SyntaxKind.IntegerLiteral); 60TestSingleToken("0xDEADBEEFu", SyntaxKind.IntegerLiteral); 62TestSingleToken("0xDEADBEEFL", SyntaxKind.IntegerLiteral); 63TestSingleToken("0xDEADBEEFl", SyntaxKind.IntegerLiteral); 65TestSingleToken("0xDEADBEEFUL", SyntaxKind.IntegerLiteral); 66TestSingleToken("0xDEADBEEFUl", SyntaxKind.IntegerLiteral); 68TestSingleToken("0xDEADBEEFuL", SyntaxKind.IntegerLiteral); 69TestSingleToken("0xDEADBEEFul", SyntaxKind.IntegerLiteral); 71TestSingleToken("0xDEADBEEFLU", SyntaxKind.IntegerLiteral); 72TestSingleToken("0xDEADBEEFLu", SyntaxKind.IntegerLiteral); 74TestSingleToken("0xDEADBEEFlU", SyntaxKind.IntegerLiteral); 75TestSingleToken("0xDEADBEEFlu", SyntaxKind.IntegerLiteral); 81TestTokenizer("0xDEADBEEFz", SyntaxFactory.Token(SyntaxKind.IntegerLiteral, "0xDEADBEEF"), IgnoreRemaining); 87TestTokenizer("3.a", SyntaxFactory.Token(SyntaxKind.IntegerLiteral, "3"), IgnoreRemaining); 93TestTokenizer("3.14159", SyntaxFactory.Token(SyntaxKind.RealLiteral, "3.14159")); 99TestTokenizer(".14159", SyntaxFactory.Token(SyntaxKind.RealLiteral, ".14159")); 105TestSingleToken("42F", SyntaxKind.RealLiteral); 106TestSingleToken("42f", SyntaxKind.RealLiteral); 107TestSingleToken("42D", SyntaxKind.RealLiteral); 108TestSingleToken("42d", SyntaxKind.RealLiteral); 109TestSingleToken("42M", SyntaxKind.RealLiteral); 110TestSingleToken("42m", SyntaxKind.RealLiteral); 116TestSingleToken("1e10", SyntaxKind.RealLiteral); 117TestSingleToken("1E10", SyntaxKind.RealLiteral); 118TestSingleToken("1e+10", SyntaxKind.RealLiteral); 119TestSingleToken("1E+10", SyntaxKind.RealLiteral); 120TestSingleToken("1e-10", SyntaxKind.RealLiteral); 121TestSingleToken("1E-10", SyntaxKind.RealLiteral); 127TestSingleToken("3.14F", SyntaxKind.RealLiteral); 128TestSingleToken("3.14f", SyntaxKind.RealLiteral); 129TestSingleToken("3.14D", SyntaxKind.RealLiteral); 130TestSingleToken("3.14d", SyntaxKind.RealLiteral); 131TestSingleToken("3.14M", SyntaxKind.RealLiteral); 132TestSingleToken("3.14m", SyntaxKind.RealLiteral); 138TestSingleToken("3.14E10", SyntaxKind.RealLiteral); 139TestSingleToken("3.14e10", SyntaxKind.RealLiteral); 140TestSingleToken("3.14E+10", SyntaxKind.RealLiteral); 141TestSingleToken("3.14e+10", SyntaxKind.RealLiteral); 142TestSingleToken("3.14E-10", SyntaxKind.RealLiteral); 143TestSingleToken("3.14e-10", SyntaxKind.RealLiteral); 149TestSingleToken("3.14E+10F", SyntaxKind.RealLiteral); 155TestSingleToken("'f'", SyntaxKind.CharacterLiteral); 161TestSingleToken("'foo'", SyntaxKind.CharacterLiteral); 167TestSingleToken("'foo bar", SyntaxKind.CharacterLiteral); 173TestSingleToken("'foo\\'bar'", SyntaxKind.CharacterLiteral); 179TestTokenizer("'foo\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo"), IgnoreRemaining); 185TestTokenizer("'foo\\\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo\\"), IgnoreRemaining); 191TestTokenizer("'foo\\\nflarg", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo\\"), IgnoreRemaining); 197TestTokenizer("'foo\\\r\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo\\"), IgnoreRemaining); 203TestTokenizer($"'foo\\\r\nflarg", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo\\"), IgnoreRemaining); 209TestTokenizer("'foo\\\\'blah", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'foo\\\\'"), IgnoreRemaining); 215TestSingleToken("\"foo\"", SyntaxKind.StringLiteral); 221TestSingleToken("\"foo bar", SyntaxKind.StringLiteral); 227TestSingleToken("\"foo\\\"bar\"", SyntaxKind.StringLiteral); 233TestTokenizer("\"foo\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo"), IgnoreRemaining); 239TestTokenizer("\"foo\\\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo\\"), IgnoreRemaining); 245TestTokenizer("\"foo\\\nflarg", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo\\"), IgnoreRemaining); 251TestTokenizer("\"foo\\\r\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo\\"), IgnoreRemaining); 257TestTokenizer($"\"foo\\\r\nflarg", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo\\"), IgnoreRemaining); 263TestTokenizer("\"foo\\\\\"blah", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"foo\\\\\""), IgnoreRemaining); 269TestSingleToken("@\"foo\nbar\nbaz\"", SyntaxKind.StringLiteral); 275TestSingleToken("@\"foo\"\"bar\"", SyntaxKind.StringLiteral); 281TestTokenizer("@\"foo\\\"bar\"", SyntaxFactory.Token(SyntaxKind.StringLiteral, "@\"foo\\\""), IgnoreRemaining); 287TestSingleToken("@\"foo", SyntaxKind.StringLiteral);

16TestSingleToken("{", SyntaxKind.LeftBrace); 22TestSingleToken("+", SyntaxKind.Plus); 28TestSingleToken("=", SyntaxKind.Assign); 34TestSingleToken("->", SyntaxKind.Arrow); 40TestSingleToken("&=", SyntaxKind.AndAssign); 46TestSingleToken("}", SyntaxKind.RightBrace); 52TestSingleToken("-", SyntaxKind.Minus); 58TestSingleToken("<", SyntaxKind.LessThan); 64TestSingleToken("==", SyntaxKind.Equals); 70TestSingleToken("|=", SyntaxKind.OrAssign); 76TestSingleToken("[", SyntaxKind.LeftBracket); 82TestSingleToken("*", SyntaxKind.Star); 88TestSingleToken(">", SyntaxKind.GreaterThan); 94TestSingleToken("!=", SyntaxKind.NotEqual); 100TestSingleToken("^=", SyntaxKind.XorAssign); 106TestSingleToken("]", SyntaxKind.RightBracket); 112TestSingleToken("/", SyntaxKind.Slash); 118TestSingleToken("?", SyntaxKind.QuestionMark); 124TestSingleToken("<=", SyntaxKind.LessThanEqual); 131SyntaxFactory.Token(SyntaxKind.LessThan, "<"), 132SyntaxFactory.Token(SyntaxKind.LessThan, "<")); 138TestSingleToken("(", SyntaxKind.LeftParenthesis); 144TestSingleToken("%", SyntaxKind.Modulo); 150TestSingleToken("??", SyntaxKind.NullCoalesce); 156TestSingleToken(">=", SyntaxKind.GreaterThanEqual); 162TestSingleToken("=>", SyntaxKind.GreaterThanEqual); 168TestSingleToken(")", SyntaxKind.RightParenthesis); 174TestSingleToken("&", SyntaxKind.And); 180TestSingleToken("::", SyntaxKind.DoubleColon); 186TestSingleToken("+=", SyntaxKind.PlusAssign); 192TestSingleToken(";", SyntaxKind.Semicolon); 198TestSingleToken("~", SyntaxKind.Tilde); 204TestSingleToken("||", SyntaxKind.DoubleOr); 210TestSingleToken("%=", SyntaxKind.ModuloAssign); 216TestSingleToken(":", SyntaxKind.Colon); 222TestSingleToken("!", SyntaxKind.Not); 228TestSingleToken("&&", SyntaxKind.DoubleAnd); 234TestSingleToken("/=", SyntaxKind.DivideAssign); 240TestSingleToken(",", SyntaxKind.Comma); 246TestSingleToken("^", SyntaxKind.Xor); 252TestSingleToken("--", SyntaxKind.Decrement); 258TestSingleToken("*=", SyntaxKind.MultiplyAssign); 264TestSingleToken(".", SyntaxKind.Dot); 270TestSingleToken("|", SyntaxKind.Or); 276TestSingleToken("++", SyntaxKind.Increment); 282TestSingleToken("-=", SyntaxKind.MinusAssign); 289SyntaxFactory.Token(SyntaxKind.GreaterThan, ">"), 290SyntaxFactory.Token(SyntaxKind.GreaterThan, ">")); 296TestSingleToken("#", SyntaxKind.Hash);

26SyntaxFactory.Token(SyntaxKind.NewLine, "\r"), 27SyntaxFactory.Token(SyntaxKind.NewLine, "\r"), 36SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 37SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 47SyntaxFactory.Token(SyntaxKind.NewLine, "\u0085"), 48SyntaxFactory.Token(SyntaxKind.NewLine, "\u0085"), 58SyntaxFactory.Token(SyntaxKind.NewLine, "\u2028"), 59SyntaxFactory.Token(SyntaxKind.NewLine, "\u2028"), 69SyntaxFactory.Token(SyntaxKind.NewLine, "\u2029"), 70SyntaxFactory.Token(SyntaxKind.NewLine, "\u2029"), 79SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 80SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 89SyntaxFactory.Token(SyntaxKind.Whitespace, " \f\t\u000B "), 90SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 91SyntaxFactory.Token(SyntaxKind.Whitespace, " ")); 97TestSingleToken("@", SyntaxKind.Transition); 105SyntaxFactory.Token(SyntaxKind.Transition, "@"), 106SyntaxFactory.Token(SyntaxKind.LeftParenthesis, "("));

12private static readonly SyntaxToken _ignoreRemaining = SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 24internal void TestSingleToken(string text, SyntaxKind expectedTokenKind)

362Assert.Equal(SyntaxKind.CSharpCodeBlock, codeBlock.Kind); 370Assert.Equal(SyntaxKind.RazorDirective, directive.Kind); 375Assert.Equal(SyntaxKind.RazorMetaCode, whitespace.Kind);

165var token = Syntax.SyntaxFactory.Token(SyntaxKind.LeftParenthesis, "("); 180var token = Syntax.SyntaxFactory.Token(SyntaxKind.RightParenthesis, ")"); 195var token = Syntax.SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"(("); 210var token = Syntax.SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'(("); 225var token = Syntax.SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"((\""); 240var token = Syntax.SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'('"); 255var token = Syntax.SyntaxFactory.Token(SyntaxKind.RightParenthesis, ")"); 270var token = Syntax.SyntaxFactory.Token(SyntaxKind.StringLiteral, "\")"); 285var token = Syntax.SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "')");

85yield return Syntax.InternalSyntax.SyntaxFactory.Token(SyntaxKind.Marker, str);

16var token = NativeCSharpLanguageCharacteristics.Instance.GetSample(SyntaxKind.RightShiftAssign);

20SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 21SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 22SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz *")); 30SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 31SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 32SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz "), 33SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 34SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); 42SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 43SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 44SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo Bar Baz "), 45SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 46SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); 52TestTokenizer("// Foo Bar Baz", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo Bar Baz")); 61""", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo Bar Baz"), IgnoreRemaining); 70""", SyntaxFactory.Token(SyntaxKind.CSharpComment, "// Foo/*Bar*/ Baz"), IgnoreRemaining); 80""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 94""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 108""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 122""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 136""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 146TestTokenizer("/// This is a single line documentation comment", SyntaxFactory.Token(SyntaxKind.CSharpComment, "/// This is a single line documentation comment")); 155""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 169""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 186""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 204""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 221""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 238""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """ 254""", SyntaxFactory.Token(SyntaxKind.CSharpComment, """

19TestTokenizer("foo", SyntaxFactory.Token(SyntaxKind.Identifier, "foo")); 25TestTokenizer("_foo", SyntaxFactory.Token(SyntaxKind.Identifier, "_foo")); 31TestTokenizer("foo4", SyntaxFactory.Token(SyntaxKind.Identifier, "foo4")); 37TestTokenizer("ῼfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ῼfoo")); 43TestTokenizer("ᵊfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ᵊfoo")); 49TestTokenizer("ƻfoo", SyntaxFactory.Token(SyntaxKind.Identifier, "ƻfoo")); 55TestTokenizer("Ⅽool", SyntaxFactory.Token(SyntaxKind.Identifier, "Ⅽool")); 61TestTokenizer("foo\u0300", SyntaxFactory.Token(SyntaxKind.Identifier, "foo\u0300")); 67TestTokenizer("fooः", SyntaxFactory.Token(SyntaxKind.Identifier, "fooः")); 73TestTokenizer("foo١", SyntaxFactory.Token(SyntaxKind.Identifier, "foo١")); 79TestTokenizer("foo‿bar", SyntaxFactory.Token(SyntaxKind.Identifier, "foo‿bar")); 85TestTokenizer("foo؃bar", SyntaxFactory.Token(SyntaxKind.Identifier, "foo؃bar")); 173TestTokenizer(keyword, SyntaxFactory.Token(SyntaxKind.Keyword, CSharpSyntaxFacts.GetText(keywordType)));

18TestSingleToken("01189998819991197253", SyntaxKind.NumericLiteral); 24TestSingleToken("42U", SyntaxKind.NumericLiteral); 25TestSingleToken("42u", SyntaxKind.NumericLiteral); 27TestSingleToken("42L", SyntaxKind.NumericLiteral); 28TestSingleToken("42l", SyntaxKind.NumericLiteral); 30TestSingleToken("42UL", SyntaxKind.NumericLiteral); 31TestSingleToken("42Ul", SyntaxKind.NumericLiteral); 33TestSingleToken("42uL", SyntaxKind.NumericLiteral); 34TestSingleToken("42ul", SyntaxKind.NumericLiteral); 36TestSingleToken("42LU", SyntaxKind.NumericLiteral); 37TestSingleToken("42Lu", SyntaxKind.NumericLiteral); 39TestSingleToken("42lU", SyntaxKind.NumericLiteral); 40TestSingleToken("42lu", SyntaxKind.NumericLiteral); 46TestTokenizer("42a", SyntaxFactory.Token(SyntaxKind.NumericLiteral, "42"), IgnoreRemaining); 52TestSingleToken("0x0123456789ABCDEF", SyntaxKind.NumericLiteral); 58TestSingleToken("0xDEADBEEFU", SyntaxKind.NumericLiteral); 59TestSingleToken("0xDEADBEEFu", SyntaxKind.NumericLiteral); 61TestSingleToken("0xDEADBEEFL", SyntaxKind.NumericLiteral); 62TestSingleToken("0xDEADBEEFl", SyntaxKind.NumericLiteral); 64TestSingleToken("0xDEADBEEFUL", SyntaxKind.NumericLiteral); 65TestSingleToken("0xDEADBEEFUl", SyntaxKind.NumericLiteral); 67TestSingleToken("0xDEADBEEFuL", SyntaxKind.NumericLiteral); 68TestSingleToken("0xDEADBEEFul", SyntaxKind.NumericLiteral); 70TestSingleToken("0xDEADBEEFLU", SyntaxKind.NumericLiteral); 71TestSingleToken("0xDEADBEEFLu", SyntaxKind.NumericLiteral); 73TestSingleToken("0xDEADBEEFlU", SyntaxKind.NumericLiteral); 74TestSingleToken("0xDEADBEEFlu", SyntaxKind.NumericLiteral); 80TestTokenizer("0xDEADBEEFz", SyntaxFactory.Token(SyntaxKind.NumericLiteral, "0xDEADBEEF"), IgnoreRemaining); 86TestSingleToken("0b01010101", SyntaxKind.NumericLiteral); 92TestSingleToken("0b01010101U", SyntaxKind.NumericLiteral); 93TestSingleToken("0b01010101u", SyntaxKind.NumericLiteral); 95TestSingleToken("0b01010101L", SyntaxKind.NumericLiteral); 96TestSingleToken("0b01010101l", SyntaxKind.NumericLiteral); 98TestSingleToken("0b01010101UL", SyntaxKind.NumericLiteral); 99TestSingleToken("0b01010101Ul", SyntaxKind.NumericLiteral); 101TestSingleToken("0b01010101uL", SyntaxKind.NumericLiteral); 102TestSingleToken("0b01010101ul", SyntaxKind.NumericLiteral); 104TestSingleToken("0b01010101LU", SyntaxKind.NumericLiteral); 105TestSingleToken("0b01010101Lu", SyntaxKind.NumericLiteral); 107TestSingleToken("0b01010101lU", SyntaxKind.NumericLiteral); 108TestSingleToken("0b01010101lu", SyntaxKind.NumericLiteral); 114TestTokenizer("0b01010101z", SyntaxFactory.Token(SyntaxKind.NumericLiteral, "0b01010101"), IgnoreRemaining); 120TestTokenizer("3.a", SyntaxFactory.Token(SyntaxKind.NumericLiteral, "3"), IgnoreRemaining); 126TestTokenizer("3.14159", SyntaxFactory.Token(SyntaxKind.NumericLiteral, "3.14159")); 132TestTokenizer(".14159", SyntaxFactory.Token(SyntaxKind.NumericLiteral, ".14159")); 138TestSingleToken("42F", SyntaxKind.NumericLiteral); 139TestSingleToken("42f", SyntaxKind.NumericLiteral); 140TestSingleToken("42D", SyntaxKind.NumericLiteral); 141TestSingleToken("42d", SyntaxKind.NumericLiteral); 142TestSingleToken("42M", SyntaxKind.NumericLiteral); 143TestSingleToken("42m", SyntaxKind.NumericLiteral); 149TestSingleToken("1e10", SyntaxKind.NumericLiteral); 150TestSingleToken("1E10", SyntaxKind.NumericLiteral); 151TestSingleToken("1e+10", SyntaxKind.NumericLiteral); 152TestSingleToken("1E+10", SyntaxKind.NumericLiteral); 153TestSingleToken("1e-10", SyntaxKind.NumericLiteral); 154TestSingleToken("1E-10", SyntaxKind.NumericLiteral); 160TestSingleToken("3.14F", SyntaxKind.NumericLiteral); 161TestSingleToken("3.14f", SyntaxKind.NumericLiteral); 162TestSingleToken("3.14D", SyntaxKind.NumericLiteral); 163TestSingleToken("3.14d", SyntaxKind.NumericLiteral); 164TestSingleToken("3.14M", SyntaxKind.NumericLiteral); 165TestSingleToken("3.14m", SyntaxKind.NumericLiteral); 171TestSingleToken("3.14E10", SyntaxKind.NumericLiteral); 172TestSingleToken("3.14e10", SyntaxKind.NumericLiteral); 173TestSingleToken("3.14E+10", SyntaxKind.NumericLiteral); 174TestSingleToken("3.14e+10", SyntaxKind.NumericLiteral); 175TestSingleToken("3.14E-10", SyntaxKind.NumericLiteral); 176TestSingleToken("3.14e-10", SyntaxKind.NumericLiteral); 182TestSingleToken("3.14E+10F", SyntaxKind.NumericLiteral); 188TestSingleToken("'f'", SyntaxKind.CharacterLiteral); 194TestSingleToken("'goo'", SyntaxKind.CharacterLiteral); 200TestSingleToken("'goo bar", SyntaxKind.CharacterLiteral); 206TestSingleToken("'goo\\'bar'", SyntaxKind.CharacterLiteral); 212TestTokenizer("'goo\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo"), IgnoreRemaining); 218TestTokenizer("'goo\\\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo\\\n"), IgnoreRemaining); 224TestTokenizer("'goo\\\nflarg", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo\\\nflarg"), IgnoreRemaining); 230TestTokenizer("'goo\\\r\n", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo\\\r"), IgnoreRemaining); 236TestTokenizer($"'goo\\\r\nflarg", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo\\\r"), IgnoreRemaining); 242TestTokenizer("'goo\\\\'blah", SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo\\\\'"), IgnoreRemaining); 249SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'f'"), 250SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 251SyntaxFactory.Token(SyntaxKind.CSharpComment, "// This is a comment")); 258SyntaxFactory.Token(SyntaxKind.CharacterLiteral, "'goo'"), 259SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 260SyntaxFactory.Token(SyntaxKind.CSharpComment, "// This is a comment")); 266TestSingleToken("\"goo\"", SyntaxKind.StringLiteral); 272TestSingleToken("\"\"", SyntaxKind.StringLiteral); 278TestSingleToken("\"goo bar", SyntaxKind.StringLiteral); 284TestSingleToken("\"goo\\\"bar\"", SyntaxKind.StringLiteral); 290TestTokenizer("\"goo\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo"), IgnoreRemaining); 296TestTokenizer("\"goo\\\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\\\n"), IgnoreRemaining); 302TestTokenizer("\"goo\\\nflarg", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\\\nflarg"), IgnoreRemaining); 308TestTokenizer("\"goo\\\r\n", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\\\r"), IgnoreRemaining); 314TestTokenizer($"\"goo\\\r\nflarg", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\\\r"), IgnoreRemaining); 320TestTokenizer("\"goo\\\\\"blah", SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\\\\\""), IgnoreRemaining); 326TestSingleToken("@\"goo\nbar\nbaz\"", SyntaxKind.StringLiteral); 332TestSingleToken("@\"goo\"\"bar\"", SyntaxKind.StringLiteral); 338TestTokenizer("@\"goo\\\"bar\"", SyntaxFactory.Token(SyntaxKind.StringLiteral, "@\"goo\\\""), IgnoreRemaining); 344TestSingleToken("@\"goo", SyntaxKind.StringLiteral); 351SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"goo\""), 352SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 353SyntaxFactory.Token(SyntaxKind.CSharpComment, "// This is a comment")); 360SyntaxFactory.Token(SyntaxKind.StringLiteral, "@\"goo\""), 361SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 362SyntaxFactory.Token(SyntaxKind.CSharpComment, "// This is a comment")); 368TestSingleToken("\"hello\"u8", SyntaxKind.StringLiteral); 374TestSingleToken("\"hello\"U8", SyntaxKind.StringLiteral); 380TestSingleToken("\"\"u8", SyntaxKind.StringLiteral); 386TestSingleToken("\"hello\\nworld\"u8", SyntaxKind.StringLiteral); 393SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"hello\"u8"), 394SyntaxFactory.Token(SyntaxKind.Semicolon, ";")); 400TestSingleToken("@\"hello\\nworld\"u8", SyntaxKind.StringLiteral); 406TestSingleToken("\"\"\"hello\"\"\"u8", SyntaxKind.StringLiteral); 412TestSingleToken("\"\"\"\nhello\nworld\n\"\"\"u8", SyntaxKind.StringLiteral); 418TestSingleToken("\"\"\"She said \"hello\"\"\"\"u8", SyntaxKind.StringLiteral); 424TestSingleToken("\"\"\"content\"\"\"U8", SyntaxKind.StringLiteral); 433SyntaxKind.StringLiteral); 442SyntaxKind.StringLiteral); 451SyntaxKind.StringLiteral); 460SyntaxKind.StringLiteral); 470SyntaxKind.StringLiteral); 480SyntaxFactory.Token(SyntaxKind.StringLiteral, """ 491SyntaxKind.StringLiteral); 501SyntaxKind.StringLiteral); 512SyntaxKind.StringLiteral); 523SyntaxKind.StringLiteral); 534SyntaxKind.StringLiteral); 546SyntaxKind.StringLiteral); 558SyntaxKind.StringLiteral); 569SyntaxKind.StringLiteral); 581SyntaxKind.StringLiteral); 598""", SyntaxKind.StringLiteral); 619""", SyntaxKind.StringLiteral); 638""", SyntaxKind.StringLiteral); 661""", SyntaxKind.StringLiteral); 678""", SyntaxKind.StringLiteral); 699""", SyntaxKind.StringLiteral); 717""", SyntaxKind.StringLiteral); 739""", SyntaxKind.StringLiteral); 745TestSingleToken("$$", SyntaxKind.StringLiteral);

16TestSingleToken("{", SyntaxKind.LeftBrace); 22TestSingleToken("+", SyntaxKind.CSharpOperator); 28TestSingleToken("=", SyntaxKind.Assign); 34TestSingleToken("->", SyntaxKind.CSharpOperator); 40TestSingleToken("&=", SyntaxKind.CSharpOperator); 46TestSingleToken("}", SyntaxKind.RightBrace); 52TestSingleToken("-", SyntaxKind.CSharpOperator); 58TestSingleToken("<", SyntaxKind.LessThan); 64TestSingleToken("==", SyntaxKind.CSharpOperator); 70TestSingleToken("|=", SyntaxKind.CSharpOperator); 76TestSingleToken("[", SyntaxKind.LeftBracket); 82TestSingleToken("*", SyntaxKind.CSharpOperator); 88TestSingleToken(">", SyntaxKind.GreaterThan); 94TestSingleToken("!=", SyntaxKind.CSharpOperator); 100TestSingleToken("^=", SyntaxKind.CSharpOperator); 106TestSingleToken("]", SyntaxKind.RightBracket); 112TestSingleToken("/", SyntaxKind.CSharpOperator); 118TestSingleToken("?", SyntaxKind.QuestionMark); 124TestSingleToken("<=", SyntaxKind.CSharpOperator); 130TestSingleToken("<<", SyntaxKind.CSharpOperator); 136TestSingleToken("(", SyntaxKind.LeftParenthesis); 142TestSingleToken("%", SyntaxKind.CSharpOperator); 148TestSingleToken("??", SyntaxKind.CSharpOperator); 154TestSingleToken(">=", SyntaxKind.CSharpOperator); 160TestSingleToken("=>", SyntaxKind.CSharpOperator); 166TestSingleToken(")", SyntaxKind.RightParenthesis); 172TestSingleToken("&", SyntaxKind.CSharpOperator); 178TestSingleToken("::", SyntaxKind.DoubleColon); 184TestSingleToken("+=", SyntaxKind.CSharpOperator); 190TestSingleToken(";", SyntaxKind.Semicolon); 196TestSingleToken("~", SyntaxKind.CSharpOperator); 202TestSingleToken("||", SyntaxKind.CSharpOperator); 208TestSingleToken("%=", SyntaxKind.CSharpOperator); 214TestSingleToken(":", SyntaxKind.Colon); 220TestSingleToken("!", SyntaxKind.Not); 226TestSingleToken("&&", SyntaxKind.CSharpOperator); 232TestSingleToken("/=", SyntaxKind.CSharpOperator); 238TestSingleToken(",", SyntaxKind.Comma); 244TestSingleToken("^", SyntaxKind.CSharpOperator); 250TestSingleToken("--", SyntaxKind.CSharpOperator); 256TestSingleToken("*=", SyntaxKind.CSharpOperator); 262TestSingleToken(".", SyntaxKind.Dot); 268TestSingleToken("|", SyntaxKind.CSharpOperator); 274TestSingleToken("++", SyntaxKind.CSharpOperator); 280TestSingleToken("-=", SyntaxKind.CSharpOperator); 287SyntaxFactory.Token(SyntaxKind.GreaterThan, ">"), 288SyntaxFactory.Token(SyntaxKind.GreaterThan, ">"));

26SyntaxFactory.Token(SyntaxKind.NewLine, "\r"), 27SyntaxFactory.Token(SyntaxKind.NewLine, "\r"), 36SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 37SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 47SyntaxFactory.Token(SyntaxKind.NewLine, "\u0085"), 48SyntaxFactory.Token(SyntaxKind.NewLine, "\u0085"), 58SyntaxFactory.Token(SyntaxKind.NewLine, "\u2028"), 59SyntaxFactory.Token(SyntaxKind.NewLine, "\u2028"), 69SyntaxFactory.Token(SyntaxKind.NewLine, "\u2029"), 70SyntaxFactory.Token(SyntaxKind.NewLine, "\u2029"), 79SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 80SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 89SyntaxFactory.Token(SyntaxKind.Whitespace, " \f\t\u000B "), 90SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 91SyntaxFactory.Token(SyntaxKind.Whitespace, " ")); 97TestSingleToken("@", SyntaxKind.Transition); 105SyntaxFactory.Token(SyntaxKind.Transition, "@"), 106SyntaxFactory.Token(SyntaxKind.LeftParenthesis, "("));

14private static readonly SyntaxToken _ignoreRemaining = SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 28internal void TestSingleToken(string text, SyntaxKind expectedTokenKind)

18SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 19SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 20SyntaxFactory.Token(SyntaxKind.Transition, "@"), 21SyntaxFactory.Token(SyntaxKind.Identifier, "something"), 22SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 23SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n")); 31SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 32SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 33SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, "included"), 34SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 35SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 36SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 37SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 38SyntaxFactory.Token(SyntaxKind.Transition, "@"), 39SyntaxFactory.Token(SyntaxKind.Identifier, "something"), 40SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 41SyntaxFactory.Token(SyntaxKind.StringLiteral, "\"value\""), 42SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"));

18SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 19SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 20SyntaxFactory.Token(SyntaxKind.OpenAngle, "<")); 28SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n"), 29SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 30SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 31SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 32SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, "included"), 33SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 34SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 35SyntaxFactory.Token(SyntaxKind.Whitespace, " "), 36SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"));

16private static readonly SyntaxToken doubleHyphenToken = SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"); 22yield return new[] { SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--") }; 23yield return new[] { SyntaxFactory.Token(SyntaxKind.Text, "asdf") }; 24yield return new[] { SyntaxFactory.Token(SyntaxKind.CloseAngle, ">") }; 25yield return new[] { SyntaxFactory.Token(SyntaxKind.OpenAngle, "<") }; 26yield return new[] { SyntaxFactory.Token(SyntaxKind.Bang, "!") }; 45var dashToken = SyntaxFactory.Token(SyntaxKind.Text, "-"); 62Assert.True(sut.At(SyntaxKind.CloseAngle)); 77Assert.True(sut.At(SyntaxKind.CloseAngle)); 166var expectedToken1 = SyntaxFactory.Token(SyntaxKind.Text, "a"); 168array.AddRange(Enumerable.Range('a', 26).Select(item => SyntaxFactory.Token(SyntaxKind.Text, ((char)item).ToString()))); 179array.Add(SyntaxFactory.Token(SyntaxKind.OpenAngle, "<")); 180array.Add(SyntaxFactory.Token(SyntaxKind.Bang, "!")); 181array.Add(SyntaxFactory.Token(SyntaxKind.Text, "-"));

23SyntaxFactory.Token(SyntaxKind.Text, "foo-9309&smlkmb;::-3029022,.sdkq92384")); 30SyntaxFactory.Token(SyntaxKind.Whitespace, " \t\f ")); 37SyntaxFactory.Token(SyntaxKind.NewLine, "\n"), 38SyntaxFactory.Token(SyntaxKind.NewLine, "\r"), 39SyntaxFactory.Token(SyntaxKind.NewLine, "\r\n")); 45TestSingleToken("foo@bar", SyntaxKind.Text); 51TestSingleToken("<", SyntaxKind.OpenAngle); 57TestSingleToken("!", SyntaxKind.Bang); 63TestSingleToken("/", SyntaxKind.ForwardSlash); 69TestSingleToken("?", SyntaxKind.QuestionMark); 75TestSingleToken("[", SyntaxKind.LeftBracket); 81TestSingleToken(">", SyntaxKind.CloseAngle); 87TestSingleToken("]", SyntaxKind.RightBracket); 93TestSingleToken("=", SyntaxKind.Equals); 99TestSingleToken("\"", SyntaxKind.DoubleQuote); 105TestSingleToken("'", SyntaxKind.SingleQuote); 111TestSingleToken("@", SyntaxKind.Transition); 117TestSingleToken("--", SyntaxKind.DoubleHyphen); 123TestSingleToken("-", SyntaxKind.Text); 129TestSingleToken("foo-bar", SyntaxKind.Text); 137SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 138SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 139SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz *")); 147SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 148SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 149SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo * Bar * Baz "), 150SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 151SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@")); 159SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"), 160SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 161SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral, " Foo Bar Baz "), 162SyntaxFactory.Token(SyntaxKind.RazorCommentStar, "*"), 163SyntaxFactory.Token(SyntaxKind.RazorCommentTransition, "@"));

13private static readonly SyntaxToken _ignoreRemaining = SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 28internal void TestSingleToken(string text, SyntaxKind expectedTokenKind)

82AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.Text, "asdf"), previousTokens.ElementAt(orderIndex++)); 83AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"), previousTokens.ElementAt(orderIndex++)); 84AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.Text, "fvd"), previousTokens.ElementAt(orderIndex++)); 104AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.Text, "fvd"), tokens.Pop()); 105AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"), tokens.Pop()); 106AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.Text, "asdf"), tokens.Pop()); 120return s.Kind == SyntaxKind.DoubleHyphen; 126AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"), tokens.Pop()); 127AssertTokenEqual(SyntaxFactory.Token(SyntaxKind.Text, "asdf"), tokens.Pop()); 159public override SyntaxKind RazorCommentStarKind 167public override SyntaxKind RazorCommentTransitionKind 175public override SyntaxKind RazorCommentKind 193SyntaxKind type,

110builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); 111builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); 129builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); 130builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); 148builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); 149builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); 167builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); 168builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); 186builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); 187builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World"));

994var token = tree.Root.DescendantTokens().Single(t => t.Kind == SyntaxKind.Whitespace); 1010var token = tree.Root.DescendantTokens().Last(t => t.Kind == SyntaxKind.Whitespace);

20var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 46var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 78var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 81var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, " "); 84var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "World"); 126var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, " "); 129var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "A"); 132var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "B"); 171var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 174var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "World"); 204var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Test"); 230var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 259var htmlToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "<div>"); 262var transitionToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Transition, "@"); 265var codeToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Identifier, "Model"); 300var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Test"); 329var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 351var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 380var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 383var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, " "); 386var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "World"); 419var htmlToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "<div>"); 422var transitionToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Transition, "@"); 425var codeToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Identifier, "Model"); 452var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 479var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "A"); 482var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "B"); 519var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Test"); 546var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "OnlyThis"); 568var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Test"); 596var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "First"); 599var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Second"); 624var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 640var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 657var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello World"); 681var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 684var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, " "); 687var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "World"); 713var htmlToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "<div>"); 716var transitionToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Transition, "@"); 719var codeToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Identifier, "Model"); 745var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Start"); 748var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Middle"); 751var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "End"); 777var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 780var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, " "); 783var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "World"); 806var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Line1\n"); 809var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Line2\t\r"); 829var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello 🌍 World! ñáéíóú"); 850var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 853var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 884var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "if (condition) { "); 887var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Transition, "@"); 890var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Identifier, "Model"); 893var token4 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "."); 896var token5 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Identifier, "Name"); 899var token6 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, " }"); 922var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Hello"); 925var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, " World!"); 944var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 962var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, tokenContent); 981var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, tokenContent); 1000var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, token1Content); 1003var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, token2Content); 1024var emptyToken1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1027var emptyToken2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, ""); 1047var emptyToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1065var token = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, longContent); 1083var singleToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, content); 1087var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Test"); 1090var token2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, " "); 1093var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, "Content"); 1115var zeroWidthToken1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1118var zeroWidthToken2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, ""); 1122var nonZeroToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, nonZeroTokenContent); 1143var emptyToken1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1146var emptyToken2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, ""); 1149var emptyToken3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1153var contentToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, contentTokenValue); 1174var token1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, token1Content); 1177var zeroWidthToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1181var token3 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, token3Content); 1203var contentToken = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, contentTokenValue); 1206var emptyToken1 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Text, ""); 1209var emptyToken2 = InternalSyntax.SyntaxFactory.Token(SyntaxKind.Whitespace, "");

21private static readonly SyntaxToken s_openAngle = SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"); 22private static readonly SyntaxToken s_closeAngle = SyntaxFactory.Token(SyntaxKind.CloseAngle, ">"); 23private static readonly SyntaxToken s_leftBrace = SyntaxFactory.Token(SyntaxKind.LeftBrace, "{"); 24private static readonly SyntaxToken s_rightBrace = SyntaxFactory.Token(SyntaxKind.RightBrace, "}"); 25private static readonly SyntaxToken s_forwardSlash = SyntaxFactory.Token(SyntaxKind.ForwardSlash, "/");

20var token = cache.GetCachedToken(SyntaxKind.Whitespace, "Hello world"); 23Assert.Equal(SyntaxKind.Whitespace, token.Kind); 35var token1 = cache.GetCachedToken(SyntaxKind.Whitespace, "Hello world"); 36var token2 = cache.GetCachedToken(SyntaxKind.Whitespace, "Hello world"); 49var token1 = cache.GetCachedToken(SyntaxKind.Whitespace, "Hello world"); 50var token2 = cache.GetCachedToken(SyntaxKind.Keyword, "Hello world"); 54Assert.Equal(SyntaxKind.Whitespace, token1.Kind); 57Assert.Equal(SyntaxKind.Keyword, token2.Kind); 68var token1 = cache.GetCachedToken(SyntaxKind.Keyword, "Text1"); 69var token2 = cache.GetCachedToken(SyntaxKind.Keyword, "Text2"); 73Assert.Equal(SyntaxKind.Keyword, token1.Kind); 76Assert.Equal(SyntaxKind.Keyword, token2.Kind);

11private static IEnumerable<SyntaxToken> Tokens(SyntaxKind start, int count) 15yield return SyntaxFactory.Token((SyntaxKind)((int)start + i)); 24list = list.Add(SyntaxFactory.Token(SyntaxKind.Arrow)); 25list = list.Add(SyntaxFactory.Token(SyntaxKind.OpenAngle)); 26list = list.Add(SyntaxFactory.Token(SyntaxKind.LeftParenthesis)); 27list = list.Add(SyntaxFactory.Token(SyntaxKind.RightParenthesis)); 30token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 31token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 32token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 33token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 42SyntaxFactory.Token(SyntaxKind.Arrow), 43SyntaxFactory.Token(SyntaxKind.OpenAngle), 44SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 45SyntaxFactory.Token(SyntaxKind.RightParenthesis)]); 48token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 49token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 50token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 51token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 58SyntaxFactory.Token(SyntaxKind.Arrow), 59SyntaxFactory.Token(SyntaxKind.OpenAngle), 60SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 61SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 64SyntaxFactory.Token(SyntaxKind.RightBracket), 65SyntaxFactory.Token(SyntaxKind.LeftBrace), 66SyntaxFactory.Token(SyntaxKind.GreaterThan)]; 71token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 72token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 73token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 74token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind), 75token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 76token => Assert.Equal(SyntaxKind.LeftBrace, token.Kind), 77token => Assert.Equal(SyntaxKind.GreaterThan, token.Kind)); 87SyntaxFactory.Token(SyntaxKind.Arrow), 88SyntaxFactory.Token(SyntaxKind.OpenAngle), 89SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 90SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 92list = list.AddRange(Tokens(SyntaxKind.AndAssign, 3)); 95token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 96token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 97token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 98token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind), 99token => Assert.Equal(SyntaxKind.AndAssign, token.Kind), 100token => Assert.Equal(SyntaxKind.And, token.Kind), 101token => Assert.Equal(SyntaxKind.DoubleAnd, token.Kind)); 109list = list.Insert(list.Count, SyntaxFactory.Token(SyntaxKind.Arrow)); 110list = list.Insert(list.Count, SyntaxFactory.Token(SyntaxKind.OpenAngle)); 111list = list.Insert(list.Count, SyntaxFactory.Token(SyntaxKind.LeftParenthesis)); 112list = list.Insert(list.Count, SyntaxFactory.Token(SyntaxKind.RightParenthesis)); 115token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 116token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 117token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 118token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 127SyntaxFactory.Token(SyntaxKind.Arrow), 128SyntaxFactory.Token(SyntaxKind.OpenAngle), 129SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 130SyntaxFactory.Token(SyntaxKind.RightParenthesis)]); 133token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 134token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 135token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 136token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 143SyntaxFactory.Token(SyntaxKind.Arrow), 144SyntaxFactory.Token(SyntaxKind.OpenAngle), 145SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 146SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 148list = list.Insert(2, SyntaxFactory.Token(SyntaxKind.RightBracket)); 151token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 152token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 153token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 154token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 155token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 162SyntaxFactory.Token(SyntaxKind.Arrow), 163SyntaxFactory.Token(SyntaxKind.OpenAngle), 164SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 165SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 168SyntaxFactory.Token(SyntaxKind.RightBracket), 169SyntaxFactory.Token(SyntaxKind.LeftBrace), 170SyntaxFactory.Token(SyntaxKind.GreaterThan)]); 173token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 174token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 175token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 176token => Assert.Equal(SyntaxKind.LeftBrace, token.Kind), 177token => Assert.Equal(SyntaxKind.GreaterThan, token.Kind), 178token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 179token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 186SyntaxFactory.Token(SyntaxKind.Arrow), 187SyntaxFactory.Token(SyntaxKind.OpenAngle), 188SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 189SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 192SyntaxFactory.Token(SyntaxKind.RightBracket), 193SyntaxFactory.Token(SyntaxKind.LeftBrace), 194SyntaxFactory.Token(SyntaxKind.GreaterThan)]; 199token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 200token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 201token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 202token => Assert.Equal(SyntaxKind.LeftBrace, token.Kind), 203token => Assert.Equal(SyntaxKind.GreaterThan, token.Kind), 204token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 205token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 215SyntaxFactory.Token(SyntaxKind.Arrow), 216SyntaxFactory.Token(SyntaxKind.OpenAngle), 217SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 218SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 220list = list.InsertRange(2, Tokens(SyntaxKind.AndAssign, 3)); 223token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 224token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 225token => Assert.Equal(SyntaxKind.AndAssign, token.Kind), 226token => Assert.Equal(SyntaxKind.And, token.Kind), 227token => Assert.Equal(SyntaxKind.DoubleAnd, token.Kind), 228token => Assert.Equal(SyntaxKind.LeftParenthesis, token.Kind), 229token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 236SyntaxFactory.Token(SyntaxKind.Arrow), 237SyntaxFactory.Token(SyntaxKind.OpenAngle), 238SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 239SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 258SyntaxFactory.Token(SyntaxKind.Arrow), 259SyntaxFactory.Token(SyntaxKind.OpenAngle), 260SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 261SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 278SyntaxFactory.Token(SyntaxKind.Arrow), 279SyntaxFactory.Token(SyntaxKind.OpenAngle), 280SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 281SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 284SyntaxFactory.Token(SyntaxKind.Minus), 285SyntaxFactory.Token(SyntaxKind.Decrement), 286SyntaxFactory.Token(SyntaxKind.MinusAssign), 287SyntaxFactory.Token(SyntaxKind.NotEqual)]; 308SyntaxFactory.Token(SyntaxKind.Arrow), 309SyntaxFactory.Token(SyntaxKind.OpenAngle), 310SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 311SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 314SyntaxFactory.Token(SyntaxKind.RightBracket), 315SyntaxFactory.Token(SyntaxKind.LeftBrace), 316SyntaxFactory.Token(SyntaxKind.GreaterThan)]); 319token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 320token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 321token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 322token => Assert.Equal(SyntaxKind.LeftBrace, token.Kind), 323token => Assert.Equal(SyntaxKind.GreaterThan, token.Kind), 324token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 331SyntaxFactory.Token(SyntaxKind.Arrow), 332SyntaxFactory.Token(SyntaxKind.OpenAngle), 333SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 334SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 337SyntaxFactory.Token(SyntaxKind.RightBracket), 338SyntaxFactory.Token(SyntaxKind.LeftBrace), 339SyntaxFactory.Token(SyntaxKind.GreaterThan)]; 344token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 345token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 346token => Assert.Equal(SyntaxKind.RightBracket, token.Kind), 347token => Assert.Equal(SyntaxKind.LeftBrace, token.Kind), 348token => Assert.Equal(SyntaxKind.GreaterThan, token.Kind), 349token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind)); 359SyntaxFactory.Token(SyntaxKind.Arrow), 360SyntaxFactory.Token(SyntaxKind.OpenAngle), 361SyntaxFactory.Token(SyntaxKind.LeftParenthesis), 362SyntaxFactory.Token(SyntaxKind.RightParenthesis)]; 364list = list.ReplaceRange(list[2], Tokens(SyntaxKind.AndAssign, 3)); 367token => Assert.Equal(SyntaxKind.Arrow, token.Kind), 368token => Assert.Equal(SyntaxKind.OpenAngle, token.Kind), 369token => Assert.Equal(SyntaxKind.AndAssign, token.Kind), 370token => Assert.Equal(SyntaxKind.And, token.Kind), 371token => Assert.Equal(SyntaxKind.DoubleAnd, token.Kind), 372token => Assert.Equal(SyntaxKind.RightParenthesis, token.Kind));

51Assert.Equal(SyntaxKind.EndOfFile, lastToken.Kind); 84if (foundNonZeroWidthToken.Kind == SyntaxKind.None) 129if (token.Kind != SyntaxKind.None) 132if (!token.IsMissing && token.Kind != SyntaxKind.Marker)

541if (node.EqualsToken.Kind == SyntaxKind.None && node.Value == null) 547if (lastToken.Kind != SyntaxKind.None) 955else if (node.EqualsToken.Kind != SyntaxKind.None) 1517if (node.LiteralTokens is [{ Kind: SyntaxKind.Marker, Content.Length: 0 }]) 1928if (node.LiteralTokens is [{ Kind: SyntaxKind.Marker, Content.Length: 0 }])

64comment = SyntaxFactory.Token(SyntaxKind.Marker, parent: node, position: node.StartCommentStar.EndPosition);

294if (At(SyntaxKind.StringLiteral) && 298var split = Language.SplitToken(CurrentToken, 1, SyntaxKind.Transition); 305else if (At(SyntaxKind.Transition)) 312transitionToken = SyntaxFactory.MissingToken(SyntaxKind.Transition); 319if (At(SyntaxKind.LeftBrace)) 329else if (At(SyntaxKind.LeftParenthesis)) 339else if (At(SyntaxKind.Identifier)) 364else if (At(SyntaxKind.Keyword)) 408if (At(SyntaxKind.Whitespace) || At(SyntaxKind.NewLine)) 445Assert(SyntaxKind.LeftParenthesis); 459SyntaxKind.LeftParenthesis, 460SyntaxKind.RightParenthesis, 465AcceptUntil(SyntaxKind.LessThan); 479if (At(SyntaxKind.RightParenthesis)) 485var missingToken = SyntaxFactory.MissingToken(SyntaxKind.RightParenthesis); 551if (CurrentToken.Kind == SyntaxKind.LeftParenthesis || 552CurrentToken.Kind == SyntaxKind.LeftBracket) 557SyntaxKind right; 572AcceptUntil(SyntaxKind.LessThan); 583if (At(SyntaxKind.QuestionMark)) 589if (next.Kind == SyntaxKind.Dot) 596return At(SyntaxKind.Identifier) || At(SyntaxKind.Keyword); 598else if (next.Kind == SyntaxKind.LeftBracket) 608else if (At(SyntaxKind.Not) && Context.Options.AllowNullableForgivenessOperator) 622if (next.Kind == SyntaxKind.Dot) 631if (nextNext.Kind == SyntaxKind.Identifier || nextNext.Kind == SyntaxKind.Keyword) 649else if (next.Kind == SyntaxKind.QuestionMark) 656else if (next.Kind == SyntaxKind.LeftBracket || next.Kind == SyntaxKind.LeftParenthesis) 667else if (At(SyntaxKind.Dot)) 672if (At(SyntaxKind.Identifier) || At(SyntaxKind.Keyword)) 694else if (!At(SyntaxKind.Whitespace) && !At(SyntaxKind.NewLine)) 706Assert(SyntaxKind.LeftBrace); 708var leftBrace = OutputAsMetaCode(EatExpectedToken(SyntaxKind.LeftBrace)); 733acceptCloseBraceAccessor.CanAcceptCloseBrace = !At(SyntaxKind.RightBrace); 741if (At(SyntaxKind.RightBrace)) 748SyntaxFactory.MissingToken(SyntaxKind.RightBrace), 755if (At(SyntaxKind.NewLine) || 756(At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.NewLine))) 768while (!EndOfFile && !At(SyntaxKind.RightBrace)) 786var lastWhitespace = tokens is [.., { Kind: SyntaxKind.Whitespace } whitespace] ? whitespace : null; 807var kind = CurrentToken.Kind; 811var isSingleLineMarkup = kind == SyntaxKind.Transition && 812(NextIs(SyntaxKind.Colon, SyntaxKind.DoubleColon)); 815kind == SyntaxKind.LessThan || 816(kind == SyntaxKind.Transition && NextIs(SyntaxKind.LessThan)); 848if (kind == SyntaxKind.Transition && !isSingleLineMarkup) 858(CurrentToken.Kind == SyntaxKind.LessThan || CurrentToken.Kind == SyntaxKind.Transition)) 869case SyntaxKind.RazorCommentTransition: 876case SyntaxKind.LeftBrace: 894Assert(SyntaxKind.RightBrace); 899case SyntaxKind.Keyword: 905case SyntaxKind.Transition: 909case SyntaxKind.RightBrace: 912case SyntaxKind.CSharpComment: 927Assert(SyntaxKind.Transition); 931if (At(SyntaxKind.Transition)) 941Assert(SyntaxKind.Transition); 948if (At(SyntaxKind.LeftBrace)) 994token.Kind is not SyntaxKind.Semicolon and 995not SyntaxKind.RazorCommentTransition and 996not SyntaxKind.Transition and 997not SyntaxKind.LeftBrace and 998not SyntaxKind.LeftParenthesis and 999not SyntaxKind.LeftBracket and 1000not SyntaxKind.RightBrace and 1001not SyntaxKind.Keyword, 1004if ((!Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) || 1005At(SyntaxKind.LeftParenthesis) || 1006At(SyntaxKind.LeftBracket)) 1014else if (Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) 1019else if (At(SyntaxKind.Transition)) 1028case SyntaxKind.LessThan: 1029case SyntaxKind.Colon: 1035case SyntaxKind.Keyword when encounteredUnexpectedMarkupTransition: 1046case SyntaxKind.Identifier: 1047case SyntaxKind.Keyword: 1056case SyntaxKind.Transition: 1057if (Lookahead(2) is not { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 1073Debug.Assert(transition.Kind == SyntaxKind.Transition); 1080var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, transition.Content); 1085else if (At(SyntaxKind.RazorCommentTransition)) 1093else if (At(SyntaxKind.Semicolon)) 1099else if (At(SyntaxKind.RightBrace)) 1104else if (At(SyntaxKind.Keyword)) 1109AcceptUntil(SyntaxKind.LeftBrace); // TODO: how do we do error recovery at this point? 1125AcceptUntil(SyntaxKind.LessThan, SyntaxKind.LeftBrace, SyntaxKind.RightBrace); 1134TryAccept(SyntaxKind.RightBrace); 1139AcceptUntil(SyntaxKind.LessThan, SyntaxKind.RightBrace); 1306Debug.Assert(CurrentToken.Kind == SyntaxKind.Identifier || CurrentToken.Kind == SyntaxKind.Keyword); 1333var foundWhitespace = At(SyntaxKind.Whitespace); 1341AcceptWhile(SyntaxKind.Whitespace); 1346if (EndOfFile || At(SyntaxKind.NewLine)) 1361AcceptUntil(SyntaxKind.NewLine); 1422TokenBuilder[0] is SyntaxToken { Kind: SyntaxKind.StringLiteral } token) 1569if (!At(SyntaxKind.Whitespace) && 1570!At(SyntaxKind.NewLine) && 1571!At(SyntaxKind.Semicolon) && 1579builder.Add(BuildDirective(SyntaxKind.Whitespace)); 1585if (At(SyntaxKind.Whitespace)) 1602if (EndOfFile || At(SyntaxKind.NewLine)) 1622if (tokenDescriptor.Optional && (EndOfFile || At(SyntaxKind.NewLine))) 1633builder.Add(BuildDirective(SyntaxKind.Identifier)); 1646builder.Add(BuildDirective(SyntaxKind.Identifier)); 1658builder.Add(BuildDirective(SyntaxKind.Identifier)); 1664if (At(SyntaxKind.Identifier)) 1674builder.Add(BuildDirective(SyntaxKind.Identifier)); 1680if (At(SyntaxKind.StringLiteral) && !CurrentToken.ContainsDiagnostics) 1689builder.Add(BuildDirective(SyntaxKind.StringLiteral)); 1704builder.Add(BuildDirective(SyntaxKind.CSharpExpressionLiteral)); 1710if (At(SyntaxKind.LeftBracket)) 1714TryAccept(SyntaxKind.RightBracket); 1722builder.Add(BuildDirective(SyntaxKind.LeftBracket)); 1728if (At(SyntaxKind.Keyword) && 1733AcceptWhile(SyntaxKind.Whitespace); 1743builder.Add(BuildDirective(SyntaxKind.Identifier)); 1748while (!At(SyntaxKind.NewLine)) 1750if (At(SyntaxKind.Semicolon)) 1764else if (At(SyntaxKind.Semicolon)) 1776builder.Add(BuildDirective(SyntaxKind.Keyword)); 1783if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.LeftParenthesis)) 1797builder.Add(BuildDirective(SyntaxKind.Identifier)); 1822TryAccept(SyntaxKind.Semicolon); 1827if (At(SyntaxKind.NewLine)) 1896Balance(childBuilder, BalancingModes.NoErrorOnFailure, SyntaxKind.LeftBrace, SyntaxKind.RightBrace, startingBraceLocation); 1911builder.Add(BuildDirective(SyntaxKind.Identifier)); 1919RazorDirectiveSyntax BuildDirective(SyntaxKind expectedTokenKindIfMissing) 1971var type = token.Kind; 1972if ((expectingDot && type == SyntaxKind.Dot) || 1973(!expectingDot && type == SyntaxKind.Identifier)) 1979if (type != SyntaxKind.Whitespace && 1980type != SyntaxKind.NewLine) 2025else if (!At(SyntaxKind.LeftBrace)) 2054if (!TryAccept(SyntaxKind.RightBrace)) 2061Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBrace)); 2084Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2101Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2161Assert(SyntaxKind.Keyword); 2191if (At(SyntaxKind.LeftParenthesis)) 2196AcceptUntil(SyntaxKind.NewLine); 2200TryAccept(SyntaxKind.RightParenthesis); 2216if (At(SyntaxKind.LessThan)) 2224else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Colon)) 2232else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Transition)) 2248Assert(SyntaxKind.Keyword); 2257Assert(SyntaxKind.Keyword); 2267while (EnsureCurrent() && CurrentToken.Kind != SyntaxKind.Colon) 2271case SyntaxKind.LeftBrace: 2272case SyntaxKind.LeftParenthesis: 2273case SyntaxKind.LeftBracket: 2282TryAccept(SyntaxKind.Colon); 2453if (TryParseCondition(builder) && TryAccept(SyntaxKind.Semicolon)) 2473var atLeftParen = At(SyntaxKind.LeftParenthesis); 2474var atIdentifier = At(SyntaxKind.Identifier); 2541Assert(SyntaxKind.LeftParenthesis); 2570if (At(SyntaxKind.Identifier) || At(CSharpSyntaxKind.GlobalKeyword)) 2577if (At(SyntaxKind.Assign)) 2581Assert(SyntaxKind.Assign); 2613hasExplicitSemicolon = TryAccept(SyntaxKind.Semicolon); 2629token.Kind != SyntaxKind.CSharpComment && 2630token.Kind != SyntaxKind.Whitespace && 2631token.Kind != SyntaxKind.NewLine) 2658if (TryAccept(SyntaxKind.LeftParenthesis)) 2660while (!TryAccept(SyntaxKind.RightParenthesis) && !EndOfFile) 2662TryAccept(SyntaxKind.Whitespace); 2669TryAccept(SyntaxKind.Whitespace); 2670TryAccept(SyntaxKind.Identifier); 2671TryAccept(SyntaxKind.Whitespace); 2672TryAccept(SyntaxKind.Comma); 2675if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2681TryAccept(SyntaxKind.QuestionMark); // Nullable 2685else if (TryAccept(SyntaxKind.Identifier) || TryAccept(SyntaxKind.Keyword)) 2687if (TryAccept(SyntaxKind.DoubleColon)) 2689if (!TryAccept(SyntaxKind.Identifier)) 2691TryAccept(SyntaxKind.Keyword); 2694if (At(SyntaxKind.LessThan)) 2698if (TryAccept(SyntaxKind.Dot)) 2703if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2709TryAccept(SyntaxKind.QuestionMark); // Nullable 2711if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.LeftBracket)) 2717while (At(SyntaxKind.LeftBracket)) 2720if (!TryAccept(SyntaxKind.RightBracket)) 2722Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBracket)); 2735Assert(SyntaxKind.LessThan); 2737if (!TryAccept(SyntaxKind.GreaterThan)) 2739Accept(SyntaxFactory.MissingToken(SyntaxKind.GreaterThan)); 2757transition = transition ?? SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 2779ReadWhile(static token => token.Kind == SyntaxKind.Whitespace, ref whitespace.AsRef()); 2780if (At(SyntaxKind.NewLine)) 2807if (At(SyntaxKind.RazorCommentTransition)) 2922var left = CurrentToken.Kind; 2923var right = Language.FlipBracket(left); 2938private bool Balance(SyntaxListBuilder<RazorSyntaxNode> builder, BalancingModes mode, SyntaxKind left, SyntaxKind right, SourceLocation start) 2944!(stopAtEndOfLine && At(SyntaxKind.NewLine))) 2960if (At(SyntaxKind.Transition)) 2965if (NextIs(SyntaxKind.Transition) && Lookahead(2) is { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 2977else if (NextIs(SyntaxKind.Keyword, SyntaxKind.Identifier)) 2999while (nesting > 0 && EnsureCurrent() && !(stopAtEndOfLine && At(SyntaxKind.NewLine))); 3034&& NextIs(SyntaxKind.LessThan, SyntaxKind.Colon, SyntaxKind.DoubleColon)) 3065Debug.Assert(CurrentToken.Kind == SyntaxKind.Transition); 3068Debug.Assert(CurrentToken.Kind is SyntaxKind.Identifier or SyntaxKind.Keyword); 3072var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, $"{transition.Content}{identifier.Content}"); 3080Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && 3088if (!At(SyntaxKind.Keyword) || result is not { } keywordKind) 3107if (result is not CSharpSyntaxKind.None and { } value && token.Kind == SyntaxKind.Keyword)

23else if (result.Result != null && _visitedFirstTokenStart && result.Result.Kind == SyntaxKind.NewLine) 50private bool IsValidTokenType(SyntaxKind kind) 52return kind != SyntaxKind.Whitespace && 53kind != SyntaxKind.NewLine && 54kind != SyntaxKind.CSharpComment && 55kind != SyntaxKind.RazorCommentLiteral && 56kind != SyntaxKind.RazorCommentStar && 57kind != SyntaxKind.RazorCommentTransition && 58kind != SyntaxKind.Transition;

50private bool IsValidTokenType(SyntaxKind kind) 52return kind != SyntaxKind.Whitespace && 53kind != SyntaxKind.NewLine && 54kind != SyntaxKind.RazorCommentLiteral && 55kind != SyntaxKind.RazorCommentStar && 56kind != SyntaxKind.RazorCommentTransition && 57kind != SyntaxKind.Transition;

19public override string GetSample(SyntaxKind type) 23case SyntaxKind.Text: 25case SyntaxKind.Whitespace: 27case SyntaxKind.NewLine: 29case SyntaxKind.OpenAngle: 31case SyntaxKind.Bang: 33case SyntaxKind.ForwardSlash: 35case SyntaxKind.QuestionMark: 37case SyntaxKind.DoubleHyphen: 39case SyntaxKind.LeftBracket: 41case SyntaxKind.CloseAngle: 43case SyntaxKind.RightBracket: 45case SyntaxKind.Equals: 47case SyntaxKind.DoubleQuote: 49case SyntaxKind.SingleQuote: 51case SyntaxKind.Transition: 53case SyntaxKind.Colon: 55case SyntaxKind.RazorCommentLiteral: 57case SyntaxKind.RazorCommentStar: 59case SyntaxKind.RazorCommentTransition: 71public override SyntaxKind FlipBracket(SyntaxKind bracket) 75case SyntaxKind.LeftBracket: 76return SyntaxKind.RightBracket; 77case SyntaxKind.OpenAngle: 78return SyntaxKind.CloseAngle; 79case SyntaxKind.RightBracket: 80return SyntaxKind.LeftBracket; 81case SyntaxKind.CloseAngle: 82return SyntaxKind.OpenAngle; 85return SyntaxKind.Marker; 91return SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 94public override SyntaxKind GetKnownTokenType(KnownTokenType type) 99return SyntaxKind.RazorCommentTransition; 101return SyntaxKind.RazorCommentStar; 103return SyntaxKind.RazorCommentLiteral; 105return SyntaxKind.Text; 107return SyntaxKind.Text; 109return SyntaxKind.NewLine; 111return SyntaxKind.Transition; 113return SyntaxKind.Whitespace; 115return SyntaxKind.Marker; 119protected override SyntaxToken CreateToken(string content, SyntaxKind kind, RazorDiagnostic[] errors)

22SyntaxFactory.Token(SyntaxKind.Text, "-"), 23SyntaxFactory.Token(SyntaxKind.Bang, "!"), 24SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"), 106return SyntaxFactory.RazorDocument(markup, SyntaxFactory.Token(SyntaxKind.EndOfFile, "", Array.Empty<RazorDiagnostic>())); 148if (At(SyntaxKind.OpenAngle)) 152else if (At(SyntaxKind.Transition)) 367static f => (f.Kind == SyntaxKind.Whitespace) || (f.Kind == SyntaxKind.NewLine), 371if (!(At(SyntaxKind.OpenAngle) || 372(At(SyntaxKind.Transition) && Lookahead(count: 1).Content.StartsWith(":", StringComparison.Ordinal)))) 385AcceptWhile(SyntaxKind.Whitespace); 386TryAccept(SyntaxKind.NewLine); 407Assert(SyntaxKind.Transition); 416if (CurrentToken.Kind == SyntaxKind.Text && CurrentToken.Content.Length > 0 && CurrentToken.Content[0] == ':') 419var split = Language.SplitToken(CurrentToken, 1, SyntaxKind.Colon); 432else if (CurrentToken.Kind == SyntaxKind.OpenAngle) 456ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 457if (At(SyntaxKind.Whitespace)) 461} while (!EndOfFile && CurrentToken.Kind != SyntaxKind.NewLine); 467if (!EndOfFile && CurrentToken.Kind == SyntaxKind.NewLine) 481Assert(SyntaxKind.OpenAngle); 486if (!NextIs(SyntaxKind.ForwardSlash)) 639Assert(SyntaxKind.OpenAngle); 648if (At(SyntaxKind.Text)) 667var tagNameToken = At(SyntaxKind.Text) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.Text); 680if (At(SyntaxKind.ForwardSlash)) 687var closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 690if (EndOfFile || !At(SyntaxKind.CloseAngle)) 702if (At(SyntaxKind.CloseAngle)) 724if (At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.ForwardSlash)) 727Assert(SyntaxKind.ForwardSlash); 729if (!At(SyntaxKind.Text) || !string.Equals(CurrentToken.Content, tagName, StringComparison.OrdinalIgnoreCase)) 747else if (At(SyntaxKind.CloseAngle)) 792Assert(SyntaxKind.Text); 805if (At(SyntaxKind.CloseAngle) || 806(At(SyntaxKind.ForwardSlash) && NextIs(SyntaxKind.CloseAngle))) 808if (At(SyntaxKind.ForwardSlash)) 845AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.NewLine); 849if (At(SyntaxKind.CloseAngle)) 855closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 862Assert(SyntaxKind.OpenAngle); 868var forwardSlashToken = At(SyntaxKind.ForwardSlash) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.ForwardSlash); 872if (At(SyntaxKind.Text)) 903tagNameToken = SyntaxFactory.MissingToken(SyntaxKind.Text); 912AcceptWhile(SyntaxKind.Whitespace); 918AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 921if (At(SyntaxKind.CloseAngle)) 934if (At(SyntaxKind.CloseAngle)) 942closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 962Assert(SyntaxKind.Text); 971isWellFormed = At(SyntaxKind.CloseAngle); 1009if (!At(SyntaxKind.Whitespace) && !At(SyntaxKind.NewLine)) 1020if (At(SyntaxKind.ForwardSlash)) 1033if (At(SyntaxKind.ForwardSlash)) 1035if (NextIs(SyntaxKind.CloseAngle) || NextIs(SyntaxKind.OpenAngle)) 1041return At(SyntaxKind.CloseAngle) || At(SyntaxKind.OpenAngle); 1057case SyntaxKind.SingleQuote: 1058case SyntaxKind.DoubleQuote: 1060var openQuoteKind = CurrentToken.Kind; 1069case SyntaxKind.OpenAngle: // Another "<" means this tag is invalid. 1070case SyntaxKind.ForwardSlash: // Empty tag 1071case SyntaxKind.CloseAngle: // End of tag 1114static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1170var atMinimizedAttribute = !TokenExistsAfterWhitespace(SyntaxKind.Equals); 1204if (At(SyntaxKind.Transition)) 1206if (NextIs(SyntaxKind.Transition)) 1223else if (At(SyntaxKind.RazorCommentTransition)) 1234token.Kind != SyntaxKind.Whitespace && 1235token.Kind != SyntaxKind.NewLine && 1236token.Kind != SyntaxKind.Equals && 1237token.Kind != SyntaxKind.CloseAngle && 1238token.Kind != SyntaxKind.OpenAngle && 1239(token.Kind != SyntaxKind.Transition || !self.Context.Options.AllowCSharpInMarkupAttributeArea) && 1240(token.Kind != SyntaxKind.ForwardSlash || !self.NextIs(SyntaxKind.CloseAngle)), 1254AcceptWhile(static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 1257Assert(SyntaxKind.Equals); // We should be at "=" 1262static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1264var quote = SyntaxKind.Marker; 1265if (At(SyntaxKind.SingleQuote) || At(SyntaxKind.DoubleQuote)) 1303if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1322if (quote != SyntaxKind.Marker && At(quote)) 1328else if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1334if (quote != SyntaxKind.Marker) 1348private RazorBlockSyntax ParseNonConditionalAttributeValue(SyntaxKind quote) 1365private void ParseConditionalAttributeValue(in SyntaxListBuilder<RazorSyntaxNode> builder, SyntaxKind quote) 1370static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1373if (At(SyntaxKind.Transition)) 1375if (NextIs(SyntaxKind.Transition)) 1443token.Kind != SyntaxKind.Whitespace && 1444token.Kind != SyntaxKind.NewLine && 1445token.Kind != SyntaxKind.Transition && 1460private bool IsEndOfAttributeValue(SyntaxKind quote, SyntaxToken token) 1463(quote != SyntaxKind.Marker 1473return token.Kind == SyntaxKind.DoubleQuote || 1474token.Kind == SyntaxKind.SingleQuote || 1475token.Kind == SyntaxKind.OpenAngle || 1476token.Kind == SyntaxKind.Equals || 1477(token.Kind == SyntaxKind.ForwardSlash && NextIs(SyntaxKind.CloseAngle)) || 1478token.Kind == SyntaxKind.CloseAngle || 1479token.Kind == SyntaxKind.Whitespace || 1480token.Kind == SyntaxKind.NewLine; 1492ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.OpenAngle); 1495if (NextIs(SyntaxKind.ForwardSlash)) 1502if (At(SyntaxKind.Text) && 1541AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 1549if (!At(SyntaxKind.CloseAngle)) 1555closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 1587return AcceptTokenUntilAll(builder, SyntaxKind.CloseAngle); 1592Assert(SyntaxKind.OpenAngle); 1594Assert(SyntaxKind.QuestionMark); 1596return AcceptTokenUntilAll(builder, SyntaxKind.QuestionMark, SyntaxKind.CloseAngle); 1602Assert(SyntaxKind.OpenAngle); 1606Debug.Assert(CurrentToken.Kind == SyntaxKind.Text && string.Equals(CurrentToken.Content, "cdata", StringComparison.OrdinalIgnoreCase)); 1608Assert(SyntaxKind.LeftBracket); 1609return AcceptTokenUntilAll(builder, SyntaxKind.RightBracket, SyntaxKind.RightBracket, SyntaxKind.CloseAngle); 1618Assert(SyntaxKind.Transition); 1653Assert(SyntaxKind.OpenAngle); 1672ParseMarkupNodes(htmlCommentBuilder, ParseMode.Text, t => t.Kind == SyntaxKind.DoubleHyphen); 1675if (At(SyntaxKind.CloseAngle)) 1739(At(SyntaxKind.NewLine) || 1740(At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.NewLine)))) 1772if (At(SyntaxKind.NewLine)) 1836if (NextIs(SyntaxKind.DoubleHyphen)) 1847if (At(SyntaxKind.Text) && IsHyphen(CurrentToken)) 1850if (!NextIs(SyntaxKind.CloseAngle)) 1862private bool AcceptTokenUntilAll(in SyntaxListBuilder<RazorSyntaxNode> builder, params SyntaxKind[] endSequence) 1881if (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1886while (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1904else if (At(SyntaxKind.RazorCommentTransition)) 1909else if (At(SyntaxKind.Transition)) 1911if (NextIs(SyntaxKind.Transition)) 1929else if (At(SyntaxKind.OpenAngle)) 1931if (NextIs(SyntaxKind.Bang)) 1940else if (Lookahead(2)?.Kind == SyntaxKind.LeftBracket && 1943Lookahead(4)?.Kind == SyntaxKind.LeftBracket) 1954else if (NextIs(SyntaxKind.QuestionMark)) 1984Assert(SyntaxKind.Bang); 1998potentialBang.Kind == SyntaxKind.Bang) 2003afterBang.Kind == SyntaxKind.Text && 2026if (!(At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.Bang))) 2037if (EndOfFile || CurrentToken.Kind != SyntaxKind.DoubleHyphen) 2043if (NextIs(SyntaxKind.CloseAngle) || NextIs(next => IsHyphen(next) && NextIs(SyntaxKind.CloseAngle))) 2052if (token.Kind == SyntaxKind.DoubleHyphen) 2054if (NextIs(SyntaxKind.CloseAngle)) 2060else if (NextIs(ns => IsHyphen(ns) && NextIs(SyntaxKind.CloseAngle))) 2069else if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.CloseAngle))) 2076else if (token.Kind == SyntaxKind.OpenAngle) 2079if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.DoubleHyphen))) 2122token.Kind == SyntaxKind.Text || 2123token.Kind == SyntaxKind.OpenAngle); 2124if (At(SyntaxKind.Text)) 2191var (preSequence, right) = Language.SplitToken(token, position, SyntaxKind.Text); 2193var (sequenceToken, _) = Language.SplitToken(right, sequence.Length, SyntaxKind.Text); 2266return token.Kind == SyntaxKind.Text && token.Content == "-"; 2280var tokenType = token.Kind; 2281return tokenType != SyntaxKind.Whitespace && 2282tokenType != SyntaxKind.NewLine && 2283tokenType != SyntaxKind.CloseAngle && 2284tokenType != SyntaxKind.OpenAngle && 2285tokenType != SyntaxKind.ForwardSlash && 2286tokenType != SyntaxKind.Equals && 2287tokenType != SyntaxKind.Marker; 2292return token.Kind == SyntaxKind.CloseAngle || 2293token.Kind == SyntaxKind.ForwardSlash || 2294token.Kind == SyntaxKind.OpenAngle || 2295token.Kind == SyntaxKind.SingleQuote || 2296token.Kind == SyntaxKind.DoubleQuote; 2322if (last.Kind == SyntaxKind.None)

17private static readonly FrozenDictionary<SyntaxKind, SyntaxToken> s_kindToTokenMap = new Dictionary<SyntaxKind, SyntaxToken>() 19[SyntaxKind.OpenAngle] = SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"), 20[SyntaxKind.Bang] = SyntaxFactory.Token(SyntaxKind.Bang, "!"), 21[SyntaxKind.ForwardSlash] = SyntaxFactory.Token(SyntaxKind.ForwardSlash, "/"), 22[SyntaxKind.QuestionMark] = SyntaxFactory.Token(SyntaxKind.QuestionMark, "?"), 23[SyntaxKind.LeftBracket] = SyntaxFactory.Token(SyntaxKind.LeftBracket, "["), 24[SyntaxKind.CloseAngle] = SyntaxFactory.Token(SyntaxKind.CloseAngle, ">"), 25[SyntaxKind.RightBracket] = SyntaxFactory.Token(SyntaxKind.RightBracket, "]"), 26[SyntaxKind.Equals] = SyntaxFactory.Token(SyntaxKind.Equals, "="), 27[SyntaxKind.DoubleQuote] = SyntaxFactory.Token(SyntaxKind.DoubleQuote, "\""), 28[SyntaxKind.SingleQuote] = SyntaxFactory.Token(SyntaxKind.SingleQuote, "'"), 29[SyntaxKind.DoubleHyphen] = SyntaxFactory.Token(SyntaxKind.DoubleHyphen, "--"), 42public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral; 44public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition; 46public override SyntaxKind RazorCommentStarKind => SyntaxKind.RazorCommentStar; 48protected override SyntaxToken CreateToken(string content, SyntaxKind type, RazorDiagnostic[] errors) 85protected override string GetTokenContent(SyntaxKind type) 93case SyntaxKind.OpenAngle: 95case SyntaxKind.Bang: 97case SyntaxKind.ForwardSlash: 99case SyntaxKind.QuestionMark: 101case SyntaxKind.LeftBracket: 103case SyntaxKind.CloseAngle: 105case SyntaxKind.RightBracket: 107case SyntaxKind.Equals: 109case SyntaxKind.DoubleQuote: 111case SyntaxKind.SingleQuote: 113case SyntaxKind.Whitespace: 124case SyntaxKind.NewLine: 137case SyntaxKind.NewLine: 139case SyntaxKind.DoubleHyphen: 165EndToken(SyntaxKind.RazorCommentTransition)); 172EndToken(SyntaxKind.Transition)); 175return Stay(EndToken(SyntaxKind.Transition)); 190return Transition(HtmlTokenizerState.Data, EndToken(SyntaxKind.Transition)); 216return Transition(HtmlTokenizerState.Data, EndToken(SyntaxKind.Text)); 229return EndToken(SyntaxKind.OpenAngle); 231return EndToken(SyntaxKind.Bang); 233return EndToken(SyntaxKind.ForwardSlash); 235return EndToken(SyntaxKind.QuestionMark); 237return EndToken(SyntaxKind.LeftBracket); 239return EndToken(SyntaxKind.CloseAngle); 241return EndToken(SyntaxKind.RightBracket); 243return EndToken(SyntaxKind.Equals); 245return EndToken(SyntaxKind.DoubleQuote); 247return EndToken(SyntaxKind.SingleQuote); 251return EndToken(SyntaxKind.DoubleHyphen); 255return EndToken(SyntaxKind.Marker); 266return EndToken(SyntaxKind.Whitespace); 282return EndToken(SyntaxKind.NewLine);

169if (token.Kind == SyntaxKind.None) 180if (tokenEndIndex >= change.Span.AbsoluteIndex + change.Span.Length && token.Kind == SyntaxKind.Identifier) 196if (newToken.Kind == SyntaxKind.Identifier) 341if (token.Kind == SyntaxKind.LeftParenthesis) 345else if (token.Kind == SyntaxKind.RightParenthesis) 354else if (token.Kind == SyntaxKind.StringLiteral) 366else if (token.Kind == SyntaxKind.CharacterLiteral)

15public abstract string GetSample(SyntaxKind type); 17public abstract SyntaxKind FlipBracket(SyntaxKind bracket); 88public virtual (SyntaxToken left, SyntaxToken right) SplitToken(SyntaxToken token, int splitAt, SyntaxKind leftType) 101public abstract SyntaxKind GetKnownTokenType(KnownTokenType type); 108protected abstract SyntaxToken CreateToken(string content, SyntaxKind type, RazorDiagnostic[] errors);

28private static readonly FrozenSet<SyntaxKind> s_transitionSpanKinds = FrozenSet.Create( 29SyntaxKind.CSharpTransition, 30SyntaxKind.MarkupTransition); 32private static readonly FrozenSet<SyntaxKind> s_commentSpanKinds = FrozenSet.Create( 33SyntaxKind.RazorCommentTransition, 34SyntaxKind.RazorCommentStar, 35SyntaxKind.RazorCommentLiteral); 37private static readonly FrozenSet<SyntaxKind> s_codeSpanKinds = FrozenSet.Create( 38SyntaxKind.CSharpStatementLiteral, 39SyntaxKind.CSharpExpressionLiteral, 40SyntaxKind.CSharpEphemeralTextLiteral); 42private static readonly FrozenSet<SyntaxKind> s_markupSpanKinds = FrozenSet.Create( 43SyntaxKind.MarkupTextLiteral, 44SyntaxKind.MarkupEphemeralTextLiteral); 46private static readonly FrozenSet<SyntaxKind> s_allSpanKinds = CreateAllSpanKindsSet(); 48private static FrozenSet<SyntaxKind> CreateAllSpanKindsSet() 50var set = new HashSet<SyntaxKind>(); 53set.Add(SyntaxKind.RazorMetaCode); 57set.Add(SyntaxKind.UnclassifiedTextLiteral); 145return node.Kind is SyntaxKind.RazorMetaCode; 173return node.Kind is SyntaxKind.UnclassifiedTextLiteral;

15private static readonly Dictionary<SyntaxKind, string> _tokenSamples = new Dictionary<SyntaxKind, string>() 17{ SyntaxKind.Arrow, "->" }, 18{ SyntaxKind.Minus, "-" }, 19{ SyntaxKind.Decrement, "--" }, 20{ SyntaxKind.MinusAssign, "-=" }, 21{ SyntaxKind.NotEqual, "!=" }, 22{ SyntaxKind.Not, "!" }, 23{ SyntaxKind.Modulo, "%" }, 24{ SyntaxKind.ModuloAssign, "%=" }, 25{ SyntaxKind.AndAssign, "&=" }, 26{ SyntaxKind.And, "&" }, 27{ SyntaxKind.DoubleAnd, "&&" }, 28{ SyntaxKind.LeftParenthesis, "(" }, 29{ SyntaxKind.RightParenthesis, ")" }, 30{ SyntaxKind.Star, "*" }, 31{ SyntaxKind.MultiplyAssign, "*=" }, 32{ SyntaxKind.Comma, "," }, 33{ SyntaxKind.Dot, "." }, 34{ SyntaxKind.Slash, "/" }, 35{ SyntaxKind.DivideAssign, "/=" }, 36{ SyntaxKind.DoubleColon, "::" }, 37{ SyntaxKind.Colon, ":" }, 38{ SyntaxKind.Semicolon, ";" }, 39{ SyntaxKind.QuestionMark, "?" }, 40{ SyntaxKind.NullCoalesce, "??" }, 41{ SyntaxKind.RightBracket, "]" }, 42{ SyntaxKind.LeftBracket, "[" }, 43{ SyntaxKind.XorAssign, "^=" }, 44{ SyntaxKind.Xor, "^" }, 45{ SyntaxKind.LeftBrace, "{" }, 46{ SyntaxKind.OrAssign, "|=" }, 47{ SyntaxKind.DoubleOr, "||" }, 48{ SyntaxKind.Or, "|" }, 49{ SyntaxKind.RightBrace, "}" }, 50{ SyntaxKind.Tilde, "~" }, 51{ SyntaxKind.Plus, "+" }, 52{ SyntaxKind.PlusAssign, "+=" }, 53{ SyntaxKind.Increment, "++" }, 54{ SyntaxKind.LessThan, "<" }, 55{ SyntaxKind.LessThanEqual, "<=" }, 56{ SyntaxKind.LeftShift, "<<" }, 57{ SyntaxKind.LeftShiftAssign, "<<=" }, 58{ SyntaxKind.Assign, "=" }, 59{ SyntaxKind.Equals, "==" }, 60{ SyntaxKind.GreaterThan, ">" }, 61{ SyntaxKind.GreaterThanEqual, ">=" }, 62{ SyntaxKind.RightShift, ">>" }, 63{ SyntaxKind.RightShiftAssign, ">>=" }, 64{ SyntaxKind.Hash, "#" }, 65{ SyntaxKind.Transition, "@" }, 81protected override SyntaxToken CreateToken(string content, SyntaxKind kind, RazorDiagnostic[] errors) 86public override string GetSample(SyntaxKind kind) 93case SyntaxKind.Identifier: 95case SyntaxKind.Keyword: 97case SyntaxKind.IntegerLiteral: 99case SyntaxKind.NewLine: 101case SyntaxKind.Whitespace: 103case SyntaxKind.CSharpComment: 105case SyntaxKind.RealLiteral: 107case SyntaxKind.CharacterLiteral: 109case SyntaxKind.StringLiteral: 120return SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 123public override SyntaxKind GetKnownTokenType(KnownTokenType type) 128return SyntaxKind.Identifier; 130return SyntaxKind.Keyword; 132return SyntaxKind.NewLine; 134return SyntaxKind.Whitespace; 136return SyntaxKind.Transition; 138return SyntaxKind.RazorCommentTransition; 140return SyntaxKind.RazorCommentStar; 142return SyntaxKind.RazorCommentLiteral; 144return SyntaxKind.Marker; 148public override SyntaxKind FlipBracket(SyntaxKind bracket) 152case SyntaxKind.LeftBrace: 153return SyntaxKind.RightBrace; 154case SyntaxKind.LeftBracket: 155return SyntaxKind.RightBracket; 156case SyntaxKind.LeftParenthesis: 157return SyntaxKind.RightParenthesis; 158case SyntaxKind.LessThan: 159return SyntaxKind.GreaterThan; 160case SyntaxKind.RightBrace: 161return SyntaxKind.LeftBrace; 162case SyntaxKind.RightBracket: 163return SyntaxKind.LeftBracket; 164case SyntaxKind.RightParenthesis: 165return SyntaxKind.LeftParenthesis; 166case SyntaxKind.GreaterThan: 167return SyntaxKind.LessThan; 170return SyntaxKind.Marker;

24private readonly Dictionary<char, Func<SyntaxKind>> _operatorHandlers; 113_operatorHandlers = new Dictionary<char, Func<SyntaxKind>>() 118{ '&', CreateTwoCharOperatorHandler(SyntaxKind.And, '=', SyntaxKind.AndAssign, '&', SyntaxKind.DoubleAnd) }, 119{ '|', CreateTwoCharOperatorHandler(SyntaxKind.Or, '=', SyntaxKind.OrAssign, '|', SyntaxKind.DoubleOr) }, 120{ '+', CreateTwoCharOperatorHandler(SyntaxKind.Plus, '=', SyntaxKind.PlusAssign, '+', SyntaxKind.Increment) }, 121{ '=', CreateTwoCharOperatorHandler(SyntaxKind.Assign, '=', SyntaxKind.Equals, '>', SyntaxKind.GreaterThanEqual) }, 122{ '!', CreateTwoCharOperatorHandler(SyntaxKind.Not, '=', SyntaxKind.NotEqual) }, 123{ '%', CreateTwoCharOperatorHandler(SyntaxKind.Modulo, '=', SyntaxKind.ModuloAssign) }, 124{ '*', CreateTwoCharOperatorHandler(SyntaxKind.Star, '=', SyntaxKind.MultiplyAssign) }, 125{ ':', CreateTwoCharOperatorHandler(SyntaxKind.Colon, ':', SyntaxKind.DoubleColon) }, 126{ '?', CreateTwoCharOperatorHandler(SyntaxKind.QuestionMark, '?', SyntaxKind.NullCoalesce) }, 127{ '^', CreateTwoCharOperatorHandler(SyntaxKind.Xor, '=', SyntaxKind.XorAssign) }, 128{ '(', () => SyntaxKind.LeftParenthesis }, 129{ ')', () => SyntaxKind.RightParenthesis }, 130{ '{', () => SyntaxKind.LeftBrace }, 131{ '}', () => SyntaxKind.RightBrace }, 132{ '[', () => SyntaxKind.LeftBracket }, 133{ ']', () => SyntaxKind.RightBracket }, 134{ ',', () => SyntaxKind.Comma }, 135{ ';', () => SyntaxKind.Semicolon }, 136{ '~', () => SyntaxKind.Tilde }, 137{ '#', () => SyntaxKind.Hash } 145public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral; 147public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition; 149public override SyntaxKind RazorCommentStarKind => SyntaxKind.RazorCommentStar; 182protected override string GetTokenContent(SyntaxKind type) 190case SyntaxKind.IntegerLiteral: 215case SyntaxKind.NewLine: 221case SyntaxKind.Whitespace: 231case SyntaxKind.Minus: 233case SyntaxKind.Not: 235case SyntaxKind.Modulo: 237case SyntaxKind.And: 239case SyntaxKind.LeftParenthesis: 241case SyntaxKind.RightParenthesis: 243case SyntaxKind.Star: 245case SyntaxKind.Comma: 247case SyntaxKind.Dot: 249case SyntaxKind.Slash: 251case SyntaxKind.Colon: 253case SyntaxKind.Semicolon: 255case SyntaxKind.QuestionMark: 257case SyntaxKind.RightBracket: 259case SyntaxKind.LeftBracket: 261case SyntaxKind.Xor: 263case SyntaxKind.LeftBrace: 265case SyntaxKind.Or: 267case SyntaxKind.RightBrace: 269case SyntaxKind.Tilde: 271case SyntaxKind.Plus: 273case SyntaxKind.LessThan: 275case SyntaxKind.Assign: 277case SyntaxKind.GreaterThan: 279case SyntaxKind.Hash: 281case SyntaxKind.Transition: 290case SyntaxKind.NewLine: 292case SyntaxKind.Arrow: 294case SyntaxKind.Decrement: 296case SyntaxKind.MinusAssign: 298case SyntaxKind.NotEqual: 300case SyntaxKind.ModuloAssign: 302case SyntaxKind.AndAssign: 304case SyntaxKind.DoubleAnd: 306case SyntaxKind.MultiplyAssign: 308case SyntaxKind.DivideAssign: 310case SyntaxKind.DoubleColon: 312case SyntaxKind.NullCoalesce: 314case SyntaxKind.XorAssign: 316case SyntaxKind.OrAssign: 318case SyntaxKind.DoubleOr: 320case SyntaxKind.PlusAssign: 322case SyntaxKind.Increment: 324case SyntaxKind.LessThanEqual: 326case SyntaxKind.LeftShift: 328case SyntaxKind.Equals: 330case SyntaxKind.GreaterThanEqual: 336case SyntaxKind.RightShift: 346case SyntaxKind.LeftShiftAssign: 348case SyntaxKind.RightShiftAssign: 356protected override SyntaxToken CreateToken(string content, SyntaxKind kind, RazorDiagnostic[] errors) 372return Stay(EndToken(SyntaxKind.NewLine)); 378return Stay(EndToken(SyntaxKind.Whitespace)); 403return Stay(Single(SyntaxKind.Dot)); 419return Stay(EndToken(SyntaxKind.DivideAssign)); 423return Stay(EndToken(SyntaxKind.Slash)); 442EndToken(SyntaxKind.RazorCommentTransition)); 449EndToken(SyntaxKind.Transition)); 452return Stay(EndToken(SyntaxKind.Transition)); 458return Transition(CSharpTokenizerState.Data, EndToken(SyntaxKind.Transition)); 461private SyntaxKind Operator() 465Func<SyntaxKind> handler; 470return SyntaxKind.Marker; 473private SyntaxKind LessThanOperator() 478return SyntaxKind.LessThanEqual; 480return SyntaxKind.LessThan; 483private SyntaxKind GreaterThanOperator() 488return SyntaxKind.GreaterThanEqual; 490return SyntaxKind.GreaterThan; 493private SyntaxKind MinusOperator() 498return SyntaxKind.Arrow; 503return SyntaxKind.Decrement; 508return SyntaxKind.MinusAssign; 510return SyntaxKind.Minus; 513private Func<SyntaxKind> CreateTwoCharOperatorHandler(SyntaxKind typeIfOnlyFirst, char second, SyntaxKind typeIfBoth) 526private Func<SyntaxKind> CreateTwoCharOperatorHandler(SyntaxKind typeIfOnlyFirst, char option1, SyntaxKind typeIfOption1, char option2, SyntaxKind typeIfOption2) 563return Transition(CSharpTokenizerState.Data, EndToken(SyntaxKind.StringLiteral)); 566private StateResult QuotedCharacterLiteral() => QuotedLiteral('\'', IsEndQuotedCharacterLiteral, SyntaxKind.CharacterLiteral); 568private StateResult QuotedStringLiteral() => QuotedLiteral('\"', IsEndQuotedStringLiteral, SyntaxKind.StringLiteral); 573private StateResult QuotedLiteral(char quote, Func<char, bool> isEndQuotedLiteral, SyntaxKind literalType) 610return Transition(CSharpTokenizerState.Data, EndToken(SyntaxKind.CSharpComment)); 618return Transition(CSharpTokenizerState.Data, EndToken(SyntaxKind.CSharpComment)); 628return Stay(EndToken(SyntaxKind.CSharpComment)); 648return Stay(EndToken(SyntaxKind.IntegerLiteral)); 666return Stay(EndToken(SyntaxKind.IntegerLiteral)); 685return Stay(EndToken(SyntaxKind.RealLiteral)); 727var type = SyntaxKind.Identifier; 731type = SyntaxKind.Keyword;

15private static readonly Dictionary<SyntaxKind, string> _tokenSamples = new Dictionary<SyntaxKind, string>() 17{ SyntaxKind.Arrow, "->" }, 18{ SyntaxKind.Minus, "-" }, 19{ SyntaxKind.Decrement, "--" }, 20{ SyntaxKind.MinusAssign, "-=" }, 21{ SyntaxKind.NotEqual, "!=" }, 22{ SyntaxKind.Not, "!" }, 23{ SyntaxKind.Modulo, "%" }, 24{ SyntaxKind.ModuloAssign, "%=" }, 25{ SyntaxKind.AndAssign, "&=" }, 26{ SyntaxKind.And, "&" }, 27{ SyntaxKind.DoubleAnd, "&&" }, 28{ SyntaxKind.LeftParenthesis, "(" }, 29{ SyntaxKind.RightParenthesis, ")" }, 30{ SyntaxKind.Star, "*" }, 31{ SyntaxKind.MultiplyAssign, "*=" }, 32{ SyntaxKind.Comma, "," }, 33{ SyntaxKind.Dot, "." }, 34{ SyntaxKind.Slash, "/" }, 35{ SyntaxKind.DivideAssign, "/=" }, 36{ SyntaxKind.DoubleColon, "::" }, 37{ SyntaxKind.Colon, ":" }, 38{ SyntaxKind.Semicolon, ";" }, 39{ SyntaxKind.QuestionMark, "?" }, 40{ SyntaxKind.NullCoalesce, "??" }, 41{ SyntaxKind.RightBracket, "]" }, 42{ SyntaxKind.LeftBracket, "[" }, 43{ SyntaxKind.XorAssign, "^=" }, 44{ SyntaxKind.Xor, "^" }, 45{ SyntaxKind.LeftBrace, "{" }, 46{ SyntaxKind.OrAssign, "|=" }, 47{ SyntaxKind.DoubleOr, "||" }, 48{ SyntaxKind.Or, "|" }, 49{ SyntaxKind.RightBrace, "}" }, 50{ SyntaxKind.Tilde, "~" }, 51{ SyntaxKind.Plus, "+" }, 52{ SyntaxKind.PlusAssign, "+=" }, 53{ SyntaxKind.Increment, "++" }, 54{ SyntaxKind.LessThan, "<" }, 55{ SyntaxKind.LessThanEqual, "<=" }, 56{ SyntaxKind.LeftShift, "<<" }, 57{ SyntaxKind.LeftShiftAssign, "<<=" }, 58{ SyntaxKind.Assign, "=" }, 59{ SyntaxKind.Equals, "==" }, 60{ SyntaxKind.GreaterThan, ">" }, 61{ SyntaxKind.GreaterThanEqual, ">=" }, 62{ SyntaxKind.RightShift, ">>" }, 63{ SyntaxKind.RightShiftAssign, ">>=" }, 64{ SyntaxKind.Hash, "#" }, 65{ SyntaxKind.Transition, "@" }, 73protected override SyntaxToken CreateToken(string content, SyntaxKind kind, RazorDiagnostic[] errors) 78public override string GetSample(SyntaxKind kind) 85case SyntaxKind.Identifier: 87case SyntaxKind.Keyword: 89case SyntaxKind.IntegerLiteral: 91case SyntaxKind.NewLine: 93case SyntaxKind.Whitespace: 95case SyntaxKind.CSharpComment: 97case SyntaxKind.RealLiteral: 99case SyntaxKind.CharacterLiteral: 101case SyntaxKind.StringLiteral: 112return SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 115public override SyntaxKind GetKnownTokenType(KnownTokenType type) 120return SyntaxKind.Identifier; 122return SyntaxKind.Keyword; 124return SyntaxKind.NewLine; 126return SyntaxKind.Whitespace; 128return SyntaxKind.Transition; 130return SyntaxKind.RazorCommentTransition; 132return SyntaxKind.RazorCommentStar; 134return SyntaxKind.RazorCommentLiteral; 136return SyntaxKind.Marker; 140public override SyntaxKind FlipBracket(SyntaxKind bracket) 144case SyntaxKind.LeftBrace: 145return SyntaxKind.RightBrace; 146case SyntaxKind.LeftBracket: 147return SyntaxKind.RightBracket; 148case SyntaxKind.LeftParenthesis: 149return SyntaxKind.RightParenthesis; 150case SyntaxKind.LessThan: 151return SyntaxKind.GreaterThan; 152case SyntaxKind.RightBrace: 153return SyntaxKind.LeftBrace; 154case SyntaxKind.RightBracket: 155return SyntaxKind.LeftBracket; 156case SyntaxKind.RightParenthesis: 157return SyntaxKind.LeftParenthesis; 158case SyntaxKind.GreaterThan: 159return SyntaxKind.LessThan; 162return SyntaxKind.Marker;

55public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral; 57public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition; 59public override SyntaxKind RazorCommentStarKind => SyntaxKind.RazorCommentStar; 146protected override string GetTokenContent(SyntaxKind type) 148Debug.Assert(type != SyntaxKind.CSharpOperator, "CSharpOperator should be handled by getting the interned text from C#"); 155case SyntaxKind.NewLine: 161case SyntaxKind.Whitespace: 171case SyntaxKind.NumericLiteral: 174case SyntaxKind.Not: 175case SyntaxKind.LeftParenthesis: 176case SyntaxKind.RightParenthesis: 177case SyntaxKind.Comma: 178case SyntaxKind.Dot: 179case SyntaxKind.Colon: 180case SyntaxKind.Semicolon: 181case SyntaxKind.QuestionMark: 182case SyntaxKind.RightBracket: 183case SyntaxKind.LeftBracket: 184case SyntaxKind.LeftBrace: 185case SyntaxKind.RightBrace: 186case SyntaxKind.LessThan: 187case SyntaxKind.Assign: 188case SyntaxKind.GreaterThan: 191case SyntaxKind.Transition: 200case SyntaxKind.NewLine: 202case SyntaxKind.DoubleColon: 203case SyntaxKind.Equals: 212protected override SyntaxToken CreateToken(string content, SyntaxKind kind, RazorDiagnostic[] errors) 297return Transition(RoslynCSharpTokenizerState.Token, EndToken(SyntaxKind.Transition)); 307return Transition(RoslynCSharpTokenizerState.TriviaForCSharpToken, EndToken(SyntaxKind.Transition)); 327var kind = token.RawKind switch 329(int)CSharpSyntaxKind.ExclamationToken => SyntaxKind.Not, 330(int)CSharpSyntaxKind.OpenParenToken => SyntaxKind.LeftParenthesis, 331(int)CSharpSyntaxKind.CloseParenToken => SyntaxKind.RightParenthesis, 332(int)CSharpSyntaxKind.CommaToken => SyntaxKind.Comma, 333(int)CSharpSyntaxKind.DotToken => SyntaxKind.Dot, 334(int)CSharpSyntaxKind.ColonColonToken => SyntaxKind.DoubleColon, 335(int)CSharpSyntaxKind.ColonToken => SyntaxKind.Colon, 336(int)CSharpSyntaxKind.OpenBraceToken => SyntaxKind.LeftBrace, 337(int)CSharpSyntaxKind.CloseBraceToken => SyntaxKind.RightBrace, 338(int)CSharpSyntaxKind.LessThanToken => SyntaxKind.LessThan, 339(int)CSharpSyntaxKind.GreaterThanToken => SyntaxKind.GreaterThan, 340(int)CSharpSyntaxKind.EqualsToken => SyntaxKind.Assign, 341(int)CSharpSyntaxKind.OpenBracketToken => SyntaxKind.LeftBracket, 342(int)CSharpSyntaxKind.CloseBracketToken => SyntaxKind.RightBracket, 343(int)CSharpSyntaxKind.QuestionToken => SyntaxKind.QuestionMark, 344(int)CSharpSyntaxKind.SemicolonToken => SyntaxKind.Semicolon, 345<= (int)CSharpSyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken and >= (int)CSharpSyntaxKind.TildeToken => SyntaxKind.CSharpOperator, 346_ => SyntaxKind.Marker, 351content = kind == SyntaxKind.Marker ? Buffer.ToString() : token.ValueText; 397var razorTokenKind = expectedStringKind == StringOrCharacterKind.Character ? SyntaxKind.CharacterLiteral : SyntaxKind.StringLiteral; 488EndToken(SyntaxKind.RazorCommentTransition)); 503SyntaxKind tokenType; 507tokenType = SyntaxKind.Whitespace; 510tokenType = SyntaxKind.NewLine; 517tokenType = SyntaxKind.CSharpComment; 536tokenType = SyntaxKind.CSharpComment; 540tokenType = SyntaxKind.CSharpDirective; 562tokenType = SyntaxKind.CSharpDisabledText; 635tokenType = SyntaxKind.ConflictMarkerTrivia; 653EndToken(SyntaxKind.RazorCommentStar)); 665return Transition(RoslynCSharpTokenizerState.TriviaForCSharpToken, EndToken(csharpToken.Text, SyntaxKind.NumericLiteral)); 674var type = SyntaxKind.Identifier; 677type = SyntaxKind.Keyword;

287case SyntaxKind.DoubleQuote: 290case SyntaxKind.SingleQuote: 357var transition = SyntaxFactory.RazorMetaCode(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 363var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, attributeName); 366var transitionToken = SyntaxFactory.Token(SyntaxKind.Transition, "@"); 374var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[0]); 377var colonToken = SyntaxFactory.Token(SyntaxKind.Colon, ":"); 380var parameterNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[1]); 418var transition = SyntaxFactory.RazorMetaCode(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 424var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, attributeName); 427var transitionToken = SyntaxFactory.Token(SyntaxKind.Transition, "@"); 435var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[0]); 438var colonToken = SyntaxFactory.Token(SyntaxKind.Colon, ":"); 441var parameterNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[1]); 579if (tokens is [{ Kind: SyntaxKind.Transition } transition, ..]) 652var transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 680transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 872var kind = node.Children[i].Kind; 873if (kind != SyntaxKind.MarkupLiteralAttributeValue && 876(kind != SyntaxKind.MarkupDynamicAttributeValue || !_options.FileKind.IsLegacy()))

44public abstract SyntaxKind RazorCommentStarKind { get; } 45public abstract SyntaxKind RazorCommentKind { get; } 46public abstract SyntaxKind RazorCommentTransitionKind { get; } 66protected abstract SyntaxToken CreateToken(string content, SyntaxKind type, RazorDiagnostic[] errors); 186protected SyntaxToken? Single(SyntaxKind type) 200protected SyntaxToken? EndToken(SyntaxKind type) 214protected SyntaxToken? EndToken(string tokenContent, SyntaxKind type) 234protected virtual string GetTokenContent(SyntaxKind type)

29return token.Kind == SyntaxKind.Whitespace; 34return IsSpacingToken(token) || token.Kind == SyntaxKind.NewLine; 39return IsSpacingToken(token) || token.Kind == SyntaxKind.CSharpComment; 44return IsSpacingTokenIncludingNewLines(token) || token.Kind is SyntaxKind.CSharpComment or SyntaxKind.CSharpDirective or SyntaxKind.CSharpDisabledText; 182internal void Assert(SyntaxKind expectedType) 222protected internal bool NextIs(SyntaxKind type) 239protected internal bool NextIs(params SyntaxKind[] types) 260protected internal bool Was(SyntaxKind type) 265protected internal bool At(SyntaxKind type) 270protected bool TokenExistsAfterWhitespace(SyntaxKind kind, bool includeNewLines = true) 276token.Kind == SyntaxKind.Whitespace || (includeNewLines && token.Kind == SyntaxKind.NewLine), 373Debug.Assert(At(SyntaxKind.RazorCommentTransition)); 374var startTransition = EatExpectedToken(SyntaxKind.RazorCommentTransition); 375var startStar = EatExpectedToken(SyntaxKind.RazorCommentStar); 376var comment = GetOptionalToken(SyntaxKind.RazorCommentLiteral); 379comment = SyntaxFactory.MissingToken(SyntaxKind.RazorCommentLiteral); 381var endStar = GetOptionalToken(SyntaxKind.RazorCommentStar); 386endStar = SyntaxFactory.MissingToken(SyntaxKind.RazorCommentStar, diagnostic); 389var endTransition = GetOptionalToken(SyntaxKind.RazorCommentTransition); 397endTransition = SyntaxFactory.MissingToken(SyntaxKind.RazorCommentTransition, diagnostic); 400endTransition = SyntaxFactory.MissingToken(SyntaxKind.RazorCommentTransition); 438protected SyntaxToken EatExpectedToken(SyntaxKind kind) 446protected SyntaxToken? GetOptionalToken(SyntaxKind kind) 458protected internal void AcceptWhile(SyntaxKind type) 464protected internal void AcceptWhile(SyntaxKind type1, SyntaxKind type2) 469protected internal void AcceptWhile(SyntaxKind type1, SyntaxKind type2, SyntaxKind type3) 474protected internal void AcceptWhile(params ImmutableArray<SyntaxKind> types) 479protected internal void AcceptUntil(SyntaxKind type) 485protected internal void AcceptUntil(SyntaxKind type1, SyntaxKind type2) 490protected internal void AcceptUntil(SyntaxKind type1, SyntaxKind type2, SyntaxKind type3) 495protected internal void AcceptUntil(params ImmutableArray<SyntaxKind> types) 526if (token.Kind == SyntaxKind.NewLine) 530else if (token.Kind != SyntaxKind.Whitespace) 544protected internal bool AcceptAll(params SyntaxKind[] kinds) 546foreach (var kind in kinds) 598protected internal bool TryAccept(SyntaxKind type)

21if (token.Kind == SyntaxKind.None) 26if (_firstToken.Kind == SyntaxKind.None) 41if (_firstToken.Kind == SyntaxKind.None) 56if (_firstToken.Kind == SyntaxKind.None) 96if (_firstToken.Kind == SyntaxKind.None) 101Debug.Assert(_lastToken.Kind != SyntaxKind.None, "Last token should not be None when first token is set."); 120if (_firstToken.Kind == SyntaxKind.None) 125Debug.Assert(_lastToken.Kind != SyntaxKind.None, "Last token should not be None when first token is set.");

93if (token.Kind != SyntaxKind.None && !token.IsMissing)

33return ForwardSlash.Kind != SyntaxKind.None && 124if (token.Kind != SyntaxKind.None && !token.IsMissing)

11internal RazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 16internal RazorBlockSyntax(SyntaxKind kind) 29internal RazorDocumentSyntax(SyntaxKind kind, RazorBlockSyntax document, SyntaxToken endOfFile, RazorDiagnostic[] diagnostics) 39internal RazorDocumentSyntax(SyntaxKind kind, RazorBlockSyntax document, SyntaxToken endOfFile) 91internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition, RazorDiagnostic[] diagnostics) 107internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition) 169internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 182internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 229internal GenericBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 240internal GenericBlockSyntax(SyntaxKind kind, GreenNode children) 285internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 298internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 343internal MarkupSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) 348internal MarkupSyntaxNode(SyntaxKind kind) 358internal MarkupBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 369internal MarkupBlockSyntax(SyntaxKind kind, GreenNode children) 414internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 427internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 476internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 489internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 538internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 551internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 598internal MarkupCommentBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 609internal MarkupCommentBlockSyntax(SyntaxKind kind, GreenNode children) 653internal MarkupMinimizedAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, RazorDiagnostic[] diagnostics) 666internal MarkupMinimizedAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) 723internal MarkupAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, RazorBlockSyntax value, MarkupTextLiteralSyntax valueSuffix, RazorDiagnostic[] diagnostics) 758internal MarkupAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, RazorBlockSyntax value, MarkupTextLiteralSyntax valueSuffix) 841internal MarkupMiscAttributeContentSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 852internal MarkupMiscAttributeContentSyntax(SyntaxKind kind, GreenNode children) 896internal MarkupLiteralAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, MarkupTextLiteralSyntax value, RazorDiagnostic[] diagnostics) 912internal MarkupLiteralAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, MarkupTextLiteralSyntax value) 967internal MarkupDynamicAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, RazorBlockSyntax value, RazorDiagnostic[] diagnostics) 980internal MarkupDynamicAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, RazorBlockSyntax value) 1029internal BaseMarkupStartTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 1034internal BaseMarkupStartTagSyntax(SyntaxKind kind) 1058internal BaseMarkupEndTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 1063internal BaseMarkupEndTagSyntax(SyntaxKind kind) 1087internal BaseMarkupElementSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 1092internal BaseMarkupElementSyntax(SyntaxKind kind) 1108internal MarkupElementSyntax(SyntaxKind kind, MarkupStartTagSyntax markupStartTag, GreenNode body, MarkupEndTagSyntax markupEndTag, RazorDiagnostic[] diagnostics) 1129internal MarkupElementSyntax(SyntaxKind kind, MarkupStartTagSyntax markupStartTag, GreenNode body, MarkupEndTagSyntax markupEndTag) 1198internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 1228internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 1315internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 1342internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 1421internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax tagHelperStartTag, GreenNode body, MarkupTagHelperEndTagSyntax tagHelperEndTag, TagHelperInfo tagHelperInfo, RazorDiagnostic[] diagnostics) 1443internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax tagHelperStartTag, GreenNode body, MarkupTagHelperEndTagSyntax tagHelperEndTag, TagHelperInfo tagHelperInfo) 1513internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 1542internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 1626internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 1652internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 1733internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) 1766internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) 1850internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) 1864internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) 1917internal MarkupTagHelperAttributeValueSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 1928internal MarkupTagHelperAttributeValueSyntax(SyntaxKind kind, GreenNode children) 1981internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) 2026internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) 2131internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) 2157internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) 2226internal CSharpSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) 2231internal CSharpSyntaxNode(SyntaxKind kind) 2241internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 2252internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children) 2297internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 2307internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 2353internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 2366internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 2415internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 2428internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 2477internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) 2490internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) 2537internal CSharpTemplateBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) 2548internal CSharpTemplateBlockSyntax(SyntaxKind kind, GreenNode children) 2589internal CSharpRazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 2594internal CSharpRazorBlockSyntax(SyntaxKind kind) 2609internal CSharpStatementSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) 2619internal CSharpStatementSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) 2669internal CSharpStatementBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openBrace, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeBrace, RazorDiagnostic[] diagnostics) 2681internal CSharpStatementBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openBrace, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeBrace) 2734internal CSharpExplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) 2744internal CSharpExplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) 2794internal CSharpExplicitExpressionBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openParen, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeParen, RazorDiagnostic[] diagnostics) 2806internal CSharpExplicitExpressionBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openParen, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeParen) 2859internal CSharpImplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) 2869internal CSharpImplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) 2917internal CSharpImplicitExpressionBodySyntax(SyntaxKind kind, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics) 2925internal CSharpImplicitExpressionBodySyntax(SyntaxKind kind, CSharpCodeBlockSyntax csharpCode) 2963internal BaseRazorDirectiveSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) 2968internal BaseRazorDirectiveSyntax(SyntaxKind kind) 2980internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) 2991internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) 3043internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) 3054internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) 3105internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics) 3118internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode) 3387if (endOfFile.Kind != SyntaxKind.EndOfFile) 3390var result = new RazorDocumentSyntax(SyntaxKind.RazorDocument, document, endOfFile); 3398if (startCommentTransition.Kind != SyntaxKind.RazorCommentTransition) 3401if (startCommentStar.Kind != SyntaxKind.RazorCommentStar) 3404if (comment.Kind != SyntaxKind.RazorCommentLiteral) 3407if (endCommentStar.Kind != SyntaxKind.RazorCommentStar) 3410if (endCommentTransition.Kind != SyntaxKind.RazorCommentTransition) 3413return new RazorCommentBlockSyntax(SyntaxKind.RazorComment, startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); 3418var result = new RazorMetaCodeSyntax(SyntaxKind.RazorMetaCode, metaCode.Node, chunkGenerator, editHandler); 3425var result = new GenericBlockSyntax(SyntaxKind.GenericBlock, children.Node); 3432var result = new UnclassifiedTextLiteralSyntax(SyntaxKind.UnclassifiedTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3439var result = new MarkupBlockSyntax(SyntaxKind.MarkupBlock, children.Node); 3446var result = new MarkupTransitionSyntax(SyntaxKind.MarkupTransition, transitionTokens.Node, chunkGenerator, editHandler); 3453var result = new MarkupTextLiteralSyntax(SyntaxKind.MarkupTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3460var result = new MarkupEphemeralTextLiteralSyntax(SyntaxKind.MarkupEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3467var result = new MarkupCommentBlockSyntax(SyntaxKind.MarkupCommentBlock, children.Node); 3476var result = new MarkupMinimizedAttributeBlockSyntax(SyntaxKind.MarkupMinimizedAttributeBlock, namePrefix, name); 3485if (equalsToken.Kind != SyntaxKind.Equals) 3488return new MarkupAttributeBlockSyntax(SyntaxKind.MarkupAttributeBlock, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); 3493var result = new MarkupMiscAttributeContentSyntax(SyntaxKind.MarkupMiscAttributeContent, children.Node); 3500var result = new MarkupLiteralAttributeValueSyntax(SyntaxKind.MarkupLiteralAttributeValue, prefix, value); 3509var result = new MarkupDynamicAttributeValueSyntax(SyntaxKind.MarkupDynamicAttributeValue, prefix, value); 3516var result = new MarkupElementSyntax(SyntaxKind.MarkupElement, markupStartTag, body.Node, markupEndTag); 3524if (openAngle.Kind != SyntaxKind.OpenAngle) 3526if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3529if (name.Kind != SyntaxKind.Text) 3531if (forwardSlash is not null && forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) 3534if (closeAngle.Kind != SyntaxKind.CloseAngle) 3537return new MarkupStartTagSyntax(SyntaxKind.MarkupStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, isMarkupTransition, chunkGenerator, editHandler); 3543if (openAngle.Kind != SyntaxKind.OpenAngle) 3546if (forwardSlash.Kind != SyntaxKind.ForwardSlash) 3548if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3551if (name.Kind != SyntaxKind.Text) 3554if (closeAngle.Kind != SyntaxKind.CloseAngle) 3557return new MarkupEndTagSyntax(SyntaxKind.MarkupEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, isMarkupTransition, chunkGenerator, editHandler); 3562return new MarkupTagHelperElementSyntax(SyntaxKind.MarkupTagHelperElement, tagHelperStartTag, body.Node, tagHelperEndTag, tagHelperInfo); 3568if (openAngle.Kind != SyntaxKind.OpenAngle) 3570if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3573if (name.Kind != SyntaxKind.Text) 3575if (forwardSlash is not null && forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) 3578if (closeAngle.Kind != SyntaxKind.CloseAngle) 3581return new MarkupTagHelperStartTagSyntax(SyntaxKind.MarkupTagHelperStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, chunkGenerator, editHandler); 3587if (openAngle.Kind != SyntaxKind.OpenAngle) 3590if (forwardSlash.Kind != SyntaxKind.ForwardSlash) 3592if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3595if (name.Kind != SyntaxKind.Text) 3598if (closeAngle.Kind != SyntaxKind.CloseAngle) 3601return new MarkupTagHelperEndTagSyntax(SyntaxKind.MarkupTagHelperEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator, editHandler); 3608if (equalsToken.Kind != SyntaxKind.Equals) 3612return new MarkupTagHelperAttributeSyntax(SyntaxKind.MarkupTagHelperAttribute, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 3619var result = new MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperAttribute, namePrefix, name, tagHelperAttributeInfo); 3626var result = new MarkupTagHelperAttributeValueSyntax(SyntaxKind.MarkupTagHelperAttributeValue, children.Node); 3636if (equalsToken.Kind != SyntaxKind.Equals) 3640return new MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 3648return new MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, tagHelperAttributeInfo); 3653var result = new CSharpCodeBlockSyntax(SyntaxKind.CSharpCodeBlock, children.Node); 3661if (transition.Kind != SyntaxKind.Transition) 3664var result = new CSharpTransitionSyntax(SyntaxKind.CSharpTransition, transition, chunkGenerator, editHandler); 3671var result = new CSharpStatementLiteralSyntax(SyntaxKind.CSharpStatementLiteral, literalTokens.Node, chunkGenerator, editHandler); 3678var result = new CSharpExpressionLiteralSyntax(SyntaxKind.CSharpExpressionLiteral, literalTokens.Node, chunkGenerator, editHandler); 3685var result = new CSharpEphemeralTextLiteralSyntax(SyntaxKind.CSharpEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3692var result = new CSharpTemplateBlockSyntax(SyntaxKind.CSharpTemplateBlock, children.Node); 3702var result = new CSharpStatementSyntax(SyntaxKind.CSharpStatement, transition, body); 3713var result = new CSharpStatementBodySyntax(SyntaxKind.CSharpStatementBody, openBrace, csharpCode, closeBrace); 3723var result = new CSharpExplicitExpressionSyntax(SyntaxKind.CSharpExplicitExpression, transition, body); 3734var result = new CSharpExplicitExpressionBodySyntax(SyntaxKind.CSharpExplicitExpressionBody, openParen, csharpCode, closeParen); 3744var result = new CSharpImplicitExpressionSyntax(SyntaxKind.CSharpImplicitExpression, transition, body); 3753var result = new CSharpImplicitExpressionBodySyntax(SyntaxKind.CSharpImplicitExpressionBody, csharpCode); 3763var result = new RazorDirectiveSyntax(SyntaxKind.RazorDirective, transition, body, directiveDescriptor); 3773var result = new RazorUsingDirectiveSyntax(SyntaxKind.RazorUsingDirective, transition, body, directiveDescriptor); 3782var result = new RazorDirectiveBodySyntax(SyntaxKind.RazorDirectiveBody, keyword, csharpCode);

393if (endOfFile.Kind is not (SyntaxKind.EndOfFile)) return ThrowHelper.ThrowArgumentException<RazorDocumentSyntax>(nameof(endOfFile), $"Invalid SyntaxKind. Expected 'SyntaxKind.EndOfFile', but it was {endOfFile.Kind}"); 399=> SyntaxFactory.RazorDocument(document, SyntaxFactory.Token(SyntaxKind.EndOfFile)); 404if (startCommentTransition.Kind is not (SyntaxKind.RazorCommentTransition)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(startCommentTransition), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentTransition', but it was {startCommentTransition.Kind}"); 405if (startCommentStar.Kind is not (SyntaxKind.RazorCommentStar)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(startCommentStar), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentStar', but it was {startCommentStar.Kind}"); 406if (comment.Kind is not (SyntaxKind.RazorCommentLiteral)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(comment), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentLiteral', but it was {comment.Kind}"); 407if (endCommentStar.Kind is not (SyntaxKind.RazorCommentStar)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(endCommentStar), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentStar', but it was {endCommentStar.Kind}"); 408if (endCommentTransition.Kind is not (SyntaxKind.RazorCommentTransition)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(endCommentTransition), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentTransition', but it was {endCommentTransition.Kind}"); 414=> SyntaxFactory.RazorCommentBlock(SyntaxFactory.Token(SyntaxKind.RazorCommentTransition), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition)); 495if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupAttributeBlockSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 501=> SyntaxFactory.MarkupAttributeBlock(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix); 505=> SyntaxFactory.MarkupAttributeBlock(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), default(RazorBlockSyntax), default(MarkupTextLiteralSyntax)); 545if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 546if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); 547if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 548if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash or SyntaxKind.None', but it was {forwardSlash.Kind}"); 549if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 555=> SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 559=> SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList<RazorSyntaxNode>), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 564if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 565if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); 566if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); 567if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 568if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 574=> SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 578=> SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 591if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 592if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); 593if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 594if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash or SyntaxKind.None', but it was {forwardSlash.Kind}"); 595if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 601=> SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 605=> SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList<RazorSyntaxNode>), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 610if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 611if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); 612if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); 613if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 614if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 620=> SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 624=> SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 630if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperAttributeSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 637=> SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 641=> SyntaxFactory.MarkupTagHelperAttribute(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); 667if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperDirectiveAttributeSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 674=> SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 678=> SyntaxFactory.MarkupTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax), default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); 703if (transition.Kind is not (SyntaxKind.Transition)) return ThrowHelper.ThrowArgumentException<CSharpTransitionSyntax>(nameof(transition), $"Invalid SyntaxKind. Expected 'SyntaxKind.Transition', but it was {transition.Kind}"); 709=> SyntaxFactory.CSharpTransition(SyntaxFactory.Token(SyntaxKind.Transition), chunkGenerator, editHandler);

20protected GreenNode(SyntaxKind kind) 25protected GreenNode(SyntaxKind kind, int width) 31protected GreenNode(SyntaxKind kind, RazorDiagnostic[]? diagnostics) 36protected GreenNode(SyntaxKind kind, int width, RazorDiagnostic[]? diagnostics) 58internal SyntaxKind Kind { get; }

10protected RazorSyntaxNode(SyntaxKind kind) : base(kind) 14protected RazorSyntaxNode(SyntaxKind kind, int width) 19protected RazorSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) 24protected RazorSyntaxNode(SyntaxKind kind, int width, RazorDiagnostic[] diagnostics)

10internal static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics) 20internal static SyntaxToken MissingToken(SyntaxKind kind, params RazorDiagnostic[] diagnostics)

14: base(SyntaxKind.List) 19: base(SyntaxKind.List, diagnostics)

154public bool Any(SyntaxKind kind)

80public bool Any(SyntaxKind kind)

76public bool Any(SyntaxKind kind)

11SyntaxKind kind, 70internal static SyntaxToken CreateMissing(SyntaxKind kind, params RazorDiagnostic[] diagnostics) 77internal MissingToken(SyntaxKind kind, RazorDiagnostic[] diagnostics)

18public bool CanBeCached(SyntaxKind kind, params RazorDiagnostic[] diagnostics) 21public SyntaxToken GetCachedToken(SyntaxKind kind, string content)

12public static SyntaxToken Token(SyntaxKind kind, params RazorDiagnostic[] diagnostics) 15public static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics) 19SyntaxKind kind, SyntaxNode? parent, int position, params RazorDiagnostic[] diagnostics) 23SyntaxKind kind, string content, SyntaxNode? parent, int position, params RazorDiagnostic[] diagnostics) 27SyntaxKind kind, SyntaxNode? parent, int position, int index, params RazorDiagnostic[] diagnostics) 31SyntaxKind kind, string content, SyntaxNode? parent, int position, int index, params RazorDiagnostic[] diagnostics) 34internal static SyntaxToken MissingToken(SyntaxKind kind, params RazorDiagnostic[] diagnostics)

551internal int IndexOf(SyntaxKind kind)

57if (token.Kind != SyntaxKind.None) 102if (token.Kind != SyntaxKind.None) 145if (token.Kind != SyntaxKind.None) 154if (token.Kind != SyntaxKind.None) 187if (token.Kind != SyntaxKind.None) 196if (token.Kind != SyntaxKind.None) 229if (token.Kind != SyntaxKind.None) 238if (token.Kind != SyntaxKind.None) 271if (token.Kind != SyntaxKind.None) 280if (token.Kind != SyntaxKind.None)

23public SyntaxKind Kind => Green.Kind; 448Debug.Assert(curNode.Kind is < SyntaxKind.FirstAvailableTokenKind and >= 0); 471if (includeWhitespace || foundToken.Kind is not (SyntaxKind.Whitespace or SyntaxKind.NewLine)) 495if (foundToken.Kind is SyntaxKind.None or SyntaxKind.NewLine) 506while (foundToken.Kind is SyntaxKind.Whitespace); 518if (currentToken.Kind == SyntaxKind.None || currentToken.Span.End > this.Span.End) 525while (currentToken is { Kind: SyntaxKind.NewLine or SyntaxKind.Whitespace });

58public SyntaxKind Kind => _token?.Kind ?? _nodeOrParent?.Kind ?? 0;

113if (isUpdating && visited.Kind != SyntaxKind.None)

230SyntaxKind.MarkupTextLiteral or 231SyntaxKind.MarkupEphemeralTextLiteral or 232SyntaxKind.MarkupStartTag or 233SyntaxKind.MarkupEndTag or 234SyntaxKind.MarkupTagHelperStartTag or 235SyntaxKind.MarkupTagHelperEndTag or 236SyntaxKind.MarkupAttributeBlock or 237SyntaxKind.MarkupMinimizedAttributeBlock or 238SyntaxKind.MarkupTagHelperAttribute or 239SyntaxKind.MarkupMinimizedTagHelperAttribute or 240SyntaxKind.MarkupLiteralAttributeValue or 241SyntaxKind.MarkupDynamicAttributeValue or 242SyntaxKind.CSharpStatementLiteral or 243SyntaxKind.CSharpExpressionLiteral or 244SyntaxKind.CSharpEphemeralTextLiteral or 245SyntaxKind.UnclassifiedTextLiteral;

50public SyntaxKind Kind => Node?.Kind ?? 0;

145internal int IndexOf(SyntaxKind kind)

98ForwardSlash: not { Kind: SyntaxKind.ForwardSlash, IsMissing: false }, 118ForwardSlash: not { Kind: SyntaxKind.ForwardSlash, IsMissing: false },

284SyntaxKind.MarkupElement or 285SyntaxKind.MarkupTagHelperElement or 286SyntaxKind.CSharpCodeBlock; 290|| node.Kind == SyntaxKind.MarkupBlock;

71if (owner.Kind != SyntaxKind.CSharpExpressionLiteral && owner.Kind != SyntaxKind.MarkupTextLiteral) 81var commonParent = owner.Kind == SyntaxKind.CSharpExpressionLiteral ? owner.Parent.Parent : owner.Parent;

15using SyntaxKind = AspNetCore.Razor.Language.SyntaxKind; 90Debug.Assert(previousToken.Kind != SyntaxKind.Marker);

67return token is { Kind: SyntaxKind.Identifier or SyntaxKind.Marker or SyntaxKind.Keyword } 68or { Kind: SyntaxKind.Transition, Parent.Kind: SyntaxKind.CSharpTransition };

210if (token.Kind == SyntaxKind.EndOfFile && 231return token.Kind is not (SyntaxKind.OpenAngle or SyntaxKind.CloseAngle);

185return token is { Kind: SyntaxKind.Identifier or SyntaxKind.Marker or SyntaxKind.Keyword } 186or { Kind: SyntaxKind.Transition, Parent.Kind: SyntaxKind.CSharpTransition };

174=> node?.Kind is SyntaxKind.CSharpExpressionLiteral 175or SyntaxKind.CSharpStatementLiteral 176or SyntaxKind.CSharpEphemeralTextLiteral;

92comment = SyntaxFactory.Token(SyntaxKind.Marker, parent: node, position: node.StartCommentStar.EndPosition);

227/// <param name="walkMarkersBack">When true, if there are multiple <see cref="SyntaxKind.Marker"/> tokens in a single location, return the parent node of the 239if (token.Kind == SyntaxKind.EndOfFile && node.Span.Contains(index - 1)) 246if (walkMarkersBack && token.Kind == SyntaxKind.Marker) 252if (previousToken.Kind != SyntaxKind.Marker || 333if (token.Kind != SyntaxKind.NewLine)

13=> token.Kind != SyntaxKind.None && !token.IsMissing; 28=> token.Kind is SyntaxKind.Whitespace or SyntaxKind.NewLine; 31=> token.Kind == SyntaxKind.Whitespace && token.Content == " "; 34=> token.Kind == SyntaxKind.Whitespace && token.Content == "\t"; 55=> token.Kind == SyntaxKind.Whitespace || (includingNewLines && token.Kind == SyntaxKind.NewLine);

41if (children.FirstOrDefault(static c => c.Kind == SyntaxKind.RazorMetaCode) is RazorMetaCodeSyntax metaCode) 43var token = metaCode.MetaCode.SingleOrDefault(static m => m.Kind == SyntaxKind.LeftBrace); 59if (children.LastOrDefault(static c => c.Kind == SyntaxKind.RazorMetaCode) is RazorMetaCodeSyntax metaCode) 61var token = metaCode.MetaCode.SingleOrDefault(static m => m.Kind == SyntaxKind.RightBrace); 77var token = metacode.MetaCode.SingleOrDefault(static m => m.Kind == SyntaxKind.LeftBrace); 93var token = metacode.MetaCode.SingleOrDefault(static m => m.Kind == SyntaxKind.RightBrace);

33LiteralTokens: [{ Kind: SyntaxKind.Keyword }, ..]

489if (node.LiteralTokens is not [{ Kind: SyntaxKind.Marker }])

351(_previousCurrentToken.Kind != SyntaxKind.Transition || previousLineStartedWithAttributeName)) 491if (lastToken.GetNextToken() is { Kind: SyntaxKind.Transition } token && 677if (node.MetaCode is [{ Kind: SyntaxKind.Transition }, ..]) 686MetaCode: [{ Kind: SyntaxKind.RightParenthesis } paren] 865if (_currentToken.Kind == SyntaxKind.RazorCommentTransition)

440codeNode.GetLastToken(includeZeroWidth: false) is not { Kind: SyntaxKind.NewLine })

18using RazorSyntaxKind = Microsoft.AspNetCore.Razor.Language.SyntaxKind; 139return node.Kind is RazorSyntaxKind.MarkupTagHelperStartTag or RazorSyntaxKind.MarkupTagHelperEndTag;

45if (owner.Kind is SyntaxKind.MarkupTextLiteral) 159case SyntaxKind.MarkupTagHelperDirectiveAttribute: 165case SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute:

51a => a.Kind is SyntaxKind.MarkupTagHelperElement || a.Kind is SyntaxKind.MarkupElement);

173=> n.Kind is SyntaxKind.MarkupStartTag or SyntaxKind.MarkupTagHelperStartTag; 176=> n.Kind is SyntaxKind.MarkupEndTag or SyntaxKind.MarkupTagHelperEndTag;

155case SyntaxKind.MarkupTextLiteral: 203CSharpExpressionLiteralSyntax { LiteralTokens: [{ Kind: SyntaxKind.LeftParenthesis } openParen] }, 205CSharpExpressionLiteralSyntax { LiteralTokens: [{ Kind: SyntaxKind.RightParenthesis } closeParen] }, 263if (node.Kind == SyntaxKind.RazorMetaCode) 276if (node.Keyword.Kind != SyntaxKind.CSharpStatementLiteral) 387if (child.Kind == SyntaxKind.MarkupTextLiteral)

361var csharpToken = SyntaxFactory.Token(SyntaxKind.Keyword, "in"); 374var csharpToken = SyntaxFactory.Token(SyntaxKind.Identifier, "model"); 387var csharpToken = SyntaxFactory.Token(SyntaxKind.Marker, string.Empty); 400var token = SyntaxFactory.Token(SyntaxKind.Text, string.Empty); 413var csharpToken = SyntaxFactory.Token(SyntaxKind.Tilde, "~");

71[InlineData(0, 1, SyntaxKind.CSharpTransition, false)] 72[InlineData(0, 1, SyntaxKind.CSharpTransition, true)] 73[InlineData(1, 5, SyntaxKind.CSharpExpressionLiteral, false)] 74[InlineData(1, 5, SyntaxKind.CSharpExpressionLiteral, true)] 75[InlineData(5, 20, SyntaxKind.MarkupTextLiteral, true)] 76[InlineData(20, 21, SyntaxKind.CSharpTransition, false)] 77[InlineData(20, 21, SyntaxKind.CSharpTransition, true)] 78[InlineData(21, 41, SyntaxKind.CSharpStatementLiteral, false)] 79[InlineData(21, 41, SyntaxKind.CSharpStatementLiteral, true)] 80[InlineData(41, 43, SyntaxKind.RazorMetaCode, true)] 81[InlineData(43, 44, SyntaxKind.CSharpTransition, false)] 82[InlineData(43, 44, SyntaxKind.CSharpTransition, true)] 83[InlineData(44, 50, SyntaxKind.CSharpExpressionLiteral, false)] 84[InlineData(44, 50, SyntaxKind.CSharpExpressionLiteral, true)] 85[InlineData(50, 93, SyntaxKind.MarkupTextLiteral, true)] 86[InlineData(93, 104, SyntaxKind.MarkupStartTag, false)] 87[InlineData(93, 104, SyntaxKind.MarkupStartTag, true)] 88[InlineData(104, 120, SyntaxKind.MarkupTextLiteral, false)] 89[InlineData(104, 120, SyntaxKind.MarkupTextLiteral, true)] 90[InlineData(120, 132, SyntaxKind.MarkupEndTag, false)] 91[InlineData(120, 132, SyntaxKind.MarkupEndTag, true)] 92[InlineData(132, 136, SyntaxKind.MarkupTextLiteral, true)] 93[InlineData(136, 140, SyntaxKind.MarkupStartTag, false)] 94[InlineData(136, 140, SyntaxKind.MarkupStartTag, true)] 95[InlineData(140, 156, SyntaxKind.MarkupTextLiteral, false)] 96[InlineData(140, 156, SyntaxKind.MarkupTextLiteral, true)] 97[InlineData(156, 161, SyntaxKind.MarkupEndTag, false)] 98[InlineData(156, 161, SyntaxKind.MarkupEndTag, true)] 99[InlineData(161, 165, SyntaxKind.MarkupTextLiteral, true)] 100[InlineData(165, 168, SyntaxKind.MarkupStartTag, false)] 101[InlineData(165, 168, SyntaxKind.MarkupStartTag, true)] 102[InlineData(168, 225, SyntaxKind.MarkupTextLiteral, false)] 103[InlineData(168, 225, SyntaxKind.MarkupTextLiteral, true)] 104[InlineData(225, 229, SyntaxKind.MarkupEndTag, false)] 105[InlineData(225, 229, SyntaxKind.MarkupEndTag, true)] 106[InlineData(229, 233, SyntaxKind.MarkupTextLiteral, true)] 107[InlineData(233, 234, SyntaxKind.CSharpTransition, false)] 108[InlineData(233, 234, SyntaxKind.CSharpTransition, true)] 109[InlineData(234, 261, SyntaxKind.CSharpStatementLiteral, false)] 110[InlineData(234, 261, SyntaxKind.CSharpStatementLiteral, true)] 111[InlineData(265, 268, SyntaxKind.MarkupStartTag, false)] 112[InlineData(261, 265, SyntaxKind.MarkupTextLiteral, true)] 113[InlineData(265, 268, SyntaxKind.MarkupStartTag, true)] 114[InlineData(268, 272, SyntaxKind.MarkupStartTag, false)] 115[InlineData(268, 272, SyntaxKind.MarkupStartTag, true)] 116[InlineData(272, 282, SyntaxKind.MarkupTextLiteral, false)] 117[InlineData(272, 282, SyntaxKind.MarkupTextLiteral, true)] 118[InlineData(282, 287, SyntaxKind.MarkupEndTag, false)] 119[InlineData(282, 287, SyntaxKind.MarkupEndTag, true)] 120[InlineData(287, 291, SyntaxKind.MarkupEndTag, false)] 121[InlineData(287, 291, SyntaxKind.MarkupEndTag, true)] 122[InlineData(291, 293, SyntaxKind.MarkupTextLiteral, true)] 123[InlineData(293, 305, SyntaxKind.CSharpStatementLiteral, false)] 124[InlineData(293, 305, SyntaxKind.CSharpStatementLiteral, true)] 125[InlineData(309, 330, SyntaxKind.MarkupStartTag, false)] 126[InlineData(305, 309, SyntaxKind.MarkupTextLiteral, true)] 127[InlineData(309, 330, SyntaxKind.MarkupStartTag, true)] 128[InlineData(315, 316, SyntaxKind.MarkupTextLiteral, true)] 129[InlineData(316, 321, SyntaxKind.MarkupTextLiteral, false)] 130[InlineData(316, 321, SyntaxKind.MarkupTextLiteral, true)] 131[InlineData(315, 329, SyntaxKind.MarkupAttributeBlock, true)] 132[InlineData(322, 323, SyntaxKind.MarkupTextLiteral, false)] 133[InlineData(322, 323, SyntaxKind.MarkupTextLiteral, true)] 134[InlineData(323, 328, SyntaxKind.MarkupTextLiteral, false)] 135[InlineData(323, 328, SyntaxKind.MarkupTextLiteral, true)] 136[InlineData(328, 329, SyntaxKind.MarkupTextLiteral, false)] 137[InlineData(328, 329, SyntaxKind.MarkupTextLiteral, true)] 138[InlineData(330, 340, SyntaxKind.MarkupTextLiteral, true)] 139[InlineData(340, 347, SyntaxKind.MarkupStartTag, false)] 140[InlineData(340, 347, SyntaxKind.MarkupStartTag, true)] 141[InlineData(347, 361, SyntaxKind.MarkupTextLiteral, true)] 142[InlineData(361, 365, SyntaxKind.MarkupStartTag, false)] 143[InlineData(361, 365, SyntaxKind.MarkupStartTag, true)] 144[InlineData(365, 383, SyntaxKind.MarkupTextLiteral, true)] 145[InlineData(383, 387, SyntaxKind.MarkupStartTag, false)] 146[InlineData(383, 387, SyntaxKind.MarkupStartTag, true)] 147[InlineData(387, 391, SyntaxKind.MarkupTextLiteral, false)] 148[InlineData(387, 391, SyntaxKind.MarkupTextLiteral, true)] 149[InlineData(391, 396, SyntaxKind.MarkupEndTag, false)] 150[InlineData(391, 396, SyntaxKind.MarkupEndTag, true)] 151[InlineData(396, 414, SyntaxKind.MarkupTextLiteral, true)] 152[InlineData(414, 418, SyntaxKind.MarkupStartTag, false)] 153[InlineData(414, 418, SyntaxKind.MarkupStartTag, true)] 154[InlineData(418, 427, SyntaxKind.MarkupTextLiteral, false)] 155[InlineData(418, 427, SyntaxKind.MarkupTextLiteral, true)] 156[InlineData(427, 432, SyntaxKind.MarkupEndTag, false)] 157[InlineData(427, 432, SyntaxKind.MarkupEndTag, true)] 158[InlineData(432, 450, SyntaxKind.MarkupTextLiteral, true)] 159[InlineData(450, 454, SyntaxKind.MarkupStartTag, false)] 160[InlineData(450, 454, SyntaxKind.MarkupStartTag, true)] 161[InlineData(454, 463, SyntaxKind.MarkupTextLiteral, false)] 162[InlineData(454, 463, SyntaxKind.MarkupTextLiteral, true)] 163[InlineData(463, 468, SyntaxKind.MarkupEndTag, false)] 164[InlineData(463, 468, SyntaxKind.MarkupEndTag, true)] 165[InlineData(468, 486, SyntaxKind.MarkupTextLiteral, true)] 166[InlineData(486, 490, SyntaxKind.MarkupStartTag, false)] 167[InlineData(486, 490, SyntaxKind.MarkupStartTag, true)] 168[InlineData(490, 497, SyntaxKind.MarkupTextLiteral, false)] 169[InlineData(490, 497, SyntaxKind.MarkupTextLiteral, true)] 170[InlineData(497, 502, SyntaxKind.MarkupEndTag, false)] 171[InlineData(497, 502, SyntaxKind.MarkupEndTag, true)] 172[InlineData(502, 516, SyntaxKind.MarkupTextLiteral, true)] 173[InlineData(516, 521, SyntaxKind.MarkupEndTag, false)] 174[InlineData(516, 521, SyntaxKind.MarkupEndTag, true)] 175[InlineData(521, 531, SyntaxKind.MarkupTextLiteral, true)] 176[InlineData(531, 539, SyntaxKind.MarkupEndTag, false)] 177[InlineData(531, 539, SyntaxKind.MarkupEndTag, true)] 178[InlineData(539, 549, SyntaxKind.MarkupTextLiteral, true)] 179[InlineData(549, 556, SyntaxKind.MarkupStartTag, false)] 180[InlineData(549, 556, SyntaxKind.MarkupStartTag, true)] 181[InlineData(556, 558, SyntaxKind.MarkupTextLiteral, true)] 182[InlineData(570, 571, SyntaxKind.CSharpTransition, false)] 183[InlineData(558, 570, SyntaxKind.CSharpStatementLiteral, true)] 184[InlineData(570, 571, SyntaxKind.CSharpTransition, true)] 185[InlineData(571, 623, SyntaxKind.CSharpStatementLiteral, false)] 186[InlineData(571, 623, SyntaxKind.CSharpStatementLiteral, true)] 187[InlineData(639, 643, SyntaxKind.MarkupStartTag, false)] 188[InlineData(623, 639, SyntaxKind.MarkupTextLiteral, true)] 189[InlineData(639, 643, SyntaxKind.MarkupStartTag, true)] 190[InlineData(643, 665, SyntaxKind.MarkupTextLiteral, true)] 191[InlineData(665, 669, SyntaxKind.MarkupStartTag, false)] 192[InlineData(665, 669, SyntaxKind.MarkupStartTag, true)] 193[InlineData(669, 670, SyntaxKind.CSharpTransition, false)] 194[InlineData(669, 670, SyntaxKind.CSharpTransition, true)] 195[InlineData(670, 703, SyntaxKind.CSharpExpressionLiteral, false)] 196[InlineData(670, 703, SyntaxKind.CSharpExpressionLiteral, true)] 197[InlineData(703, 708, SyntaxKind.MarkupEndTag, false)] 198[InlineData(703, 708, SyntaxKind.MarkupEndTag, true)] 199[InlineData(708, 730, SyntaxKind.MarkupTextLiteral, true)] 200[InlineData(730, 734, SyntaxKind.MarkupStartTag, false)] 201[InlineData(730, 734, SyntaxKind.MarkupStartTag, true)] 202[InlineData(734, 735, SyntaxKind.CSharpTransition, false)] 203[InlineData(734, 735, SyntaxKind.CSharpTransition, true)] 204[InlineData(735, 756, SyntaxKind.CSharpExpressionLiteral, false)] 205[InlineData(735, 756, SyntaxKind.CSharpExpressionLiteral, true)] 206[InlineData(756, 761, SyntaxKind.MarkupEndTag, false)] 207[InlineData(756, 761, SyntaxKind.MarkupEndTag, true)] 208[InlineData(761, 783, SyntaxKind.MarkupTextLiteral, true)] 209[InlineData(783, 787, SyntaxKind.MarkupStartTag, false)] 210[InlineData(783, 787, SyntaxKind.MarkupStartTag, true)] 211[InlineData(787, 788, SyntaxKind.CSharpTransition, false)] 212[InlineData(787, 788, SyntaxKind.CSharpTransition, true)] 213[InlineData(788, 809, SyntaxKind.CSharpExpressionLiteral, false)] 214[InlineData(788, 809, SyntaxKind.CSharpExpressionLiteral, true)] 215[InlineData(809, 814, SyntaxKind.MarkupEndTag, false)] 216[InlineData(809, 814, SyntaxKind.MarkupEndTag, true)] 217[InlineData(814, 836, SyntaxKind.MarkupTextLiteral, true)] 218[InlineData(836, 840, SyntaxKind.MarkupStartTag, false)] 219[InlineData(836, 840, SyntaxKind.MarkupStartTag, true)] 220[InlineData(840, 841, SyntaxKind.CSharpTransition, false)] 221[InlineData(840, 841, SyntaxKind.CSharpTransition, true)] 222[InlineData(841, 857, SyntaxKind.CSharpExpressionLiteral, false)] 223[InlineData(841, 857, SyntaxKind.CSharpExpressionLiteral, true)] 224[InlineData(857, 862, SyntaxKind.MarkupEndTag, false)] 225[InlineData(857, 862, SyntaxKind.MarkupEndTag, true)] 226[InlineData(862, 880, SyntaxKind.MarkupTextLiteral, true)] 227[InlineData(880, 885, SyntaxKind.MarkupEndTag, false)] 228[InlineData(880, 885, SyntaxKind.MarkupEndTag, true)] 229[InlineData(885, 887, SyntaxKind.MarkupTextLiteral, true)] 230[InlineData(887, 902, SyntaxKind.CSharpStatementLiteral, false)] 231[InlineData(887, 902, SyntaxKind.CSharpStatementLiteral, true)] 232[InlineData(910, 918, SyntaxKind.MarkupEndTag, false)] 233[InlineData(902, 910, SyntaxKind.MarkupTextLiteral, true)] 234[InlineData(910, 918, SyntaxKind.MarkupEndTag, true)] 235[InlineData(918, 924, SyntaxKind.MarkupTextLiteral, true)] 236[InlineData(924, 932, SyntaxKind.MarkupEndTag, false)] 237[InlineData(924, 932, SyntaxKind.MarkupEndTag, true)] 238[InlineData(932, 934, SyntaxKind.MarkupTextLiteral, true)] 239[InlineData(934, 937, SyntaxKind.CSharpStatementLiteral, false)] 240[InlineData(934, 937, SyntaxKind.CSharpStatementLiteral, true)] 241[InlineData(939, 940, SyntaxKind.CSharpTransition, false)] 242[InlineData(937, 939, SyntaxKind.MarkupTextLiteral, true)] 243[InlineData(939, 940, SyntaxKind.CSharpTransition, true)] 244[InlineData(940, 944, SyntaxKind.CSharpExpressionLiteral, false)] 245[InlineData(940, 944, SyntaxKind.CSharpExpressionLiteral, true)] 246[InlineData(944, 1162, SyntaxKind.MarkupTextLiteral, true)] 247[InlineData(0, 1162, SyntaxKind.MarkupBlock, false)] 248internal void Test_On_FetchData(int start, int end, SyntaxKind kind, bool includeWhitespace) 251private static void Verify(string input, int start, int end, SyntaxKind kind, bool includeWhitespace, bool innermostForTie)