1392 references to SyntaxKind
Microsoft.CodeAnalysis.Razor.Compiler (1392)
Language\DefaultRazorIntermediateNodeLoweringPhase.cs (5)
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 }])
Language\Legacy\ClassifiedSpanVisitor.cs (1)
63comment = SyntaxFactory.Token(SyntaxKind.Marker, parent: node, position: node.StartCommentStar.EndPosition);
Language\Legacy\CSharpCodeParser.cs (232)
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) 864case SyntaxKind.RazorCommentTransition: 871case SyntaxKind.LeftBrace: 889Assert(SyntaxKind.RightBrace); 894case SyntaxKind.Keyword: 900case SyntaxKind.Transition: 904case SyntaxKind.RightBrace: 907case SyntaxKind.CSharpComment: 922Assert(SyntaxKind.Transition); 926if (At(SyntaxKind.Transition)) 936Assert(SyntaxKind.Transition); 943if (At(SyntaxKind.LeftBrace)) 989token.Kind is not SyntaxKind.Semicolon and 990not SyntaxKind.RazorCommentTransition and 991not SyntaxKind.Transition and 992not SyntaxKind.LeftBrace and 993not SyntaxKind.LeftParenthesis and 994not SyntaxKind.LeftBracket and 995not SyntaxKind.RightBrace and 996not SyntaxKind.Keyword, 999if ((!Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) || 1000At(SyntaxKind.LeftParenthesis) || 1001At(SyntaxKind.LeftBracket)) 1009else if (Context.Options.AllowRazorInAllCodeBlocks && At(SyntaxKind.LeftBrace)) 1014else if (At(SyntaxKind.Transition)) 1023case SyntaxKind.LessThan: 1024case SyntaxKind.Colon: 1030case SyntaxKind.Keyword when encounteredUnexpectedMarkupTransition: 1041case SyntaxKind.Identifier: 1042case SyntaxKind.Keyword: 1051case SyntaxKind.Transition: 1052if (Lookahead(2) is not { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 1068Debug.Assert(transition.Kind == SyntaxKind.Transition); 1075var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, transition.Content); 1080else if (At(SyntaxKind.RazorCommentTransition)) 1088else if (At(SyntaxKind.Semicolon)) 1094else if (At(SyntaxKind.RightBrace)) 1099else if (At(SyntaxKind.Keyword)) 1104AcceptUntil(SyntaxKind.LeftBrace); // TODO: how do we do error recovery at this point? 1120AcceptUntil(SyntaxKind.LessThan, SyntaxKind.LeftBrace, SyntaxKind.RightBrace); 1129TryAccept(SyntaxKind.RightBrace); 1134AcceptUntil(SyntaxKind.LessThan, SyntaxKind.RightBrace); 1301Debug.Assert(CurrentToken.Kind == SyntaxKind.Identifier || CurrentToken.Kind == SyntaxKind.Keyword); 1328var foundWhitespace = At(SyntaxKind.Whitespace); 1336AcceptWhile(SyntaxKind.Whitespace); 1341if (EndOfFile || At(SyntaxKind.NewLine)) 1356AcceptUntil(SyntaxKind.NewLine); 1417TokenBuilder[0] is SyntaxToken { Kind: SyntaxKind.StringLiteral } token) 1564if (!At(SyntaxKind.Whitespace) && 1565!At(SyntaxKind.NewLine) && 1566!At(SyntaxKind.Semicolon) && 1574builder.Add(BuildDirective(SyntaxKind.Whitespace)); 1580if (At(SyntaxKind.Whitespace)) 1597if (EndOfFile || At(SyntaxKind.NewLine)) 1617if (tokenDescriptor.Optional && (EndOfFile || At(SyntaxKind.NewLine))) 1628builder.Add(BuildDirective(SyntaxKind.Identifier)); 1641builder.Add(BuildDirective(SyntaxKind.Identifier)); 1653builder.Add(BuildDirective(SyntaxKind.Identifier)); 1659if (At(SyntaxKind.Identifier)) 1669builder.Add(BuildDirective(SyntaxKind.Identifier)); 1675if (At(SyntaxKind.StringLiteral) && !CurrentToken.ContainsDiagnostics) 1684builder.Add(BuildDirective(SyntaxKind.StringLiteral)); 1699builder.Add(BuildDirective(SyntaxKind.CSharpExpressionLiteral)); 1705if (At(SyntaxKind.LeftBracket)) 1709TryAccept(SyntaxKind.RightBracket); 1717builder.Add(BuildDirective(SyntaxKind.LeftBracket)); 1723if (At(SyntaxKind.Keyword) && 1728AcceptWhile(SyntaxKind.Whitespace); 1738builder.Add(BuildDirective(SyntaxKind.Identifier)); 1743while (!At(SyntaxKind.NewLine)) 1745if (At(SyntaxKind.Semicolon)) 1759else if (At(SyntaxKind.Semicolon)) 1771builder.Add(BuildDirective(SyntaxKind.Keyword)); 1778if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.LeftParenthesis)) 1792builder.Add(BuildDirective(SyntaxKind.Identifier)); 1817TryAccept(SyntaxKind.Semicolon); 1822if (At(SyntaxKind.NewLine)) 1891Balance(childBuilder, BalancingModes.NoErrorOnFailure, SyntaxKind.LeftBrace, SyntaxKind.RightBrace, startingBraceLocation); 1906builder.Add(BuildDirective(SyntaxKind.Identifier)); 1914RazorDirectiveSyntax BuildDirective(SyntaxKind expectedTokenKindIfMissing) 1966var type = token.Kind; 1967if ((expectingDot && type == SyntaxKind.Dot) || 1968(!expectingDot && type == SyntaxKind.Identifier)) 1974if (type != SyntaxKind.Whitespace && 1975type != SyntaxKind.NewLine) 2020else if (!At(SyntaxKind.LeftBrace)) 2049if (!TryAccept(SyntaxKind.RightBrace)) 2056Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBrace)); 2079Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2096Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && result.HasValue); 2156Assert(SyntaxKind.Keyword); 2186if (At(SyntaxKind.LeftParenthesis)) 2191AcceptUntil(SyntaxKind.NewLine); 2195TryAccept(SyntaxKind.RightParenthesis); 2211if (At(SyntaxKind.LessThan)) 2219else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Colon)) 2227else if (At(SyntaxKind.Transition) && NextIs(SyntaxKind.Transition)) 2243Assert(SyntaxKind.Keyword); 2252Assert(SyntaxKind.Keyword); 2262while (EnsureCurrent() && CurrentToken.Kind != SyntaxKind.Colon) 2266case SyntaxKind.LeftBrace: 2267case SyntaxKind.LeftParenthesis: 2268case SyntaxKind.LeftBracket: 2277TryAccept(SyntaxKind.Colon); 2448if (TryParseCondition(builder) && TryAccept(SyntaxKind.Semicolon)) 2468var atLeftParen = At(SyntaxKind.LeftParenthesis); 2469var atIdentifier = At(SyntaxKind.Identifier); 2536Assert(SyntaxKind.LeftParenthesis); 2565if (At(SyntaxKind.Identifier) || At(CSharpSyntaxKind.GlobalKeyword)) 2572if (At(SyntaxKind.Assign)) 2576Assert(SyntaxKind.Assign); 2608hasExplicitSemicolon = TryAccept(SyntaxKind.Semicolon); 2624token.Kind != SyntaxKind.CSharpComment && 2625token.Kind != SyntaxKind.Whitespace && 2626token.Kind != SyntaxKind.NewLine) 2650if (TryAccept(SyntaxKind.LeftParenthesis)) 2652while (!TryAccept(SyntaxKind.RightParenthesis) && !EndOfFile) 2654TryAccept(SyntaxKind.Whitespace); 2661TryAccept(SyntaxKind.Whitespace); 2662TryAccept(SyntaxKind.Identifier); 2663TryAccept(SyntaxKind.Whitespace); 2664TryAccept(SyntaxKind.Comma); 2667if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2673TryAccept(SyntaxKind.QuestionMark); // Nullable 2677else if (TryAccept(SyntaxKind.Identifier) || TryAccept(SyntaxKind.Keyword)) 2679if (TryAccept(SyntaxKind.DoubleColon)) 2681if (!TryAccept(SyntaxKind.Identifier)) 2683TryAccept(SyntaxKind.Keyword); 2686if (At(SyntaxKind.LessThan)) 2690if (TryAccept(SyntaxKind.Dot)) 2695if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.QuestionMark)) 2701TryAccept(SyntaxKind.QuestionMark); // Nullable 2703if (At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.LeftBracket)) 2709while (At(SyntaxKind.LeftBracket)) 2712if (!TryAccept(SyntaxKind.RightBracket)) 2714Accept(SyntaxFactory.MissingToken(SyntaxKind.RightBracket)); 2727Assert(SyntaxKind.LessThan); 2729if (!TryAccept(SyntaxKind.GreaterThan)) 2731Accept(SyntaxFactory.MissingToken(SyntaxKind.GreaterThan)); 2749transition = transition ?? SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); 2770ReadWhile(static token => token.Kind == SyntaxKind.Whitespace, ref whitespace.AsRef()); 2771if (At(SyntaxKind.NewLine)) 2798if (At(SyntaxKind.RazorCommentTransition)) 2913var left = CurrentToken.Kind; 2914var right = Language.FlipBracket(left); 2929private bool Balance(SyntaxListBuilder<RazorSyntaxNode> builder, BalancingModes mode, SyntaxKind left, SyntaxKind right, SourceLocation start) 2935!(stopAtEndOfLine && At(SyntaxKind.NewLine))) 2951if (At(SyntaxKind.Transition)) 2956if (NextIs(SyntaxKind.Transition) && Lookahead(2) is { Kind: SyntaxKind.Identifier or SyntaxKind.Keyword }) 2968else if (NextIs(SyntaxKind.Keyword, SyntaxKind.Identifier)) 2990while (nesting > 0 && EnsureCurrent() && !(stopAtEndOfLine && At(SyntaxKind.NewLine))); 3025&& NextIs(SyntaxKind.LessThan, SyntaxKind.Colon, SyntaxKind.DoubleColon)) 3056Debug.Assert(CurrentToken.Kind == SyntaxKind.Transition); 3059Debug.Assert(CurrentToken.Kind is SyntaxKind.Identifier or SyntaxKind.Keyword); 3063var finalIdentifier = SyntaxFactory.Token(SyntaxKind.Identifier, $"{transition.Content}{identifier.Content}"); 3071Debug.Assert(CurrentToken.Kind == SyntaxKind.Keyword && 3079if (!At(SyntaxKind.Keyword) || result is not { } keywordKind) 3098if (result is not CSharpSyntaxKind.None and { } value && token.Kind == SyntaxKind.Keyword)
Language\Legacy\DirectiveCSharpTokenizer.cs (9)
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;
Language\Legacy\DirectiveHtmlTokenizer.cs (7)
50private bool IsValidTokenType(SyntaxKind kind) 52return kind != SyntaxKind.Whitespace && 53kind != SyntaxKind.NewLine && 54kind != SyntaxKind.RazorCommentLiteral && 55kind != SyntaxKind.RazorCommentStar && 56kind != SyntaxKind.RazorCommentTransition && 57kind != SyntaxKind.Transition;
Language\Legacy\HtmlLanguageCharacteristics.cs (43)
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)
Language\Legacy\HtmlMarkupParser.cs (197)
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)) 362static f => (f.Kind == SyntaxKind.Whitespace) || (f.Kind == SyntaxKind.NewLine), 366if (!(At(SyntaxKind.OpenAngle) || 367(At(SyntaxKind.Transition) && Lookahead(count: 1).Content.StartsWith(":", StringComparison.Ordinal)))) 380AcceptWhile(SyntaxKind.Whitespace); 381TryAccept(SyntaxKind.NewLine); 401Assert(SyntaxKind.Transition); 410if (CurrentToken.Kind == SyntaxKind.Text && CurrentToken.Content.Length > 0 && CurrentToken.Content[0] == ':') 413var split = Language.SplitToken(CurrentToken, 1, SyntaxKind.Colon); 426else if (CurrentToken.Kind == SyntaxKind.OpenAngle) 450ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 451if (At(SyntaxKind.Whitespace)) 455} while (!EndOfFile && CurrentToken.Kind != SyntaxKind.NewLine); 461if (!EndOfFile && CurrentToken.Kind == SyntaxKind.NewLine) 475Assert(SyntaxKind.OpenAngle); 480if (!NextIs(SyntaxKind.ForwardSlash)) 633Assert(SyntaxKind.OpenAngle); 642if (At(SyntaxKind.Text)) 661var tagNameToken = At(SyntaxKind.Text) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.Text); 674if (At(SyntaxKind.ForwardSlash)) 681var closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 684if (EndOfFile || !At(SyntaxKind.CloseAngle)) 696if (At(SyntaxKind.CloseAngle)) 718if (At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.ForwardSlash)) 721Assert(SyntaxKind.ForwardSlash); 723if (!At(SyntaxKind.Text) || !string.Equals(CurrentToken.Content, tagName, StringComparison.OrdinalIgnoreCase)) 741else if (At(SyntaxKind.CloseAngle)) 786Assert(SyntaxKind.Text); 799if (At(SyntaxKind.CloseAngle) || 800(At(SyntaxKind.ForwardSlash) && NextIs(SyntaxKind.CloseAngle))) 802if (At(SyntaxKind.ForwardSlash)) 839AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.NewLine); 843if (At(SyntaxKind.CloseAngle)) 849closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 856Assert(SyntaxKind.OpenAngle); 862var forwardSlashToken = At(SyntaxKind.ForwardSlash) ? EatCurrentToken() : SyntaxFactory.MissingToken(SyntaxKind.ForwardSlash); 866if (At(SyntaxKind.Text)) 897tagNameToken = SyntaxFactory.MissingToken(SyntaxKind.Text); 906AcceptWhile(SyntaxKind.Whitespace); 912AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 915if (At(SyntaxKind.CloseAngle)) 928if (At(SyntaxKind.CloseAngle)) 936closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 956Assert(SyntaxKind.Text); 965isWellFormed = At(SyntaxKind.CloseAngle); 1003if (!At(SyntaxKind.Whitespace) && !At(SyntaxKind.NewLine)) 1014if (At(SyntaxKind.ForwardSlash)) 1027if (At(SyntaxKind.ForwardSlash)) 1029if (NextIs(SyntaxKind.CloseAngle) || NextIs(SyntaxKind.OpenAngle)) 1035return At(SyntaxKind.CloseAngle) || At(SyntaxKind.OpenAngle); 1051case SyntaxKind.SingleQuote: 1052case SyntaxKind.DoubleQuote: 1054var openQuoteKind = CurrentToken.Kind; 1063case SyntaxKind.OpenAngle: // Another "<" means this tag is invalid. 1064case SyntaxKind.ForwardSlash: // Empty tag 1065case SyntaxKind.CloseAngle: // End of tag 1108static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1164var atMinimizedAttribute = !TokenExistsAfterWhitespace(SyntaxKind.Equals); 1198if (At(SyntaxKind.Transition)) 1200if (NextIs(SyntaxKind.Transition)) 1217else if (At(SyntaxKind.RazorCommentTransition)) 1228token.Kind != SyntaxKind.Whitespace && 1229token.Kind != SyntaxKind.NewLine && 1230token.Kind != SyntaxKind.Equals && 1231token.Kind != SyntaxKind.CloseAngle && 1232token.Kind != SyntaxKind.OpenAngle && 1233(token.Kind != SyntaxKind.Transition || !self.Context.Options.AllowCSharpInMarkupAttributeArea) && 1234(token.Kind != SyntaxKind.ForwardSlash || !self.NextIs(SyntaxKind.CloseAngle)), 1248AcceptWhile(static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine); 1251Assert(SyntaxKind.Equals); // We should be at "=" 1256static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1258var quote = SyntaxKind.Marker; 1259if (At(SyntaxKind.SingleQuote) || At(SyntaxKind.DoubleQuote)) 1297if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1316if (quote != SyntaxKind.Marker && At(quote)) 1322else if (quote != SyntaxKind.Marker || !whitespaceAfterEquals.Any()) 1328if (quote != SyntaxKind.Marker) 1342private RazorBlockSyntax ParseNonConditionalAttributeValue(SyntaxKind quote) 1359private void ParseConditionalAttributeValue(in SyntaxListBuilder<RazorSyntaxNode> builder, SyntaxKind quote) 1364static token => token.Kind == SyntaxKind.Whitespace || token.Kind == SyntaxKind.NewLine, 1367if (At(SyntaxKind.Transition)) 1369if (NextIs(SyntaxKind.Transition)) 1437token.Kind != SyntaxKind.Whitespace && 1438token.Kind != SyntaxKind.NewLine && 1439token.Kind != SyntaxKind.Transition && 1454private bool IsEndOfAttributeValue(SyntaxKind quote, SyntaxToken token) 1457(quote != SyntaxKind.Marker 1467return token.Kind == SyntaxKind.DoubleQuote || 1468token.Kind == SyntaxKind.SingleQuote || 1469token.Kind == SyntaxKind.OpenAngle || 1470token.Kind == SyntaxKind.Equals || 1471(token.Kind == SyntaxKind.ForwardSlash && NextIs(SyntaxKind.CloseAngle)) || 1472token.Kind == SyntaxKind.CloseAngle || 1473token.Kind == SyntaxKind.Whitespace || 1474token.Kind == SyntaxKind.NewLine; 1486ParseMarkupNodes(builder, ParseMode.Text, token => token.Kind == SyntaxKind.OpenAngle); 1489if (NextIs(SyntaxKind.ForwardSlash)) 1496if (At(SyntaxKind.Text) && 1535AcceptUntil(SyntaxKind.CloseAngle, SyntaxKind.OpenAngle); 1543if (!At(SyntaxKind.CloseAngle)) 1549closeAngleToken = SyntaxFactory.MissingToken(SyntaxKind.CloseAngle); 1581return AcceptTokenUntilAll(builder, SyntaxKind.CloseAngle); 1586Assert(SyntaxKind.OpenAngle); 1588Assert(SyntaxKind.QuestionMark); 1590return AcceptTokenUntilAll(builder, SyntaxKind.QuestionMark, SyntaxKind.CloseAngle); 1596Assert(SyntaxKind.OpenAngle); 1600Debug.Assert(CurrentToken.Kind == SyntaxKind.Text && string.Equals(CurrentToken.Content, "cdata", StringComparison.OrdinalIgnoreCase)); 1602Assert(SyntaxKind.LeftBracket); 1603return AcceptTokenUntilAll(builder, SyntaxKind.RightBracket, SyntaxKind.RightBracket, SyntaxKind.CloseAngle); 1612Assert(SyntaxKind.Transition); 1647Assert(SyntaxKind.OpenAngle); 1666ParseMarkupNodes(htmlCommentBuilder, ParseMode.Text, t => t.Kind == SyntaxKind.DoubleHyphen); 1669if (At(SyntaxKind.CloseAngle)) 1733(At(SyntaxKind.NewLine) || 1734(At(SyntaxKind.Whitespace) && NextIs(SyntaxKind.NewLine)))) 1766if (At(SyntaxKind.NewLine)) 1830if (NextIs(SyntaxKind.DoubleHyphen)) 1841if (At(SyntaxKind.Text) && IsHyphen(CurrentToken)) 1844if (!NextIs(SyntaxKind.CloseAngle)) 1856private bool AcceptTokenUntilAll(in SyntaxListBuilder<RazorSyntaxNode> builder, params SyntaxKind[] endSequence) 1875if (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1880while (EnsureCurrent() && (CurrentToken.Kind == SyntaxKind.Whitespace || CurrentToken.Kind == SyntaxKind.NewLine)) 1898else if (At(SyntaxKind.RazorCommentTransition)) 1903else if (At(SyntaxKind.Transition)) 1905if (NextIs(SyntaxKind.Transition)) 1923else if (At(SyntaxKind.OpenAngle)) 1925if (NextIs(SyntaxKind.Bang)) 1934else if (Lookahead(2)?.Kind == SyntaxKind.LeftBracket && 1937Lookahead(4)?.Kind == SyntaxKind.LeftBracket) 1948else if (NextIs(SyntaxKind.QuestionMark)) 1978Assert(SyntaxKind.Bang); 1992potentialBang.Kind == SyntaxKind.Bang) 1997afterBang.Kind == SyntaxKind.Text && 2020if (!(At(SyntaxKind.OpenAngle) && NextIs(SyntaxKind.Bang))) 2031if (EndOfFile || CurrentToken.Kind != SyntaxKind.DoubleHyphen) 2037if (NextIs(SyntaxKind.CloseAngle) || NextIs(next => IsHyphen(next) && NextIs(SyntaxKind.CloseAngle))) 2046if (token.Kind == SyntaxKind.DoubleHyphen) 2048if (NextIs(SyntaxKind.CloseAngle)) 2054else if (NextIs(ns => IsHyphen(ns) && NextIs(SyntaxKind.CloseAngle))) 2063else if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.CloseAngle))) 2070else if (token.Kind == SyntaxKind.OpenAngle) 2073if (NextIs(ns => ns.Kind == SyntaxKind.Bang && NextIs(SyntaxKind.DoubleHyphen))) 2116token.Kind == SyntaxKind.Text || 2117token.Kind == SyntaxKind.OpenAngle); 2118if (At(SyntaxKind.Text)) 2185var (preSequence, right) = Language.SplitToken(token, position, SyntaxKind.Text); 2187var (sequenceToken, _) = Language.SplitToken(right, sequence.Length, SyntaxKind.Text); 2260return token.Kind == SyntaxKind.Text && token.Content == "-"; 2274var tokenType = token.Kind; 2275return tokenType != SyntaxKind.Whitespace && 2276tokenType != SyntaxKind.NewLine && 2277tokenType != SyntaxKind.CloseAngle && 2278tokenType != SyntaxKind.OpenAngle && 2279tokenType != SyntaxKind.ForwardSlash && 2280tokenType != SyntaxKind.Equals && 2281tokenType != SyntaxKind.Marker; 2286return token.Kind == SyntaxKind.CloseAngle || 2287token.Kind == SyntaxKind.ForwardSlash || 2288token.Kind == SyntaxKind.OpenAngle || 2289token.Kind == SyntaxKind.SingleQuote || 2290token.Kind == SyntaxKind.DoubleQuote; 2316if (last.Kind == SyntaxKind.None)
Language\Legacy\HtmlTokenizer.cs (65)
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);
Language\Legacy\ImplicitExpressionEditHandler.cs (7)
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)
Language\Legacy\LanguageCharacteristics.cs (6)
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);
Language\Legacy\LegacySyntaxNodeExtensions.cs (21)
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;
Language\Legacy\NativeCSharpLanguageCharacteristics.cs (92)
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;
Language\Legacy\NativeCSharpTokenizer.cs (140)
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;
Language\Legacy\RoslynCSharpLanguageCharacteristics.cs (92)
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;
Language\Legacy\RoslynCSharpTokenizer.cs (70)
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;
Language\Legacy\TagHelperBlockRewriter.cs (20)
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()))
Language\Legacy\Tokenizer.cs (8)
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)
Language\Legacy\TokenizerBackedParser.cs (45)
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)
Language\SpanComputer.cs (8)
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.");
Language\Syntax\BaseMarkupEndTagSyntax.cs (1)
93if (token.Kind != SyntaxKind.None && !token.IsMissing)
Language\Syntax\BaseMarkupStartTagSyntax.cs (2)
33return ForwardSlash.Kind != SyntaxKind.None && 124if (token.Kind != SyntaxKind.None && !token.IsMissing)
Language\Syntax\Generated\Syntax.xml.Internal.Generated.cs (175)
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);
Language\Syntax\Generated\Syntax.xml.Main.Generated.cs (77)
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);
Language\Syntax\GreenNode.cs (5)
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; }
Language\Syntax\InternalSyntax\RazorSyntaxNode.cs (4)
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)
Language\Syntax\InternalSyntax\SyntaxFactory.cs (2)
10internal static SyntaxToken Token(SyntaxKind kind, string content, params RazorDiagnostic[] diagnostics) 20internal static SyntaxToken MissingToken(SyntaxKind kind, params RazorDiagnostic[] diagnostics)
Language\Syntax\InternalSyntax\SyntaxList.cs (2)
14: base(SyntaxKind.List) 19: base(SyntaxKind.List, diagnostics)
Language\Syntax\InternalSyntax\SyntaxListBuilder.cs (1)
154public bool Any(SyntaxKind kind)
Language\Syntax\InternalSyntax\SyntaxListBuilderOfT.cs (1)
80public bool Any(SyntaxKind kind)
Language\Syntax\InternalSyntax\SyntaxListOfT.cs (1)
76public bool Any(SyntaxKind kind)
Language\Syntax\InternalSyntax\SyntaxToken.cs (3)
11SyntaxKind kind, 70internal static SyntaxToken CreateMissing(SyntaxKind kind, params RazorDiagnostic[] diagnostics) 77internal MissingToken(SyntaxKind kind, RazorDiagnostic[] diagnostics)
Language\Syntax\InternalSyntax\SyntaxTokenCache.cs (2)
18public bool CanBeCached(SyntaxKind kind, params RazorDiagnostic[] diagnostics) 21public SyntaxToken GetCachedToken(SyntaxKind kind, string content)
Language\Syntax\SyntaxFactory.cs (7)
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)
Language\Syntax\SyntaxList`1.cs (1)
551internal int IndexOf(SyntaxKind kind)
Language\Syntax\SyntaxNavigator.cs (10)
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)
Language\Syntax\SyntaxNode.cs (10)
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 });
Language\Syntax\SyntaxNodeOrToken.cs (1)
58public SyntaxKind Kind => _token?.Kind ?? _nodeOrParent?.Kind ?? 0;
Language\Syntax\SyntaxRewriter.cs (1)
113if (isUpdating && visited.Kind != SyntaxKind.None)
Language\Syntax\SyntaxSerializer.cs (16)
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;
Language\Syntax\SyntaxToken.cs (1)
50public SyntaxKind Kind => Node?.Kind ?? 0;
Language\Syntax\SyntaxTokenList.cs (1)
145internal int IndexOf(SyntaxKind kind)