564if (node.EqualsToken.Kind == SyntaxKind.None && node.Value == null) 570if (lastToken.Kind != SyntaxKind.None) 978else if (node.EqualsToken.Kind != SyntaxKind.None) 1540if (node.LiteralTokens is [{ Kind: SyntaxKind.Marker, Content.Length: 0 }]) 1930tokens is [{ Kind: SyntaxKind.Transition }, ..] && 1931(tokens.Count == 1 || tokens[1].Kind != SyntaxKind.Transition); 1971if (node.LiteralTokens is [{ Kind: SyntaxKind.Marker, Content.Length: 0 }])

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

296if (At(SyntaxKind.StringLiteral) && 300var split = Language.SplitToken(CurrentToken, 1, SyntaxKind.Transition); 307else if (At(SyntaxKind.Transition)) 314transitionToken = SyntaxFactory.MissingToken(SyntaxKind.Transition); 321if (At(SyntaxKind.LeftBrace)) 331else if (At(SyntaxKind.LeftParenthesis)) 341else if (At(SyntaxKind.Identifier)) 366else if (At(SyntaxKind.Keyword)) 410if (At(SyntaxKind.Whitespace) || At(SyntaxKind.NewLine)) 447Assert(SyntaxKind.LeftParenthesis); 461SyntaxKind.LeftParenthesis, 462SyntaxKind.RightParenthesis, 467AcceptUntil(SyntaxKind.LessThan); 481if (At(SyntaxKind.RightParenthesis)) 487var missingToken = SyntaxFactory.MissingToken(SyntaxKind.RightParenthesis); 553if (CurrentToken.Kind == SyntaxKind.LeftParenthesis || 554CurrentToken.Kind == SyntaxKind.LeftBracket) 559SyntaxKind right; 574AcceptUntil(SyntaxKind.LessThan); 585if (At(SyntaxKind.QuestionMark)) 591if (next.Kind == SyntaxKind.Dot) 598return At(SyntaxKind.Identifier) || At(SyntaxKind.Keyword); 600else if (next.Kind == SyntaxKind.LeftBracket) 610else if (At(SyntaxKind.Not) && Context.Options.AllowNullableForgivenessOperator) 624if (next.Kind == SyntaxKind.Dot) 633if (nextNext.Kind == SyntaxKind.Identifier || nextNext.Kind == SyntaxKind.Keyword) 651else if (next.Kind == SyntaxKind.QuestionMark) 658else if (next.Kind == SyntaxKind.LeftBracket || next.Kind == SyntaxKind.LeftParenthesis) 669else if (At(SyntaxKind.Dot)) 674if (At(SyntaxKind.Identifier) || At(SyntaxKind.Keyword)) 696else if (!At(SyntaxKind.Whitespace) && !At(SyntaxKind.NewLine)) 708Assert(SyntaxKind.LeftBrace); 710var leftBrace = OutputAsMetaCode(EatExpectedToken(SyntaxKind.LeftBrace)); 735acceptCloseBraceAccessor.CanAcceptCloseBrace = !At(SyntaxKind.RightBrace); 743if (At(SyntaxKind.RightBrace)) 750SyntaxFactory.MissingToken(SyntaxKind.RightBrace), 757if (At(SyntaxKind.NewLine) || 758(At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.NewLine))) 770while (!EndOfFile && !At(SyntaxKind.RightBrace)) 788var lastWhitespace = tokens is [.., { Kind: SyntaxKind.Whitespace } whitespace] ? whitespace : null; 809var kind = CurrentToken.Kind; 813var isSingleLineMarkup = kind == SyntaxKind.Transition && 814(NextIs(SyntaxKind.Colon, SyntaxKind.DoubleColon)); 817kind == SyntaxKind.LessThan || 818(kind == SyntaxKind.Transition && NextIs(SyntaxKind.LessThan)); 850if (kind == SyntaxKind.Transition && !isSingleLineMarkup) 866case SyntaxKind.RazorCommentTransition: 873case SyntaxKind.LeftBrace: 891Assert(SyntaxKind.RightBrace); 896case SyntaxKind.Keyword: 902case SyntaxKind.Transition: 906case SyntaxKind.RightBrace: 909case SyntaxKind.CSharpComment: 924Assert(SyntaxKind.Transition); 928if (At(SyntaxKind.Transition)) 938Assert(SyntaxKind.Transition); 945if (At(SyntaxKind.LeftBrace)) 991token.Kind is not SyntaxKind.Semicolon and 992not SyntaxKind.RazorCommentTransition and 993not SyntaxKind.Transition and 994not SyntaxKind.LeftBrace and 995not SyntaxKind.LeftParenthesis and 996not SyntaxKind.LeftBracket and 997not SyntaxKind.RightBrace and 998not SyntaxKind.Keyword, 1001if ((!Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) || 1002At(SyntaxKind.LeftParenthesis) || 1003At(SyntaxKind.LeftBracket)) 1011else if (Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) 1016else if (At(SyntaxKind.Transition)) 1025case SyntaxKind.LessThan: 1026case SyntaxKind.Colon: 1032case SyntaxKind.Keyword when encounteredUnexpectedMarkupTransition: 1043case SyntaxKind.Identifier: 1044case SyntaxKind.Keyword: 1053case SyntaxKind.Transition: 1054if (Lookahead(2) is not { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 1070Debug.Assert(transition.Kind == SyntaxKind.Transition); 1077var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, transition.Content); 1082else if (At(SyntaxKind.RazorCommentTransition)) 1090else if (At(SyntaxKind.Semicolon)) 1096else if (At(SyntaxKind.RightBrace)) 1101else if (At(SyntaxKind.Keyword)) 1106AcceptUntil(SyntaxKind.LeftBrace); 1109if (!At(SyntaxKind.LeftBrace)) 1132AcceptUntil(SyntaxKind.LessThan, SyntaxKind.LeftBrace, SyntaxKind.RightBrace); 1147TryAccept(SyntaxKind.RightBrace); 1152AcceptUntil(SyntaxKind.LessThan, SyntaxKind.RightBrace); 1328Debug.Assert(CurrentToken.Kind == SyntaxKind.Identifier || CurrentToken.Kind == SyntaxKind.Keyword); 1355var foundWhitespace = At(SyntaxKind.Whitespace); 1363AcceptWhile(SyntaxKind.Whitespace); 1368if (EndOfFile || At(SyntaxKind.NewLine)) 1383AcceptUntil(SyntaxKind.NewLine); 1444TokenBuilder[0] is SyntaxToken { Kind: SyntaxKind.StringLiteral } token) 1591if (!At(SyntaxKind.Whitespace) && 1592!At(SyntaxKind.NewLine) && 1593!At(SyntaxKind.Semicolon) && 1601builder.Add(BuildDirective(SyntaxKind.Whitespace)); 1607if (At(SyntaxKind.Whitespace)) 1624if (EndOfFile || At(SyntaxKind.NewLine)) 1644if (tokenDescriptor.Optional && (EndOfFile || At(SyntaxKind.NewLine))) 1655builder.Add(BuildDirective(SyntaxKind.Identifier)); 1668builder.Add(BuildDirective(SyntaxKind.Identifier)); 1680builder.Add(BuildDirective(SyntaxKind.Identifier)); 1686if (At(SyntaxKind.Identifier)) 1696builder.Add(BuildDirective(SyntaxKind.Identifier)); 1702if (At(SyntaxKind.StringLiteral) && !CurrentToken.ContainsDiagnostics) 1711builder.Add(BuildDirective(SyntaxKind.StringLiteral)); 1726builder.Add(BuildDirective(SyntaxKind.CSharpExpressionLiteral)); 1732if (At(SyntaxKind.LeftBracket)) 1736TryAccept(SyntaxKind.RightBracket); 1744builder.Add(BuildDirective(SyntaxKind.LeftBracket)); 1750if (At(SyntaxKind.Keyword) && 1755AcceptWhile(SyntaxKind.Whitespace); 1765builder.Add(BuildDirective(SyntaxKind.Identifier)); 1770while (!At(SyntaxKind.NewLine)) 1772if (At(SyntaxKind.Semicolon)) 1786else if (At(SyntaxKind.Semicolon)) 1798builder.Add(BuildDirective(SyntaxKind.Keyword)); 1805if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.LeftParenthesis)) 1819builder.Add(BuildDirective(SyntaxKind.Identifier)); 1844TryAccept(SyntaxKind.Semicolon); 1849if (At(SyntaxKind.NewLine)) 1924Balance(childBuilder, BalancingModes.NoErrorOnFailure, SyntaxKind.LeftBrace, SyntaxKind.RightBrace, startingBraceLocation); 1939builder.Add(BuildDirective(SyntaxKind.Identifier)); 1947BaseRazorDirectiveSyntax BuildDirective(SyntaxKind expectedTokenKindIfMissing) 2001var type = token.Kind; 2002if ((expectingDot && type == SyntaxKind.Dot) || 2003(!expectingDot && type == SyntaxKind.Identifier)) 2009if (type != SyntaxKind.Whitespace && 2010type != SyntaxKind.NewLine) 2081SyntaxFactory.Token(SyntaxKind.Text, content), 2191else if (!At(SyntaxKind.LeftBrace)) 2220if (!TryAccept(SyntaxKind.RightBrace)) 2227Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBrace)); 2250Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2267Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2327Assert(SyntaxKind.Keyword); 2357if (At(SyntaxKind.LeftParenthesis)) 2362AcceptUntil(SyntaxKind.NewLine); 2366TryAccept(SyntaxKind.RightParenthesis); 2382if (At(SyntaxKind.LessThan)) 2390else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Colon)) 2398else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Transition)) 2414Assert(SyntaxKind.Keyword); 2423Assert(SyntaxKind.Keyword); 2433while (EnsureCurrent() && CurrentToken.Kind != SyntaxKind.Colon) 2437case SyntaxKind.LeftBrace: 2438case SyntaxKind.LeftParenthesis: 2439case SyntaxKind.LeftBracket: 2448TryAccept(SyntaxKind.Colon); 2619if (TryParseCondition(builder) && TryAccept(SyntaxKind.Semicolon)) 2639var atLeftParen = At(SyntaxKind.LeftParenthesis); 2640var atIdentifier = At(SyntaxKind.Identifier); 2707Assert(SyntaxKind.LeftParenthesis); 2736if (At(SyntaxKind.Identifier) || At(CSharpSyntaxKind.GlobalKeyword)) 2743if (At(SyntaxKind.Assign)) 2747Assert(SyntaxKind.Assign); 2779hasExplicitSemicolon = TryAccept(SyntaxKind.Semicolon); 2795token.Kind != SyntaxKind.CSharpComment && 2796token.Kind != SyntaxKind.Whitespace && 2797token.Kind != SyntaxKind.NewLine) 2821if (TryAccept(SyntaxKind.LeftParenthesis)) 2823while (!TryAccept(SyntaxKind.RightParenthesis) && !EndOfFile) 2825TryAccept(SyntaxKind.Whitespace); 2832TryAccept(SyntaxKind.Whitespace); 2833TryAccept(SyntaxKind.Identifier); 2834TryAccept(SyntaxKind.Whitespace); 2835TryAccept(SyntaxKind.Comma); 2838if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2844TryAccept(SyntaxKind.QuestionMark); // Nullable 2848else if (TryAccept(SyntaxKind.Identifier) || TryAccept(SyntaxKind.Keyword)) 2850if (TryAccept(SyntaxKind.DoubleColon)) 2852if (!TryAccept(SyntaxKind.Identifier)) 2854TryAccept(SyntaxKind.Keyword); 2857if (At(SyntaxKind.LessThan)) 2861if (TryAccept(SyntaxKind.Dot)) 2866if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2872TryAccept(SyntaxKind.QuestionMark); // Nullable 2874if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.LeftBracket)) 2880while (At(SyntaxKind.LeftBracket)) 2883if (!TryAccept(SyntaxKind.RightBracket)) 2885Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBracket)); 2898Assert(SyntaxKind.LessThan); 2900if (!TryAccept(SyntaxKind.GreaterThan)) 2902Accept(SyntaxFactory.MissingToken(SyntaxKind.GreaterThan)); 2920transition = transition ?? SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 2941ReadWhile(static token => token.Kind == SyntaxKind.Whitespace, ref whitespace.AsRef()); 2942if (At(SyntaxKind.NewLine)) 2969if (At(SyntaxKind.RazorCommentTransition)) 3084var left = CurrentToken.Kind; 3085var right = Language.FlipBracket(left); 3100private bool Balance(SyntaxListBuilder<RazorSyntaxNode> builder, BalancingModes mode, SyntaxKind left, SyntaxKind right, SourceLocation start) 3106!(stopAtEndOfLine && At(SyntaxKind.NewLine))) 3126if (At(SyntaxKind.Transition)) 3131if (NextIs(SyntaxKind.Transition) && Lookahead(2) is { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 3143else if (NextIs(SyntaxKind.Keyword, SyntaxKind.Identifier)) 3189while (nesting > 0 && EnsureCurrent() && !(stopAtEndOfLine && At(SyntaxKind.NewLine))); 3224&& NextIs(SyntaxKind.LessThan, SyntaxKind.Colon, SyntaxKind.DoubleColon)) 3255Debug.Assert(CurrentToken.Kind == SyntaxKind.Transition); 3258Debug.Assert(CurrentToken.Kind is SyntaxKind.Identifier or SyntaxKind.Keyword); 3262var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, $"{transition.Content}{identifier.Content}"); 3270Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && 3278if (!At(SyntaxKind.Keyword) || result is not { } keywordKind) 3297if (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)

23SyntaxFactory.Token(SyntaxKind.Text, "-"), 24SyntaxFactory.Token(SyntaxKind.Bang, "!"), 25SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"), 125return SyntaxFactory.RazorDocument(markup, SyntaxFactory.Token(SyntaxKind.EndOfFile, "", Array.Empty<RazorDiagnostic>())); 167if (At(SyntaxKind.OpenAngle)) 171else if (At(SyntaxKind.Transition)) 380static f => (f.Kind == SyntaxKind.Whitespace) || (f.Kind == SyntaxKind.NewLine), 384if (!(At(SyntaxKind.OpenAngle) || 385(At(SyntaxKind.Transition) && Lookahead(count: 1).Content.StartsWith(":", StringComparison.Ordinal)))) 398AcceptWhile(SyntaxKind.Whitespace); 399TryAccept(SyntaxKind.NewLine); 419Assert(SyntaxKind.Transition); 428if (CurrentToken.Kind == SyntaxKind.Text && CurrentToken.Content.Length > 0 && CurrentToken.Content[0] == ':') 431var split = Language.SplitToken(CurrentToken, 1, SyntaxKind.Colon); 444else if (CurrentToken.Kind == SyntaxKind.OpenAngle) 468ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 469if (At(SyntaxKind.Whitespace)) 473} while (!EndOfFile && CurrentToken.Kind != SyntaxKind.NewLine); 479if (!EndOfFile && CurrentToken.Kind == SyntaxKind.NewLine) 493Assert(SyntaxKind.OpenAngle); 498if (!NextIs(SyntaxKind.ForwardSlash)) 652Assert(SyntaxKind.OpenAngle); 661if (At(SyntaxKind.Text)) 683At(SyntaxKind.CloseAngle)) 691var tagNameToken = At(SyntaxKind.Text) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.Text); 704if (At(SyntaxKind.ForwardSlash)) 711var closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 714if (EndOfFile || !At(SyntaxKind.CloseAngle)) 726if (At(SyntaxKind.CloseAngle)) 748if (At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.ForwardSlash)) 751Assert(SyntaxKind.ForwardSlash); 753if (!At(SyntaxKind.Text) || !string.Equals(CurrentToken.Content, tagName, StringComparison.OrdinalIgnoreCase)) 771else if (At(SyntaxKind.CloseAngle)) 816Assert(SyntaxKind.Text); 829if (At(SyntaxKind.CloseAngle) || 830(At(SyntaxKind.ForwardSlash) && NextIs(SyntaxKind.CloseAngle))) 832if (At(SyntaxKind.ForwardSlash)) 869AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.NewLine); 873if (At(SyntaxKind.CloseAngle)) 879closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 886Assert(SyntaxKind.OpenAngle); 892var forwardSlashToken = At(SyntaxKind.ForwardSlash) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.ForwardSlash); 896if (At(SyntaxKind.Text)) 927tagNameToken = SyntaxFactory.MissingToken(SyntaxKind.Text); 942AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 945if (At(SyntaxKind.CloseAngle)) 958if (At(SyntaxKind.CloseAngle)) 964closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 984Assert(SyntaxKind.Text); 993if (!At(SyntaxKind.CloseAngle)) 1030if (!At(SyntaxKind.Whitespace) && !At(SyntaxKind.NewLine)) 1041if (At(SyntaxKind.ForwardSlash)) 1054if (At(SyntaxKind.ForwardSlash)) 1056if (NextIs(SyntaxKind.CloseAngle) || NextIs(SyntaxKind.OpenAngle)) 1062return At(SyntaxKind.CloseAngle) || At(SyntaxKind.OpenAngle); 1078case SyntaxKind.SingleQuote: 1079case SyntaxKind.DoubleQuote: 1081var openQuoteKind = CurrentToken.Kind; 1090case SyntaxKind.OpenAngle: // Another "<" means this tag is invalid. 1091case SyntaxKind.ForwardSlash: // Empty tag 1092case SyntaxKind.CloseAngle: // End of tag 1135static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1191var atMinimizedAttribute = !TokenExistsAfterWhitespace(SyntaxKind.Equals); 1223if (At(SyntaxKind.RazorCommentTransition)) 1231if (At(SyntaxKind.Transition)) 1233if (NextIs(SyntaxKind.Transition)) 1256token.Kind != SyntaxKind.Whitespace && 1257token.Kind != SyntaxKind.NewLine && 1258token.Kind != SyntaxKind.Equals && 1259token.Kind != SyntaxKind.CloseAngle && 1260token.Kind != SyntaxKind.OpenAngle && 1261(token.Kind != SyntaxKind.Transition || !self.Context.Options.AllowCSharpInMarkupAttributeArea) && 1262(token.Kind != SyntaxKind.ForwardSlash || !self.NextIs(SyntaxKind.CloseAngle)), 1276AcceptWhile(static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 1279Assert(SyntaxKind.Equals); // We should be at "=" 1284static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1286var quote = SyntaxKind.Marker; 1287if (At(SyntaxKind.SingleQuote) || At(SyntaxKind.DoubleQuote)) 1325if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1344if (quote != SyntaxKind.Marker && At(quote)) 1350else if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1356if (quote != SyntaxKind.Marker) 1370private RazorBlockSyntax ParseNonConditionalAttributeValue(SyntaxKind quote) 1387private void ParseConditionalAttributeValue(in SyntaxListBuilder<RazorSyntaxNode> builder, SyntaxKind quote) 1392static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1395if (At(SyntaxKind.Transition)) 1397if (NextIs(SyntaxKind.Transition)) 1465token.Kind != SyntaxKind.Whitespace && 1466token.Kind != SyntaxKind.NewLine && 1467token.Kind != SyntaxKind.Transition && 1482private bool IsEndOfAttributeValue(SyntaxKind quote, SyntaxToken token) 1485(quote != SyntaxKind.Marker 1495return token.Kind == SyntaxKind.DoubleQuote || 1496token.Kind == SyntaxKind.SingleQuote || 1497token.Kind == SyntaxKind.OpenAngle || 1498token.Kind == SyntaxKind.Equals || 1499(token.Kind == SyntaxKind.ForwardSlash && NextIs(SyntaxKind.CloseAngle)) || 1500token.Kind == SyntaxKind.CloseAngle || 1501token.Kind == SyntaxKind.Whitespace || 1502token.Kind == SyntaxKind.NewLine; 1514ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.OpenAngle); 1517if (NextIs(SyntaxKind.ForwardSlash)) 1524if (At(SyntaxKind.Text) && 1563AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 1571if (!At(SyntaxKind.CloseAngle)) 1577closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 1609AcceptTokenUntilAll(builder, SyntaxKind.CloseAngle); 1614Assert(SyntaxKind.OpenAngle); 1616Assert(SyntaxKind.QuestionMark); 1618AcceptTokenUntilAll(builder, SyntaxKind.QuestionMark, SyntaxKind.CloseAngle); 1624Assert(SyntaxKind.OpenAngle); 1628Debug.Assert(CurrentToken.Kind == SyntaxKind.Text && string.Equals(CurrentToken.Content, "cdata", StringComparison.OrdinalIgnoreCase)); 1630Assert(SyntaxKind.LeftBracket); 1631AcceptTokenUntilAll(builder, SyntaxKind.RightBracket, SyntaxKind.RightBracket, SyntaxKind.CloseAngle); 1640Assert(SyntaxKind.Transition); 1675Assert(SyntaxKind.OpenAngle); 1694ParseMarkupNodes(htmlCommentBuilder, ParseMode.Text, t => t.Kind == SyntaxKind.DoubleHyphen); 1697if (At(SyntaxKind.CloseAngle)) 1761(At(SyntaxKind.NewLine) || 1762(At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.NewLine)))) 1794if (At(SyntaxKind.NewLine)) 1863if (NextIs(SyntaxKind.DoubleHyphen)) 1874if (At(SyntaxKind.Text) && IsHyphen(CurrentToken)) 1877if (!NextIs(SyntaxKind.CloseAngle)) 1889private void AcceptTokenUntilAll(in SyntaxListBuilder<RazorSyntaxNode> builder, params SyntaxKind[] endSequence) 1918if (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1923while (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1941else if (At(SyntaxKind.RazorCommentTransition)) 1946else if (At(SyntaxKind.Transition)) 1948if (NextIs(SyntaxKind.Transition)) 1966else if (At(SyntaxKind.OpenAngle)) 1968if (NextIs(SyntaxKind.Bang)) 1973if (_parseAsXml ? Lookahead(2)?.Kind == SyntaxKind.DoubleHyphen : IsHtmlCommentAhead()) 1977else if (Lookahead(2)?.Kind == SyntaxKind.LeftBracket && 1980Lookahead(4)?.Kind == SyntaxKind.LeftBracket) 1991else if (NextIs(SyntaxKind.QuestionMark)) 2021Assert(SyntaxKind.Bang); 2040potentialBang.Kind == SyntaxKind.Bang) 2045afterBang.Kind == SyntaxKind.Text && 2068if (!(At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.Bang))) 2079if (EndOfFile || CurrentToken.Kind != SyntaxKind.DoubleHyphen) 2085if (NextIs(SyntaxKind.CloseAngle) || NextIs(next => IsHyphen(next) && NextIs(SyntaxKind.CloseAngle))) 2094if (token.Kind == SyntaxKind.DoubleHyphen) 2096if (NextIs(SyntaxKind.CloseAngle)) 2102else if (NextIs(ns => IsHyphen(ns) && NextIs(SyntaxKind.CloseAngle))) 2111else if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.CloseAngle))) 2118else if (token.Kind == SyntaxKind.OpenAngle) 2121if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.DoubleHyphen))) 2163ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind is SyntaxKind.Text or SyntaxKind.OpenAngle); 2164if (At(SyntaxKind.Text)) 2237var (preSequence, right) = Language.SplitToken(token, position, SyntaxKind.Text); 2239var (sequenceToken, _) = Language.SplitToken(right, sequence.Length, SyntaxKind.Text); 2313return token.Kind == SyntaxKind.Text && token.Content == "-"; 2327var tokenType = token.Kind; 2328return tokenType != SyntaxKind.Whitespace && 2329tokenType != SyntaxKind.NewLine && 2330tokenType != SyntaxKind.CloseAngle && 2331tokenType != SyntaxKind.OpenAngle && 2332tokenType != SyntaxKind.ForwardSlash && 2333tokenType != SyntaxKind.Equals && 2334tokenType != SyntaxKind.Marker; 2339return token.Kind == SyntaxKind.CloseAngle || 2340token.Kind == SyntaxKind.ForwardSlash || 2341token.Kind == SyntaxKind.OpenAngle || 2342token.Kind == SyntaxKind.SingleQuote || 2343token.Kind == SyntaxKind.DoubleQuote; 2369if (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, "--"), 44public override SyntaxKind RazorCommentKind => SyntaxKind.RazorCommentLiteral; 46public override SyntaxKind RazorCommentTransitionKind => SyntaxKind.RazorCommentTransition; 48public override SyntaxKind RazorCommentStarKind => SyntaxKind.RazorCommentStar; 50protected override SyntaxToken CreateToken(string content, SyntaxKind type, RazorDiagnostic[] errors) 87protected override string GetTokenContent(SyntaxKind type) 95case SyntaxKind.OpenAngle: 97case SyntaxKind.Bang: 99case SyntaxKind.ForwardSlash: 101case SyntaxKind.QuestionMark: 103case SyntaxKind.LeftBracket: 105case SyntaxKind.CloseAngle: 107case SyntaxKind.RightBracket: 109case SyntaxKind.Equals: 111case SyntaxKind.DoubleQuote: 113case SyntaxKind.SingleQuote: 115case SyntaxKind.Whitespace: 126case SyntaxKind.NewLine: 139case SyntaxKind.NewLine: 141case SyntaxKind.DoubleHyphen: 167EndToken(SyntaxKind.RazorCommentTransition)); 174EndToken(SyntaxKind.Transition)); 177return Stay(EndToken(SyntaxKind.Transition)); 192return Transition(HtmlTokenizerState.Data, EndToken(SyntaxKind.Transition)); 218return Transition(HtmlTokenizerState.Data, EndToken(SyntaxKind.Text)); 231return EndToken(SyntaxKind.OpenAngle); 233return EndToken(SyntaxKind.Bang); 235return EndToken(SyntaxKind.ForwardSlash); 237return EndToken(SyntaxKind.QuestionMark); 239return EndToken(SyntaxKind.LeftBracket); 241return EndToken(SyntaxKind.CloseAngle); 243return EndToken(SyntaxKind.RightBracket); 245return EndToken(SyntaxKind.Equals); 247return EndToken(SyntaxKind.DoubleQuote); 249return EndToken(SyntaxKind.SingleQuote); 253return EndToken(SyntaxKind.DoubleHyphen); 257return EndToken(SyntaxKind.Marker); 268return EndToken(SyntaxKind.Whitespace); 284return 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; 637tokenType = SyntaxKind.ConflictMarkerTrivia; 655EndToken(SyntaxKind.RazorCommentStar)); 667return Transition(RoslynCSharpTokenizerState.TriviaForCSharpToken, EndToken(csharpToken.Text, SyntaxKind.NumericLiteral)); 676var type = SyntaxKind.Identifier; 679type = 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]); 583if (tokens is [{ Kind: SyntaxKind.Transition } transition, ..]) 656var transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 684transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 882var kind = node.Children[i].Kind; 883if (kind != SyntaxKind.MarkupLiteralAttributeValue && 886(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) 2982internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) 2993internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) 3045internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) 3056internal RazorUsingDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) 3108internal RazorDocumentationDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) 3119internal RazorDocumentationDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) 3170internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics) 3183internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode) 3457if (endOfFile.Kind != SyntaxKind.EndOfFile) 3460var result = new RazorDocumentSyntax(SyntaxKind.RazorDocument, document, endOfFile); 3468if (startCommentTransition.Kind != SyntaxKind.RazorCommentTransition) 3471if (startCommentStar.Kind != SyntaxKind.RazorCommentStar) 3474if (comment.Kind != SyntaxKind.RazorCommentLiteral) 3477if (endCommentStar.Kind != SyntaxKind.RazorCommentStar) 3480if (endCommentTransition.Kind != SyntaxKind.RazorCommentTransition) 3483return new RazorCommentBlockSyntax(SyntaxKind.RazorComment, startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); 3488var result = new RazorMetaCodeSyntax(SyntaxKind.RazorMetaCode, metaCode.Node, chunkGenerator, editHandler); 3495var result = new GenericBlockSyntax(SyntaxKind.GenericBlock, children.Node); 3502var result = new UnclassifiedTextLiteralSyntax(SyntaxKind.UnclassifiedTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3509var result = new MarkupBlockSyntax(SyntaxKind.MarkupBlock, children.Node); 3516var result = new MarkupTransitionSyntax(SyntaxKind.MarkupTransition, transitionTokens.Node, chunkGenerator, editHandler); 3523var result = new MarkupTextLiteralSyntax(SyntaxKind.MarkupTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3530var result = new MarkupEphemeralTextLiteralSyntax(SyntaxKind.MarkupEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3537var result = new MarkupCommentBlockSyntax(SyntaxKind.MarkupCommentBlock, children.Node); 3546var result = new MarkupMinimizedAttributeBlockSyntax(SyntaxKind.MarkupMinimizedAttributeBlock, namePrefix, name); 3555if (equalsToken.Kind != SyntaxKind.Equals) 3558return new MarkupAttributeBlockSyntax(SyntaxKind.MarkupAttributeBlock, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); 3563var result = new MarkupMiscAttributeContentSyntax(SyntaxKind.MarkupMiscAttributeContent, children.Node); 3570var result = new MarkupLiteralAttributeValueSyntax(SyntaxKind.MarkupLiteralAttributeValue, prefix, value); 3579var result = new MarkupDynamicAttributeValueSyntax(SyntaxKind.MarkupDynamicAttributeValue, prefix, value); 3586var result = new MarkupElementSyntax(SyntaxKind.MarkupElement, markupStartTag, body.Node, markupEndTag); 3594if (openAngle.Kind != SyntaxKind.OpenAngle) 3596if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3599if (name.Kind != SyntaxKind.Text) 3601if (forwardSlash is not null && forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) 3604if (closeAngle.Kind != SyntaxKind.CloseAngle) 3607return new MarkupStartTagSyntax(SyntaxKind.MarkupStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, isMarkupTransition, chunkGenerator, editHandler); 3613if (openAngle.Kind != SyntaxKind.OpenAngle) 3616if (forwardSlash.Kind != SyntaxKind.ForwardSlash) 3618if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3621if (name.Kind != SyntaxKind.Text) 3624if (closeAngle.Kind != SyntaxKind.CloseAngle) 3627return new MarkupEndTagSyntax(SyntaxKind.MarkupEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, isMarkupTransition, chunkGenerator, editHandler); 3632return new MarkupTagHelperElementSyntax(SyntaxKind.MarkupTagHelperElement, tagHelperStartTag, body.Node, tagHelperEndTag, tagHelperInfo); 3638if (openAngle.Kind != SyntaxKind.OpenAngle) 3640if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3643if (name.Kind != SyntaxKind.Text) 3645if (forwardSlash is not null && forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) 3648if (closeAngle.Kind != SyntaxKind.CloseAngle) 3651return new MarkupTagHelperStartTagSyntax(SyntaxKind.MarkupTagHelperStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, chunkGenerator, editHandler); 3657if (openAngle.Kind != SyntaxKind.OpenAngle) 3660if (forwardSlash.Kind != SyntaxKind.ForwardSlash) 3662if (bang is not null && bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) 3665if (name.Kind != SyntaxKind.Text) 3668if (closeAngle.Kind != SyntaxKind.CloseAngle) 3671return new MarkupTagHelperEndTagSyntax(SyntaxKind.MarkupTagHelperEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator, editHandler); 3678if (equalsToken.Kind != SyntaxKind.Equals) 3682return new MarkupTagHelperAttributeSyntax(SyntaxKind.MarkupTagHelperAttribute, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 3689var result = new MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperAttribute, namePrefix, name, tagHelperAttributeInfo); 3696var result = new MarkupTagHelperAttributeValueSyntax(SyntaxKind.MarkupTagHelperAttributeValue, children.Node); 3706if (equalsToken.Kind != SyntaxKind.Equals) 3710return new MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 3718return new MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, tagHelperAttributeInfo); 3723var result = new CSharpCodeBlockSyntax(SyntaxKind.CSharpCodeBlock, children.Node); 3731if (transition.Kind != SyntaxKind.Transition) 3734var result = new CSharpTransitionSyntax(SyntaxKind.CSharpTransition, transition, chunkGenerator, editHandler); 3741var result = new CSharpStatementLiteralSyntax(SyntaxKind.CSharpStatementLiteral, literalTokens.Node, chunkGenerator, editHandler); 3748var result = new CSharpExpressionLiteralSyntax(SyntaxKind.CSharpExpressionLiteral, literalTokens.Node, chunkGenerator, editHandler); 3755var result = new CSharpEphemeralTextLiteralSyntax(SyntaxKind.CSharpEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); 3762var result = new CSharpTemplateBlockSyntax(SyntaxKind.CSharpTemplateBlock, children.Node); 3772var result = new CSharpStatementSyntax(SyntaxKind.CSharpStatement, transition, body); 3783var result = new CSharpStatementBodySyntax(SyntaxKind.CSharpStatementBody, openBrace, csharpCode, closeBrace); 3793var result = new CSharpExplicitExpressionSyntax(SyntaxKind.CSharpExplicitExpression, transition, body); 3804var result = new CSharpExplicitExpressionBodySyntax(SyntaxKind.CSharpExplicitExpressionBody, openParen, csharpCode, closeParen); 3814var result = new CSharpImplicitExpressionSyntax(SyntaxKind.CSharpImplicitExpression, transition, body); 3823var result = new CSharpImplicitExpressionBodySyntax(SyntaxKind.CSharpImplicitExpressionBody, csharpCode); 3833var result = new RazorDirectiveSyntax(SyntaxKind.RazorDirective, transition, body, directiveDescriptor); 3843var result = new RazorUsingDirectiveSyntax(SyntaxKind.RazorUsingDirective, transition, body, directiveDescriptor); 3853var result = new RazorDocumentationDirectiveSyntax(SyntaxKind.RazorDocumentationDirective, transition, body, directiveDescriptor); 3862var result = new RazorDirectiveBodySyntax(SyntaxKind.RazorDirectiveBody, keyword, csharpCode);

402if (endOfFile.Kind is not (SyntaxKind.EndOfFile)) return ThrowHelper.ThrowArgumentException<RazorDocumentSyntax>(nameof(endOfFile), $"Invalid SyntaxKind. Expected 'SyntaxKind.EndOfFile', but it was {endOfFile.Kind}"); 408=> SyntaxFactory.RazorDocument(document, SyntaxFactory.Token(SyntaxKind.EndOfFile)); 413if (startCommentTransition.Kind is not (SyntaxKind.RazorCommentTransition)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(startCommentTransition), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentTransition', but it was {startCommentTransition.Kind}"); 414if (startCommentStar.Kind is not (SyntaxKind.RazorCommentStar)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(startCommentStar), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentStar', but it was {startCommentStar.Kind}"); 415if (comment.Kind is not (SyntaxKind.RazorCommentLiteral)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(comment), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentLiteral', but it was {comment.Kind}"); 416if (endCommentStar.Kind is not (SyntaxKind.RazorCommentStar)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(endCommentStar), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentStar', but it was {endCommentStar.Kind}"); 417if (endCommentTransition.Kind is not (SyntaxKind.RazorCommentTransition)) return ThrowHelper.ThrowArgumentException<RazorCommentBlockSyntax>(nameof(endCommentTransition), $"Invalid SyntaxKind. Expected 'SyntaxKind.RazorCommentTransition', but it was {endCommentTransition.Kind}"); 423=> SyntaxFactory.RazorCommentBlock(SyntaxFactory.Token(SyntaxKind.RazorCommentTransition), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition)); 504if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupAttributeBlockSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 510=> SyntaxFactory.MarkupAttributeBlock(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix); 514=> SyntaxFactory.MarkupAttributeBlock(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), default(RazorBlockSyntax), default(MarkupTextLiteralSyntax)); 554if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 555if (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}"); 556if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 557if (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}"); 558if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupStartTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 564=> SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 568=> SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList<RazorSyntaxNode>), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 573if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 574if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); 575if (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}"); 576if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 577if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupEndTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 583=> SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); 587=> 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); 600if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 601if (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}"); 602if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 603if (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}"); 604if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperStartTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 610=> SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 614=> SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList<RazorSyntaxNode>), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 619if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); 620if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); 621if (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}"); 622if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); 623if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperEndTagSyntax>(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); 629=> SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 633=> SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); 639if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperAttributeSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 646=> SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 650=> SyntaxFactory.MarkupTagHelperAttribute(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); 676if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException<MarkupTagHelperDirectiveAttributeSyntax>(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); 683=> SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); 687=> SyntaxFactory.MarkupTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax), default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); 712if (transition.Kind is not (SyntaxKind.Transition)) return ThrowHelper.ThrowArgumentException<CSharpTransitionSyntax>(nameof(transition), $"Invalid SyntaxKind. Expected 'SyntaxKind.Transition', but it was {transition.Kind}"); 718=> 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; 469Debug.Assert(curNode.Kind is < SyntaxKind.FirstAvailableTokenKind and >= 0); 492if (includeWhitespace || foundToken.Kind is not (SyntaxKind.Whitespace or SyntaxKind.NewLine)) 516if (foundToken.Kind is SyntaxKind.None or SyntaxKind.NewLine) 527while (foundToken.Kind is SyntaxKind.Whitespace); 539if (currentToken.Kind == SyntaxKind.None || currentToken.Span.End > this.Span.End) 546while (currentToken is { Kind: SyntaxKind.NewLine or SyntaxKind.Whitespace });

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

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

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

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

145internal int IndexOf(SyntaxKind kind)