diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/legacyTest/Legacy/ImplicitExpressionEditHandlerTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/legacyTest/Legacy/ImplicitExpressionEditHandlerTest.cs index 2ec20c8b2eb..18f6996b2d5 100644 --- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/legacyTest/Legacy/ImplicitExpressionEditHandlerTest.cs +++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/legacyTest/Legacy/ImplicitExpressionEditHandlerTest.cs @@ -451,7 +451,8 @@ private static Syntax.MarkupTextLiteralSyntax GetSyntaxNode(SourceLocation start { builder.Add(token); } - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(parent: null, position: start.AbsoluteIndex); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null) + .CreateRed(parent: null, position: start.AbsoluteIndex); return (Syntax.MarkupTextLiteralSyntax)node; } diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DirectiveTokenEditHandlerTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DirectiveTokenEditHandlerTest.cs index 1caaa4f02c9..27e3a4c3795 100644 --- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DirectiveTokenEditHandlerTest.cs +++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/DirectiveTokenEditHandlerTest.cs @@ -72,9 +72,7 @@ private static CSharpStatementLiteralSyntax GetSyntaxNode(DirectiveTokenEditHand builder.Add(new SyntaxToken(token)); } - var node = SyntaxFactory.CSharpStatementLiteral(builder.ToList(), SpanChunkGenerator.Null); - - return node.WithEditHandler(editHandler); + return SyntaxFactory.CSharpStatementLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler); } private class TestDirectiveTokenEditHandler : DirectiveTokenEditHandler diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Legacy/CodeBlockEditHandlerTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Legacy/CodeBlockEditHandlerTest.cs index 6cac8ce8636..58320868dfc 100644 --- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Legacy/CodeBlockEditHandlerTest.cs +++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Legacy/CodeBlockEditHandlerTest.cs @@ -289,8 +289,7 @@ private static SyntaxNode GetSpan(SourceLocation start, string content) { builder.Add(new SyntaxToken(token)); } - var node = SyntaxFactory.CSharpStatementLiteral(builder.ToList(), SpanChunkGenerator.Null); - return node; + return SyntaxFactory.CSharpStatementLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null); } } diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/SourceChangeTest.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/SourceChangeTest.cs index 24390d43331..0f0cda0f13f 100644 --- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/SourceChangeTest.cs +++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/SourceChangeTest.cs @@ -110,7 +110,7 @@ public void GetEditedContent_SyntaxNode_ReturnsNewContent() builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null).CreateRed(); var change = new SourceChange(2, 2, "heyo"); @@ -129,7 +129,7 @@ public void GetOffSet_SpanIsOwner_ReturnsOffset() builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(null, 13); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null).CreateRed(null, 13); var change = new SourceChange(15, 2, "heyo"); @@ -148,7 +148,7 @@ public void GetOffSet_SpanIsNotOwnerOfChange_ThrowsException() builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(null, 13); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null).CreateRed(null, 13); var change = new SourceChange(12, 2, "heyo"); @@ -167,7 +167,7 @@ public void GetOrigninalText_SpanIsOwner_ReturnsContent() builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(null, 13); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null).CreateRed(null, 13); var change = new SourceChange(15, 2, "heyo"); @@ -186,7 +186,7 @@ public void GetOrigninalText_SpanIsOwner_ReturnsContent_ZeroLengthSpan() builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "Hello, ")); builder.Add(SyntaxFactory.Token(SyntaxKind.Marker, "World")); - var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null).CreateRed(null, 13); + var node = SyntaxFactory.MarkupTextLiteral(builder.ToList(), SpanChunkGenerator.Null, editHandler: null).CreateRed(null, 13); var change = new SourceChange(15, 0, "heyo"); diff --git a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Syntax/SyntaxListTests.cs b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Syntax/SyntaxListTests.cs index 752dff9bd90..f4d56c71790 100644 --- a/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Syntax/SyntaxListTests.cs +++ b/src/Compiler/Microsoft.AspNetCore.Razor.Language/test/Syntax/SyntaxListTests.cs @@ -15,7 +15,7 @@ private static MarkupTextLiteralSyntax CreateMarkupTextLiteral(params ReadOnlySp using var builder = new PooledArrayBuilder(tokens.Length); builder.AddRange(tokens); - return SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null); + return SyntaxFactory.MarkupTextLiteral(builder.ToList()); } private static readonly SyntaxToken s_openAngle = SyntaxFactory.Token(SyntaxKind.OpenAngle, "<"); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultDirectiveSyntaxTreePass.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultDirectiveSyntaxTreePass.cs index eed054f6414..f39e404aaa3 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultDirectiveSyntaxTreePass.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultDirectiveSyntaxTreePass.cs @@ -69,7 +69,7 @@ public override SyntaxNode VisitRazorDirective(RazorDirectiveSyntax node) { _cancellationToken.ThrowIfCancellationRequested(); - if (node.DirectiveDescriptor?.Directive != SectionDirective.Directive.Directive) + if (!node.IsDirective(SectionDirective.Directive)) { // We only want to track the nesting of section directives. return base.VisitRazorDirective(node); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs index 0a217d897fa..d9a9aaaf626 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/DefaultRazorIntermediateNodeLoweringPhase.cs @@ -595,12 +595,13 @@ protected static MarkupTextLiteralSyntax MergeAttributeValue(MarkupLiteralAttrib node.Prefix?.LiteralTokens, node.Value?.LiteralTokens); - var rewritten = node.Prefix?.Update(valueTokens, node.Prefix.ChunkGenerator) ?? node.Value?.Update(valueTokens, node.Value.ChunkGenerator); + var rewritten = node.Prefix?.Update(valueTokens) ?? node.Value?.Update(valueTokens); + rewritten = (MarkupTextLiteralSyntax)rewritten?.Green.CreateRed(node, node.Position); - if (rewritten.GetEditHandler() is { } originalEditHandler) + if (rewritten.EditHandler is { } originalEditHandler) { - rewritten = rewritten.Update(rewritten.LiteralTokens, MarkupChunkGenerator.Instance).WithEditHandler(originalEditHandler); + rewritten = rewritten.Update(rewritten.LiteralTokens, MarkupChunkGenerator.Instance, originalEditHandler); } return rewritten; @@ -633,7 +634,8 @@ public override void VisitMarkupAttributeBlock(MarkupAttributeBlockSyntax node) new SyntaxTokenList(node.EqualsToken), node.ValuePrefix?.LiteralTokens); - var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens, chunkGenerator: null).Green.CreateRed(node, node.NamePrefix?.Position ?? node.Name.Position); + var position = node.NamePrefix?.Position ?? node.Name.Position; + var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens).Green.CreateRed(node, position); var name = node.Name.GetContent(); if (!_options.AllowConditionalDataDashAttributes && name.StartsWith("data-", StringComparison.OrdinalIgnoreCase)) @@ -658,14 +660,14 @@ public override void VisitMarkupAttributeBlock(MarkupAttributeBlockSyntax node) builder.AddRange(mergedValue.LiteralTokens); } - var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null); + var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList()); var mergedLiterals = MergeTokenLists( prefix?.LiteralTokens, rewritten.LiteralTokens, node.ValueSuffix?.LiteralTokens); - var mergedAttribute = SyntaxFactory.MarkupTextLiteral(mergedLiterals, chunkGenerator: null).Green.CreateRed(node.Parent, node.Position); + var mergedAttribute = SyntaxFactory.MarkupTextLiteral(mergedLiterals).Green.CreateRed(node.Parent, node.Position); Visit(mergedAttribute); return; @@ -704,7 +706,7 @@ public override void VisitMarkupMinimizedAttributeBlock(MarkupMinimizedAttribute node.NamePrefix?.LiteralTokens, node.Name?.LiteralTokens); - var literal = SyntaxFactory.MarkupTextLiteral(literals, chunkGenerator: null).Green.CreateRed(node.Parent, node.Position); + var literal = SyntaxFactory.MarkupTextLiteral(literals).Green.CreateRed(node.Parent, node.Position); Visit(literal); } @@ -889,7 +891,7 @@ public override void VisitCSharpExpressionLiteral(CSharpExpressionLiteralSyntax // If we are top level in a tag helper HTML attribute, we want to be rendered as markup. // This case happens for duplicate non-string bound attributes. They would be initially be categorized as // CSharp but since they are duplicate, they should just be markup. - var markupLiteral = SyntaxFactory.MarkupTextLiteral(node.LiteralTokens, chunkGenerator: null).Green.CreateRed(node.Parent, node.Position); + var markupLiteral = SyntaxFactory.MarkupTextLiteral(node.LiteralTokens).Green.CreateRed(node.Parent, node.Position); Visit(markupLiteral); return; } @@ -1184,7 +1186,7 @@ private void VisitAttributeValue(SyntaxNode node) builder.AddRange(mergedValue.LiteralTokens); } - var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null).Green.CreateRed(node.Parent, position); + var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList()).Green.CreateRed(node.Parent, position); Visit(rewritten); } else if (children.TryCast(out var markupLiteralArray)) @@ -1196,7 +1198,7 @@ private void VisitAttributeValue(SyntaxNode node) builder.AddRange(literal.LiteralTokens); } - var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null).Green.CreateRed(node.Parent, position); + var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList()).Green.CreateRed(node.Parent, position); Visit(rewritten); } else if (children.TryCast(out var expressionLiteralArray)) @@ -1208,12 +1210,11 @@ private void VisitAttributeValue(SyntaxNode node) foreach (var literal in expressionLiteralArray) { generator = literal.ChunkGenerator; - editHandler = literal.GetEditHandler(); + editHandler = literal.EditHandler; builder.AddRange(literal.LiteralTokens); } - var rewritten = SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), generator).Green.CreateRed(node.Parent, position); - rewritten = editHandler != null ? rewritten.WithEditHandler(editHandler) : rewritten; + var rewritten = SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), generator, editHandler).Green.CreateRed(node.Parent, position); Visit(rewritten); } else @@ -1380,7 +1381,8 @@ public override void VisitMarkupAttributeBlock(MarkupAttributeBlockSyntax node) new SyntaxTokenList(node.EqualsToken), node.ValuePrefix?.LiteralTokens); - var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens, chunkGenerator: null).Green.CreateRed(node, node.NamePrefix?.Position ?? node.Name.Position); + var position = node.NamePrefix?.Position ?? node.Name.Position; + var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens).Green.CreateRed(node, position); var name = node.Name.GetContent(); _builder.Push(new HtmlAttributeIntermediateNode() @@ -1402,7 +1404,8 @@ public override void VisitMarkupMinimizedAttributeBlock(MarkupMinimizedAttribute node.NamePrefix?.LiteralTokens, node.Name.LiteralTokens); - var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens, chunkGenerator: null).Green.CreateRed(node, node.NamePrefix?.Position ?? node.Name.Position); + var position = node.NamePrefix?.Position ?? node.Name.Position; + var prefix = (MarkupTextLiteralSyntax)SyntaxFactory.MarkupTextLiteral(prefixTokens).Green.CreateRed(node, position); var name = node.Name.GetContent(); _builder.Add(new HtmlAttributeIntermediateNode() @@ -1492,7 +1495,7 @@ public override void VisitMarkupTextLiteral(MarkupTextLiteralSyntax node) return; } - var context = node.GetEditHandler(); + var context = node.EditHandler; if (node.ChunkGenerator == SpanChunkGenerator.Null) { return; @@ -1699,7 +1702,7 @@ public override void VisitCSharpExpressionLiteral(CSharpExpressionLiteralSyntax // If we are top level in a tag helper HTML attribute, we want to be rendered as markup. // This case happens for duplicate non-string bound attributes. They would be initially be categorized as // CSharp but since they are duplicate, they should just be markup. - var markupLiteral = SyntaxFactory.MarkupTextLiteral(node.LiteralTokens, chunkGenerator: null).Green.CreateRed(node.Parent, node.Position); + var markupLiteral = SyntaxFactory.MarkupTextLiteral(node.LiteralTokens).Green.CreateRed(node.Parent, node.Position); Visit(markupLiteral); return; } @@ -2047,7 +2050,7 @@ private void VisitAttributeValue(SyntaxNode node) valueTokens.AddRange(mergedValue.LiteralTokens); } - var rewritten = SyntaxFactory.MarkupTextLiteral(valueTokens.ToList(), chunkGenerator: null).Green.CreateRed(node.Parent, position); + var rewritten = SyntaxFactory.MarkupTextLiteral(valueTokens.ToList()).Green.CreateRed(node.Parent, position); Visit(rewritten); } else if (children.TryCast(out var markupLiteralArray)) @@ -2059,7 +2062,7 @@ private void VisitAttributeValue(SyntaxNode node) builder.AddRange(literal.LiteralTokens); } - var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null).Green.CreateRed(node.Parent, position); + var rewritten = SyntaxFactory.MarkupTextLiteral(builder.ToList()).Green.CreateRed(node.Parent, position); Visit(rewritten); } else if (children.TryCast(out var expressionLiteralArray)) @@ -2071,16 +2074,11 @@ private void VisitAttributeValue(SyntaxNode node) foreach (var literal in expressionLiteralArray) { generator = literal.ChunkGenerator; - editHandler = literal.GetEditHandler(); + editHandler = literal.EditHandler; builder.AddRange(literal.LiteralTokens); } - var rewritten = SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), generator).Green.CreateRed(node.Parent, position); - - if (editHandler != null) - { - rewritten = rewritten.WithEditHandler(editHandler); - } + var rewritten = SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), generator, editHandler).Green.CreateRed(node.Parent, position); Visit(rewritten); } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/CSharpCodeParser.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/CSharpCodeParser.cs index 99a8e06c2a5..1270c10c540 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/CSharpCodeParser.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/CSharpCodeParser.cs @@ -314,7 +314,7 @@ public HtmlMarkupParser HtmlParser chunkGenerator = SpanChunkGenerator.Null; SetAcceptedCharacters(AcceptedCharactersInternal.None); - var transition = GetNodeWithEditHandler(SyntaxFactory.CSharpTransition(transitionToken, chunkGenerator)); + var transition = SyntaxFactory.CSharpTransition(transitionToken, chunkGenerator, GetEditHandler()); if (At(SyntaxKind.LeftBrace)) { @@ -1893,17 +1893,17 @@ RazorDirectiveSyntax BuildDirective(SyntaxKind expectedTokenKindIfMissing) var node = OutputTokensAsStatementLiteral(); if (node == null && directiveBuilder.Count == 0) { - node = SyntaxFactory.CSharpStatementLiteral(new SyntaxList(SyntaxFactory.MissingToken(expectedTokenKindIfMissing)), chunkGenerator); + node = SyntaxFactory.CSharpStatementLiteral(SyntaxFactory.MissingToken(expectedTokenKindIfMissing), chunkGenerator, editHandler: null); } + directiveBuilder.Add(node); var directiveCodeBlock = SyntaxFactory.CSharpCodeBlock(directiveBuilder.ToList()); var directiveBody = SyntaxFactory.RazorDirectiveBody(keywordBlock, directiveCodeBlock); - var directive = SyntaxFactory.RazorDirective(transition, directiveBody); + var directive = SyntaxFactory.RazorDirective(transition, directiveBody, descriptor); var diagnostics = directiveErrorSink.GetErrorsAndClear(); directive = directive.WithDiagnosticsGreen(diagnostics); - directive = directive.WithDirectiveDescriptor(descriptor); return directive; } } @@ -2709,7 +2709,7 @@ private void ParseReservedDirective(SyntaxListBuilder builder, var directiveBody = SyntaxFactory.RazorDirectiveBody(keyword, csharpCode: null); // transition could be null if we're already inside a code block. - transition = transition ?? SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition), chunkGenerator: null); + transition = transition ?? SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); var directive = SyntaxFactory.RazorDirective(transition, directiveBody); builder.Add(directive); } @@ -2811,7 +2811,7 @@ private void ExplicitExpressionSpanContextConfig(SpanEditHandlerBuilder? editHan return null; } - return GetNodeWithEditHandler(SyntaxFactory.CSharpStatementLiteral(tokens, chunkGenerator)); + return SyntaxFactory.CSharpStatementLiteral(tokens, chunkGenerator, GetEditHandler()); } private CSharpExpressionLiteralSyntax? OutputTokensAsExpressionLiteral() @@ -2822,7 +2822,7 @@ private void ExplicitExpressionSpanContextConfig(SpanEditHandlerBuilder? editHan return null; } - return GetNodeWithEditHandler(SyntaxFactory.CSharpExpressionLiteral(tokens, chunkGenerator)); + return SyntaxFactory.CSharpExpressionLiteral(tokens, chunkGenerator, GetEditHandler()); } private CSharpEphemeralTextLiteralSyntax? OutputTokensAsEphemeralLiteral() @@ -2833,7 +2833,7 @@ private void ExplicitExpressionSpanContextConfig(SpanEditHandlerBuilder? editHan return null; } - return GetNodeWithEditHandler(SyntaxFactory.CSharpEphemeralTextLiteral(tokens, chunkGenerator)); + return SyntaxFactory.CSharpEphemeralTextLiteral(tokens, chunkGenerator, GetEditHandler()); } private UnclassifiedTextLiteralSyntax? OutputTokensAsUnclassifiedLiteral() @@ -2844,7 +2844,7 @@ private void ExplicitExpressionSpanContextConfig(SpanEditHandlerBuilder? editHan return null; } - return GetNodeWithEditHandler(SyntaxFactory.UnclassifiedTextLiteral(tokens, chunkGenerator)); + return SyntaxFactory.UnclassifiedTextLiteral(tokens, chunkGenerator, GetEditHandler()); } private void OtherParserBlock(in SyntaxListBuilder builder) diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/HtmlMarkupParser.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/HtmlMarkupParser.cs index 3414da9cd18..7e6a22403f3 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/HtmlMarkupParser.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/HtmlMarkupParser.cs @@ -409,7 +409,7 @@ private void ParseMarkupTransition(in SyntaxListBuilder builder AcceptAndMoveNext(); SetAcceptedCharacters(AcceptedCharactersInternal.None); chunkGenerator = SpanChunkGenerator.Null; - var transition = GetNodeWithEditHandler(SyntaxFactory.MarkupTransition(Output(), chunkGenerator)); + var transition = SyntaxFactory.MarkupTransition(Output(), chunkGenerator, GetEditHandler()); builder.Add(transition); // "@:" => Explicit Single Line Block @@ -751,7 +751,17 @@ private MarkupStartTagSyntax ParseStartTag( } // End tag block - var startTag = SyntaxFactory.MarkupStartTag(openAngleToken, bangToken, tagNameToken, attributes, forwardSlashToken, closeAngleToken, chunkGenerator); + var startTag = SyntaxFactory.MarkupStartTag( + openAngleToken, + bangToken, + tagNameToken, + attributes, + forwardSlashToken, + closeAngleToken, + isMarkupTransition: false, + chunkGenerator, + GetEditHandler()); + if (string.Equals(tagName, ScriptTagName, StringComparison.OrdinalIgnoreCase)) { // If the script tag expects javascript content then we should do minimal parsing until we reach @@ -771,7 +781,7 @@ private MarkupStartTagSyntax ParseStartTag( tagMode = MarkupTagMode.Invalid; } - return GetNodeWithEditHandler(startTag); + return startTag; } private MarkupStartTagSyntax ParseStartTextTag(SyntaxToken openAngleToken, out MarkupTagMode tagMode, out bool isWellFormed) @@ -816,16 +826,16 @@ private MarkupStartTagSyntax ParseStartTextTag(SyntaxToken openAngleToken, out M isWellFormed = true; chunkGenerator = SpanChunkGenerator.Null; - var startTextTag = SyntaxFactory.MarkupStartTag( + return SyntaxFactory.MarkupStartTag( openAngleToken, bang: null, name: tagNameToken, attributes: miscAttributeContentBuilder.ToList(), forwardSlash: forwardSlashToken, closeAngle: closeAngleToken, - chunkGenerator); - - return GetNodeWithEditHandler(startTextTag).AsMarkupTransition(); + isMarkupTransition: true, + chunkGenerator, + GetEditHandler()); } } @@ -933,8 +943,16 @@ private MarkupEndTagSyntax ParseEndTag(ParseMode mode, out string tagName, out b } // End tag block - var endTag = SyntaxFactory.MarkupEndTag(openAngleToken, forwardSlashToken, bangToken, tagNameToken, miscAttributeContent, closeAngleToken, chunkGenerator); - return GetNodeWithEditHandler(endTag); + return SyntaxFactory.MarkupEndTag( + openAngleToken, + forwardSlashToken, + bangToken, + tagNameToken, + miscAttributeContent, + closeAngleToken, + isMarkupTransition: false, + chunkGenerator, + GetEditHandler()); } private MarkupEndTagSyntax ParseEndTextTag(SyntaxToken openAngleToken, SyntaxToken forwardSlashToken, out bool isWellFormed) @@ -974,15 +992,16 @@ private MarkupEndTagSyntax ParseEndTextTag(SyntaxToken openAngleToken, SyntaxTok } chunkGenerator = SpanChunkGenerator.Null; - var endTextTag = SyntaxFactory.MarkupEndTag( + return SyntaxFactory.MarkupEndTag( openAngleToken, forwardSlashToken, bang: null, name: tagNameToken, miscAttributeContent: miscAttributeContent, closeAngle: closeAngleToken, - chunkGenerator); - return GetNodeWithEditHandler(endTextTag).AsMarkupTransition(); + isMarkupTransition: true, + chunkGenerator, + GetEditHandler()); } private void ParseAttributes(in SyntaxListBuilder builder) @@ -1550,8 +1569,9 @@ private void ParseJavascriptAndEndScriptTag(in SyntaxListBuilder private static readonly ConditionalWeakTable s_spanDataTable = new(); - private static readonly ImmutableHashSet s_transitionSpanKinds = ImmutableHashSet.Create( + private static readonly FrozenSet s_transitionSpanKinds = FrozenSet.Create( SyntaxKind.CSharpTransition, SyntaxKind.MarkupTransition); - private static readonly ImmutableHashSet s_metaCodeSpanKinds = ImmutableHashSet.Create( - SyntaxKind.RazorMetaCode); - - private static readonly ImmutableHashSet s_commentSpanKinds = ImmutableHashSet.Create( + private static readonly FrozenSet s_commentSpanKinds = FrozenSet.Create( SyntaxKind.RazorCommentTransition, SyntaxKind.RazorCommentStar, SyntaxKind.RazorCommentLiteral); - private static readonly ImmutableHashSet s_codeSpanKinds = ImmutableHashSet.Create( + private static readonly FrozenSet s_codeSpanKinds = FrozenSet.Create( SyntaxKind.CSharpStatementLiteral, SyntaxKind.CSharpExpressionLiteral, SyntaxKind.CSharpEphemeralTextLiteral); - private static readonly ImmutableHashSet s_markupSpanKinds = ImmutableHashSet.Create( + private static readonly FrozenSet s_markupSpanKinds = FrozenSet.Create( SyntaxKind.MarkupTextLiteral, SyntaxKind.MarkupEphemeralTextLiteral); - private static readonly ImmutableHashSet s_noneSpanKinds = ImmutableHashSet.Create( - SyntaxKind.UnclassifiedTextLiteral); - - private static readonly ImmutableHashSet s_allSpanKinds = CreateAllSpanKindsSet(); + private static readonly FrozenSet s_allSpanKinds = CreateAllSpanKindsSet(); - private static ImmutableHashSet CreateAllSpanKindsSet() + private static FrozenSet CreateAllSpanKindsSet() { - var set = ImmutableHashSet.Empty.ToBuilder(); + var set = new HashSet(); set.UnionWith(s_transitionSpanKinds); - set.UnionWith(s_metaCodeSpanKinds); + set.Add(SyntaxKind.RazorMetaCode); set.UnionWith(s_commentSpanKinds); set.UnionWith(s_codeSpanKinds); set.UnionWith(s_markupSpanKinds); - set.UnionWith(s_noneSpanKinds); + set.Add(SyntaxKind.UnclassifiedTextLiteral); - return set.ToImmutable(); + return set.ToFrozenSet(); } internal static ISpanChunkGenerator? GetChunkGenerator(this SyntaxNode node) - => node switch - { - MarkupStartTagSyntax start => start.ChunkGenerator, - MarkupEndTagSyntax end => end.ChunkGenerator, - MarkupEphemeralTextLiteralSyntax ephemeral => ephemeral.ChunkGenerator, - MarkupTagHelperStartTagSyntax start => start.ChunkGenerator, - MarkupTagHelperEndTagSyntax end => end.ChunkGenerator, - MarkupTextLiteralSyntax text => text.ChunkGenerator, - MarkupTransitionSyntax transition => transition.ChunkGenerator, - CSharpStatementLiteralSyntax csharp => csharp.ChunkGenerator, - CSharpExpressionLiteralSyntax csharp => csharp.ChunkGenerator, - CSharpEphemeralTextLiteralSyntax csharp => csharp.ChunkGenerator, - CSharpTransitionSyntax transition => transition.ChunkGenerator, - RazorMetaCodeSyntax meta => meta.ChunkGenerator, - UnclassifiedTextLiteralSyntax unclassified => unclassified.ChunkGenerator, - _ => null, - }; - - public static SpanEditHandler? GetEditHandler(this SyntaxNode node) => node.GetAnnotationValue(SyntaxConstants.EditHandlerKind) as SpanEditHandler; - - public static SpanEditHandler? GetEditHandler(this SyntaxToken token) => token.GetAnnotationValue(SyntaxConstants.EditHandlerKind) as SpanEditHandler; - - public static TNode WithEditHandler(this TNode node, SpanEditHandler? editHandler) where TNode : SyntaxNode - { - if (node is null) - { - throw new ArgumentNullException(nameof(node)); - } + => (node as ILegacySyntax)?.ChunkGenerator; - if (editHandler is null) - { - if (node.ContainsAnnotations) - { - List? filteredAnnotations = null; - foreach (var annotation in node.GetAnnotations()) - { - if (annotation.Kind != SyntaxConstants.EditHandlerKind) - { - (filteredAnnotations ??= new List()).Add(annotation); - } - } - - return node.WithAnnotations(filteredAnnotations?.ToArray() ?? Array.Empty()); - } - else - { - return node; - } - } - - var newAnnotation = new SyntaxAnnotation(SyntaxConstants.EditHandlerKind, editHandler); - - List? newAnnotations = null; - if (node.ContainsAnnotations) - { - foreach (var annotation in node.GetAnnotations()) - { - if (annotation.Kind != newAnnotation.Kind) - { - newAnnotations ??= new List - { - newAnnotation - }; - - newAnnotations.Add(annotation); - } - } - } - - var newAnnotationsArray = newAnnotations is null - ? new[] { newAnnotation } - : newAnnotations.ToArray(); - - return node.WithAnnotations(newAnnotationsArray); - } + public static SpanEditHandler? GetEditHandler(this SyntaxNode node) + => (node as ILegacySyntax)?.EditHandler; [Obsolete("Use FindToken or FindInnermostNode instead", error: false)] public static SyntaxNode? LocateOwner(this SyntaxNode node, SourceChange change) @@ -212,16 +135,14 @@ public static bool IsTransitionSpanKind(this SyntaxNode node) public static bool IsMetaCodeSpanKind(this SyntaxNodeOrToken nodeOrToken) { - ArgHelper.ThrowIfNull(nodeOrToken); - - return s_metaCodeSpanKinds.Contains(nodeOrToken.Kind); + return nodeOrToken.AsNode(out var node) && node.IsMetaCodeSpanKind(); } public static bool IsMetaCodeSpanKind(this SyntaxNode node) { ArgHelper.ThrowIfNull(node); - return s_metaCodeSpanKinds.Contains(node.Kind); + return node.Kind is SyntaxKind.RazorMetaCode; } public static bool IsCommentSpanKind(this SyntaxNode node) @@ -249,7 +170,7 @@ public static bool IsNoneSpanKind(this SyntaxNode node) { ArgHelper.ThrowIfNull(node); - return s_noneSpanKinds.Contains(node.Kind); + return node.Kind is SyntaxKind.UnclassifiedTextLiteral; } public static bool IsSpanKind(this SyntaxNode node) diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SpanEditHandler.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SpanEditHandler.cs index c11f98ce705..68e78e7e7ce 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SpanEditHandler.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SpanEditHandler.cs @@ -6,7 +6,6 @@ using System; using System.Collections.Generic; using System.Collections.Immutable; -using System.Diagnostics; using Microsoft.AspNetCore.Razor.Language.Syntax; namespace Microsoft.AspNetCore.Razor.Language.Legacy; @@ -96,43 +95,17 @@ protected virtual SyntaxNode UpdateSpan(SyntaxNode target, SourceChange change) builder.Add(token); } - SyntaxNode newTarget = null; - if (target is RazorMetaCodeSyntax metaCode) + var newTarget = target switch { - newTarget = Syntax.InternalSyntax.SyntaxFactory.RazorMetaCode(builder.ToList(), metaCode.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is MarkupTextLiteralSyntax markupLiteral) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.MarkupTextLiteral(builder.ToList(), markupLiteral.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is MarkupEphemeralTextLiteralSyntax ephemeral) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.MarkupEphemeralTextLiteral(builder.ToList(), ephemeral.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is CSharpStatementLiteralSyntax statement) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.CSharpStatementLiteral(builder.ToList(), statement.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is CSharpExpressionLiteralSyntax expression) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), expression.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is CSharpEphemeralTextLiteralSyntax cSharpEphemeral) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.CSharpEphemeralTextLiteral(builder.ToList(), cSharpEphemeral.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else if (target is UnclassifiedTextLiteralSyntax unclassified) - { - newTarget = Syntax.InternalSyntax.SyntaxFactory.UnclassifiedTextLiteral(builder.ToList(), unclassified.ChunkGenerator).CreateRed(target.Parent, target.Position); - } - else - { - Debug.Fail($"The type {target?.GetType().Name} is not a supported span node."); - } - - var editHandler = target.GetEditHandler(); - newTarget = editHandler != null ? newTarget?.WithEditHandler(editHandler) : newTarget; - + RazorMetaCodeSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.RazorMetaCode(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + MarkupTextLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.MarkupTextLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + MarkupEphemeralTextLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.MarkupEphemeralTextLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + CSharpStatementLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.CSharpStatementLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + CSharpExpressionLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + CSharpEphemeralTextLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.CSharpEphemeralTextLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + UnclassifiedTextLiteralSyntax syntax => Syntax.InternalSyntax.SyntaxFactory.UnclassifiedTextLiteral(builder.ToList(), syntax.ChunkGenerator, syntax.EditHandler).CreateRed(target.Parent, target.Position), + _ => Assumed.Unreachable($"The type {target?.GetType().Name} is not a supported span node."), + }; return newTarget; } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpEphemeralTextLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpEphemeralTextLiteralSyntax.cs new file mode 100644 index 00000000000..c40a53efb43 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpEphemeralTextLiteralSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class CSharpEphemeralTextLiteralSyntax : ILegacySyntax +{ + public CSharpEphemeralTextLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpExpressionLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpExpressionLiteralSyntax.cs new file mode 100644 index 00000000000..3562f85e7b5 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpExpressionLiteralSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class CSharpExpressionLiteralSyntax : ILegacySyntax +{ + public CSharpExpressionLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpStatementLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpStatementLiteralSyntax.cs new file mode 100644 index 00000000000..4c577c86eed --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpStatementLiteralSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class CSharpStatementLiteralSyntax : ILegacySyntax +{ + public CSharpStatementLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpTransitionSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpTransitionSyntax.cs new file mode 100644 index 00000000000..b256c5649af --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/CSharpTransitionSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class CSharpTransitionSyntax : ILegacySyntax +{ + public CSharpTransitionSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(Transition, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEndTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEndTagSyntax.cs new file mode 100644 index 00000000000..1f4e115afe3 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEndTagSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupEndTagSyntax : ILegacySyntax +{ + public MarkupEndTagSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEphemeralTextLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEphemeralTextLiteralSyntax.cs new file mode 100644 index 00000000000..6c99e8bdcd8 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupEphemeralTextLiteralSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupEphemeralTextLiteralSyntax : ILegacySyntax +{ + public MarkupEphemeralTextLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupStartTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupStartTagSyntax.cs new file mode 100644 index 00000000000..98550a5f2a5 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupStartTagSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupStartTagSyntax : ILegacySyntax +{ + public MarkupStartTagSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperEndTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperEndTagSyntax.cs new file mode 100644 index 00000000000..ce0bc29a0cf --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperEndTagSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupTagHelperEndTagSyntax : ILegacySyntax +{ + public MarkupTagHelperEndTagSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperStartTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperStartTagSyntax.cs new file mode 100644 index 00000000000..1e59e59a433 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTagHelperStartTagSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupTagHelperStartTagSyntax : ILegacySyntax +{ + public MarkupTagHelperStartTagSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTextLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTextLiteralSyntax.cs new file mode 100644 index 00000000000..03c4e6b28ac --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTextLiteralSyntax.cs @@ -0,0 +1,21 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupTextLiteralSyntax : ILegacySyntax +{ + public MarkupTextLiteralSyntax Update(SyntaxTokenList literalTokens) + => Update(literalTokens, ChunkGenerator, EditHandler); + + public MarkupTextLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTransitionSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTransitionSyntax.cs new file mode 100644 index 00000000000..daff0cbb1e6 --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/MarkupTransitionSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class MarkupTransitionSyntax : ILegacySyntax +{ + public MarkupTransitionSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(TransitionTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/RazorMetaCodeSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/RazorMetaCodeSyntax.cs new file mode 100644 index 00000000000..ded029e622f --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/RazorMetaCodeSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class RazorMetaCodeSyntax : ILegacySyntax +{ + public RazorMetaCodeSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(MetaCode, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/SyntaxFactory.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/SyntaxFactory.cs new file mode 100644 index 00000000000..a0806c26c0a --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/SyntaxFactory.cs @@ -0,0 +1,28 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal static partial class SyntaxFactory +{ + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(SyntaxToken token) + => CSharpExpressionLiteral(new SyntaxTokenList(token), chunkGenerator: null, editHandler: null); + + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(SyntaxTokenList literalTokens) + => CSharpExpressionLiteral(literalTokens, chunkGenerator: null, editHandler: null); + + public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition) + => CSharpTransition(transition, chunkGenerator: null, editHandler: null); + + public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxToken token) + => MarkupTextLiteral(new SyntaxTokenList(token), chunkGenerator: null, editHandler: null); + + public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxTokenList literalTokens) + => MarkupTextLiteral(literalTokens, chunkGenerator: null, editHandler: null); + + public static RazorMetaCodeSyntax RazorMetaCode(SyntaxToken token) + => RazorMetaCode(new SyntaxTokenList(token), chunkGenerator:null, editHandler: null); + + public static RazorMetaCodeSyntax RazorMetaCode(SyntaxTokenList metaCode) + => RazorMetaCode(metaCode, chunkGenerator: null, editHandler: null); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/UnclassifiedTextLiteralSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/UnclassifiedTextLiteralSyntax.cs new file mode 100644 index 00000000000..f4ea2bdeb7d --- /dev/null +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/Syntax/UnclassifiedTextLiteralSyntax.cs @@ -0,0 +1,18 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. + +using Microsoft.AspNetCore.Razor.Language.Legacy; + +namespace Microsoft.AspNetCore.Razor.Language.Syntax; + +internal partial class UnclassifiedTextLiteralSyntax : ILegacySyntax +{ + public UnclassifiedTextLiteralSyntax Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(LiteralTokens, chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.Update(ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => Update(chunkGenerator, editHandler); + + SyntaxNode ILegacySyntax.WithEditHandler(SpanEditHandler? editHandler) + => WithEditHandler(editHandler); +} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SyntaxConstants.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SyntaxConstants.cs index 6794dfe0390..b11b2f319d1 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SyntaxConstants.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/SyntaxConstants.cs @@ -12,7 +12,6 @@ internal static class SyntaxConstants public const string TransitionString = "@"; public const string StartCommentSequence = "@*"; public const string EndCommentSequence = "*@"; - public const string EditHandlerKind = "EditHandler"; public static class CSharp { diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs index debec884d2a..1b69b0860bc 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperBlockRewriter.cs @@ -202,10 +202,15 @@ public static MarkupTagHelperStartTagSyntax Rewrite( attributes = attributeBuilder.ToList(); } - var tagHelperStartTag = SyntaxFactory.MarkupTagHelperStartTag( - startTag.OpenAngle, startTag.Bang, startTag.Name, attributes, startTag.ForwardSlash, startTag.CloseAngle, startTag.ChunkGenerator); - - return tagHelperStartTag.WithEditHandler(startTag.GetEditHandler()); + return SyntaxFactory.MarkupTagHelperStartTag( + startTag.OpenAngle, + startTag.Bang, + startTag.Name, + attributes, + startTag.ForwardSlash, + startTag.CloseAngle, + startTag.ChunkGenerator, + startTag.EditHandler); } private static TryParseResult TryParseMinimizedAttribute( @@ -231,10 +236,13 @@ private static TryParseResult TryParseMinimizedAttribute( { var rewritten = SyntaxFactory.MarkupMinimizedTagHelperAttribute( attributeBlock.NamePrefix, - attributeBlock.Name); - - rewritten = rewritten.WithTagHelperAttributeInfo( - new TagHelperAttributeInfo(result.AttributeName, parameterName: null, result.AttributeStructure, result.IsBoundAttribute, isDirectiveAttribute: false)); + attributeBlock.Name, + new TagHelperAttributeInfo( + result.AttributeName, + parameterName: null, + result.AttributeStructure, + result.IsBoundAttribute, + isDirectiveAttribute: false)); result.RewrittenAttribute = rewritten; @@ -287,7 +295,7 @@ private static TryParseResult TryParseAttribute( using PooledArrayBuilder builder = []; // Add a marker for attribute value when there are no quotes like,

- builder.Add(SyntaxFactory.MarkupTextLiteral(literalTokens: default, chunkGenerator: null)); + builder.Add(SyntaxFactory.MarkupTextLiteral(literalTokens: default)); attributeValue = SyntaxFactory.GenericBlock(builder.ToList()); } @@ -309,10 +317,13 @@ private static TryParseResult TryParseAttribute( attributeBlock.EqualsToken, attributeBlock.ValuePrefix, rewrittenValue, - attributeBlock.ValueSuffix); - - rewritten = rewritten.WithTagHelperAttributeInfo( - new TagHelperAttributeInfo(result.AttributeName, parameterName: null, result.AttributeStructure, result.IsBoundAttribute, isDirectiveAttribute: false)); + attributeBlock.ValueSuffix, + new TagHelperAttributeInfo( + result.AttributeName, + parameterName: null, + result.AttributeStructure, + result.IsBoundAttribute, + isDirectiveAttribute: false)); result.RewrittenAttribute = rewritten; @@ -336,18 +347,17 @@ private static MarkupTagHelperDirectiveAttributeSyntax RewriteToDirectiveAttribu // var attributeName = result.AttributeName; var attributeNameSyntax = attributeBlock.Name; - var transition = SyntaxFactory.RazorMetaCode( - new SyntaxTokenList(SyntaxFactory.MissingToken(SyntaxKind.Transition)), chunkGenerator: null); + var transition = SyntaxFactory.RazorMetaCode(SyntaxFactory.MissingToken(SyntaxKind.Transition)); RazorMetaCodeSyntax colon = null; MarkupTextLiteralSyntax parameterName = null; if (attributeName.StartsWith("@", StringComparison.Ordinal)) { attributeName = attributeName.Substring(1); var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, attributeName); - attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(attributeNameToken); + attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(attributeNameToken); var transitionToken = SyntaxFactory.Token(SyntaxKind.Transition, "@"); - transition = SyntaxFactory.RazorMetaCode(new SyntaxTokenList(transitionToken), chunkGenerator: null); + transition = SyntaxFactory.RazorMetaCode(transitionToken); } if (attributeName.IndexOf(':') != -1) @@ -355,16 +365,16 @@ private static MarkupTagHelperDirectiveAttributeSyntax RewriteToDirectiveAttribu var segments = attributeName.Split(new[] { ':' }, 2); var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[0]); - attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(attributeNameToken); + attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(attributeNameToken); var colonToken = SyntaxFactory.Token(SyntaxKind.Colon, ":"); - colon = SyntaxFactory.RazorMetaCode(new SyntaxTokenList(colonToken), chunkGenerator: null); + colon = SyntaxFactory.RazorMetaCode(colonToken); var parameterNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[1]); - parameterName = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(parameterNameToken); + parameterName = SyntaxFactory.MarkupTextLiteral(parameterNameToken); } - var rewritten = SyntaxFactory.MarkupTagHelperDirectiveAttribute( + return SyntaxFactory.MarkupTagHelperDirectiveAttribute( attributeBlock.NamePrefix, transition, attributeNameSyntax, @@ -374,12 +384,13 @@ private static MarkupTagHelperDirectiveAttributeSyntax RewriteToDirectiveAttribu attributeBlock.EqualsToken, attributeBlock.ValuePrefix, rewrittenValue, - attributeBlock.ValueSuffix); - - rewritten = rewritten.WithTagHelperAttributeInfo( - new TagHelperAttributeInfo(result.AttributeName, parameterName?.GetContent(), result.AttributeStructure, result.IsBoundAttribute, isDirectiveAttribute: true)); - - return rewritten; + attributeBlock.ValueSuffix, + new TagHelperAttributeInfo( + result.AttributeName, + parameterName?.GetContent(), + result.AttributeStructure, + result.IsBoundAttribute, + isDirectiveAttribute: true)); } private static MarkupMinimizedTagHelperDirectiveAttributeSyntax RewriteToMinimizedDirectiveAttribute( @@ -397,18 +408,17 @@ private static MarkupMinimizedTagHelperDirectiveAttributeSyntax RewriteToMinimiz // var attributeName = result.AttributeName; var attributeNameSyntax = attributeBlock.Name; - var transition = SyntaxFactory.RazorMetaCode( - new SyntaxTokenList(SyntaxFactory.MissingToken(SyntaxKind.Transition)), chunkGenerator: null); + var transition = SyntaxFactory.RazorMetaCode(SyntaxFactory.MissingToken(SyntaxKind.Transition)); RazorMetaCodeSyntax colon = null; MarkupTextLiteralSyntax parameterName = null; if (attributeName.StartsWith("@", StringComparison.Ordinal)) { attributeName = attributeName.Substring(1); var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, attributeName); - attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(attributeNameToken); + attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(attributeNameToken); var transitionToken = SyntaxFactory.Token(SyntaxKind.Transition, "@"); - transition = SyntaxFactory.RazorMetaCode(new SyntaxTokenList(transitionToken), chunkGenerator: null); + transition = SyntaxFactory.RazorMetaCode(transitionToken); } if (attributeName.IndexOf(':') != -1) @@ -416,26 +426,27 @@ private static MarkupMinimizedTagHelperDirectiveAttributeSyntax RewriteToMinimiz var segments = attributeName.Split(new[] { ':' }, 2); var attributeNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[0]); - attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(attributeNameToken); + attributeNameSyntax = SyntaxFactory.MarkupTextLiteral(attributeNameToken); var colonToken = SyntaxFactory.Token(SyntaxKind.Colon, ":"); - colon = SyntaxFactory.RazorMetaCode(new SyntaxTokenList(colonToken), chunkGenerator: null); + colon = SyntaxFactory.RazorMetaCode(colonToken); var parameterNameToken = SyntaxFactory.Token(SyntaxKind.Text, segments[1]); - parameterName = SyntaxFactory.MarkupTextLiteral(chunkGenerator: null).AddLiteralTokens(parameterNameToken); + parameterName = SyntaxFactory.MarkupTextLiteral(parameterNameToken); } - var rewritten = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute( + return SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute( attributeBlock.NamePrefix, transition, attributeNameSyntax, colon, - parameterName); - - rewritten = rewritten.WithTagHelperAttributeInfo( - new TagHelperAttributeInfo(result.AttributeName, parameterName?.GetContent(), result.AttributeStructure, result.IsBoundAttribute, isDirectiveAttribute: true)); - - return rewritten; + parameterName, + new TagHelperAttributeInfo( + result.AttributeName, + parameterName?.GetContent(), + result.AttributeStructure, + result.IsBoundAttribute, + isDirectiveAttribute: true)); } private static MarkupTagHelperAttributeValueSyntax RewriteAttributeValue(TryParseResult result, RazorBlockSyntax attributeValue, RazorParserOptions options) @@ -566,7 +577,7 @@ public override SyntaxNode VisitGenericBlock(GenericBlockSyntax node) return SyntaxFactory.MarkupBlock( [SyntaxFactory.CSharpCodeBlock( [SyntaxFactory.CSharpImplicitExpression( - SyntaxFactory.CSharpTransition(transition, chunkGenerator: null), + SyntaxFactory.CSharpTransition(transition), SyntaxFactory.CSharpImplicitExpressionBody( SyntaxFactory.CSharpCodeBlock(children)))])]); } @@ -578,7 +589,7 @@ public override SyntaxNode VisitGenericBlock(GenericBlockSyntax node) SyntaxList createExpressionLiteral(SyntaxTokenList tokens) { - var expression = SyntaxFactory.CSharpExpressionLiteral(tokens, chunkGenerator: null); + var expression = SyntaxFactory.CSharpExpressionLiteral(tokens); var rewrittenExpression = (CSharpExpressionLiteralSyntax)VisitCSharpExpressionLiteral(expression); return [rewrittenExpression]; } @@ -603,7 +614,7 @@ public override SyntaxNode VisitCSharpTransition(CSharpTransitionSyntax node) if (_rewriteAsMarkup) { // Change to a MarkupChunkGenerator so that the '@' \ parenthesis is generated as part of the output. - var expression = SyntaxFactory.CSharpExpressionLiteral(new SyntaxTokenList(node.Transition), MarkupChunkGenerator.Instance).WithEditHandler(node.GetEditHandler()); + var expression = SyntaxFactory.CSharpExpressionLiteral(node.Transition, MarkupChunkGenerator.Instance, node.EditHandler); return base.VisitCSharpExpressionLiteral(expression); } @@ -627,13 +638,11 @@ public override SyntaxNode VisitCSharpImplicitExpression(CSharpImplicitExpressio var firstToken = firstChild.GetFirstToken(); var newFirstToken = SyntaxFactory.Token(firstToken.Kind, node.Transition.Transition.Content + firstToken.Content); - firstToken.CopyAnnotationsTo(newFirstToken); - var newFirstChild = firstChild.ReplaceToken(firstToken, newFirstToken); builder.AddRange(rewrittenBody.Children.Replace(firstChild, newFirstChild)); // Since the original transition is part of the body, we need something to take it's place. - var transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition), chunkGenerator: null); + var transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); var rewrittenCodeBlock = SyntaxFactory.CSharpCodeBlock(builder.ToList()); return SyntaxFactory.CSharpImplicitExpression(transition, SyntaxFactory.CSharpImplicitExpressionBody(rewrittenCodeBlock)); @@ -653,15 +662,15 @@ public override SyntaxNode VisitCSharpExplicitExpression(CSharpExplicitExpressio // Change to a MarkupChunkGenerator so that the '@' \ parenthesis is generated as part of the output. // This is bad code, since @( is never valid C#, so we don't worry about trying to stitch the @ and the ( together. var editHandler = _options.EnableSpanEditHandlers - ? node.GetEditHandler() ?? SpanEditHandler.GetDefault(AcceptedCharactersInternal.Any) + ? SpanEditHandler.GetDefault(AcceptedCharactersInternal.Any) : null; - var expression = SyntaxFactory.CSharpExpressionLiteral(new SyntaxTokenList(node.Transition.Transition), MarkupChunkGenerator.Instance).WithEditHandler(editHandler); + var expression = SyntaxFactory.CSharpExpressionLiteral(node.Transition.Transition, MarkupChunkGenerator.Instance, editHandler); expression = (CSharpExpressionLiteralSyntax)VisitCSharpExpressionLiteral(expression); builder.Add(expression); // Since the original transition is part of the body, we need something to take it's place. - transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition), chunkGenerator: null); + transition = SyntaxFactory.CSharpTransition(SyntaxFactory.MissingToken(SyntaxKind.Transition)); var body = (CSharpExplicitExpressionBodySyntax)node.Body; var rewrittenOpenParen = (RazorSyntaxNode)VisitRazorMetaCode(body.OpenParen); @@ -700,7 +709,7 @@ public override SyntaxNode VisitRazorMetaCode(RazorMetaCodeSyntax node) if (_rewriteAsMarkup) { // Change to a MarkupChunkGenerator so that the '@' \ parenthesis is generated as part of the output. - var expression = SyntaxFactory.CSharpExpressionLiteral(node.MetaCode, MarkupChunkGenerator.Instance).WithEditHandler(node.GetEditHandler()); + var expression = SyntaxFactory.CSharpExpressionLiteral(node.MetaCode, MarkupChunkGenerator.Instance, node.EditHandler); return VisitCSharpExpressionLiteral(expression); } @@ -762,14 +771,12 @@ public override SyntaxNode VisitMarkupLiteralAttributeValue(MarkupLiteralAttribu { _rewriteAsMarkup = true; // Since this is a bound non-string attribute, we want to convert LiteralAttributeValue to just be a CSharp Expression literal. - var expression = SyntaxFactory.CSharpExpressionLiteral(builder.ToList(), chunkGenerator: null); + var expression = SyntaxFactory.CSharpExpressionLiteral(builder.ToList()); return VisitCSharpExpressionLiteral(expression); } else { - var literal = SyntaxFactory.MarkupTextLiteral(builder.ToList(), node.Value?.ChunkGenerator); - var editHandler = node.Value?.GetEditHandler(); - literal = literal.WithEditHandler(editHandler); + var literal = SyntaxFactory.MarkupTextLiteral(builder.ToList(), node.Value?.ChunkGenerator, node.Value?.EditHandler); return Visit(literal); } @@ -815,8 +822,7 @@ public override SyntaxNode VisitMarkupTextLiteral(MarkupTextLiteralSyntax node) _rewriteAsMarkup = true; node = (MarkupTextLiteralSyntax)ConfigureNonStringAttribute(node); - var value = SyntaxFactory.CSharpExpressionLiteral(node.LiteralTokens, node.ChunkGenerator); - return value.WithEditHandler(node.GetEditHandler()); + return SyntaxFactory.CSharpExpressionLiteral(node.LiteralTokens, node.ChunkGenerator, node.EditHandler); } public override SyntaxNode VisitMarkupEphemeralTextLiteral(MarkupEphemeralTextLiteralSyntax node) @@ -830,8 +836,7 @@ public override SyntaxNode VisitMarkupEphemeralTextLiteral(MarkupEphemeralTextLi // Rewriting it to CSharpEphemeralTextLiteral so that it is not rendered to output. _rewriteAsMarkup = true; node = (MarkupEphemeralTextLiteralSyntax)ConfigureNonStringAttribute(node); - var value = SyntaxFactory.CSharpEphemeralTextLiteral(node.LiteralTokens, node.ChunkGenerator); - return value.WithEditHandler(node.GetEditHandler()); + return SyntaxFactory.CSharpEphemeralTextLiteral(node.LiteralTokens, node.ChunkGenerator, node.EditHandler); } // Being collapsed represents that a block contains several identical looking markup literal attribute values. This can be the case @@ -893,30 +898,18 @@ private SyntaxNode ConfigureNonStringAttribute(SyntaxNode node) newGenerator = new ExpressionChunkGenerator(); } + context = builder?.Build(AcceptedCharactersInternal.AnyExceptNewline); + if (originalGenerator != newGenerator) { - node = node switch - { - MarkupStartTagSyntax start => start.Update(start.OpenAngle, start.Bang, start.Name, start.Attributes, start.ForwardSlash, start.CloseAngle, newGenerator), - MarkupEndTagSyntax end => end.Update(end.OpenAngle, end.ForwardSlash, end.Bang, end.Name, end.MiscAttributeContent, end.CloseAngle, newGenerator), - MarkupEphemeralTextLiteralSyntax ephemeral => ephemeral.Update(ephemeral.LiteralTokens, newGenerator), - MarkupTagHelperStartTagSyntax start => start.Update(start.OpenAngle, start.Bang, start.Name, start.Attributes, start.ForwardSlash, start.CloseAngle, newGenerator), - MarkupTagHelperEndTagSyntax end => end.Update(end.OpenAngle, end.ForwardSlash, end.Bang, end.Name, end.MiscAttributeContent, end.CloseAngle, newGenerator), - MarkupTextLiteralSyntax text => text.Update(text.LiteralTokens, newGenerator), - MarkupTransitionSyntax transition => transition.Update(transition.TransitionTokens, newGenerator), - CSharpStatementLiteralSyntax csharp => csharp.Update(csharp.LiteralTokens, newGenerator), - CSharpExpressionLiteralSyntax csharp => csharp.Update(csharp.LiteralTokens, newGenerator), - CSharpEphemeralTextLiteralSyntax ephemeral => ephemeral.Update(ephemeral.LiteralTokens, newGenerator), - CSharpTransitionSyntax transition => transition.Update(transition.Transition, newGenerator), - RazorMetaCodeSyntax meta => meta.Update(meta.MetaCode, newGenerator), - UnclassifiedTextLiteralSyntax unclassified => unclassified.Update(unclassified.LiteralTokens, newGenerator), - _ => throw new InvalidOperationException($"Unexpected node type {node.Kind}"), - }; + return (node as ILegacySyntax)?.Update(newGenerator, context) + ?? Assumed.Unreachable($"Unexpected node type {node.Kind}"); + } + else + { + return (node as ILegacySyntax)?.WithEditHandler(context) + ?? Assumed.Unreachable($"Unexpected node type {node.Kind}"); } - - context = builder?.Build(AcceptedCharactersInternal.AnyExceptNewline); - - return node.WithEditHandler(context); } } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs index f422085c7eb..26dc3dae791 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperParseTreeRewriter.cs @@ -120,17 +120,17 @@ public override SyntaxNode VisitMarkupElement(MarkupElementSyntax node) // This is a tag helper. if (tagHelperInfo.TagMode == TagMode.SelfClosing || tagHelperInfo.TagMode == TagMode.StartTagOnly) { - var tagHelperElement = SyntaxFactory.MarkupTagHelperElement(tagHelperStart, body: default, endTag: null); - var rewrittenTagHelper = tagHelperElement.WithTagHelperInfo(tagHelperInfo); + var tagHelperElement = SyntaxFactory.MarkupTagHelperElement(tagHelperStart, body: default, endTag: null, tagHelperInfo); + if (node.Body.Count == 0 && node.EndTag == null) { - return rewrittenTagHelper; + return tagHelperElement; } // This tag contains a body and/or an end tag which needs to be moved to the parent. using PooledArrayBuilder rewrittenNodes = []; - rewrittenNodes.Add(rewrittenTagHelper); + rewrittenNodes.Add(tagHelperElement); var rewrittenBody = VisitList(node.Body); rewrittenNodes.AddRange(rewrittenBody); @@ -208,8 +208,7 @@ public override SyntaxNode VisitMarkupElement(MarkupElementSyntax node) if (tagHelperInfo != null) { // If we get here it means this element was rewritten as a tag helper. - var tagHelperElement = SyntaxFactory.MarkupTagHelperElement(tagHelperStart, body, tagHelperEnd); - return tagHelperElement.WithTagHelperInfo(tagHelperInfo); + return SyntaxFactory.MarkupTagHelperElement(tagHelperStart, body, tagHelperEnd, tagHelperInfo); } // There was no matching tag helper for this element. Return. @@ -380,7 +379,14 @@ private bool TryRewriteTagHelperEnd( } rewritten = SyntaxFactory.MarkupTagHelperEndTag( - endTag.OpenAngle, endTag.ForwardSlash, endTag.Bang, endTag.Name, endTag.MiscAttributeContent, endTag.CloseAngle, chunkGenerator: null); + endTag.OpenAngle, + endTag.ForwardSlash, + endTag.Bang, + endTag.Name, + endTag.MiscAttributeContent, + endTag.CloseAngle, + chunkGenerator: null, + editHandler: null); return true; } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperSpanVisitor.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperSpanVisitor.cs index f680a1a00d9..6a5041f7637 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperSpanVisitor.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TagHelperSpanVisitor.cs @@ -30,7 +30,7 @@ public static ImmutableArray VisitRoot(RazorSyntaxTree sy public override void VisitMarkupTagHelperElement(MarkupTagHelperElementSyntax node) { - var span = new TagHelperSpanInternal(node.GetSourceSpan(_source), node.TagHelperInfo.AssumeNotNull().BindingResult); + var span = new TagHelperSpanInternal(node.GetSourceSpan(_source), node.TagHelperInfo.BindingResult); _spans.Add(span); base.VisitMarkupTagHelperElement(node); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TokenizerBackedParser.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TokenizerBackedParser.cs index 38f57e353a1..0caf3ec8bbb 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TokenizerBackedParser.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/TokenizerBackedParser.cs @@ -621,7 +621,7 @@ protected MarkupTextLiteralSyntax OutputAsMarkupLiteralRequired() throw new InvalidOperationException("No tokens to output."); } - return GetNodeWithEditHandler(SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator)); + return SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator, GetEditHandler()); } protected MarkupTextLiteralSyntax? OutputAsMarkupLiteral() @@ -632,7 +632,7 @@ protected MarkupTextLiteralSyntax OutputAsMarkupLiteralRequired() return null; } - return GetNodeWithEditHandler(SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator)); + return SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator, GetEditHandler()); } protected MarkupEphemeralTextLiteralSyntax? OutputAsMarkupEphemeralLiteral() @@ -643,7 +643,7 @@ protected MarkupTextLiteralSyntax OutputAsMarkupLiteralRequired() return null; } - return GetNodeWithEditHandler(SyntaxFactory.MarkupEphemeralTextLiteral(tokens, chunkGenerator)); + return SyntaxFactory.MarkupEphemeralTextLiteral(tokens, chunkGenerator, GetEditHandler()); } protected RazorMetaCodeSyntax? OutputAsMetaCode(SyntaxList tokens, AcceptedCharactersInternal? accepted = null) @@ -653,27 +653,25 @@ protected MarkupTextLiteralSyntax OutputAsMarkupLiteralRequired() return null; } - var metaCode = SyntaxFactory.RazorMetaCode(tokens, SpanChunkGenerator.Null); chunkGenerator = SpanChunkGenerator.Null; Context.CurrentAcceptedCharacters = accepted ?? AcceptedCharactersInternal.None; - return GetNodeWithEditHandler(metaCode); + return SyntaxFactory.RazorMetaCode(tokens, SpanChunkGenerator.Null, GetEditHandler()); } - protected TNode GetNodeWithEditHandler(TNode node) where TNode : Syntax.GreenNode + protected SpanEditHandler? GetEditHandler() { Context.MakeMarkerNode = Context.CurrentAcceptedCharacters != AcceptedCharactersInternal.Any; if (this.editHandlerBuilder == null) { InitializeContext(); - return node; + return null; } - var editHandlerBuilder = this.editHandlerBuilder.Build(Context.CurrentAcceptedCharacters); + var editHandler = this.editHandlerBuilder.Build(Context.CurrentAcceptedCharacters); InitializeContext(); - var annotation = new Syntax.SyntaxAnnotation(SyntaxConstants.EditHandlerKind, editHandlerBuilder); - return (TNode)node.SetAnnotations([annotation]); + return editHandler; } protected DisposableAction<(TokenizerBackedParser, SpanContextConfigAction?)> PushSpanContextConfig() diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/WhiteSpaceRewriter.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/WhiteSpaceRewriter.cs index 9dade0fab76..e9be6fce09e 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/WhiteSpaceRewriter.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Legacy/WhiteSpaceRewriter.cs @@ -58,7 +58,7 @@ private static bool TryRewriteWhitespace( if (!containsNonWhitespace) { // Literal node is all whitespace. Can rewrite. - whitespaceLiteral = SyntaxFactory.MarkupTextLiteral(literal.LiteralTokens, chunkGenerator: null); + whitespaceLiteral = SyntaxFactory.MarkupTextLiteral(literal.LiteralTokens); rewritten = codeBlock.ReplaceNode(literal, newNode: null); return true; } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/NamespaceComputer.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/NamespaceComputer.cs index c4160da46eb..458af4e5599 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/NamespaceComputer.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/NamespaceComputer.cs @@ -247,7 +247,7 @@ public override void VisitRazorDirective(RazorDirectiveSyntax node) { Debug.Assert(_source != null); - if (node.DirectiveDescriptor == NamespaceDirective.Directive && + if (node.IsDirective(NamespaceDirective.Directive) && node.Body is RazorDirectiveBodySyntax { CSharpCode.Children: [_, CSharpSyntaxNode @namespace, ..] }) { _lastNamespaceName = @namespace.GetContent(); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupEndTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupEndTagSyntax.cs index 47ba7a8373b..981cf77bb86 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupEndTagSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupEndTagSyntax.cs @@ -33,7 +33,7 @@ private SyntaxNode ComputeEndTagLegacyChildren() // for each call to ToListAndClear(). ref var tokens = ref tokensBuilder.AsRef(); - var editHandler = this.GetEditHandler(); + var editHandler = EditHandler; var chunkGenerator = ChunkGenerator; if (IsValidToken(OpenAngle, out var openAngle)) @@ -58,10 +58,10 @@ private SyntaxNode ComputeEndTagLegacyChildren() } // The prefix of an end tag(E.g '|') will have 'Any' accepted characters if a bang exists. - builder.Add(MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, acceptsAnyHandler)); + builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, acceptsAnyHandler)); // We can skip adding bang to the tokens builder, since we just cleared it. - builder.Add(RazorMetaCode(bang, chunkGenerator, acceptsNoneHandler)); + builder.Add(SyntaxFactory.RazorMetaCode(bang, chunkGenerator, acceptsNoneHandler)); } if (IsValidToken(Name, out var name)) @@ -83,7 +83,7 @@ private SyntaxNode ComputeEndTagLegacyChildren() tokens.Add(closeAngle); } - builder.Add(MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, editHandler)); + builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, editHandler)); return builder.ToListNode(parent: this, Position) .AssumeNotNull($"ToListNode should not return null since builder was not empty."); @@ -99,32 +99,6 @@ static bool IsValidToken(SyntaxToken token, out SyntaxToken validToken) validToken = default; return false; } - - static MarkupTextLiteralSyntax MarkupTextLiteral( - SyntaxTokenList tokens, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) - { - var node = SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator); - - if (editHandler != null) - { - node = node.WithEditHandler(editHandler); - } - - return node; - } - - static RazorMetaCodeSyntax RazorMetaCode( - SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) - { - var node = SyntaxFactory.RazorMetaCode(token, chunkGenerator); - - if (editHandler != null) - { - node = node.WithEditHandler(editHandler); - } - - return node; - } } public abstract BaseMarkupStartTagSyntax? GetStartTag(); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupStartTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupStartTagSyntax.cs index 5c27f8fbad4..681ab1aeb67 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupStartTagSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/BaseMarkupStartTagSyntax.cs @@ -39,7 +39,7 @@ private SyntaxNode ComputeStartTagLegacyChildren() var containsAttributesContent = false; - var editHandler = this.GetEditHandler(); + var editHandler = EditHandler; if (editHandler != null) { acceptsAnyHandler = SpanEditHandler.GetDefault(AcceptedCharactersInternal.Any); @@ -71,10 +71,10 @@ private SyntaxNode ComputeStartTagLegacyChildren() if (IsValidToken(Bang, out var bang)) { - builder.Add(MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, acceptsAnyHandler)); + builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, acceptsAnyHandler)); // We can skip adding bang to the tokens builder, since we just cleared it. - builder.Add(RazorMetaCode(bang, chunkGenerator, acceptsNoneHandler)); + builder.Add(SyntaxFactory.RazorMetaCode(bang, chunkGenerator, acceptsNoneHandler)); } if (IsValidToken(Name, out var name)) @@ -82,7 +82,7 @@ private SyntaxNode ComputeStartTagLegacyChildren() tokens.Add(name); } - builder.Add(MarkupTextLiteral( + builder.Add(SyntaxFactory.MarkupTextLiteral( tokens.ToListAndClear(), chunkGenerator, containsAttributesContent ? acceptsAnyHandler : editHandler)); builder.AddRange(Attributes); @@ -99,7 +99,7 @@ private SyntaxNode ComputeStartTagLegacyChildren() if (tokens.Count > 0) { - builder.Add(MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, editHandler)); + builder.Add(SyntaxFactory.MarkupTextLiteral(tokens.ToListAndClear(), chunkGenerator, editHandler)); } return builder.ToListNode(parent: this, Position) @@ -116,31 +116,5 @@ static bool IsValidToken(SyntaxToken token, out SyntaxToken validToken) validToken = default; return false; } - - static MarkupTextLiteralSyntax MarkupTextLiteral( - SyntaxTokenList tokens, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) - { - var node = SyntaxFactory.MarkupTextLiteral(tokens, chunkGenerator); - - if (editHandler != null) - { - node = node.WithEditHandler(editHandler); - } - - return node; - } - - static RazorMetaCodeSyntax RazorMetaCode( - SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) - { - var node = SyntaxFactory.RazorMetaCode(token, chunkGenerator); - - if (editHandler != null) - { - node = node.WithEditHandler(editHandler); - } - - return node; - } } } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs index a6c76fafe6d..f943c3886b1 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Internal.Generated.cs @@ -8,8 +8,8 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax; internal abstract partial class RazorBlockSyntax : RazorSyntaxNode { - internal RazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -26,8 +26,8 @@ internal sealed partial class RazorDocumentSyntax : RazorSyntaxNode internal readonly RazorBlockSyntax _document; internal readonly SyntaxToken _endOfFile; - internal RazorDocumentSyntax(SyntaxKind kind, RazorBlockSyntax document, SyntaxToken endOfFile, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorDocumentSyntax(SyntaxKind kind, RazorBlockSyntax document, SyntaxToken endOfFile, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(document); @@ -70,9 +70,6 @@ public RazorDocumentSyntax Update(RazorBlockSyntax document, SyntaxToken endOfFi var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -80,10 +77,7 @@ public RazorDocumentSyntax Update(RazorBlockSyntax document, SyntaxToken endOfFi } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new RazorDocumentSyntax(Kind, _document, _endOfFile, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new RazorDocumentSyntax(Kind, _document, _endOfFile, GetDiagnostics(), annotations); + => new RazorDocumentSyntax(Kind, _document, _endOfFile, diagnostics); } internal sealed partial class RazorCommentBlockSyntax : RazorSyntaxNode @@ -94,8 +88,8 @@ internal sealed partial class RazorCommentBlockSyntax : RazorSyntaxNode internal readonly SyntaxToken _endCommentStar; internal readonly SyntaxToken _endCommentTransition; - internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorCommentBlockSyntax(SyntaxKind kind, SyntaxToken startCommentTransition, SyntaxToken startCommentStar, SyntaxToken comment, SyntaxToken endCommentStar, SyntaxToken endCommentTransition, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 5; AdjustFlagsAndWidth(startCommentTransition); @@ -156,9 +150,6 @@ public RazorCommentBlockSyntax Update(SyntaxToken startCommentTransition, Syntax var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -166,19 +157,17 @@ public RazorCommentBlockSyntax Update(SyntaxToken startCommentTransition, Syntax } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new RazorCommentBlockSyntax(Kind, _startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new RazorCommentBlockSyntax(Kind, _startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition, GetDiagnostics(), annotations); + => new RazorCommentBlockSyntax(Kind, _startCommentTransition, _startCommentStar, _comment, _endCommentStar, _endCommentTransition, diagnostics); } internal sealed partial class RazorMetaCodeSyntax : RazorSyntaxNode { internal readonly GreenNode _metaCode; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (metaCode != null) @@ -187,9 +176,10 @@ internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGene _metaCode = metaCode; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator) + internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -199,10 +189,12 @@ internal RazorMetaCodeSyntax(SyntaxKind kind, GreenNode metaCode, ISpanChunkGene _metaCode = metaCode; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList MetaCode => new SyntaxList(_metaCode); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._metaCode : null; @@ -212,17 +204,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitRazorMetaCode(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorMetaCode(this); - public RazorMetaCodeSyntax Update(InternalSyntax.SyntaxList metaCode, ISpanChunkGenerator chunkGenerator) + public RazorMetaCodeSyntax Update(InternalSyntax.SyntaxList metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (metaCode != MetaCode) { - var newNode = SyntaxFactory.RazorMetaCode(metaCode, chunkGenerator); + var newNode = SyntaxFactory.RazorMetaCode(metaCode, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -230,18 +219,15 @@ public RazorMetaCodeSyntax Update(InternalSyntax.SyntaxList metaCod } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new RazorMetaCodeSyntax(Kind, _metaCode, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new RazorMetaCodeSyntax(Kind, _metaCode, _chunkGenerator, GetDiagnostics(), annotations); + => new RazorMetaCodeSyntax(Kind, _metaCode, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class GenericBlockSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal GenericBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal GenericBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -280,9 +266,6 @@ public GenericBlockSyntax Update(InternalSyntax.SyntaxList chil var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -290,19 +273,17 @@ public GenericBlockSyntax Update(InternalSyntax.SyntaxList chil } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new GenericBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new GenericBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + => new GenericBlockSyntax(Kind, _children, diagnostics); } internal sealed partial class UnclassifiedTextLiteralSyntax : RazorSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -311,9 +292,10 @@ internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -323,10 +305,12 @@ internal UnclassifiedTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -336,17 +320,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitUnclassifiedTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitUnclassifiedTextLiteral(this); - public UnclassifiedTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public UnclassifiedTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.UnclassifiedTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.UnclassifiedTextLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -354,16 +335,13 @@ public UnclassifiedTextLiteralSyntax Update(InternalSyntax.SyntaxList new UnclassifiedTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new UnclassifiedTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new UnclassifiedTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal abstract partial class MarkupSyntaxNode : RazorSyntaxNode { - internal MarkupSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -377,8 +355,8 @@ internal sealed partial class MarkupBlockSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal MarkupBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -417,9 +395,6 @@ public MarkupBlockSyntax Update(InternalSyntax.SyntaxList child var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -427,19 +402,17 @@ public MarkupBlockSyntax Update(InternalSyntax.SyntaxList child } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + => new MarkupBlockSyntax(Kind, _children, diagnostics); } internal sealed partial class MarkupTransitionSyntax : MarkupSyntaxNode { internal readonly GreenNode _transitionTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (transitionTokens != null) @@ -448,9 +421,10 @@ internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISp _transitionTokens = transitionTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator) + internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -460,10 +434,12 @@ internal MarkupTransitionSyntax(SyntaxKind kind, GreenNode transitionTokens, ISp _transitionTokens = transitionTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList TransitionTokens => new SyntaxList(_transitionTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._transitionTokens : null; @@ -473,17 +449,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTransition(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTransition(this); - public MarkupTransitionSyntax Update(InternalSyntax.SyntaxList transitionTokens, ISpanChunkGenerator chunkGenerator) + public MarkupTransitionSyntax Update(InternalSyntax.SyntaxList transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (transitionTokens != TransitionTokens) { - var newNode = SyntaxFactory.MarkupTransition(transitionTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupTransition(transitionTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -491,19 +464,17 @@ public MarkupTransitionSyntax Update(InternalSyntax.SyntaxList tran } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTransitionSyntax(Kind, _transitionTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTransitionSyntax(Kind, _transitionTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupTransitionSyntax(Kind, _transitionTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupTextLiteralSyntax : MarkupSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -512,9 +483,10 @@ internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpan _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -524,10 +496,12 @@ internal MarkupTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpan _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -537,17 +511,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTextLiteral(this); - public MarkupTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public MarkupTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.MarkupTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupTextLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -555,19 +526,17 @@ public MarkupTextLiteralSyntax Update(InternalSyntax.SyntaxList lit } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupEphemeralTextLiteralSyntax : MarkupSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -576,9 +545,10 @@ internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalToke _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -588,10 +558,12 @@ internal MarkupEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalToke _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -601,17 +573,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEphemeralTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEphemeralTextLiteral(this); - public MarkupEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public MarkupEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -619,18 +588,15 @@ public MarkupEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList new MarkupEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupCommentBlockSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal MarkupCommentBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupCommentBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -669,9 +635,6 @@ public MarkupCommentBlockSyntax Update(InternalSyntax.SyntaxList 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -679,10 +642,7 @@ public MarkupCommentBlockSyntax Update(InternalSyntax.SyntaxList new MarkupCommentBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupCommentBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + => new MarkupCommentBlockSyntax(Kind, _children, diagnostics); } internal sealed partial class MarkupMinimizedAttributeBlockSyntax : MarkupSyntaxNode @@ -690,8 +650,8 @@ internal sealed partial class MarkupMinimizedAttributeBlockSyntax : MarkupSyntax internal readonly MarkupTextLiteralSyntax _namePrefix; internal readonly MarkupTextLiteralSyntax _name; - internal MarkupMinimizedAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupMinimizedAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; if (namePrefix != null) @@ -740,9 +700,6 @@ public MarkupMinimizedAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePr var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -750,10 +707,7 @@ public MarkupMinimizedAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePr } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupMinimizedAttributeBlockSyntax(Kind, _namePrefix, _name, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupMinimizedAttributeBlockSyntax(Kind, _namePrefix, _name, GetDiagnostics(), annotations); + => new MarkupMinimizedAttributeBlockSyntax(Kind, _namePrefix, _name, diagnostics); } internal sealed partial class MarkupAttributeBlockSyntax : MarkupSyntaxNode @@ -766,8 +720,8 @@ internal sealed partial class MarkupAttributeBlockSyntax : MarkupSyntaxNode internal readonly RazorBlockSyntax _value; internal readonly MarkupTextLiteralSyntax _valueSuffix; - internal MarkupAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, RazorBlockSyntax value, MarkupTextLiteralSyntax valueSuffix, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupAttributeBlockSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, RazorBlockSyntax value, MarkupTextLiteralSyntax valueSuffix, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 7; if (namePrefix != null) @@ -870,9 +824,6 @@ public MarkupAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePrefix, Mar var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -880,18 +831,15 @@ public MarkupAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePrefix, Mar } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupAttributeBlockSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupAttributeBlockSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, GetDiagnostics(), annotations); + => new MarkupAttributeBlockSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, diagnostics); } internal sealed partial class MarkupMiscAttributeContentSyntax : MarkupSyntaxNode { internal readonly GreenNode _children; - internal MarkupMiscAttributeContentSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupMiscAttributeContentSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -930,9 +878,6 @@ public MarkupMiscAttributeContentSyntax Update(InternalSyntax.SyntaxList 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -940,10 +885,7 @@ public MarkupMiscAttributeContentSyntax Update(InternalSyntax.SyntaxList new MarkupMiscAttributeContentSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupMiscAttributeContentSyntax(Kind, _children, GetDiagnostics(), annotations); + => new MarkupMiscAttributeContentSyntax(Kind, _children, diagnostics); } internal sealed partial class MarkupLiteralAttributeValueSyntax : MarkupSyntaxNode @@ -951,8 +893,8 @@ internal sealed partial class MarkupLiteralAttributeValueSyntax : MarkupSyntaxNo internal readonly MarkupTextLiteralSyntax _prefix; internal readonly MarkupTextLiteralSyntax _value; - internal MarkupLiteralAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, MarkupTextLiteralSyntax value, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupLiteralAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, MarkupTextLiteralSyntax value, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; if (prefix != null) @@ -1007,9 +949,6 @@ public MarkupLiteralAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1017,10 +956,7 @@ public MarkupLiteralAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupLiteralAttributeValueSyntax(Kind, _prefix, _value, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupLiteralAttributeValueSyntax(Kind, _prefix, _value, GetDiagnostics(), annotations); + => new MarkupLiteralAttributeValueSyntax(Kind, _prefix, _value, diagnostics); } internal sealed partial class MarkupDynamicAttributeValueSyntax : MarkupSyntaxNode @@ -1028,8 +964,8 @@ internal sealed partial class MarkupDynamicAttributeValueSyntax : MarkupSyntaxNo internal readonly MarkupTextLiteralSyntax _prefix; internal readonly RazorBlockSyntax _value; - internal MarkupDynamicAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, RazorBlockSyntax value, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupDynamicAttributeValueSyntax(SyntaxKind kind, MarkupTextLiteralSyntax prefix, RazorBlockSyntax value, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; if (prefix != null) @@ -1078,9 +1014,6 @@ public MarkupDynamicAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1088,16 +1021,13 @@ public MarkupDynamicAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupDynamicAttributeValueSyntax(Kind, _prefix, _value, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupDynamicAttributeValueSyntax(Kind, _prefix, _value, GetDiagnostics(), annotations); + => new MarkupDynamicAttributeValueSyntax(Kind, _prefix, _value, diagnostics); } internal abstract partial class BaseMarkupStartTagSyntax : MarkupSyntaxNode { - internal BaseMarkupStartTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal BaseMarkupStartTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -1119,12 +1049,14 @@ internal BaseMarkupStartTagSyntax(SyntaxKind kind) public abstract SyntaxToken CloseAngle { get; } public abstract ISpanChunkGenerator ChunkGenerator { get; } + + public abstract SpanEditHandler EditHandler { get; } } internal abstract partial class BaseMarkupEndTagSyntax : MarkupSyntaxNode { - internal BaseMarkupEndTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal BaseMarkupEndTagSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -1146,6 +1078,8 @@ internal BaseMarkupEndTagSyntax(SyntaxKind kind) public abstract SyntaxToken CloseAngle { get; } public abstract ISpanChunkGenerator ChunkGenerator { get; } + + public abstract SpanEditHandler EditHandler { get; } } internal sealed partial class MarkupElementSyntax : MarkupSyntaxNode @@ -1154,8 +1088,8 @@ internal sealed partial class MarkupElementSyntax : MarkupSyntaxNode internal readonly GreenNode _body; internal readonly MarkupEndTagSyntax _endTag; - internal MarkupElementSyntax(SyntaxKind kind, MarkupStartTagSyntax startTag, GreenNode body, MarkupEndTagSyntax endTag, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupElementSyntax(SyntaxKind kind, MarkupStartTagSyntax startTag, GreenNode body, MarkupEndTagSyntax endTag, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 3; if (startTag != null) @@ -1222,9 +1156,6 @@ public MarkupElementSyntax Update(MarkupStartTagSyntax startTag, InternalSyntax. var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1232,10 +1163,7 @@ public MarkupElementSyntax Update(MarkupStartTagSyntax startTag, InternalSyntax. } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupElementSyntax(Kind, _startTag, _body, _endTag, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupElementSyntax(Kind, _startTag, _body, _endTag, GetDiagnostics(), annotations); + => new MarkupElementSyntax(Kind, _startTag, _body, _endTag, diagnostics); } internal sealed partial class MarkupStartTagSyntax : BaseMarkupStartTagSyntax @@ -1246,10 +1174,12 @@ internal sealed partial class MarkupStartTagSyntax : BaseMarkupStartTagSyntax internal readonly GreenNode _attributes; internal readonly SyntaxToken _forwardSlash; internal readonly SyntaxToken _closeAngle; + internal readonly bool _isMarkupTransition; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 6; AdjustFlagsAndWidth(openAngle); @@ -1273,10 +1203,12 @@ internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToke } AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; + _isMarkupTransition = isMarkupTransition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 6; @@ -1301,7 +1233,9 @@ internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToke } AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; + _isMarkupTransition = isMarkupTransition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public override SyntaxToken OpenAngle => _openAngle; @@ -1310,7 +1244,9 @@ internal MarkupStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToke public override SyntaxList Attributes => new SyntaxList(_attributes); public override SyntaxToken ForwardSlash => _forwardSlash; public override SyntaxToken CloseAngle => _closeAngle; + public bool IsMarkupTransition => _isMarkupTransition; public override ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public override SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index switch @@ -1329,17 +1265,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupStartTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupStartTag(this); - public MarkupStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle) { - var newNode = SyntaxFactory.MarkupStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, isMarkupTransition, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1347,10 +1280,7 @@ public MarkupStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, Synt } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _isMarkupTransition, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupEndTagSyntax : BaseMarkupEndTagSyntax @@ -1361,10 +1291,12 @@ internal sealed partial class MarkupEndTagSyntax : BaseMarkupEndTagSyntax internal readonly SyntaxToken _name; internal readonly MarkupMiscAttributeContentSyntax _miscAttributeContent; internal readonly SyntaxToken _closeAngle; + internal readonly bool _isMarkupTransition; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 6; AdjustFlagsAndWidth(openAngle); @@ -1385,10 +1317,12 @@ internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken } AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; + _isMarkupTransition = isMarkupTransition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 6; @@ -1410,7 +1344,9 @@ internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken } AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; + _isMarkupTransition = isMarkupTransition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public override SyntaxToken OpenAngle => _openAngle; @@ -1419,7 +1355,9 @@ internal MarkupEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken public override SyntaxToken Name => _name; public override MarkupMiscAttributeContentSyntax MiscAttributeContent => _miscAttributeContent; public override SyntaxToken CloseAngle => _closeAngle; + public bool IsMarkupTransition => _isMarkupTransition; public override ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public override SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index switch @@ -1438,17 +1376,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEndTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEndTag(this); - public MarkupEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle) { - var newNode = SyntaxFactory.MarkupEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, isMarkupTransition, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1456,10 +1391,7 @@ public MarkupEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _isMarkupTransition, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupTagHelperElementSyntax : MarkupSyntaxNode @@ -1467,9 +1399,10 @@ internal sealed partial class MarkupTagHelperElementSyntax : MarkupSyntaxNode internal readonly MarkupTagHelperStartTagSyntax _startTag; internal readonly GreenNode _body; internal readonly MarkupTagHelperEndTagSyntax _endTag; + internal readonly TagHelperInfo _tagHelperInfo; - internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax startTag, GreenNode body, MarkupTagHelperEndTagSyntax endTag, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax startTag, GreenNode body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 3; AdjustFlagsAndWidth(startTag); @@ -1484,9 +1417,10 @@ internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSy AdjustFlagsAndWidth(endTag); _endTag = endTag; } + _tagHelperInfo = tagHelperInfo; } - internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax startTag, GreenNode body, MarkupTagHelperEndTagSyntax endTag) + internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSyntax startTag, GreenNode body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo) : base(kind) { SlotCount = 3; @@ -1502,11 +1436,13 @@ internal MarkupTagHelperElementSyntax(SyntaxKind kind, MarkupTagHelperStartTagSy AdjustFlagsAndWidth(endTag); _endTag = endTag; } + _tagHelperInfo = tagHelperInfo; } public MarkupTagHelperStartTagSyntax StartTag => _startTag; public SyntaxList Body => new SyntaxList(_body); public MarkupTagHelperEndTagSyntax EndTag => _endTag; + public TagHelperInfo TagHelperInfo => _tagHelperInfo; internal override GreenNode GetSlot(int index) => index switch @@ -1522,17 +1458,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperElement(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperElement(this); - public MarkupTagHelperElementSyntax Update(MarkupTagHelperStartTagSyntax startTag, InternalSyntax.SyntaxList body, MarkupTagHelperEndTagSyntax endTag) + public MarkupTagHelperElementSyntax Update(MarkupTagHelperStartTagSyntax startTag, InternalSyntax.SyntaxList body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo) { if (startTag != StartTag || body != Body || endTag != EndTag) { - var newNode = SyntaxFactory.MarkupTagHelperElement(startTag, body, endTag); + var newNode = SyntaxFactory.MarkupTagHelperElement(startTag, body, endTag, tagHelperInfo); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1540,10 +1473,7 @@ public MarkupTagHelperElementSyntax Update(MarkupTagHelperStartTagSyntax startTa } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTagHelperElementSyntax(Kind, _startTag, _body, _endTag, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperElementSyntax(Kind, _startTag, _body, _endTag, GetDiagnostics(), annotations); + => new MarkupTagHelperElementSyntax(Kind, _startTag, _body, _endTag, _tagHelperInfo, diagnostics); } internal sealed partial class MarkupTagHelperStartTagSyntax : BaseMarkupStartTagSyntax @@ -1555,9 +1485,10 @@ internal sealed partial class MarkupTagHelperStartTagSyntax : BaseMarkupStartTag internal readonly SyntaxToken _forwardSlash; internal readonly SyntaxToken _closeAngle; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 6; AdjustFlagsAndWidth(openAngle); @@ -1582,9 +1513,10 @@ internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, S AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, GreenNode attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 6; @@ -1610,6 +1542,7 @@ internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, S AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public override SyntaxToken OpenAngle => _openAngle; @@ -1619,6 +1552,7 @@ internal MarkupTagHelperStartTagSyntax(SyntaxKind kind, SyntaxToken openAngle, S public override SyntaxToken ForwardSlash => _forwardSlash; public override SyntaxToken CloseAngle => _closeAngle; public override ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public override SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index switch @@ -1637,17 +1571,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperStartTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperStartTag(this); - public MarkupTagHelperStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupTagHelperStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle) { - var newNode = SyntaxFactory.MarkupTagHelperStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupTagHelperStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1655,10 +1586,7 @@ public MarkupTagHelperStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken b } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTagHelperStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupTagHelperStartTagSyntax(Kind, _openAngle, _bang, _name, _attributes, _forwardSlash, _closeAngle, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupTagHelperEndTagSyntax : BaseMarkupEndTagSyntax @@ -1670,9 +1598,10 @@ internal sealed partial class MarkupTagHelperEndTagSyntax : BaseMarkupEndTagSynt internal readonly MarkupMiscAttributeContentSyntax _miscAttributeContent; internal readonly SyntaxToken _closeAngle; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 6; AdjustFlagsAndWidth(openAngle); @@ -1694,9 +1623,10 @@ internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, Syn AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 6; @@ -1719,6 +1649,7 @@ internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, Syn AdjustFlagsAndWidth(closeAngle); _closeAngle = closeAngle; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public override SyntaxToken OpenAngle => _openAngle; @@ -1728,6 +1659,7 @@ internal MarkupTagHelperEndTagSyntax(SyntaxKind kind, SyntaxToken openAngle, Syn public override MarkupMiscAttributeContentSyntax MiscAttributeContent => _miscAttributeContent; public override SyntaxToken CloseAngle => _closeAngle; public override ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public override SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index switch @@ -1746,17 +1678,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperEndTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperEndTag(this); - public MarkupTagHelperEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupTagHelperEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle) { - var newNode = SyntaxFactory.MarkupTagHelperEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupTagHelperEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1764,10 +1693,7 @@ public MarkupTagHelperEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken for } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTagHelperEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _chunkGenerator, GetDiagnostics(), annotations); + => new MarkupTagHelperEndTagSyntax(Kind, _openAngle, _forwardSlash, _bang, _name, _miscAttributeContent, _closeAngle, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class MarkupTagHelperAttributeSyntax : MarkupSyntaxNode @@ -1779,9 +1705,10 @@ internal sealed partial class MarkupTagHelperAttributeSyntax : MarkupSyntaxNode internal readonly MarkupTextLiteralSyntax _valuePrefix; internal readonly MarkupTagHelperAttributeValueSyntax _value; internal readonly MarkupTextLiteralSyntax _valueSuffix; + internal readonly TagHelperAttributeInfo _tagHelperAttributeInfo; - internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 7; if (namePrefix != null) @@ -1810,9 +1737,10 @@ internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax AdjustFlagsAndWidth(valueSuffix); _valueSuffix = valueSuffix; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } - internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) : base(kind) { SlotCount = 7; @@ -1842,6 +1770,7 @@ internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax AdjustFlagsAndWidth(valueSuffix); _valueSuffix = valueSuffix; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } public MarkupTextLiteralSyntax NamePrefix => _namePrefix; @@ -1851,6 +1780,7 @@ internal MarkupTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax public MarkupTextLiteralSyntax ValuePrefix => _valuePrefix; public MarkupTagHelperAttributeValueSyntax Value => _value; public MarkupTextLiteralSyntax ValueSuffix => _valueSuffix; + public TagHelperAttributeInfo TagHelperAttributeInfo => _tagHelperAttributeInfo; internal override GreenNode GetSlot(int index) => index switch @@ -1870,17 +1800,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperAttribute(this); - public MarkupTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public MarkupTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || name != Name || nameSuffix != NameSuffix || equalsToken != EqualsToken || valuePrefix != ValuePrefix || value != Value || valueSuffix != ValueSuffix) { - var newNode = SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + var newNode = SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1888,19 +1815,17 @@ public MarkupTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTagHelperAttributeSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperAttributeSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, GetDiagnostics(), annotations); + => new MarkupTagHelperAttributeSyntax(Kind, _namePrefix, _name, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, _tagHelperAttributeInfo, diagnostics); } internal sealed partial class MarkupMinimizedTagHelperAttributeSyntax : MarkupSyntaxNode { internal readonly MarkupTextLiteralSyntax _namePrefix; internal readonly MarkupTextLiteralSyntax _name; + internal readonly TagHelperAttributeInfo _tagHelperAttributeInfo; - internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; if (namePrefix != null) @@ -1910,9 +1835,10 @@ internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLite } AdjustFlagsAndWidth(name); _name = name; + _tagHelperAttributeInfo = tagHelperAttributeInfo; } - internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) + internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) : base(kind) { SlotCount = 2; @@ -1923,10 +1849,12 @@ internal MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind kind, MarkupTextLite } AdjustFlagsAndWidth(name); _name = name; + _tagHelperAttributeInfo = tagHelperAttributeInfo; } public MarkupTextLiteralSyntax NamePrefix => _namePrefix; public MarkupTextLiteralSyntax Name => _name; + public TagHelperAttributeInfo TagHelperAttributeInfo => _tagHelperAttributeInfo; internal override GreenNode GetSlot(int index) => index switch @@ -1941,17 +1869,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperAttribute(this); - public MarkupMinimizedTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) + public MarkupMinimizedTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || name != Name) { - var newNode = SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix, name); + var newNode = SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix, name, tagHelperAttributeInfo); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -1959,18 +1884,15 @@ public MarkupMinimizedTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax na } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupMinimizedTagHelperAttributeSyntax(Kind, _namePrefix, _name, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupMinimizedTagHelperAttributeSyntax(Kind, _namePrefix, _name, GetDiagnostics(), annotations); + => new MarkupMinimizedTagHelperAttributeSyntax(Kind, _namePrefix, _name, _tagHelperAttributeInfo, diagnostics); } internal sealed partial class MarkupTagHelperAttributeValueSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal MarkupTagHelperAttributeValueSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupTagHelperAttributeValueSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -2009,9 +1931,6 @@ public MarkupTagHelperAttributeValueSyntax Update(InternalSyntax.SyntaxList 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2019,10 +1938,7 @@ public MarkupTagHelperAttributeValueSyntax Update(InternalSyntax.SyntaxList new MarkupTagHelperAttributeValueSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperAttributeValueSyntax(Kind, _children, GetDiagnostics(), annotations); + => new MarkupTagHelperAttributeValueSyntax(Kind, _children, diagnostics); } internal sealed partial class MarkupTagHelperDirectiveAttributeSyntax : MarkupSyntaxNode @@ -2037,9 +1953,10 @@ internal sealed partial class MarkupTagHelperDirectiveAttributeSyntax : MarkupSy internal readonly MarkupTextLiteralSyntax _valuePrefix; internal readonly MarkupTagHelperAttributeValueSyntax _value; internal readonly MarkupTextLiteralSyntax _valueSuffix; + internal readonly TagHelperAttributeInfo _tagHelperAttributeInfo; - internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal 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) + : base(kind, diagnostics) { SlotCount = 10; if (namePrefix != null) @@ -2080,9 +1997,10 @@ internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLite AdjustFlagsAndWidth(valueSuffix); _valueSuffix = valueSuffix; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } - internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + internal 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) : base(kind) { SlotCount = 10; @@ -2124,6 +2042,7 @@ internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLite AdjustFlagsAndWidth(valueSuffix); _valueSuffix = valueSuffix; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } public MarkupTextLiteralSyntax NamePrefix => _namePrefix; @@ -2136,6 +2055,7 @@ internal MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLite public MarkupTextLiteralSyntax ValuePrefix => _valuePrefix; public MarkupTagHelperAttributeValueSyntax Value => _value; public MarkupTextLiteralSyntax ValueSuffix => _valueSuffix; + public TagHelperAttributeInfo TagHelperAttributeInfo => _tagHelperAttributeInfo; internal override GreenNode GetSlot(int index) => index switch @@ -2158,17 +2078,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperDirectiveAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperDirectiveAttribute(this); - public MarkupTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public MarkupTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || transition != Transition || name != Name || colon != Colon || parameterName != ParameterName || nameSuffix != NameSuffix || equalsToken != EqualsToken || valuePrefix != ValuePrefix || value != Value || valueSuffix != ValueSuffix) { - var newNode = SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + var newNode = SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2176,10 +2093,7 @@ public MarkupTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax na } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, GetDiagnostics(), annotations); + => new MarkupTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, _nameSuffix, _equalsToken, _valuePrefix, _value, _valueSuffix, _tagHelperAttributeInfo, diagnostics); } internal sealed partial class MarkupMinimizedTagHelperDirectiveAttributeSyntax : MarkupSyntaxNode @@ -2189,9 +2103,10 @@ internal sealed partial class MarkupMinimizedTagHelperDirectiveAttributeSyntax : internal readonly MarkupTextLiteralSyntax _name; internal readonly RazorMetaCodeSyntax _colon; internal readonly MarkupTextLiteralSyntax _parameterName; + internal readonly TagHelperAttributeInfo _tagHelperAttributeInfo; - internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 5; if (namePrefix != null) @@ -2213,9 +2128,10 @@ internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, Marku AdjustFlagsAndWidth(parameterName); _parameterName = parameterName; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } - internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName) + internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) : base(kind) { SlotCount = 5; @@ -2238,6 +2154,7 @@ internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, Marku AdjustFlagsAndWidth(parameterName); _parameterName = parameterName; } + _tagHelperAttributeInfo = tagHelperAttributeInfo; } public MarkupTextLiteralSyntax NamePrefix => _namePrefix; @@ -2245,6 +2162,7 @@ internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind kind, Marku public MarkupTextLiteralSyntax Name => _name; public RazorMetaCodeSyntax Colon => _colon; public MarkupTextLiteralSyntax ParameterName => _parameterName; + public TagHelperAttributeInfo TagHelperAttributeInfo => _tagHelperAttributeInfo; internal override GreenNode GetSlot(int index) => index switch @@ -2262,17 +2180,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperDirectiveAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperDirectiveAttribute(this); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName) + public MarkupMinimizedTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || transition != Transition || name != Name || colon != Colon || parameterName != ParameterName) { - var newNode = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName); + var newNode = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, tagHelperAttributeInfo); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2280,16 +2195,13 @@ public MarkupMinimizedTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteral } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new MarkupMinimizedTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new MarkupMinimizedTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, GetDiagnostics(), annotations); + => new MarkupMinimizedTagHelperDirectiveAttributeSyntax(Kind, _namePrefix, _transition, _name, _colon, _parameterName, _tagHelperAttributeInfo, diagnostics); } internal abstract partial class CSharpSyntaxNode : RazorSyntaxNode { - internal CSharpSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -2303,8 +2215,8 @@ internal sealed partial class CSharpCodeBlockSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpCodeBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -2343,9 +2255,6 @@ public CSharpCodeBlockSyntax Update(InternalSyntax.SyntaxList c var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2353,37 +2262,38 @@ public CSharpCodeBlockSyntax Update(InternalSyntax.SyntaxList c } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpCodeBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpCodeBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + => new CSharpCodeBlockSyntax(Kind, _children, diagnostics); } internal sealed partial class CSharpTransitionSyntax : CSharpSyntaxNode { internal readonly SyntaxToken _transition; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; AdjustFlagsAndWidth(transition); _transition = transition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator) + internal CSharpTransitionSyntax(SyntaxKind kind, SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; AdjustFlagsAndWidth(transition); _transition = transition; _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxToken Transition => _transition; public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._transition : null; @@ -2393,17 +2303,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpTransition(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpTransition(this); - public CSharpTransitionSyntax Update(SyntaxToken transition, ISpanChunkGenerator chunkGenerator) + public CSharpTransitionSyntax Update(SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (transition != Transition) { - var newNode = SyntaxFactory.CSharpTransition(transition, chunkGenerator); + var newNode = SyntaxFactory.CSharpTransition(transition, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2411,19 +2318,17 @@ public CSharpTransitionSyntax Update(SyntaxToken transition, ISpanChunkGenerator } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpTransitionSyntax(Kind, _transition, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpTransitionSyntax(Kind, _transition, _chunkGenerator, GetDiagnostics(), annotations); + => new CSharpTransitionSyntax(Kind, _transition, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class CSharpStatementLiteralSyntax : CSharpSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -2432,9 +2337,10 @@ internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -2444,10 +2350,12 @@ internal CSharpStatementLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -2457,17 +2365,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpStatementLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpStatementLiteral(this); - public CSharpStatementLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpStatementLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.CSharpStatementLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpStatementLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2475,19 +2380,17 @@ public CSharpStatementLiteralSyntax Update(InternalSyntax.SyntaxList new CSharpStatementLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpStatementLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new CSharpStatementLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class CSharpExpressionLiteralSyntax : CSharpSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -2496,9 +2399,10 @@ internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -2508,10 +2412,12 @@ internal CSharpExpressionLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -2521,17 +2427,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpExpressionLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpExpressionLiteral(this); - public CSharpExpressionLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpExpressionLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.CSharpExpressionLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpExpressionLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2539,19 +2442,17 @@ public CSharpExpressionLiteralSyntax Update(InternalSyntax.SyntaxList new CSharpExpressionLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpExpressionLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new CSharpExpressionLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class CSharpEphemeralTextLiteralSyntax : CSharpSyntaxNode { internal readonly GreenNode _literalTokens; internal readonly ISpanChunkGenerator _chunkGenerator; + internal readonly SpanEditHandler _editHandler; - internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (literalTokens != null) @@ -2560,9 +2461,10 @@ internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalToke _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } - internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator) + internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) : base(kind) { SlotCount = 1; @@ -2572,10 +2474,12 @@ internal CSharpEphemeralTextLiteralSyntax(SyntaxKind kind, GreenNode literalToke _literalTokens = literalTokens; } _chunkGenerator = chunkGenerator; + _editHandler = editHandler; } public SyntaxList LiteralTokens => new SyntaxList(_literalTokens); public ISpanChunkGenerator ChunkGenerator => _chunkGenerator; + public SpanEditHandler EditHandler => _editHandler; internal override GreenNode GetSlot(int index) => index == 0 ? this._literalTokens : null; @@ -2585,17 +2489,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpEphemeralTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpEphemeralTextLiteral(this); - public CSharpEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (literalTokens != LiteralTokens) { - var newNode = SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens, chunkGenerator, editHandler); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2603,18 +2504,15 @@ public CSharpEphemeralTextLiteralSyntax Update(InternalSyntax.SyntaxList new CSharpEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, GetDiagnostics(), annotations); + => new CSharpEphemeralTextLiteralSyntax(Kind, _literalTokens, _chunkGenerator, _editHandler, diagnostics); } internal sealed partial class CSharpTemplateBlockSyntax : RazorBlockSyntax { internal readonly GreenNode _children; - internal CSharpTemplateBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpTemplateBlockSyntax(SyntaxKind kind, GreenNode children, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; if (children != null) @@ -2653,9 +2551,6 @@ public CSharpTemplateBlockSyntax Update(InternalSyntax.SyntaxList 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2663,16 +2558,13 @@ public CSharpTemplateBlockSyntax Update(InternalSyntax.SyntaxList new CSharpTemplateBlockSyntax(Kind, _children, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpTemplateBlockSyntax(Kind, _children, GetDiagnostics(), annotations); + => new CSharpTemplateBlockSyntax(Kind, _children, diagnostics); } internal abstract partial class CSharpRazorBlockSyntax : CSharpSyntaxNode { - internal CSharpRazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpRazorBlockSyntax(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } @@ -2691,8 +2583,8 @@ internal sealed partial class CSharpStatementSyntax : CSharpRazorBlockSyntax internal readonly CSharpTransitionSyntax _transition; internal readonly CSharpSyntaxNode _body; - internal CSharpStatementSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpStatementSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(transition); @@ -2735,9 +2627,6 @@ public CSharpStatementSyntax Update(CSharpTransitionSyntax transition, CSharpSyn var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2745,10 +2634,7 @@ public CSharpStatementSyntax Update(CSharpTransitionSyntax transition, CSharpSyn } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpStatementSyntax(Kind, _transition, _body, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpStatementSyntax(Kind, _transition, _body, GetDiagnostics(), annotations); + => new CSharpStatementSyntax(Kind, _transition, _body, diagnostics); } internal sealed partial class CSharpStatementBodySyntax : CSharpSyntaxNode @@ -2757,8 +2643,8 @@ internal sealed partial class CSharpStatementBodySyntax : CSharpSyntaxNode internal readonly CSharpCodeBlockSyntax _csharpCode; internal readonly RazorMetaCodeSyntax _closeBrace; - internal CSharpStatementBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openBrace, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeBrace, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpStatementBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openBrace, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeBrace, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 3; AdjustFlagsAndWidth(openBrace); @@ -2807,9 +2693,6 @@ public CSharpStatementBodySyntax Update(RazorMetaCodeSyntax openBrace, CSharpCod var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2817,10 +2700,7 @@ public CSharpStatementBodySyntax Update(RazorMetaCodeSyntax openBrace, CSharpCod } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpStatementBodySyntax(Kind, _openBrace, _csharpCode, _closeBrace, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpStatementBodySyntax(Kind, _openBrace, _csharpCode, _closeBrace, GetDiagnostics(), annotations); + => new CSharpStatementBodySyntax(Kind, _openBrace, _csharpCode, _closeBrace, diagnostics); } internal sealed partial class CSharpExplicitExpressionSyntax : CSharpRazorBlockSyntax @@ -2828,8 +2708,8 @@ internal sealed partial class CSharpExplicitExpressionSyntax : CSharpRazorBlockS internal readonly CSharpTransitionSyntax _transition; internal readonly CSharpSyntaxNode _body; - internal CSharpExplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpExplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(transition); @@ -2872,9 +2752,6 @@ public CSharpExplicitExpressionSyntax Update(CSharpTransitionSyntax transition, var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2882,10 +2759,7 @@ public CSharpExplicitExpressionSyntax Update(CSharpTransitionSyntax transition, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpExplicitExpressionSyntax(Kind, _transition, _body, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpExplicitExpressionSyntax(Kind, _transition, _body, GetDiagnostics(), annotations); + => new CSharpExplicitExpressionSyntax(Kind, _transition, _body, diagnostics); } internal sealed partial class CSharpExplicitExpressionBodySyntax : CSharpSyntaxNode @@ -2894,8 +2768,8 @@ internal sealed partial class CSharpExplicitExpressionBodySyntax : CSharpSyntaxN internal readonly CSharpCodeBlockSyntax _csharpCode; internal readonly RazorMetaCodeSyntax _closeParen; - internal CSharpExplicitExpressionBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openParen, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeParen, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpExplicitExpressionBodySyntax(SyntaxKind kind, RazorMetaCodeSyntax openParen, CSharpCodeBlockSyntax csharpCode, RazorMetaCodeSyntax closeParen, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 3; AdjustFlagsAndWidth(openParen); @@ -2944,9 +2818,6 @@ public CSharpExplicitExpressionBodySyntax Update(RazorMetaCodeSyntax openParen, var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -2954,10 +2825,7 @@ public CSharpExplicitExpressionBodySyntax Update(RazorMetaCodeSyntax openParen, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpExplicitExpressionBodySyntax(Kind, _openParen, _csharpCode, _closeParen, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpExplicitExpressionBodySyntax(Kind, _openParen, _csharpCode, _closeParen, GetDiagnostics(), annotations); + => new CSharpExplicitExpressionBodySyntax(Kind, _openParen, _csharpCode, _closeParen, diagnostics); } internal sealed partial class CSharpImplicitExpressionSyntax : CSharpRazorBlockSyntax @@ -2965,8 +2833,8 @@ internal sealed partial class CSharpImplicitExpressionSyntax : CSharpRazorBlockS internal readonly CSharpTransitionSyntax _transition; internal readonly CSharpSyntaxNode _body; - internal CSharpImplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpImplicitExpressionSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(transition); @@ -3009,9 +2877,6 @@ public CSharpImplicitExpressionSyntax Update(CSharpTransitionSyntax transition, var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -3019,18 +2884,15 @@ public CSharpImplicitExpressionSyntax Update(CSharpTransitionSyntax transition, } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpImplicitExpressionSyntax(Kind, _transition, _body, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpImplicitExpressionSyntax(Kind, _transition, _body, GetDiagnostics(), annotations); + => new CSharpImplicitExpressionSyntax(Kind, _transition, _body, diagnostics); } internal sealed partial class CSharpImplicitExpressionBodySyntax : CSharpSyntaxNode { internal readonly CSharpCodeBlockSyntax _csharpCode; - internal CSharpImplicitExpressionBodySyntax(SyntaxKind kind, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal CSharpImplicitExpressionBodySyntax(SyntaxKind kind, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 1; AdjustFlagsAndWidth(csharpCode); @@ -3063,9 +2925,6 @@ public CSharpImplicitExpressionBodySyntax Update(CSharpCodeBlockSyntax csharpCod var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -3073,28 +2932,27 @@ public CSharpImplicitExpressionBodySyntax Update(CSharpCodeBlockSyntax csharpCod } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new CSharpImplicitExpressionBodySyntax(Kind, _csharpCode, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new CSharpImplicitExpressionBodySyntax(Kind, _csharpCode, GetDiagnostics(), annotations); + => new CSharpImplicitExpressionBodySyntax(Kind, _csharpCode, diagnostics); } internal sealed partial class RazorDirectiveSyntax : CSharpRazorBlockSyntax { internal readonly CSharpTransitionSyntax _transition; internal readonly CSharpSyntaxNode _body; + internal readonly DirectiveDescriptor _directiveDescriptor; - internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(transition); _transition = transition; AdjustFlagsAndWidth(body); _body = body; + _directiveDescriptor = directiveDescriptor; } - internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body) + internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) : base(kind) { SlotCount = 2; @@ -3102,10 +2960,12 @@ internal RazorDirectiveSyntax(SyntaxKind kind, CSharpTransitionSyntax transition _transition = transition; AdjustFlagsAndWidth(body); _body = body; + _directiveDescriptor = directiveDescriptor; } public override CSharpTransitionSyntax Transition => _transition; public override CSharpSyntaxNode Body => _body; + public DirectiveDescriptor DirectiveDescriptor => _directiveDescriptor; internal override GreenNode GetSlot(int index) => index switch @@ -3120,17 +2980,14 @@ internal override GreenNode GetSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitRazorDirective(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorDirective(this); - public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) { if (transition != Transition || body != Body) { - var newNode = SyntaxFactory.RazorDirective(transition, body); + var newNode = SyntaxFactory.RazorDirective(transition, body, directiveDescriptor); var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -3138,10 +2995,7 @@ public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSynt } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new RazorDirectiveSyntax(Kind, _transition, _body, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new RazorDirectiveSyntax(Kind, _transition, _body, GetDiagnostics(), annotations); + => new RazorDirectiveSyntax(Kind, _transition, _body, _directiveDescriptor, diagnostics); } internal sealed partial class RazorDirectiveBodySyntax : CSharpSyntaxNode @@ -3149,8 +3003,8 @@ internal sealed partial class RazorDirectiveBodySyntax : CSharpSyntaxNode internal readonly RazorSyntaxNode _keyword; internal readonly CSharpCodeBlockSyntax _csharpCode; - internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + internal RazorDirectiveBodySyntax(SyntaxKind kind, RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(keyword); @@ -3199,9 +3053,6 @@ public RazorDirectiveBodySyntax Update(RazorSyntaxNode keyword, CSharpCodeBlockS var diags = GetDiagnostics(); if (diags != null && diags.Length > 0) newNode = newNode.WithDiagnosticsGreen(diags); - var annotations = GetAnnotations(); - if (annotations != null && annotations.Length > 0) - newNode = newNode.WithAnnotationsGreen(annotations); return newNode; } @@ -3209,10 +3060,7 @@ public RazorDirectiveBodySyntax Update(RazorSyntaxNode keyword, CSharpCodeBlockS } internal override GreenNode SetDiagnostics(RazorDiagnostic[] diagnostics) - => new RazorDirectiveBodySyntax(Kind, _keyword, _csharpCode, diagnostics, GetAnnotations()); - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - => new RazorDirectiveBodySyntax(Kind, _keyword, _csharpCode, GetDiagnostics(), annotations); + => new RazorDirectiveBodySyntax(Kind, _keyword, _csharpCode, diagnostics); } internal partial class SyntaxVisitor @@ -3312,25 +3160,25 @@ public override GreenNode VisitRazorCommentBlock(RazorCommentBlockSyntax node) => node.Update((SyntaxToken)Visit(node.StartCommentTransition), (SyntaxToken)Visit(node.StartCommentStar), (SyntaxToken)Visit(node.Comment), (SyntaxToken)Visit(node.EndCommentStar), (SyntaxToken)Visit(node.EndCommentTransition)); public override GreenNode VisitRazorMetaCode(RazorMetaCodeSyntax node) - => node.Update(VisitList(node.MetaCode), node.ChunkGenerator); + => node.Update(VisitList(node.MetaCode), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitGenericBlock(GenericBlockSyntax node) => node.Update(VisitList(node.Children)); public override GreenNode VisitUnclassifiedTextLiteral(UnclassifiedTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupBlock(MarkupBlockSyntax node) => node.Update(VisitList(node.Children)); public override GreenNode VisitMarkupTransition(MarkupTransitionSyntax node) - => node.Update(VisitList(node.TransitionTokens), node.ChunkGenerator); + => node.Update(VisitList(node.TransitionTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupTextLiteral(MarkupTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupEphemeralTextLiteral(MarkupEphemeralTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupCommentBlock(MarkupCommentBlockSyntax node) => node.Update(VisitList(node.Children)); @@ -3354,49 +3202,49 @@ public override GreenNode VisitMarkupElement(MarkupElementSyntax node) => node.Update((MarkupStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupEndTagSyntax)Visit(node.EndTag)); public override GreenNode VisitMarkupStartTag(MarkupStartTagSyntax node) - => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), VisitList(node.Attributes), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), VisitList(node.Attributes), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.CloseAngle), node.IsMarkupTransition, node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupEndTag(MarkupEndTagSyntax node) - => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)Visit(node.CloseAngle), node.IsMarkupTransition, node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupTagHelperElement(MarkupTagHelperElementSyntax node) - => node.Update((MarkupTagHelperStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupTagHelperEndTagSyntax)Visit(node.EndTag)); + => node.Update((MarkupTagHelperStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupTagHelperEndTagSyntax)Visit(node.EndTag), node.TagHelperInfo); public override GreenNode VisitMarkupTagHelperStartTag(MarkupTagHelperStartTagSyntax node) - => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), VisitList(node.Attributes), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), VisitList(node.Attributes), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupTagHelperEndTag(MarkupTagHelperEndTagSyntax node) - => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)Visit(node.OpenAngle), (SyntaxToken)Visit(node.ForwardSlash), (SyntaxToken)Visit(node.Bang), (SyntaxToken)Visit(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)Visit(node.CloseAngle), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitMarkupTagHelperAttribute(MarkupTagHelperAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)Visit(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)Visit(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix), node.TagHelperAttributeInfo); public override GreenNode VisitMarkupMinimizedTagHelperAttribute(MarkupMinimizedTagHelperAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), node.TagHelperAttributeInfo); public override GreenNode VisitMarkupTagHelperAttributeValue(MarkupTagHelperAttributeValueSyntax node) => node.Update(VisitList(node.Children)); public override GreenNode VisitMarkupTagHelperDirectiveAttribute(MarkupTagHelperDirectiveAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)Visit(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)Visit(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix), node.TagHelperAttributeInfo); public override GreenNode VisitMarkupMinimizedTagHelperDirectiveAttribute(MarkupMinimizedTagHelperDirectiveAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), node.TagHelperAttributeInfo); public override GreenNode VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) => node.Update(VisitList(node.Children)); public override GreenNode VisitCSharpTransition(CSharpTransitionSyntax node) - => node.Update((SyntaxToken)Visit(node.Transition), node.ChunkGenerator); + => node.Update((SyntaxToken)Visit(node.Transition), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitCSharpStatementLiteral(CSharpStatementLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitCSharpExpressionLiteral(CSharpExpressionLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitCSharpEphemeralTextLiteral(CSharpEphemeralTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override GreenNode VisitCSharpTemplateBlock(CSharpTemplateBlockSyntax node) => node.Update(VisitList(node.Children)); @@ -3420,7 +3268,7 @@ public override GreenNode VisitCSharpImplicitExpressionBody(CSharpImplicitExpres => node.Update((CSharpCodeBlockSyntax)Visit(node.CSharpCode)); public override GreenNode VisitRazorDirective(RazorDirectiveSyntax node) - => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body)); + => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor); public override GreenNode VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => node.Update((RazorSyntaxNode)Visit(node.Keyword), (CSharpCodeBlockSyntax)Visit(node.CSharpCode)); @@ -3461,9 +3309,9 @@ public static RazorCommentBlockSyntax RazorCommentBlock(SyntaxToken startComment return new RazorCommentBlockSyntax(SyntaxKind.RazorComment, startCommentTransition, startCommentStar, comment, endCommentStar, endCommentTransition); } - public static RazorMetaCodeSyntax RazorMetaCode(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList metaCode, ISpanChunkGenerator chunkGenerator) + public static RazorMetaCodeSyntax RazorMetaCode(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new RazorMetaCodeSyntax(SyntaxKind.RazorMetaCode, metaCode.Node, chunkGenerator); + var result = new RazorMetaCodeSyntax(SyntaxKind.RazorMetaCode, metaCode.Node, chunkGenerator, editHandler); return result; } @@ -3475,9 +3323,9 @@ public static GenericBlockSyntax GenericBlock(Microsoft.AspNetCore.Razor.Languag return result; } - public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new UnclassifiedTextLiteralSyntax(SyntaxKind.UnclassifiedTextLiteral, literalTokens.Node, chunkGenerator); + var result = new UnclassifiedTextLiteralSyntax(SyntaxKind.UnclassifiedTextLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } @@ -3489,23 +3337,23 @@ public static MarkupBlockSyntax MarkupBlock(Microsoft.AspNetCore.Razor.Language. return result; } - public static MarkupTransitionSyntax MarkupTransition(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList transitionTokens, ISpanChunkGenerator chunkGenerator) + public static MarkupTransitionSyntax MarkupTransition(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new MarkupTransitionSyntax(SyntaxKind.MarkupTransition, transitionTokens.Node, chunkGenerator); + var result = new MarkupTransitionSyntax(SyntaxKind.MarkupTransition, transitionTokens.Node, chunkGenerator, editHandler); return result; } - public static MarkupTextLiteralSyntax MarkupTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static MarkupTextLiteralSyntax MarkupTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new MarkupTextLiteralSyntax(SyntaxKind.MarkupTextLiteral, literalTokens.Node, chunkGenerator); + var result = new MarkupTextLiteralSyntax(SyntaxKind.MarkupTextLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } - public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new MarkupEphemeralTextLiteralSyntax(SyntaxKind.MarkupEphemeralTextLiteral, literalTokens.Node, chunkGenerator); + var result = new MarkupEphemeralTextLiteralSyntax(SyntaxKind.MarkupEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } @@ -3566,7 +3414,7 @@ public static MarkupElementSyntax MarkupElement(MarkupStartTagSyntax startTag, M return result; } - public static MarkupStartTagSyntax MarkupStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupStartTagSyntax MarkupStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { ArgHelper.ThrowIfNull(openAngle); if (openAngle.Kind != SyntaxKind.OpenAngle) @@ -3582,10 +3430,10 @@ public static MarkupStartTagSyntax MarkupStartTag(SyntaxToken openAngle, SyntaxT if (closeAngle.Kind != SyntaxKind.CloseAngle) ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return new MarkupStartTagSyntax(SyntaxKind.MarkupStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, chunkGenerator); + return new MarkupStartTagSyntax(SyntaxKind.MarkupStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, isMarkupTransition, chunkGenerator, editHandler); } - public static MarkupEndTagSyntax MarkupEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupEndTagSyntax MarkupEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { ArgHelper.ThrowIfNull(openAngle); if (openAngle.Kind != SyntaxKind.OpenAngle) @@ -3602,19 +3450,17 @@ public static MarkupEndTagSyntax MarkupEndTag(SyntaxToken openAngle, SyntaxToken if (closeAngle.Kind != SyntaxKind.CloseAngle) ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return new MarkupEndTagSyntax(SyntaxKind.MarkupEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + return new MarkupEndTagSyntax(SyntaxKind.MarkupEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, isMarkupTransition, chunkGenerator, editHandler); } - public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList body, MarkupTagHelperEndTagSyntax endTag) + public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo) { ArgHelper.ThrowIfNull(startTag); - var result = new MarkupTagHelperElementSyntax(SyntaxKind.MarkupTagHelperElement, startTag, body.Node, endTag); - - return result; + return new MarkupTagHelperElementSyntax(SyntaxKind.MarkupTagHelperElement, startTag, body.Node, endTag, tagHelperInfo); } - public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { ArgHelper.ThrowIfNull(openAngle); if (openAngle.Kind != SyntaxKind.OpenAngle) @@ -3630,10 +3476,10 @@ public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxToken if (closeAngle.Kind != SyntaxKind.CloseAngle) ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return new MarkupTagHelperStartTagSyntax(SyntaxKind.MarkupTagHelperStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, chunkGenerator); + return new MarkupTagHelperStartTagSyntax(SyntaxKind.MarkupTagHelperStartTag, openAngle, bang, name, attributes.Node, forwardSlash, closeAngle, chunkGenerator, editHandler); } - public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { ArgHelper.ThrowIfNull(openAngle); if (openAngle.Kind != SyntaxKind.OpenAngle) @@ -3650,10 +3496,10 @@ public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(SyntaxToken open if (closeAngle.Kind != SyntaxKind.CloseAngle) ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return new MarkupTagHelperEndTagSyntax(SyntaxKind.MarkupTagHelperEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + return new MarkupTagHelperEndTagSyntax(SyntaxKind.MarkupTagHelperEndTag, openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator, editHandler); } - public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(name); ArgHelper.ThrowIfNull(equalsToken); @@ -3661,14 +3507,14 @@ public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupText ThrowHelper.ThrowArgumentException(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); ArgHelper.ThrowIfNull(value); - return new MarkupTagHelperAttributeSyntax(SyntaxKind.MarkupTagHelperAttribute, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + return new MarkupTagHelperAttributeSyntax(SyntaxKind.MarkupTagHelperAttribute, namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); } - public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) + public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(name); - var result = new MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperAttribute, namePrefix, name); + var result = new MarkupMinimizedTagHelperAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperAttribute, namePrefix, name, tagHelperAttributeInfo); return result; } @@ -3680,7 +3526,7 @@ public static MarkupTagHelperAttributeValueSyntax MarkupTagHelperAttributeValue( return result; } - public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(name); @@ -3689,15 +3535,15 @@ public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAt ThrowHelper.ThrowArgumentException(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); ArgHelper.ThrowIfNull(value); - return new MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + return new MarkupTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); } - public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName) + public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(name); - return new MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName); + return new MarkupMinimizedTagHelperDirectiveAttributeSyntax(SyntaxKind.MarkupMinimizedTagHelperDirectiveAttribute, namePrefix, transition, name, colon, parameterName, tagHelperAttributeInfo); } public static CSharpCodeBlockSyntax CSharpCodeBlock(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList children) @@ -3707,34 +3553,34 @@ public static CSharpCodeBlockSyntax CSharpCodeBlock(Microsoft.AspNetCore.Razor.L return result; } - public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition, ISpanChunkGenerator chunkGenerator) + public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { ArgHelper.ThrowIfNull(transition); if (transition.Kind != SyntaxKind.Transition) ThrowHelper.ThrowArgumentException(nameof(transition), $"Invalid SyntaxKind. Expected 'SyntaxKind.Transition', but it was {transition.Kind}"); - var result = new CSharpTransitionSyntax(SyntaxKind.CSharpTransition, transition, chunkGenerator); + var result = new CSharpTransitionSyntax(SyntaxKind.CSharpTransition, transition, chunkGenerator, editHandler); return result; } - public static CSharpStatementLiteralSyntax CSharpStatementLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static CSharpStatementLiteralSyntax CSharpStatementLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new CSharpStatementLiteralSyntax(SyntaxKind.CSharpStatementLiteral, literalTokens.Node, chunkGenerator); + var result = new CSharpStatementLiteralSyntax(SyntaxKind.CSharpStatementLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } - public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new CSharpExpressionLiteralSyntax(SyntaxKind.CSharpExpressionLiteral, literalTokens.Node, chunkGenerator); + var result = new CSharpExpressionLiteralSyntax(SyntaxKind.CSharpExpressionLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } - public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator) + public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax.SyntaxList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - var result = new CSharpEphemeralTextLiteralSyntax(SyntaxKind.CSharpEphemeralTextLiteral, literalTokens.Node, chunkGenerator); + var result = new CSharpEphemeralTextLiteralSyntax(SyntaxKind.CSharpEphemeralTextLiteral, literalTokens.Node, chunkGenerator, editHandler); return result; } @@ -3807,12 +3653,12 @@ public static CSharpImplicitExpressionBodySyntax CSharpImplicitExpressionBody(CS return result; } - public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(body); - var result = new RazorDirectiveSyntax(SyntaxKind.RazorDirective, transition, body); + var result = new RazorDirectiveSyntax(SyntaxKind.RazorDirective, transition, body, directiveDescriptor); return result; } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Main.Generated.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Main.Generated.cs index ab9f28f0b8e..d2ddbe4e266 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Main.Generated.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Main.Generated.cs @@ -261,25 +261,25 @@ public override SyntaxNode VisitRazorCommentBlock(RazorCommentBlockSyntax node) => node.Update((SyntaxToken)VisitToken(node.StartCommentTransition), (SyntaxToken)VisitToken(node.StartCommentStar), (SyntaxToken)VisitToken(node.Comment), (SyntaxToken)VisitToken(node.EndCommentStar), (SyntaxToken)VisitToken(node.EndCommentTransition)); public override SyntaxNode VisitRazorMetaCode(RazorMetaCodeSyntax node) - => node.Update(VisitList(node.MetaCode), node.ChunkGenerator); + => node.Update(VisitList(node.MetaCode), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitGenericBlock(GenericBlockSyntax node) => node.Update(VisitList(node.Children)); public override SyntaxNode VisitUnclassifiedTextLiteral(UnclassifiedTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupBlock(MarkupBlockSyntax node) => node.Update(VisitList(node.Children)); public override SyntaxNode VisitMarkupTransition(MarkupTransitionSyntax node) - => node.Update(VisitList(node.TransitionTokens), node.ChunkGenerator); + => node.Update(VisitList(node.TransitionTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupTextLiteral(MarkupTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupEphemeralTextLiteral(MarkupEphemeralTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupCommentBlock(MarkupCommentBlockSyntax node) => node.Update(VisitList(node.Children)); @@ -303,49 +303,49 @@ public override SyntaxNode VisitMarkupElement(MarkupElementSyntax node) => node.Update((MarkupStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupEndTagSyntax)Visit(node.EndTag)); public override SyntaxNode VisitMarkupStartTag(MarkupStartTagSyntax node) - => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), VisitList(node.Attributes), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), VisitList(node.Attributes), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.CloseAngle), node.IsMarkupTransition, node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupEndTag(MarkupEndTagSyntax node) - => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)VisitToken(node.CloseAngle), node.IsMarkupTransition, node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupTagHelperElement(MarkupTagHelperElementSyntax node) - => node.Update((MarkupTagHelperStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupTagHelperEndTagSyntax)Visit(node.EndTag)); + => node.Update((MarkupTagHelperStartTagSyntax)Visit(node.StartTag), VisitList(node.Body), (MarkupTagHelperEndTagSyntax)Visit(node.EndTag), node.TagHelperInfo); public override SyntaxNode VisitMarkupTagHelperStartTag(MarkupTagHelperStartTagSyntax node) - => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), VisitList(node.Attributes), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), VisitList(node.Attributes), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupTagHelperEndTag(MarkupTagHelperEndTagSyntax node) - => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator); + => node.Update((SyntaxToken)VisitToken(node.OpenAngle), (SyntaxToken)VisitToken(node.ForwardSlash), (SyntaxToken)VisitToken(node.Bang), (SyntaxToken)VisitToken(node.Name), (MarkupMiscAttributeContentSyntax)Visit(node.MiscAttributeContent), (SyntaxToken)VisitToken(node.CloseAngle), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitMarkupTagHelperAttribute(MarkupTagHelperAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)VisitToken(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)VisitToken(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix), node.TagHelperAttributeInfo); public override SyntaxNode VisitMarkupMinimizedTagHelperAttribute(MarkupMinimizedTagHelperAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (MarkupTextLiteralSyntax)Visit(node.Name), node.TagHelperAttributeInfo); public override SyntaxNode VisitMarkupTagHelperAttributeValue(MarkupTagHelperAttributeValueSyntax node) => node.Update(VisitList(node.Children)); public override SyntaxNode VisitMarkupTagHelperDirectiveAttribute(MarkupTagHelperDirectiveAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)VisitToken(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), (MarkupTextLiteralSyntax)Visit(node.NameSuffix), (SyntaxToken)VisitToken(node.EqualsToken), (MarkupTextLiteralSyntax)Visit(node.ValuePrefix), (MarkupTagHelperAttributeValueSyntax)Visit(node.Value), (MarkupTextLiteralSyntax)Visit(node.ValueSuffix), node.TagHelperAttributeInfo); public override SyntaxNode VisitMarkupMinimizedTagHelperDirectiveAttribute(MarkupMinimizedTagHelperDirectiveAttributeSyntax node) - => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName)); + => node.Update((MarkupTextLiteralSyntax)Visit(node.NamePrefix), (RazorMetaCodeSyntax)Visit(node.Transition), (MarkupTextLiteralSyntax)Visit(node.Name), (RazorMetaCodeSyntax)Visit(node.Colon), (MarkupTextLiteralSyntax)Visit(node.ParameterName), node.TagHelperAttributeInfo); public override SyntaxNode VisitCSharpCodeBlock(CSharpCodeBlockSyntax node) => node.Update(VisitList(node.Children)); public override SyntaxNode VisitCSharpTransition(CSharpTransitionSyntax node) - => node.Update((SyntaxToken)VisitToken(node.Transition), node.ChunkGenerator); + => node.Update((SyntaxToken)VisitToken(node.Transition), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitCSharpStatementLiteral(CSharpStatementLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitCSharpExpressionLiteral(CSharpExpressionLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitCSharpEphemeralTextLiteral(CSharpEphemeralTextLiteralSyntax node) - => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator); + => node.Update(VisitList(node.LiteralTokens), node.ChunkGenerator, node.EditHandler); public override SyntaxNode VisitCSharpTemplateBlock(CSharpTemplateBlockSyntax node) => node.Update(VisitList(node.Children)); @@ -369,7 +369,7 @@ public override SyntaxNode VisitCSharpImplicitExpressionBody(CSharpImplicitExpre => node.Update((CSharpCodeBlockSyntax)Visit(node.CSharpCode)); public override SyntaxNode VisitRazorDirective(RazorDirectiveSyntax node) - => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body)); + => node.Update((CSharpTransitionSyntax)Visit(node.Transition), (CSharpSyntaxNode)Visit(node.Body), node.DirectiveDescriptor); public override SyntaxNode VisitRazorDirectiveBody(RazorDirectiveBodySyntax node) => node.Update((RazorSyntaxNode)Visit(node.Keyword), (CSharpCodeBlockSyntax)Visit(node.CSharpCode)); @@ -405,12 +405,12 @@ public static RazorCommentBlockSyntax RazorCommentBlock() => SyntaxFactory.RazorCommentBlock(SyntaxFactory.Token(SyntaxKind.RazorCommentTransition), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentLiteral), SyntaxFactory.Token(SyntaxKind.RazorCommentStar), SyntaxFactory.Token(SyntaxKind.RazorCommentTransition)); ///

Creates a new RazorMetaCodeSyntax instance. - public static RazorMetaCodeSyntax RazorMetaCode(SyntaxTokenList metaCode, ISpanChunkGenerator chunkGenerator) - => (RazorMetaCodeSyntax)InternalSyntax.SyntaxFactory.RazorMetaCode(metaCode.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static RazorMetaCodeSyntax RazorMetaCode(SyntaxTokenList metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (RazorMetaCodeSyntax)InternalSyntax.SyntaxFactory.RazorMetaCode(metaCode.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new RazorMetaCodeSyntax instance. - public static RazorMetaCodeSyntax RazorMetaCode(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.RazorMetaCode(default(SyntaxTokenList), chunkGenerator); + public static RazorMetaCodeSyntax RazorMetaCode(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.RazorMetaCode(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new GenericBlockSyntax instance. public static GenericBlockSyntax GenericBlock(SyntaxList children) @@ -421,12 +421,12 @@ public static GenericBlockSyntax GenericBlock() => SyntaxFactory.GenericBlock(default(SyntaxList)); /// Creates a new UnclassifiedTextLiteralSyntax instance. - public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (UnclassifiedTextLiteralSyntax)InternalSyntax.SyntaxFactory.UnclassifiedTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (UnclassifiedTextLiteralSyntax)InternalSyntax.SyntaxFactory.UnclassifiedTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new UnclassifiedTextLiteralSyntax instance. - public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.UnclassifiedTextLiteral(default(SyntaxTokenList), chunkGenerator); + public static UnclassifiedTextLiteralSyntax UnclassifiedTextLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.UnclassifiedTextLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new MarkupBlockSyntax instance. public static MarkupBlockSyntax MarkupBlock(SyntaxList children) @@ -437,28 +437,28 @@ public static MarkupBlockSyntax MarkupBlock() => SyntaxFactory.MarkupBlock(default(SyntaxList)); /// Creates a new MarkupTransitionSyntax instance. - public static MarkupTransitionSyntax MarkupTransition(SyntaxTokenList transitionTokens, ISpanChunkGenerator chunkGenerator) - => (MarkupTransitionSyntax)InternalSyntax.SyntaxFactory.MarkupTransition(transitionTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static MarkupTransitionSyntax MarkupTransition(SyntaxTokenList transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (MarkupTransitionSyntax)InternalSyntax.SyntaxFactory.MarkupTransition(transitionTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new MarkupTransitionSyntax instance. - public static MarkupTransitionSyntax MarkupTransition(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTransition(default(SyntaxTokenList), chunkGenerator); + public static MarkupTransitionSyntax MarkupTransition(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTransition(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new MarkupTextLiteralSyntax instance. - public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (MarkupTextLiteralSyntax)InternalSyntax.SyntaxFactory.MarkupTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (MarkupTextLiteralSyntax)InternalSyntax.SyntaxFactory.MarkupTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new MarkupTextLiteralSyntax instance. - public static MarkupTextLiteralSyntax MarkupTextLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTextLiteral(default(SyntaxTokenList), chunkGenerator); + public static MarkupTextLiteralSyntax MarkupTextLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTextLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new MarkupEphemeralTextLiteralSyntax instance. - public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (MarkupEphemeralTextLiteralSyntax)InternalSyntax.SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (MarkupEphemeralTextLiteralSyntax)InternalSyntax.SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new MarkupEphemeralTextLiteralSyntax instance. - public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupEphemeralTextLiteral(default(SyntaxTokenList), chunkGenerator); + public static MarkupEphemeralTextLiteralSyntax MarkupEphemeralTextLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupEphemeralTextLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new MarkupCommentBlockSyntax instance. public static MarkupCommentBlockSyntax MarkupCommentBlock(SyntaxList children) @@ -531,119 +531,119 @@ public static MarkupElementSyntax MarkupElement(MarkupStartTagSyntax startTag, S => SyntaxFactory.MarkupElement(default(MarkupStartTagSyntax), body, default(MarkupEndTagSyntax)); /// Creates a new MarkupStartTagSyntax instance. - public static MarkupStartTagSyntax MarkupStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupStartTagSyntax MarkupStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash or SyntaxKind.None', but it was {forwardSlash.Kind}"); if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return (MarkupStartTagSyntax)InternalSyntax.SyntaxFactory.MarkupStartTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, attributes.Node.ToGreenList(), (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator).CreateRed(); + return (MarkupStartTagSyntax)InternalSyntax.SyntaxFactory.MarkupStartTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, attributes.Node.ToGreenList(), (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, isMarkupTransition, chunkGenerator, editHandler).CreateRed(); } /// Creates a new MarkupStartTagSyntax instance. - public static MarkupStartTagSyntax MarkupStartTag(SyntaxList attributes, ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupStartTagSyntax MarkupStartTag(SyntaxList attributes, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); /// Creates a new MarkupStartTagSyntax instance. - public static MarkupStartTagSyntax MarkupStartTag(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupStartTagSyntax MarkupStartTag(bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); /// Creates a new MarkupEndTagSyntax instance. - public static MarkupEndTagSyntax MarkupEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupEndTagSyntax MarkupEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return (MarkupEndTagSyntax)InternalSyntax.SyntaxFactory.MarkupEndTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, miscAttributeContent == null ? null : (InternalSyntax.MarkupMiscAttributeContentSyntax)miscAttributeContent.Green, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator).CreateRed(); + return (MarkupEndTagSyntax)InternalSyntax.SyntaxFactory.MarkupEndTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, miscAttributeContent == null ? null : (InternalSyntax.MarkupMiscAttributeContentSyntax)miscAttributeContent.Green, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, isMarkupTransition, chunkGenerator, editHandler).CreateRed(); } /// Creates a new MarkupEndTagSyntax instance. - public static MarkupEndTagSyntax MarkupEndTag(MarkupMiscAttributeContentSyntax miscAttributeContent, ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupEndTagSyntax MarkupEndTag(MarkupMiscAttributeContentSyntax miscAttributeContent, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), isMarkupTransition, chunkGenerator, editHandler); /// Creates a new MarkupEndTagSyntax instance. - public static MarkupEndTagSyntax MarkupEndTag(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupEndTagSyntax MarkupEndTag(bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => 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); /// Creates a new MarkupTagHelperElementSyntax instance. - public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag, SyntaxList body, MarkupTagHelperEndTagSyntax endTag) + public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag, SyntaxList body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo) { ArgHelper.ThrowIfNull(startTag); - return (MarkupTagHelperElementSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperElement(startTag == null ? null : (InternalSyntax.MarkupTagHelperStartTagSyntax)startTag.Green, body.Node.ToGreenList(), endTag == null ? null : (InternalSyntax.MarkupTagHelperEndTagSyntax)endTag.Green).CreateRed(); + return (MarkupTagHelperElementSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperElement(startTag == null ? null : (InternalSyntax.MarkupTagHelperStartTagSyntax)startTag.Green, body.Node.ToGreenList(), endTag == null ? null : (InternalSyntax.MarkupTagHelperEndTagSyntax)endTag.Green, tagHelperInfo).CreateRed(); } /// Creates a new MarkupTagHelperElementSyntax instance. - public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag) - => SyntaxFactory.MarkupTagHelperElement(startTag, default(SyntaxList), default(MarkupTagHelperEndTagSyntax)); + public static MarkupTagHelperElementSyntax MarkupTagHelperElement(MarkupTagHelperStartTagSyntax startTag, TagHelperInfo tagHelperInfo) + => SyntaxFactory.MarkupTagHelperElement(startTag, default(SyntaxList), default(MarkupTagHelperEndTagSyntax), tagHelperInfo); /// Creates a new MarkupTagHelperStartTagSyntax instance. - public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash or SyntaxKind.None', but it was {forwardSlash.Kind}"); if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return (MarkupTagHelperStartTagSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperStartTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, attributes.Node.ToGreenList(), (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator).CreateRed(); + return (MarkupTagHelperStartTagSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperStartTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, attributes.Node.ToGreenList(), (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator, editHandler).CreateRed(); } /// Creates a new MarkupTagHelperStartTagSyntax instance. - public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxList attributes, ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(SyntaxList attributes, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), attributes, default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); /// Creates a new MarkupTagHelperStartTagSyntax instance. - public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupTagHelperStartTagSyntax MarkupTagHelperStartTag(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTagHelperStartTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(SyntaxList), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); /// Creates a new MarkupTagHelperEndTagSyntax instance. - public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (openAngle.Kind is not (SyntaxKind.OpenAngle)) return ThrowHelper.ThrowArgumentException(nameof(openAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.OpenAngle', but it was {openAngle.Kind}"); if (forwardSlash.Kind is not (SyntaxKind.ForwardSlash)) return ThrowHelper.ThrowArgumentException(nameof(forwardSlash), $"Invalid SyntaxKind. Expected 'SyntaxKind.ForwardSlash', but it was {forwardSlash.Kind}"); if (bang.Kind is not (SyntaxKind.Bang or SyntaxKind.None)) return ThrowHelper.ThrowArgumentException(nameof(bang), $"Invalid SyntaxKind. Expected 'SyntaxKind.Bang or SyntaxKind.None', but it was {bang.Kind}"); if (name.Kind is not (SyntaxKind.Text)) return ThrowHelper.ThrowArgumentException(nameof(name), $"Invalid SyntaxKind. Expected 'SyntaxKind.Text', but it was {name.Kind}"); if (closeAngle.Kind is not (SyntaxKind.CloseAngle)) return ThrowHelper.ThrowArgumentException(nameof(closeAngle), $"Invalid SyntaxKind. Expected 'SyntaxKind.CloseAngle', but it was {closeAngle.Kind}"); - return (MarkupTagHelperEndTagSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperEndTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, miscAttributeContent == null ? null : (InternalSyntax.MarkupMiscAttributeContentSyntax)miscAttributeContent.Green, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator).CreateRed(); + return (MarkupTagHelperEndTagSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperEndTag((Syntax.InternalSyntax.SyntaxToken)openAngle.Node, (Syntax.InternalSyntax.SyntaxToken)forwardSlash.Node, (Syntax.InternalSyntax.SyntaxToken)bang.Node, (Syntax.InternalSyntax.SyntaxToken)name.Node, miscAttributeContent == null ? null : (InternalSyntax.MarkupMiscAttributeContentSyntax)miscAttributeContent.Green, (Syntax.InternalSyntax.SyntaxToken)closeAngle.Node, chunkGenerator, editHandler).CreateRed(); } /// Creates a new MarkupTagHelperEndTagSyntax instance. - public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(MarkupMiscAttributeContentSyntax miscAttributeContent, ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(MarkupMiscAttributeContentSyntax miscAttributeContent, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), miscAttributeContent, SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); /// Creates a new MarkupTagHelperEndTagSyntax instance. - public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator); + public static MarkupTagHelperEndTagSyntax MarkupTagHelperEndTag(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.MarkupTagHelperEndTag(SyntaxFactory.Token(SyntaxKind.OpenAngle), SyntaxFactory.Token(SyntaxKind.ForwardSlash), default(SyntaxToken), SyntaxFactory.Token(SyntaxKind.Text), default(MarkupMiscAttributeContentSyntax), SyntaxFactory.Token(SyntaxKind.CloseAngle), chunkGenerator, editHandler); /// Creates a new MarkupTagHelperAttributeSyntax instance. - public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(name); if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); ArgHelper.ThrowIfNull(value); - return (MarkupTagHelperAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, nameSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)nameSuffix.Green, (Syntax.InternalSyntax.SyntaxToken)equalsToken.Node, valuePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valuePrefix.Green, value == null ? null : (InternalSyntax.MarkupTagHelperAttributeValueSyntax)value.Green, valueSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valueSuffix.Green).CreateRed(); + return (MarkupTagHelperAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, nameSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)nameSuffix.Green, (Syntax.InternalSyntax.SyntaxToken)equalsToken.Node, valuePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valuePrefix.Green, value == null ? null : (InternalSyntax.MarkupTagHelperAttributeValueSyntax)value.Green, valueSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valueSuffix.Green, tagHelperAttributeInfo).CreateRed(); } /// Creates a new MarkupTagHelperAttributeSyntax instance. - public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) - => SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix); + public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); /// Creates a new MarkupTagHelperAttributeSyntax instance. - public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax name) - => SyntaxFactory.MarkupTagHelperAttribute(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax)); + public static MarkupTagHelperAttributeSyntax MarkupTagHelperAttribute(MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupTagHelperAttribute(default(MarkupTextLiteralSyntax), name, default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); /// Creates a new MarkupMinimizedTagHelperAttributeSyntax instance. - public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) + public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(name); - return (MarkupMinimizedTagHelperAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green).CreateRed(); + return (MarkupMinimizedTagHelperAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, tagHelperAttributeInfo).CreateRed(); } /// Creates a new MarkupMinimizedTagHelperAttributeSyntax instance. - public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax name) - => SyntaxFactory.MarkupMinimizedTagHelperAttribute(default(MarkupTextLiteralSyntax), name); + public static MarkupMinimizedTagHelperAttributeSyntax MarkupMinimizedTagHelperAttribute(MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupMinimizedTagHelperAttribute(default(MarkupTextLiteralSyntax), name, tagHelperAttributeInfo); /// Creates a new MarkupTagHelperAttributeValueSyntax instance. public static MarkupTagHelperAttributeValueSyntax MarkupTagHelperAttributeValue(SyntaxList children) @@ -654,34 +654,34 @@ public static MarkupTagHelperAttributeValueSyntax MarkupTagHelperAttributeValue( => SyntaxFactory.MarkupTagHelperAttributeValue(default(SyntaxList)); /// Creates a new MarkupTagHelperDirectiveAttributeSyntax instance. - public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(name); if (equalsToken.Kind is not (SyntaxKind.Equals)) return ThrowHelper.ThrowArgumentException(nameof(equalsToken), $"Invalid SyntaxKind. Expected 'SyntaxKind.Equals', but it was {equalsToken.Kind}"); ArgHelper.ThrowIfNull(value); - return (MarkupTagHelperDirectiveAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, transition == null ? null : (InternalSyntax.RazorMetaCodeSyntax)transition.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, colon == null ? null : (InternalSyntax.RazorMetaCodeSyntax)colon.Green, parameterName == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)parameterName.Green, nameSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)nameSuffix.Green, (Syntax.InternalSyntax.SyntaxToken)equalsToken.Node, valuePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valuePrefix.Green, value == null ? null : (InternalSyntax.MarkupTagHelperAttributeValueSyntax)value.Green, valueSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valueSuffix.Green).CreateRed(); + return (MarkupTagHelperDirectiveAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, transition == null ? null : (InternalSyntax.RazorMetaCodeSyntax)transition.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, colon == null ? null : (InternalSyntax.RazorMetaCodeSyntax)colon.Green, parameterName == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)parameterName.Green, nameSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)nameSuffix.Green, (Syntax.InternalSyntax.SyntaxToken)equalsToken.Node, valuePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valuePrefix.Green, value == null ? null : (InternalSyntax.MarkupTagHelperAttributeValueSyntax)value.Green, valueSuffix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)valueSuffix.Green, tagHelperAttributeInfo).CreateRed(); } /// Creates a new MarkupTagHelperDirectiveAttributeSyntax instance. - public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) - => SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix); + public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, SyntaxFactory.Token(SyntaxKind.Equals), valuePrefix, value, valueSuffix, tagHelperAttributeInfo); /// Creates a new MarkupTagHelperDirectiveAttributeSyntax instance. - public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name) - => SyntaxFactory.MarkupTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax), default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax)); + public static MarkupTagHelperDirectiveAttributeSyntax MarkupTagHelperDirectiveAttribute(RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax), default(MarkupTextLiteralSyntax), SyntaxFactory.Token(SyntaxKind.Equals), default(MarkupTextLiteralSyntax), SyntaxFactory.MarkupTagHelperAttributeValue(), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); /// Creates a new MarkupMinimizedTagHelperDirectiveAttributeSyntax instance. - public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName) + public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(name); - return (MarkupMinimizedTagHelperDirectiveAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, transition == null ? null : (InternalSyntax.RazorMetaCodeSyntax)transition.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, colon == null ? null : (InternalSyntax.RazorMetaCodeSyntax)colon.Green, parameterName == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)parameterName.Green).CreateRed(); + return (MarkupMinimizedTagHelperDirectiveAttributeSyntax)InternalSyntax.SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)namePrefix.Green, transition == null ? null : (InternalSyntax.RazorMetaCodeSyntax)transition.Green, name == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)name.Green, colon == null ? null : (InternalSyntax.RazorMetaCodeSyntax)colon.Green, parameterName == null ? null : (InternalSyntax.MarkupTextLiteralSyntax)parameterName.Green, tagHelperAttributeInfo).CreateRed(); } /// Creates a new MarkupMinimizedTagHelperDirectiveAttributeSyntax instance. - public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name) - => SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax)); + public static MarkupMinimizedTagHelperDirectiveAttributeSyntax MarkupMinimizedTagHelperDirectiveAttribute(RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) + => SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(default(MarkupTextLiteralSyntax), transition, name, default(RazorMetaCodeSyntax), default(MarkupTextLiteralSyntax), tagHelperAttributeInfo); /// Creates a new CSharpCodeBlockSyntax instance. public static CSharpCodeBlockSyntax CSharpCodeBlock(SyntaxList children) @@ -692,39 +692,39 @@ public static CSharpCodeBlockSyntax CSharpCodeBlock() => SyntaxFactory.CSharpCodeBlock(default(SyntaxList)); /// Creates a new CSharpTransitionSyntax instance. - public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition, ISpanChunkGenerator chunkGenerator) + public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { if (transition.Kind is not (SyntaxKind.Transition)) return ThrowHelper.ThrowArgumentException(nameof(transition), $"Invalid SyntaxKind. Expected 'SyntaxKind.Transition', but it was {transition.Kind}"); - return (CSharpTransitionSyntax)InternalSyntax.SyntaxFactory.CSharpTransition((Syntax.InternalSyntax.SyntaxToken)transition.Node, chunkGenerator).CreateRed(); + return (CSharpTransitionSyntax)InternalSyntax.SyntaxFactory.CSharpTransition((Syntax.InternalSyntax.SyntaxToken)transition.Node, chunkGenerator, editHandler).CreateRed(); } /// Creates a new CSharpTransitionSyntax instance. - public static CSharpTransitionSyntax CSharpTransition(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.CSharpTransition(SyntaxFactory.Token(SyntaxKind.Transition), chunkGenerator); + public static CSharpTransitionSyntax CSharpTransition(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.CSharpTransition(SyntaxFactory.Token(SyntaxKind.Transition), chunkGenerator, editHandler); /// Creates a new CSharpStatementLiteralSyntax instance. - public static CSharpStatementLiteralSyntax CSharpStatementLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (CSharpStatementLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpStatementLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static CSharpStatementLiteralSyntax CSharpStatementLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (CSharpStatementLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpStatementLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new CSharpStatementLiteralSyntax instance. - public static CSharpStatementLiteralSyntax CSharpStatementLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.CSharpStatementLiteral(default(SyntaxTokenList), chunkGenerator); + public static CSharpStatementLiteralSyntax CSharpStatementLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.CSharpStatementLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new CSharpExpressionLiteralSyntax instance. - public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (CSharpExpressionLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpExpressionLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (CSharpExpressionLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpExpressionLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new CSharpExpressionLiteralSyntax instance. - public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.CSharpExpressionLiteral(default(SyntaxTokenList), chunkGenerator); + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.CSharpExpressionLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new CSharpEphemeralTextLiteralSyntax instance. - public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) - => (CSharpEphemeralTextLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator).CreateRed(); + public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => (CSharpEphemeralTextLiteralSyntax)InternalSyntax.SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens.Node.ToGreenList(), chunkGenerator, editHandler).CreateRed(); /// Creates a new CSharpEphemeralTextLiteralSyntax instance. - public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(ISpanChunkGenerator chunkGenerator) - => SyntaxFactory.CSharpEphemeralTextLiteral(default(SyntaxTokenList), chunkGenerator); + public static CSharpEphemeralTextLiteralSyntax CSharpEphemeralTextLiteral(ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) + => SyntaxFactory.CSharpEphemeralTextLiteral(default(SyntaxTokenList), chunkGenerator, editHandler); /// Creates a new CSharpTemplateBlockSyntax instance. public static CSharpTemplateBlockSyntax CSharpTemplateBlock(SyntaxList children) @@ -796,13 +796,17 @@ public static CSharpImplicitExpressionBodySyntax CSharpImplicitExpressionBody() => SyntaxFactory.CSharpImplicitExpressionBody(SyntaxFactory.CSharpCodeBlock()); /// Creates a new RazorDirectiveSyntax instance. - public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) { ArgHelper.ThrowIfNull(transition); ArgHelper.ThrowIfNull(body); - return (RazorDirectiveSyntax)InternalSyntax.SyntaxFactory.RazorDirective(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green).CreateRed(); + return (RazorDirectiveSyntax)InternalSyntax.SyntaxFactory.RazorDirective(transition == null ? null : (InternalSyntax.CSharpTransitionSyntax)transition.Green, body == null ? null : (InternalSyntax.CSharpSyntaxNode)body.Green, directiveDescriptor).CreateRed(); } + /// Creates a new RazorDirectiveSyntax instance. + public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + => SyntaxFactory.RazorDirective(transition, body, default(DirectiveDescriptor)); + /// Creates a new RazorDirectiveBodySyntax instance. public static RazorDirectiveBodySyntax RazorDirectiveBody(RazorSyntaxNode keyword, CSharpCodeBlockSyntax csharpCode) { diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs index 4e9bda6a89e..707646b4f14 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Generated/Syntax.xml.Syntax.Generated.cs @@ -48,8 +48,7 @@ public RazorDocumentSyntax Update(RazorBlockSyntax document, SyntaxToken endOfFi var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -87,8 +86,7 @@ public RazorCommentBlockSyntax Update(SyntaxToken startCommentTransition, Syntax var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -117,6 +115,7 @@ public SyntaxTokenList MetaCode } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.RazorMetaCodeSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.RazorMetaCodeSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -125,23 +124,23 @@ public SyntaxTokenList MetaCode public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitRazorMetaCode(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorMetaCode(this); - public RazorMetaCodeSyntax Update(SyntaxTokenList metaCode, ISpanChunkGenerator chunkGenerator) + public RazorMetaCodeSyntax Update(SyntaxTokenList metaCode, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (metaCode != MetaCode || chunkGenerator != ChunkGenerator) + if (metaCode != MetaCode || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.RazorMetaCode(metaCode, chunkGenerator); + var newNode = SyntaxFactory.RazorMetaCode(metaCode, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public RazorMetaCodeSyntax WithMetaCode(SyntaxTokenList metaCode) => Update(metaCode, ChunkGenerator); - public RazorMetaCodeSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(MetaCode, chunkGenerator); + public RazorMetaCodeSyntax WithMetaCode(SyntaxTokenList metaCode) => Update(metaCode, ChunkGenerator, EditHandler); + public RazorMetaCodeSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(MetaCode, chunkGenerator, EditHandler); + public RazorMetaCodeSyntax WithEditHandler(SpanEditHandler editHandler) => Update(MetaCode, ChunkGenerator, editHandler); public RazorMetaCodeSyntax AddMetaCode(params SyntaxToken[] items) => WithMetaCode(this.MetaCode.AddRange(items)); } @@ -172,8 +171,7 @@ public GenericBlockSyntax Update(SyntaxList children) var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -202,6 +200,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.UnclassifiedTextLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.UnclassifiedTextLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -210,23 +209,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitUnclassifiedTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitUnclassifiedTextLiteral(this); - public UnclassifiedTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public UnclassifiedTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.UnclassifiedTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.UnclassifiedTextLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public UnclassifiedTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public UnclassifiedTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public UnclassifiedTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public UnclassifiedTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public UnclassifiedTextLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public UnclassifiedTextLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -265,8 +264,7 @@ public MarkupBlockSyntax Update(SyntaxList children) var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -295,6 +293,7 @@ public SyntaxTokenList TransitionTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupTransitionSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.MarkupTransitionSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -303,23 +302,23 @@ public SyntaxTokenList TransitionTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTransition(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTransition(this); - public MarkupTransitionSyntax Update(SyntaxTokenList transitionTokens, ISpanChunkGenerator chunkGenerator) + public MarkupTransitionSyntax Update(SyntaxTokenList transitionTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (transitionTokens != TransitionTokens || chunkGenerator != ChunkGenerator) + if (transitionTokens != TransitionTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupTransition(transitionTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupTransition(transitionTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupTransitionSyntax WithTransitionTokens(SyntaxTokenList transitionTokens) => Update(transitionTokens, ChunkGenerator); - public MarkupTransitionSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(TransitionTokens, chunkGenerator); + public MarkupTransitionSyntax WithTransitionTokens(SyntaxTokenList transitionTokens) => Update(transitionTokens, ChunkGenerator, EditHandler); + public MarkupTransitionSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(TransitionTokens, chunkGenerator, EditHandler); + public MarkupTransitionSyntax WithEditHandler(SpanEditHandler editHandler) => Update(TransitionTokens, ChunkGenerator, editHandler); public MarkupTransitionSyntax AddTransitionTokens(params SyntaxToken[] items) => WithTransitionTokens(this.TransitionTokens.AddRange(items)); } @@ -340,6 +339,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupTextLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.MarkupTextLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -348,23 +348,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTextLiteral(this); - public MarkupTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public MarkupTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupTextLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public MarkupTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public MarkupTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public MarkupTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public MarkupTextLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public MarkupTextLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -385,6 +385,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupEphemeralTextLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.MarkupEphemeralTextLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -393,23 +394,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEphemeralTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEphemeralTextLiteral(this); - public MarkupEphemeralTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public MarkupEphemeralTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.MarkupEphemeralTextLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupEphemeralTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public MarkupEphemeralTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public MarkupEphemeralTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public MarkupEphemeralTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public MarkupEphemeralTextLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public MarkupEphemeralTextLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -440,8 +441,7 @@ public MarkupCommentBlockSyntax Update(SyntaxList children) var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -494,8 +494,7 @@ public MarkupMinimizedAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePr var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -564,8 +563,7 @@ public MarkupAttributeBlockSyntax Update(MarkupTextLiteralSyntax namePrefix, Mar var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -608,8 +606,7 @@ public MarkupMiscAttributeContentSyntax Update(SyntaxList child var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -660,8 +657,7 @@ public MarkupLiteralAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -711,8 +707,7 @@ public MarkupDynamicAttributeValueSyntax Update(MarkupTextLiteralSyntax prefix, var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -757,6 +752,8 @@ internal BaseMarkupStartTagSyntax(GreenNode green, SyntaxNode parent, int positi internal abstract BaseMarkupStartTagSyntax WithCloseAngleCore(SyntaxToken closeAngle); public abstract ISpanChunkGenerator ChunkGenerator { get; } + + public abstract SpanEditHandler EditHandler { get; } } internal abstract partial class BaseMarkupEndTagSyntax : MarkupSyntaxNode @@ -794,6 +791,8 @@ internal BaseMarkupEndTagSyntax(GreenNode green, SyntaxNode parent, int position internal abstract BaseMarkupEndTagSyntax WithCloseAngleCore(SyntaxToken closeAngle); public abstract ISpanChunkGenerator ChunkGenerator { get; } + + public abstract SpanEditHandler EditHandler { get; } } internal sealed partial class MarkupElementSyntax : MarkupSyntaxNode @@ -840,8 +839,7 @@ public MarkupElementSyntax Update(MarkupStartTagSyntax startTag, SyntaxList 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -883,7 +881,9 @@ public override SyntaxToken ForwardSlash } } public override SyntaxToken CloseAngle => new SyntaxToken(this, ((InternalSyntax.MarkupStartTagSyntax)Green)._closeAngle, GetChildPosition(5), GetChildIndex(5)); + public bool IsMarkupTransition => ((InternalSyntax.MarkupStartTagSyntax)Green).IsMarkupTransition; public override ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupStartTagSyntax)Green).ChunkGenerator; + public override SpanEditHandler EditHandler => ((InternalSyntax.MarkupStartTagSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => index == 3 ? GetRed(ref this._attributes, 3) : null; @@ -892,34 +892,35 @@ public override SyntaxToken ForwardSlash public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupStartTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupStartTag(this); - public MarkupStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator) + if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, isMarkupTransition, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } internal override BaseMarkupStartTagSyntax WithOpenAngleCore(SyntaxToken openAngle) => WithOpenAngle(openAngle); - public new MarkupStartTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupStartTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithBangCore(SyntaxToken bang) => WithBang(bang); - public new MarkupStartTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupStartTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, bang, Name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithNameCore(SyntaxToken name) => WithName(name); - public new MarkupStartTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, Bang, name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupStartTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, Bang, name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithAttributesCore(SyntaxList attributes) => WithAttributes(attributes); - public new MarkupStartTagSyntax WithAttributes(SyntaxList attributes) => Update(OpenAngle, Bang, Name, attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupStartTagSyntax WithAttributes(SyntaxList attributes) => Update(OpenAngle, Bang, Name, attributes, ForwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithForwardSlashCore(SyntaxToken forwardSlash) => WithForwardSlash(forwardSlash); - public new MarkupStartTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, Bang, Name, Attributes, forwardSlash, CloseAngle, ChunkGenerator); + public new MarkupStartTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, Bang, Name, Attributes, forwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithCloseAngleCore(SyntaxToken closeAngle) => WithCloseAngle(closeAngle); - public new MarkupStartTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, closeAngle, ChunkGenerator); - public MarkupStartTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, chunkGenerator); + public new MarkupStartTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, closeAngle, IsMarkupTransition, ChunkGenerator, EditHandler); + public MarkupStartTagSyntax WithIsMarkupTransition(bool isMarkupTransition) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, isMarkupTransition, ChunkGenerator, EditHandler); + public MarkupStartTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, chunkGenerator, EditHandler); + public MarkupStartTagSyntax WithEditHandler(SpanEditHandler editHandler) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, IsMarkupTransition, ChunkGenerator, editHandler); internal override BaseMarkupStartTagSyntax AddAttributesCore(params RazorSyntaxNode[] items) => AddAttributes(items); public new MarkupStartTagSyntax AddAttributes(params RazorSyntaxNode[] items) => WithAttributes(this.Attributes.AddRange(items)); @@ -947,7 +948,9 @@ public override SyntaxToken Bang public override SyntaxToken Name => new SyntaxToken(this, ((InternalSyntax.MarkupEndTagSyntax)Green)._name, GetChildPosition(3), GetChildIndex(3)); public override MarkupMiscAttributeContentSyntax MiscAttributeContent => GetRed(ref _miscAttributeContent, 4); public override SyntaxToken CloseAngle => new SyntaxToken(this, ((InternalSyntax.MarkupEndTagSyntax)Green)._closeAngle, GetChildPosition(5), GetChildIndex(5)); + public bool IsMarkupTransition => ((InternalSyntax.MarkupEndTagSyntax)Green).IsMarkupTransition; public override ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupEndTagSyntax)Green).ChunkGenerator; + public override SpanEditHandler EditHandler => ((InternalSyntax.MarkupEndTagSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => index == 4 ? GetRed(ref this._miscAttributeContent, 4) : null; @@ -956,34 +959,35 @@ public override SyntaxToken Bang public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEndTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupEndTag(this); - public MarkupEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, bool isMarkupTransition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator) + if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, isMarkupTransition, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } internal override BaseMarkupEndTagSyntax WithOpenAngleCore(SyntaxToken openAngle) => WithOpenAngle(openAngle); - public new MarkupEndTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupEndTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithForwardSlashCore(SyntaxToken forwardSlash) => WithForwardSlash(forwardSlash); - public new MarkupEndTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, forwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupEndTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, forwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithBangCore(SyntaxToken bang) => WithBang(bang); - public new MarkupEndTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, ForwardSlash, bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupEndTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, ForwardSlash, bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithNameCore(SyntaxToken name) => WithName(name); - public new MarkupEndTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, ForwardSlash, Bang, name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupEndTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, ForwardSlash, Bang, name, MiscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithMiscAttributeContentCore(MarkupMiscAttributeContentSyntax miscAttributeContent) => WithMiscAttributeContent(miscAttributeContent); - public new MarkupEndTagSyntax WithMiscAttributeContent(MarkupMiscAttributeContentSyntax miscAttributeContent) => Update(OpenAngle, ForwardSlash, Bang, Name, miscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupEndTagSyntax WithMiscAttributeContent(MarkupMiscAttributeContentSyntax miscAttributeContent) => Update(OpenAngle, ForwardSlash, Bang, Name, miscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithCloseAngleCore(SyntaxToken closeAngle) => WithCloseAngle(closeAngle); - public new MarkupEndTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, closeAngle, ChunkGenerator); - public MarkupEndTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, chunkGenerator); + public new MarkupEndTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, closeAngle, IsMarkupTransition, ChunkGenerator, EditHandler); + public MarkupEndTagSyntax WithIsMarkupTransition(bool isMarkupTransition) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, isMarkupTransition, ChunkGenerator, EditHandler); + public MarkupEndTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, chunkGenerator, EditHandler); + public MarkupEndTagSyntax WithEditHandler(SpanEditHandler editHandler) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, IsMarkupTransition, ChunkGenerator, editHandler); internal override BaseMarkupEndTagSyntax AddMiscAttributeContentChildrenCore(params RazorSyntaxNode[] items) => AddMiscAttributeContentChildren(items); public new MarkupEndTagSyntax AddMiscAttributeContentChildren(params RazorSyntaxNode[] items) @@ -1007,6 +1011,7 @@ internal MarkupTagHelperElementSyntax(GreenNode green, SyntaxNode parent, int po public MarkupTagHelperStartTagSyntax StartTag => GetRedAtZero(ref _startTag); public SyntaxList Body => new SyntaxList(GetRed(ref _body, 1)); public MarkupTagHelperEndTagSyntax EndTag => GetRed(ref _endTag, 2); + public TagHelperInfo TagHelperInfo => ((InternalSyntax.MarkupTagHelperElementSyntax)Green).TagHelperInfo; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -1029,24 +1034,24 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperElement(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperElement(this); - public MarkupTagHelperElementSyntax Update(MarkupTagHelperStartTagSyntax startTag, SyntaxList body, MarkupTagHelperEndTagSyntax endTag) + public MarkupTagHelperElementSyntax Update(MarkupTagHelperStartTagSyntax startTag, SyntaxList body, MarkupTagHelperEndTagSyntax endTag, TagHelperInfo tagHelperInfo) { if (startTag != StartTag || body != Body || endTag != EndTag) { - var newNode = SyntaxFactory.MarkupTagHelperElement(startTag, body, endTag); + var newNode = SyntaxFactory.MarkupTagHelperElement(startTag, body, endTag, tagHelperInfo); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupTagHelperElementSyntax WithStartTag(MarkupTagHelperStartTagSyntax startTag) => Update(startTag, Body, EndTag); - public MarkupTagHelperElementSyntax WithBody(SyntaxList body) => Update(StartTag, body, EndTag); - public MarkupTagHelperElementSyntax WithEndTag(MarkupTagHelperEndTagSyntax endTag) => Update(StartTag, Body, endTag); + public MarkupTagHelperElementSyntax WithStartTag(MarkupTagHelperStartTagSyntax startTag) => Update(startTag, Body, EndTag, TagHelperInfo); + public MarkupTagHelperElementSyntax WithBody(SyntaxList body) => Update(StartTag, body, EndTag, TagHelperInfo); + public MarkupTagHelperElementSyntax WithEndTag(MarkupTagHelperEndTagSyntax endTag) => Update(StartTag, Body, endTag, TagHelperInfo); + public MarkupTagHelperElementSyntax WithTagHelperInfo(TagHelperInfo tagHelperInfo) => Update(StartTag, Body, EndTag, tagHelperInfo); public MarkupTagHelperElementSyntax AddStartTagAttributes(params RazorSyntaxNode[] items) => WithStartTag(this.StartTag.WithAttributes(this.StartTag.Attributes.AddRange(items))); @@ -1083,6 +1088,7 @@ public override SyntaxToken ForwardSlash } public override SyntaxToken CloseAngle => new SyntaxToken(this, ((InternalSyntax.MarkupTagHelperStartTagSyntax)Green)._closeAngle, GetChildPosition(5), GetChildIndex(5)); public override ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupTagHelperStartTagSyntax)Green).ChunkGenerator; + public override SpanEditHandler EditHandler => ((InternalSyntax.MarkupTagHelperStartTagSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => index == 3 ? GetRed(ref this._attributes, 3) : null; @@ -1091,34 +1097,34 @@ public override SyntaxToken ForwardSlash public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperStartTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperStartTag(this); - public MarkupTagHelperStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupTagHelperStartTagSyntax Update(SyntaxToken openAngle, SyntaxToken bang, SyntaxToken name, SyntaxList attributes, SyntaxToken forwardSlash, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator) + if (openAngle != OpenAngle || bang != Bang || name != Name || attributes != Attributes || forwardSlash != ForwardSlash || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupTagHelperStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupTagHelperStartTag(openAngle, bang, name, attributes, forwardSlash, closeAngle, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } internal override BaseMarkupStartTagSyntax WithOpenAngleCore(SyntaxToken openAngle) => WithOpenAngle(openAngle); - public new MarkupTagHelperStartTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupTagHelperStartTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithBangCore(SyntaxToken bang) => WithBang(bang); - public new MarkupTagHelperStartTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupTagHelperStartTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithNameCore(SyntaxToken name) => WithName(name); - public new MarkupTagHelperStartTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, Bang, name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupTagHelperStartTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, Bang, name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithAttributesCore(SyntaxList attributes) => WithAttributes(attributes); - public new MarkupTagHelperStartTagSyntax WithAttributes(SyntaxList attributes) => Update(OpenAngle, Bang, Name, attributes, ForwardSlash, CloseAngle, ChunkGenerator); + public new MarkupTagHelperStartTagSyntax WithAttributes(SyntaxList attributes) => Update(OpenAngle, Bang, Name, attributes, ForwardSlash, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithForwardSlashCore(SyntaxToken forwardSlash) => WithForwardSlash(forwardSlash); - public new MarkupTagHelperStartTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, Bang, Name, Attributes, forwardSlash, CloseAngle, ChunkGenerator); + public new MarkupTagHelperStartTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, Bang, Name, Attributes, forwardSlash, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupStartTagSyntax WithCloseAngleCore(SyntaxToken closeAngle) => WithCloseAngle(closeAngle); - public new MarkupTagHelperStartTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, closeAngle, ChunkGenerator); - public MarkupTagHelperStartTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, chunkGenerator); + public new MarkupTagHelperStartTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, closeAngle, ChunkGenerator, EditHandler); + public MarkupTagHelperStartTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, chunkGenerator, EditHandler); + public MarkupTagHelperStartTagSyntax WithEditHandler(SpanEditHandler editHandler) => Update(OpenAngle, Bang, Name, Attributes, ForwardSlash, CloseAngle, ChunkGenerator, editHandler); internal override BaseMarkupStartTagSyntax AddAttributesCore(params RazorSyntaxNode[] items) => AddAttributes(items); public new MarkupTagHelperStartTagSyntax AddAttributes(params RazorSyntaxNode[] items) => WithAttributes(this.Attributes.AddRange(items)); @@ -1147,6 +1153,7 @@ public override SyntaxToken Bang public override MarkupMiscAttributeContentSyntax MiscAttributeContent => GetRed(ref _miscAttributeContent, 4); public override SyntaxToken CloseAngle => new SyntaxToken(this, ((InternalSyntax.MarkupTagHelperEndTagSyntax)Green)._closeAngle, GetChildPosition(5), GetChildIndex(5)); public override ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.MarkupTagHelperEndTagSyntax)Green).ChunkGenerator; + public override SpanEditHandler EditHandler => ((InternalSyntax.MarkupTagHelperEndTagSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => index == 4 ? GetRed(ref this._miscAttributeContent, 4) : null; @@ -1155,34 +1162,34 @@ public override SyntaxToken Bang public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperEndTag(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperEndTag(this); - public MarkupTagHelperEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator) + public MarkupTagHelperEndTagSyntax Update(SyntaxToken openAngle, SyntaxToken forwardSlash, SyntaxToken bang, SyntaxToken name, MarkupMiscAttributeContentSyntax miscAttributeContent, SyntaxToken closeAngle, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator) + if (openAngle != OpenAngle || forwardSlash != ForwardSlash || bang != Bang || name != Name || miscAttributeContent != MiscAttributeContent || closeAngle != CloseAngle || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.MarkupTagHelperEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator); + var newNode = SyntaxFactory.MarkupTagHelperEndTag(openAngle, forwardSlash, bang, name, miscAttributeContent, closeAngle, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } internal override BaseMarkupEndTagSyntax WithOpenAngleCore(SyntaxToken openAngle) => WithOpenAngle(openAngle); - public new MarkupTagHelperEndTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupTagHelperEndTagSyntax WithOpenAngle(SyntaxToken openAngle) => Update(openAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithForwardSlashCore(SyntaxToken forwardSlash) => WithForwardSlash(forwardSlash); - public new MarkupTagHelperEndTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, forwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupTagHelperEndTagSyntax WithForwardSlash(SyntaxToken forwardSlash) => Update(OpenAngle, forwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithBangCore(SyntaxToken bang) => WithBang(bang); - public new MarkupTagHelperEndTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, ForwardSlash, bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupTagHelperEndTagSyntax WithBang(SyntaxToken bang) => Update(OpenAngle, ForwardSlash, bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithNameCore(SyntaxToken name) => WithName(name); - public new MarkupTagHelperEndTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, ForwardSlash, Bang, name, MiscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupTagHelperEndTagSyntax WithName(SyntaxToken name) => Update(OpenAngle, ForwardSlash, Bang, name, MiscAttributeContent, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithMiscAttributeContentCore(MarkupMiscAttributeContentSyntax miscAttributeContent) => WithMiscAttributeContent(miscAttributeContent); - public new MarkupTagHelperEndTagSyntax WithMiscAttributeContent(MarkupMiscAttributeContentSyntax miscAttributeContent) => Update(OpenAngle, ForwardSlash, Bang, Name, miscAttributeContent, CloseAngle, ChunkGenerator); + public new MarkupTagHelperEndTagSyntax WithMiscAttributeContent(MarkupMiscAttributeContentSyntax miscAttributeContent) => Update(OpenAngle, ForwardSlash, Bang, Name, miscAttributeContent, CloseAngle, ChunkGenerator, EditHandler); internal override BaseMarkupEndTagSyntax WithCloseAngleCore(SyntaxToken closeAngle) => WithCloseAngle(closeAngle); - public new MarkupTagHelperEndTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, closeAngle, ChunkGenerator); - public MarkupTagHelperEndTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, chunkGenerator); + public new MarkupTagHelperEndTagSyntax WithCloseAngle(SyntaxToken closeAngle) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, closeAngle, ChunkGenerator, EditHandler); + public MarkupTagHelperEndTagSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, chunkGenerator, EditHandler); + public MarkupTagHelperEndTagSyntax WithEditHandler(SpanEditHandler editHandler) => Update(OpenAngle, ForwardSlash, Bang, Name, MiscAttributeContent, CloseAngle, ChunkGenerator, editHandler); internal override BaseMarkupEndTagSyntax AddMiscAttributeContentChildrenCore(params RazorSyntaxNode[] items) => AddMiscAttributeContentChildren(items); public new MarkupTagHelperEndTagSyntax AddMiscAttributeContentChildren(params RazorSyntaxNode[] items) @@ -1213,6 +1220,7 @@ internal MarkupTagHelperAttributeSyntax(GreenNode green, SyntaxNode parent, int public MarkupTextLiteralSyntax ValuePrefix => GetRed(ref _valuePrefix, 4); public MarkupTagHelperAttributeValueSyntax Value => GetRed(ref _value, 5); public MarkupTextLiteralSyntax ValueSuffix => GetRed(ref _valueSuffix, 6); + public TagHelperAttributeInfo TagHelperAttributeInfo => ((InternalSyntax.MarkupTagHelperAttributeSyntax)Green).TagHelperAttributeInfo; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -1241,28 +1249,28 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperAttribute(this); - public MarkupTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public MarkupTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || name != Name || nameSuffix != NameSuffix || equalsToken != EqualsToken || valuePrefix != ValuePrefix || value != Value || valueSuffix != ValueSuffix) { - var newNode = SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + var newNode = SyntaxFactory.MarkupTagHelperAttribute(namePrefix, name, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupTagHelperAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, name, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithNameSuffix(MarkupTextLiteralSyntax nameSuffix) => Update(NamePrefix, Name, nameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithEqualsToken(SyntaxToken equalsToken) => Update(NamePrefix, Name, NameSuffix, equalsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithValuePrefix(MarkupTextLiteralSyntax valuePrefix) => Update(NamePrefix, Name, NameSuffix, EqualsToken, valuePrefix, Value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithValue(MarkupTagHelperAttributeValueSyntax value) => Update(NamePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, value, ValueSuffix); - public MarkupTagHelperAttributeSyntax WithValueSuffix(MarkupTextLiteralSyntax valueSuffix) => Update(NamePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, Value, valueSuffix); + public MarkupTagHelperAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, name, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithNameSuffix(MarkupTextLiteralSyntax nameSuffix) => Update(NamePrefix, Name, nameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithEqualsToken(SyntaxToken equalsToken) => Update(NamePrefix, Name, NameSuffix, equalsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithValuePrefix(MarkupTextLiteralSyntax valuePrefix) => Update(NamePrefix, Name, NameSuffix, EqualsToken, valuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithValue(MarkupTagHelperAttributeValueSyntax value) => Update(NamePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithValueSuffix(MarkupTextLiteralSyntax valueSuffix) => Update(NamePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, Value, valueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo tagHelperAttributeInfo) => Update(NamePrefix, Name, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, tagHelperAttributeInfo); public MarkupTagHelperAttributeSyntax AddNameLiteralTokens(params SyntaxToken[] items) => WithName(this.Name.WithLiteralTokens(this.Name.LiteralTokens.AddRange(items))); @@ -1281,6 +1289,7 @@ internal MarkupMinimizedTagHelperAttributeSyntax(GreenNode green, SyntaxNode par public MarkupTextLiteralSyntax NamePrefix => GetRedAtZero(ref _namePrefix); public MarkupTextLiteralSyntax Name => GetRed(ref _name, 1); + public TagHelperAttributeInfo TagHelperAttributeInfo => ((InternalSyntax.MarkupMinimizedTagHelperAttributeSyntax)Green).TagHelperAttributeInfo; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -1301,23 +1310,23 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperAttribute(this); - public MarkupMinimizedTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name) + public MarkupMinimizedTagHelperAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, MarkupTextLiteralSyntax name, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || name != Name) { - var newNode = SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix, name); + var newNode = SyntaxFactory.MarkupMinimizedTagHelperAttribute(namePrefix, name, tagHelperAttributeInfo); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupMinimizedTagHelperAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Name); - public MarkupMinimizedTagHelperAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, name); + public MarkupMinimizedTagHelperAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Name, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, name, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo tagHelperAttributeInfo) => Update(NamePrefix, Name, tagHelperAttributeInfo); public MarkupMinimizedTagHelperAttributeSyntax AddNameLiteralTokens(params SyntaxToken[] items) => WithName(this.Name.WithLiteralTokens(this.Name.LiteralTokens.AddRange(items))); } @@ -1348,8 +1357,7 @@ public MarkupTagHelperAttributeValueSyntax Update(SyntaxList ch var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -1389,6 +1397,7 @@ internal MarkupTagHelperDirectiveAttributeSyntax(GreenNode green, SyntaxNode par public MarkupTextLiteralSyntax ValuePrefix => GetRed(ref _valuePrefix, 7); public MarkupTagHelperAttributeValueSyntax Value => GetRed(ref _value, 8); public MarkupTextLiteralSyntax ValueSuffix => GetRed(ref _valueSuffix, 9); + public TagHelperAttributeInfo TagHelperAttributeInfo => ((InternalSyntax.MarkupTagHelperDirectiveAttributeSyntax)Green).TagHelperAttributeInfo; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -1423,31 +1432,31 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperDirectiveAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupTagHelperDirectiveAttribute(this); - public MarkupTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix) + public MarkupTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, MarkupTextLiteralSyntax nameSuffix, SyntaxToken equalsToken, MarkupTextLiteralSyntax valuePrefix, MarkupTagHelperAttributeValueSyntax value, MarkupTextLiteralSyntax valueSuffix, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || transition != Transition || name != Name || colon != Colon || parameterName != ParameterName || nameSuffix != NameSuffix || equalsToken != EqualsToken || valuePrefix != ValuePrefix || value != Value || valueSuffix != ValueSuffix) { - var newNode = SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix); + var newNode = SyntaxFactory.MarkupTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, nameSuffix, equalsToken, valuePrefix, value, valueSuffix, tagHelperAttributeInfo); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupTagHelperDirectiveAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithTransition(RazorMetaCodeSyntax transition) => Update(NamePrefix, transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, Transition, name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithColon(RazorMetaCodeSyntax colon) => Update(NamePrefix, Transition, Name, colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithParameterName(MarkupTextLiteralSyntax parameterName) => Update(NamePrefix, Transition, Name, Colon, parameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithNameSuffix(MarkupTextLiteralSyntax nameSuffix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, nameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithEqualsToken(SyntaxToken equalsToken) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, equalsToken, ValuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithValuePrefix(MarkupTextLiteralSyntax valuePrefix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, valuePrefix, Value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithValue(MarkupTagHelperAttributeValueSyntax value) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, value, ValueSuffix); - public MarkupTagHelperDirectiveAttributeSyntax WithValueSuffix(MarkupTextLiteralSyntax valueSuffix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, valueSuffix); + public MarkupTagHelperDirectiveAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithTransition(RazorMetaCodeSyntax transition) => Update(NamePrefix, transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, Transition, name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithColon(RazorMetaCodeSyntax colon) => Update(NamePrefix, Transition, Name, colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithParameterName(MarkupTextLiteralSyntax parameterName) => Update(NamePrefix, Transition, Name, Colon, parameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithNameSuffix(MarkupTextLiteralSyntax nameSuffix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, nameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithEqualsToken(SyntaxToken equalsToken) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, equalsToken, ValuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithValuePrefix(MarkupTextLiteralSyntax valuePrefix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, valuePrefix, Value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithValue(MarkupTagHelperAttributeValueSyntax value) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, value, ValueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithValueSuffix(MarkupTextLiteralSyntax valueSuffix) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, valueSuffix, TagHelperAttributeInfo); + public MarkupTagHelperDirectiveAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo tagHelperAttributeInfo) => Update(NamePrefix, Transition, Name, Colon, ParameterName, NameSuffix, EqualsToken, ValuePrefix, Value, ValueSuffix, tagHelperAttributeInfo); public MarkupTagHelperDirectiveAttributeSyntax AddTransitionMetaCode(params SyntaxToken[] items) => WithTransition(this.Transition.WithMetaCode(this.Transition.MetaCode.AddRange(items))); @@ -1474,6 +1483,7 @@ internal MarkupMinimizedTagHelperDirectiveAttributeSyntax(GreenNode green, Synta public MarkupTextLiteralSyntax Name => GetRed(ref _name, 2); public RazorMetaCodeSyntax Colon => GetRed(ref _colon, 3); public MarkupTextLiteralSyntax ParameterName => GetRed(ref _parameterName, 4); + public TagHelperAttributeInfo TagHelperAttributeInfo => ((InternalSyntax.MarkupMinimizedTagHelperDirectiveAttributeSyntax)Green).TagHelperAttributeInfo; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -1500,26 +1510,26 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperDirectiveAttribute(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitMarkupMinimizedTagHelperDirectiveAttribute(this); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName) + public MarkupMinimizedTagHelperDirectiveAttributeSyntax Update(MarkupTextLiteralSyntax namePrefix, RazorMetaCodeSyntax transition, MarkupTextLiteralSyntax name, RazorMetaCodeSyntax colon, MarkupTextLiteralSyntax parameterName, TagHelperAttributeInfo tagHelperAttributeInfo) { if (namePrefix != NamePrefix || transition != Transition || name != Name || colon != Colon || parameterName != ParameterName) { - var newNode = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName); + var newNode = SyntaxFactory.MarkupMinimizedTagHelperDirectiveAttribute(namePrefix, transition, name, colon, parameterName, tagHelperAttributeInfo); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Transition, Name, Colon, ParameterName); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithTransition(RazorMetaCodeSyntax transition) => Update(NamePrefix, transition, Name, Colon, ParameterName); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, Transition, name, Colon, ParameterName); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithColon(RazorMetaCodeSyntax colon) => Update(NamePrefix, Transition, Name, colon, ParameterName); - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithParameterName(MarkupTextLiteralSyntax parameterName) => Update(NamePrefix, Transition, Name, Colon, parameterName); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithNamePrefix(MarkupTextLiteralSyntax namePrefix) => Update(namePrefix, Transition, Name, Colon, ParameterName, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithTransition(RazorMetaCodeSyntax transition) => Update(NamePrefix, transition, Name, Colon, ParameterName, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithName(MarkupTextLiteralSyntax name) => Update(NamePrefix, Transition, name, Colon, ParameterName, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithColon(RazorMetaCodeSyntax colon) => Update(NamePrefix, Transition, Name, colon, ParameterName, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithParameterName(MarkupTextLiteralSyntax parameterName) => Update(NamePrefix, Transition, Name, Colon, parameterName, TagHelperAttributeInfo); + public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo tagHelperAttributeInfo) => Update(NamePrefix, Transition, Name, Colon, ParameterName, tagHelperAttributeInfo); public MarkupMinimizedTagHelperDirectiveAttributeSyntax AddTransitionMetaCode(params SyntaxToken[] items) => WithTransition(this.Transition.WithMetaCode(this.Transition.MetaCode.AddRange(items))); @@ -1560,8 +1570,7 @@ public CSharpCodeBlockSyntax Update(SyntaxList children) var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -1583,6 +1592,7 @@ internal CSharpTransitionSyntax(GreenNode green, SyntaxNode parent, int position public SyntaxToken Transition => new SyntaxToken(this, ((InternalSyntax.CSharpTransitionSyntax)Green)._transition, Position, 0); public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.CSharpTransitionSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.CSharpTransitionSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -1591,23 +1601,23 @@ internal CSharpTransitionSyntax(GreenNode green, SyntaxNode parent, int position public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpTransition(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpTransition(this); - public CSharpTransitionSyntax Update(SyntaxToken transition, ISpanChunkGenerator chunkGenerator) + public CSharpTransitionSyntax Update(SyntaxToken transition, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (transition != Transition || chunkGenerator != ChunkGenerator) + if (transition != Transition || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.CSharpTransition(transition, chunkGenerator); + var newNode = SyntaxFactory.CSharpTransition(transition, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public CSharpTransitionSyntax WithTransition(SyntaxToken transition) => Update(transition, ChunkGenerator); - public CSharpTransitionSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(Transition, chunkGenerator); + public CSharpTransitionSyntax WithTransition(SyntaxToken transition) => Update(transition, ChunkGenerator, EditHandler); + public CSharpTransitionSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(Transition, chunkGenerator, EditHandler); + public CSharpTransitionSyntax WithEditHandler(SpanEditHandler editHandler) => Update(Transition, ChunkGenerator, editHandler); } internal sealed partial class CSharpStatementLiteralSyntax : CSharpSyntaxNode @@ -1626,6 +1636,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.CSharpStatementLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.CSharpStatementLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -1634,23 +1645,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpStatementLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpStatementLiteral(this); - public CSharpStatementLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpStatementLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.CSharpStatementLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpStatementLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public CSharpStatementLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public CSharpStatementLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public CSharpStatementLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public CSharpStatementLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public CSharpStatementLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public CSharpStatementLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -1671,6 +1682,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.CSharpExpressionLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.CSharpExpressionLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -1679,23 +1691,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpExpressionLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpExpressionLiteral(this); - public CSharpExpressionLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpExpressionLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.CSharpExpressionLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpExpressionLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public CSharpExpressionLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public CSharpExpressionLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public CSharpExpressionLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public CSharpExpressionLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public CSharpExpressionLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public CSharpExpressionLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -1716,6 +1728,7 @@ public SyntaxTokenList LiteralTokens } } public ISpanChunkGenerator ChunkGenerator => ((InternalSyntax.CSharpEphemeralTextLiteralSyntax)Green).ChunkGenerator; + public SpanEditHandler EditHandler => ((InternalSyntax.CSharpEphemeralTextLiteralSyntax)Green).EditHandler; internal override SyntaxNode GetNodeSlot(int index) => null; @@ -1724,23 +1737,23 @@ public SyntaxTokenList LiteralTokens public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitCSharpEphemeralTextLiteral(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitCSharpEphemeralTextLiteral(this); - public CSharpEphemeralTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator) + public CSharpEphemeralTextLiteralSyntax Update(SyntaxTokenList literalTokens, ISpanChunkGenerator chunkGenerator, SpanEditHandler editHandler) { - if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator) + if (literalTokens != LiteralTokens || chunkGenerator != ChunkGenerator || editHandler != EditHandler) { - var newNode = SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens, chunkGenerator); + var newNode = SyntaxFactory.CSharpEphemeralTextLiteral(literalTokens, chunkGenerator, editHandler); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } - public CSharpEphemeralTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator); - public CSharpEphemeralTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator); + public CSharpEphemeralTextLiteralSyntax WithLiteralTokens(SyntaxTokenList literalTokens) => Update(literalTokens, ChunkGenerator, EditHandler); + public CSharpEphemeralTextLiteralSyntax WithChunkGenerator(ISpanChunkGenerator chunkGenerator) => Update(LiteralTokens, chunkGenerator, EditHandler); + public CSharpEphemeralTextLiteralSyntax WithEditHandler(SpanEditHandler editHandler) => Update(LiteralTokens, ChunkGenerator, editHandler); public CSharpEphemeralTextLiteralSyntax AddLiteralTokens(params SyntaxToken[] items) => WithLiteralTokens(this.LiteralTokens.AddRange(items)); } @@ -1771,8 +1784,7 @@ public CSharpTemplateBlockSyntax Update(SyntaxList children) var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -1841,8 +1853,7 @@ public CSharpStatementSyntax Update(CSharpTransitionSyntax transition, CSharpSyn var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -1898,8 +1909,7 @@ public CSharpStatementBodySyntax Update(RazorMetaCodeSyntax openBrace, CSharpCod var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -1956,8 +1966,7 @@ public CSharpExplicitExpressionSyntax Update(CSharpTransitionSyntax transition, var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -2013,8 +2022,7 @@ public CSharpExplicitExpressionBodySyntax Update(RazorMetaCodeSyntax openParen, var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -2071,8 +2079,7 @@ public CSharpImplicitExpressionSyntax Update(CSharpTransitionSyntax transition, var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -2110,8 +2117,7 @@ public CSharpImplicitExpressionBodySyntax Update(CSharpCodeBlockSyntax csharpCod var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; @@ -2134,6 +2140,7 @@ internal RazorDirectiveSyntax(GreenNode green, SyntaxNode parent, int position) public override CSharpTransitionSyntax Transition => GetRedAtZero(ref _transition); public override CSharpSyntaxNode Body => GetRed(ref _body, 1); + public DirectiveDescriptor DirectiveDescriptor => ((InternalSyntax.RazorDirectiveSyntax)Green).DirectiveDescriptor; internal override SyntaxNode GetNodeSlot(int index) => index switch @@ -2154,25 +2161,25 @@ internal override SyntaxNode GetCachedSlot(int index) public override TResult Accept(SyntaxVisitor visitor) => visitor.VisitRazorDirective(this); public override void Accept(SyntaxVisitor visitor) => visitor.VisitRazorDirective(this); - public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + public RazorDirectiveSyntax Update(CSharpTransitionSyntax transition, CSharpSyntaxNode body, DirectiveDescriptor directiveDescriptor) { - if (transition != Transition || body != Body) + if (transition != Transition || body != Body || directiveDescriptor != DirectiveDescriptor) { - var newNode = SyntaxFactory.RazorDirective(transition, body); + var newNode = SyntaxFactory.RazorDirective(transition, body, directiveDescriptor); var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; } internal override CSharpRazorBlockSyntax WithTransitionCore(CSharpTransitionSyntax transition) => WithTransition(transition); - public new RazorDirectiveSyntax WithTransition(CSharpTransitionSyntax transition) => Update(transition, Body); + public new RazorDirectiveSyntax WithTransition(CSharpTransitionSyntax transition) => Update(transition, Body, DirectiveDescriptor); internal override CSharpRazorBlockSyntax WithBodyCore(CSharpSyntaxNode body) => WithBody(body); - public new RazorDirectiveSyntax WithBody(CSharpSyntaxNode body) => Update(Transition, body); + public new RazorDirectiveSyntax WithBody(CSharpSyntaxNode body) => Update(Transition, body, DirectiveDescriptor); + public RazorDirectiveSyntax WithDirectiveDescriptor(DirectiveDescriptor directiveDescriptor) => Update(Transition, Body, directiveDescriptor); } internal sealed partial class RazorDirectiveBodySyntax : CSharpSyntaxNode @@ -2215,8 +2222,7 @@ public RazorDirectiveBodySyntax Update(RazorSyntaxNode keyword, CSharpCodeBlockS var diagnostics = GetDiagnostics(); if (diagnostics != null && diagnostics.Length > 0) newNode = newNode.WithDiagnostics(diagnostics); - var annotations = GetAnnotations(); - return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode; + return newNode; } return this; diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNode.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNode.cs index 99def989ac0..328be19cb52 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNode.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNode.cs @@ -11,10 +11,8 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax; [DebuggerDisplay("{GetDebuggerDisplay(), nq}")] internal abstract partial class GreenNode { - private static readonly RazorDiagnostic[] EmptyDiagnostics = []; - private static readonly SyntaxAnnotation[] EmptyAnnotations = []; - private static readonly ConditionalWeakTable DiagnosticsTable = new(); - private static readonly ConditionalWeakTable AnnotationsTable = new(); + private static readonly ConditionalWeakTable s_diagnosticsTable = new(); + private static readonly RazorDiagnostic[] s_emptyDiagnostics = []; private int _width; private byte _slotCount; @@ -30,32 +28,18 @@ protected GreenNode(SyntaxKind kind, int width) _width = width; } - protected GreenNode(SyntaxKind kind, RazorDiagnostic[]? diagnostics, SyntaxAnnotation[]? annotations) - : this(kind, 0, diagnostics, annotations) + protected GreenNode(SyntaxKind kind, RazorDiagnostic[]? diagnostics) + : this(kind, 0, diagnostics) { } - protected GreenNode(SyntaxKind kind, int width, RazorDiagnostic[]? diagnostics, SyntaxAnnotation[]? annotations) + protected GreenNode(SyntaxKind kind, int width, RazorDiagnostic[]? diagnostics) : this(kind, width) { if (diagnostics?.Length > 0) { Flags |= NodeFlags.ContainsDiagnostics; - DiagnosticsTable.Add(this, diagnostics); - } - - if (annotations?.Length > 0) - { - foreach (var annotation in annotations) - { - if (annotation == null) - { - throw new ArgumentException("Annotation cannot be null", nameof(annotations)); - } - } - - Flags |= NodeFlags.ContainsAnnotations; - AnnotationsTable.Add(this, annotations); + s_diagnosticsTable.Add(this, diagnostics); } } @@ -171,8 +155,6 @@ internal void ClearFlags(NodeFlags flags) internal virtual bool IsMissing => (Flags & NodeFlags.IsMissing) != 0; public bool ContainsDiagnostics => (Flags & NodeFlags.ContainsDiagnostics) != 0; - - public bool ContainsAnnotations => (Flags & NodeFlags.ContainsAnnotations) != 0; #endregion #region Diagnostics @@ -182,31 +164,13 @@ internal RazorDiagnostic[] GetDiagnostics() { if (ContainsDiagnostics) { - if (DiagnosticsTable.TryGetValue(this, out var diagnostics)) + if (s_diagnosticsTable.TryGetValue(this, out var diagnostics)) { return diagnostics; } } - return EmptyDiagnostics; - } - #endregion - - #region Annotations - internal abstract GreenNode SetAnnotations(SyntaxAnnotation[]? annotations); - - internal SyntaxAnnotation[] GetAnnotations() - { - if (ContainsAnnotations) - { - if (AnnotationsTable.TryGetValue(this, out var annotations)) - { - Debug.Assert(annotations.Length != 0, "There cannot be an empty annotation entry."); - return annotations; - } - } - - return EmptyAnnotations; + return s_emptyDiagnostics; } #endregion diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNodeExtensions.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNodeExtensions.cs index ccf55bf34d3..4ecfcd6418b 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNodeExtensions.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/GreenNodeExtensions.cs @@ -5,7 +5,6 @@ using System.Collections.Immutable; using System.Runtime.InteropServices; -using Microsoft.AspNetCore.Razor.PooledObjects; namespace Microsoft.AspNetCore.Razor.Language.Syntax; @@ -23,31 +22,6 @@ internal static InternalSyntax.SyntaxList ToGreenList(this GreenNode node) return new InternalSyntax.SyntaxList(node); } - public static TNode WithAnnotationsGreen(this TNode node, params SyntaxAnnotation[] annotations) where TNode : GreenNode - { - if (annotations.Length == 0) - { - var existingAnnotations = node.GetAnnotations(); - if (existingAnnotations != null && existingAnnotations.Length > 0) - { - node = (TNode)node.SetAnnotations(null); - } - - return node; - } - - using var newAnnotations = new PooledArrayBuilder(annotations.Length); - foreach (var candidate in annotations) - { - if (!newAnnotations.Contains(candidate)) - { - newAnnotations.Add(candidate); - } - } - - return (TNode)node.SetAnnotations(newAnnotations.ToArray()); - } - public static TNode WithDiagnosticsGreen(this TNode node, RazorDiagnostic[] diagnostics) where TNode : GreenNode { diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupEndTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupEndTagSyntax.cs deleted file mode 100644 index 740886fe747..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupEndTagSyntax.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -using System.Collections.Generic; -using System.Linq; - -namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax; - -internal sealed partial class MarkupEndTagSyntax -{ - private const string MarkupTransitionKey = "MarkupTransition"; - - public bool IsMarkupTransition - { - get - { - var annotation = GetAnnotations().FirstOrDefault(n => n.Kind == MarkupTransitionKey); - return annotation != null; - } - } - - public MarkupEndTagSyntax AsMarkupTransition() - => this.WithAnnotationsGreen([.. GetAnnotations(), new(MarkupTransitionKey, new object())]); -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupStartTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupStartTagSyntax.cs deleted file mode 100644 index 1e996ac2c67..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/MarkupStartTagSyntax.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -using System.Collections.Generic; -using System.Linq; - -namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax; - -internal sealed partial class MarkupStartTagSyntax -{ - private const string MarkupTransitionKey = "MarkupTransition"; - - public bool IsMarkupTransition - { - get - { - var annotation = GetAnnotations().FirstOrDefault(n => n.Kind == MarkupTransitionKey); - return annotation != null; - } - } - - public MarkupStartTagSyntax AsMarkupTransition() - => this.WithAnnotationsGreen([.. GetAnnotations(), new(MarkupTransitionKey, new object())]); -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorDirectiveSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorDirectiveSyntax.cs deleted file mode 100644 index 3fafc5094d5..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorDirectiveSyntax.cs +++ /dev/null @@ -1,26 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -using System.Collections.Generic; -using System.Linq; - -namespace Microsoft.AspNetCore.Razor.Language.Syntax.InternalSyntax; - -internal sealed partial class RazorDirectiveSyntax -{ - private static readonly string DirectiveDescriptorKey = typeof(DirectiveDescriptor).Name; - - public DirectiveDescriptor DirectiveDescriptor - { - get - { - var annotation = GetAnnotations().FirstOrDefault(n => n.Kind == DirectiveDescriptorKey); - return annotation?.Data as DirectiveDescriptor; - } - } - - public RazorDirectiveSyntax WithDirectiveDescriptor(DirectiveDescriptor descriptor) - => this.WithAnnotationsGreen([.. GetAnnotations(), new(DirectiveDescriptorKey, descriptor)]); -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorSyntaxNode.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorSyntaxNode.cs index facc207fcf3..28510b4278b 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorSyntaxNode.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/RazorSyntaxNode.cs @@ -16,13 +16,13 @@ protected RazorSyntaxNode(SyntaxKind kind, int width) { } - protected RazorSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, diagnostics, annotations) + protected RazorSyntaxNode(SyntaxKind kind, RazorDiagnostic[] diagnostics) + : base(kind, diagnostics) { } - protected RazorSyntaxNode(SyntaxKind kind, int width, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(kind, width, diagnostics, annotations) + protected RazorSyntaxNode(SyntaxKind kind, int width, RazorDiagnostic[] diagnostics) + : base(kind, width, diagnostics) { } } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxFactory.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxFactory.cs index 8cef2cc70f9..e3397f47b05 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxFactory.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxFactory.cs @@ -23,11 +23,14 @@ internal static SyntaxToken MissingToken(SyntaxKind kind, params RazorDiagnostic } public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral(SyntaxList literalTokens) - => CSharpExpressionLiteral(literalTokens, chunkGenerator: null); + => CSharpExpressionLiteral(literalTokens, chunkGenerator: null, editHandler: null); public static CSharpTransitionSyntax CSharpTransition(SyntaxToken transition) - => CSharpTransition(transition, chunkGenerator: null); + => CSharpTransition(transition, chunkGenerator: null, editHandler: null); public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxList literalTokens) - => MarkupTextLiteral(literalTokens, chunkGenerator: null); + => MarkupTextLiteral(literalTokens, chunkGenerator: null, editHandler: null); + + public static RazorDirectiveSyntax RazorDirective(CSharpTransitionSyntax transition, CSharpSyntaxNode body) + => RazorDirective(transition, body, directiveDescriptor: null); } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxList.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxList.cs index 5f86787ca40..5b605011b1b 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxList.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxList.cs @@ -15,8 +15,8 @@ internal SyntaxList() { } - internal SyntaxList(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations) - : base(SyntaxKind.List, diagnostics, annotations) + internal SyntaxList(RazorDiagnostic[] diagnostics) + : base(SyntaxKind.List, diagnostics) { } @@ -72,7 +72,7 @@ internal static WithThreeChildren List(GreenNode child0, GreenNode child1, Green } internal static GreenNode List(ReadOnlySpan nodes) - where TNode : GreenNode + where TNode : GreenNode { var count = nodes.Length; var array = new ArrayElement[count]; @@ -184,7 +184,8 @@ internal WithTwoChildren(GreenNode child0, GreenNode child1) _child1 = child1; } - internal WithTwoChildren(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations, GreenNode child0, GreenNode child1) + internal WithTwoChildren(GreenNode child0, GreenNode child1, RazorDiagnostic[] diagnostics) + : base(diagnostics) { SlotCount = 2; AdjustFlagsAndWidth(child0); @@ -219,12 +220,7 @@ internal override SyntaxNode CreateRed(SyntaxNode parent, int position) internal override GreenNode SetDiagnostics(RazorDiagnostic[] errors) { - return new WithTwoChildren(errors, this.GetAnnotations(), _child0, _child1); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - { - return new WithTwoChildren(GetDiagnostics(), annotations, _child0, _child1); + return new WithTwoChildren(_child0, _child1, errors); } } @@ -245,8 +241,8 @@ internal WithThreeChildren(GreenNode child0, GreenNode child1, GreenNode child2) _child2 = child2; } - internal WithThreeChildren(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations, GreenNode child0, GreenNode child1, GreenNode child2) - : base(diagnostics, annotations) + internal WithThreeChildren(GreenNode child0, GreenNode child1, GreenNode child2, RazorDiagnostic[] diagnostics) + : base(diagnostics) { SlotCount = 3; AdjustFlagsAndWidth(child0); @@ -286,12 +282,7 @@ internal override SyntaxNode CreateRed(SyntaxNode parent, int position) internal override GreenNode SetDiagnostics(RazorDiagnostic[] errors) { - return new WithThreeChildren(errors, GetAnnotations(), _child0, _child1, _child2); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - { - return new WithThreeChildren(GetDiagnostics(), annotations, _child0, _child1, _child2); + return new WithThreeChildren(_child0, _child1, _child2, errors); } } @@ -305,8 +296,8 @@ internal WithManyChildrenBase(ArrayElement[] children) this.InitializeChildren(); } - internal WithManyChildrenBase(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations, ArrayElement[] children) - : base(diagnostics, annotations) + internal WithManyChildrenBase(ArrayElement[] children, RazorDiagnostic[] diagnostics) + : base(diagnostics) { this.children = children; this.InitializeChildren(); @@ -358,19 +349,14 @@ internal WithManyChildren(ArrayElement[] children) { } - internal WithManyChildren(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations, ArrayElement[] children) - : base(diagnostics, annotations, children) + internal WithManyChildren(ArrayElement[] children, RazorDiagnostic[] diagnostics) + : base(children, diagnostics) { } internal override GreenNode SetDiagnostics(RazorDiagnostic[] errors) { - return new WithManyChildren(errors, GetAnnotations(), children); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - { - return new WithManyChildren(GetDiagnostics(), annotations, children); + return new WithManyChildren(children, errors); } } @@ -384,8 +370,8 @@ internal WithLotsOfChildren(ArrayElement[] children) _childOffsets = CalculateOffsets(children); } - internal WithLotsOfChildren(RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations, ArrayElement[] children, int[] childOffsets) - : base(diagnostics, annotations, children) + internal WithLotsOfChildren(ArrayElement[] children, int[] childOffsets, RazorDiagnostic[] diagnostics) + : base(children, diagnostics) { _childOffsets = childOffsets; } @@ -425,12 +411,7 @@ private static int[] CalculateOffsets(ArrayElement[] children) internal override GreenNode SetDiagnostics(RazorDiagnostic[] errors) { - return new WithLotsOfChildren(errors, this.GetAnnotations(), children, _childOffsets); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations) - { - return new WithLotsOfChildren(GetDiagnostics(), annotations, children, _childOffsets); + return new WithLotsOfChildren(children, _childOffsets, errors); } /// diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxToken.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxToken.cs index 018513e46f9..f4c8913b4ab 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxToken.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/InternalSyntax/SyntaxToken.cs @@ -10,9 +10,8 @@ internal class SyntaxToken : RazorSyntaxNode internal SyntaxToken( SyntaxKind kind, string content, - RazorDiagnostic[]? diagnostics, - SyntaxAnnotation[]? annotations = null) - : base(kind, content.Length, diagnostics, annotations) + RazorDiagnostic[]? diagnostics) + : base(kind, content.Length, diagnostics) { Content = content; } @@ -28,12 +27,7 @@ internal override SyntaxNode CreateRed(SyntaxNode? parent, int position) internal override GreenNode SetDiagnostics(RazorDiagnostic[]? diagnostics) { - return new SyntaxToken(Kind, Content, diagnostics, GetAnnotations()); - } - - internal override GreenNode SetAnnotations(SyntaxAnnotation[]? annotations) - { - return new SyntaxToken(Kind, Content, GetDiagnostics(), annotations); + return new SyntaxToken(Kind, Content, diagnostics); } protected sealed override int GetSlotCount() diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupEndTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupEndTagSyntax.cs index 222c060fa26..4a67861b292 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupEndTagSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupEndTagSyntax.cs @@ -5,9 +5,6 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal partial class MarkupEndTagSyntax { - public bool IsMarkupTransition - => ((InternalSyntax.MarkupEndTagSyntax)Green).IsMarkupTransition; - public string GetTagNameWithOptionalBang() { return Name.IsMissing ? string.Empty : Bang.Content + Name.Content; diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperAttributeSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperAttributeSyntax.cs deleted file mode 100644 index 86143e6b527..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperAttributeSyntax.cs +++ /dev/null @@ -1,27 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -namespace Microsoft.AspNetCore.Razor.Language.Syntax; - -internal sealed partial class MarkupMinimizedTagHelperAttributeSyntax -{ - private static readonly string TagHelperAttributeInfoKey = typeof(TagHelperAttributeInfo).Name; - - public TagHelperAttributeInfo TagHelperAttributeInfo - { - get - { - var tagHelperAttributeInfo = this.GetAnnotationValue(TagHelperAttributeInfoKey) as TagHelperAttributeInfo; - return tagHelperAttributeInfo; - } - } - - public MarkupMinimizedTagHelperAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo info) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(TagHelperAttributeInfoKey, info)]); - - return (MarkupMinimizedTagHelperAttributeSyntax)newGreen.CreateRed(Parent, Position); - } -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperDirectiveAttributeSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperDirectiveAttributeSyntax.cs index 6e4efd94b40..e0f9c7b7a41 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperDirectiveAttributeSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupMinimizedTagHelperDirectiveAttributeSyntax.cs @@ -1,23 +1,10 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -#nullable disable - namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal sealed partial class MarkupMinimizedTagHelperDirectiveAttributeSyntax { - private static readonly string TagHelperAttributeInfoKey = typeof(TagHelperAttributeInfo).Name; - - public TagHelperAttributeInfo TagHelperAttributeInfo - { - get - { - var tagHelperAttributeInfo = this.GetAnnotationValue(TagHelperAttributeInfoKey) as TagHelperAttributeInfo; - return tagHelperAttributeInfo; - } - } - public string FullName { get @@ -30,11 +17,4 @@ public string FullName return fullName; } } - - public MarkupMinimizedTagHelperDirectiveAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo info) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(TagHelperAttributeInfoKey, info)]); - - return (MarkupMinimizedTagHelperDirectiveAttributeSyntax)newGreen.CreateRed(Parent, Position); - } } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupStartTagSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupStartTagSyntax.cs index a275e66f8fb..788618550c6 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupStartTagSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupStartTagSyntax.cs @@ -7,9 +7,6 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal partial class MarkupStartTagSyntax { - public bool IsMarkupTransition - => ((InternalSyntax.MarkupStartTagSyntax)Green).IsMarkupTransition; - public string GetTagNameWithOptionalBang() { return Name.IsMissing ? string.Empty : Bang.Content + Name.Content; diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperAttributeSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperAttributeSyntax.cs deleted file mode 100644 index 884ebb031d2..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperAttributeSyntax.cs +++ /dev/null @@ -1,27 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -namespace Microsoft.AspNetCore.Razor.Language.Syntax; - -internal sealed partial class MarkupTagHelperAttributeSyntax -{ - private static readonly string TagHelperAttributeInfoKey = typeof(TagHelperAttributeInfo).Name; - - public TagHelperAttributeInfo TagHelperAttributeInfo - { - get - { - var tagHelperAttributeInfo = this.GetAnnotationValue(TagHelperAttributeInfoKey) as TagHelperAttributeInfo; - return tagHelperAttributeInfo; - } - } - - public MarkupTagHelperAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo info) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(TagHelperAttributeInfoKey, info)]); - - return (MarkupTagHelperAttributeSyntax)newGreen.CreateRed(Parent, Position); - } -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperDirectiveAttributeSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperDirectiveAttributeSyntax.cs index 3153ed202b4..223df95ed10 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperDirectiveAttributeSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperDirectiveAttributeSyntax.cs @@ -1,23 +1,10 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -#nullable disable - namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal sealed partial class MarkupTagHelperDirectiveAttributeSyntax { - private static readonly string TagHelperAttributeInfoKey = typeof(TagHelperAttributeInfo).Name; - - public TagHelperAttributeInfo TagHelperAttributeInfo - { - get - { - var tagHelperAttributeInfo = this.GetAnnotationValue(TagHelperAttributeInfoKey) as TagHelperAttributeInfo; - return tagHelperAttributeInfo; - } - } - public string FullName { get @@ -30,11 +17,4 @@ public string FullName return fullName; } } - - public MarkupTagHelperDirectiveAttributeSyntax WithTagHelperAttributeInfo(TagHelperAttributeInfo info) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(TagHelperAttributeInfoKey, info)]); - - return (MarkupTagHelperDirectiveAttributeSyntax)newGreen.CreateRed(Parent, Position); - } } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperElementSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperElementSyntax.cs deleted file mode 100644 index fd642e989ea..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/MarkupTagHelperElementSyntax.cs +++ /dev/null @@ -1,19 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -namespace Microsoft.AspNetCore.Razor.Language.Syntax; - -internal sealed partial class MarkupTagHelperElementSyntax -{ - private static readonly string TagHelperInfoKey = typeof(TagHelperInfo).Name; - - public TagHelperInfo? TagHelperInfo - => this.GetAnnotationValue(TagHelperInfoKey) as TagHelperInfo; - - public MarkupTagHelperElementSyntax WithTagHelperInfo(TagHelperInfo info) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(TagHelperInfoKey, info)]); - - return (MarkupTagHelperElementSyntax)newGreen.CreateRed(Parent, Position); - } -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/NodeFlags.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/NodeFlags.cs index 93219c18eee..37b7e7cbc4a 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/NodeFlags.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/NodeFlags.cs @@ -10,8 +10,7 @@ internal enum NodeFlags : byte { None = 0, ContainsDiagnostics = 1 << 0, - ContainsAnnotations = 1 << 1, IsMissing = 1 << 2, - InheritMask = ContainsDiagnostics | ContainsAnnotations | IsMissing + InheritMask = ContainsDiagnostics | IsMissing } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/RazorDirectiveSyntax.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/RazorDirectiveSyntax.cs index 74a9d094b46..6c6e6d5fcf5 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/RazorDirectiveSyntax.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/RazorDirectiveSyntax.cs @@ -1,27 +1,21 @@ // Licensed to the .NET Foundation under one or more agreements. // The .NET Foundation licenses this file to you under the MIT license. -#nullable disable +using System.Diagnostics.CodeAnalysis; namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal sealed partial class RazorDirectiveSyntax { - private static readonly string DirectiveDescriptorKey = typeof(DirectiveDescriptor).Name; + [MemberNotNullWhen(true, nameof(DirectiveDescriptor))] + public bool HasDirectiveDescriptor + => DirectiveDescriptor is not null; - public DirectiveDescriptor DirectiveDescriptor - { - get - { - var descriptor = this.GetAnnotationValue(DirectiveDescriptorKey) as DirectiveDescriptor; - return descriptor; - } - } + [MemberNotNullWhen(true, nameof(DirectiveDescriptor))] + public bool IsDirective(DirectiveDescriptor directive) + => DirectiveDescriptor == directive; - public RazorDirectiveSyntax WithDirectiveDescriptor(DirectiveDescriptor descriptor) - { - var newGreen = Green.WithAnnotationsGreen([.. GetAnnotations(), new(DirectiveDescriptorKey, descriptor)]); - - return (RazorDirectiveSyntax)newGreen.CreateRed(Parent, Position); - } + [MemberNotNullWhen(true, nameof(DirectiveDescriptor))] + public bool IsDirectiveKind(DirectiveKind kind) + => DirectiveDescriptor?.Kind == kind; } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Syntax.xml b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Syntax.xml index 8150a5b46d0..889f13c7936 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Syntax.xml +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/Syntax.xml @@ -36,7 +36,8 @@ - + + @@ -45,7 +46,8 @@ - + + @@ -58,16 +60,19 @@ + + + @@ -122,6 +127,7 @@ + @@ -141,6 +147,7 @@ + @@ -166,7 +173,9 @@ + + @@ -186,13 +195,16 @@ + + + @@ -213,6 +225,7 @@ + @@ -233,6 +246,7 @@ + @@ -245,11 +259,13 @@ + + @@ -269,6 +285,7 @@ + @@ -277,6 +294,7 @@ + @@ -291,21 +309,25 @@ + + + + @@ -366,6 +388,7 @@ + diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxAnnotation.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxAnnotation.cs deleted file mode 100644 index f1dfe76dfeb..00000000000 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxAnnotation.cs +++ /dev/null @@ -1,95 +0,0 @@ -// Licensed to the .NET Foundation under one or more agreements. -// The .NET Foundation licenses this file to you under the MIT license. - -#nullable disable - -using System; -using System.Diagnostics; -using System.Globalization; - -namespace Microsoft.AspNetCore.Razor.Language.Syntax; - -/// -/// A SyntaxAnnotation is used to annotate syntax elements with additional information. -/// -/// Since syntax elements are immutable, annotating them requires creating new instances of them -/// with the annotations attached. -/// -[DebuggerDisplay("{GetDebuggerDisplay(), nq}")] -internal sealed class SyntaxAnnotation : IEquatable -{ - // use a value identity instead of object identity so a deserialized instance matches the original instance. - private readonly long _id; - private static long s_nextId; - - // use a value identity instead of object identity so a deserialized instance matches the original instance. - public string Kind { get; } - public object Data { get; } - - public SyntaxAnnotation() - { - _id = System.Threading.Interlocked.Increment(ref s_nextId); - } - - public SyntaxAnnotation(string kind) - : this() - { - Kind = kind; - } - - public SyntaxAnnotation(string kind, object data) - : this(kind) - { - Data = data; - } - - private string GetDebuggerDisplay() - { - return string.Format(CultureInfo.InvariantCulture, "Annotation: Kind='{0}' Data='{1}'", this.Kind ?? "", this.Data ?? ""); - } - - public bool Equals(SyntaxAnnotation other) - { - return (object)other != null && _id == other._id; - } - - public static bool operator ==(SyntaxAnnotation left, SyntaxAnnotation right) - { - if ((object)left == (object)right) - { - return true; - } - - if ((object)left == null || (object)right == null) - { - return false; - } - - return left.Equals(right); - } - - public static bool operator !=(SyntaxAnnotation left, SyntaxAnnotation right) - { - if ((object)left == (object)right) - { - return false; - } - - if ((object)left == null || (object)right == null) - { - return true; - } - - return !left.Equals(right); - } - - public override bool Equals(object obj) - { - return Equals(obj as SyntaxAnnotation); - } - - public override int GetHashCode() - { - return _id.GetHashCode(); - } -} diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxFactory.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxFactory.cs index 51506537b4d..e340e5c7567 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxFactory.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxFactory.cs @@ -62,9 +62,15 @@ public static SyntaxTokenList TokenList(params ReadOnlySpan tokens) public static SyntaxTokenList TokenList(IEnumerable tokens) => SyntaxList.Create(tokens); - public static MarkupTextLiteralSyntax MarkupTextLiteral(SyntaxToken token, ISpanChunkGenerator? chunkGenerator) - => MarkupTextLiteral(new SyntaxTokenList(token), chunkGenerator); + public static CSharpExpressionLiteralSyntax CSharpExpressionLiteral( + SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => CSharpExpressionLiteral(new SyntaxTokenList(token), chunkGenerator, editHandler); - public static RazorMetaCodeSyntax RazorMetaCode(SyntaxToken token, ISpanChunkGenerator? chunkGenerator) - => RazorMetaCode(new SyntaxTokenList(token), chunkGenerator); + public static MarkupTextLiteralSyntax MarkupTextLiteral( + SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => MarkupTextLiteral(new SyntaxTokenList(token), chunkGenerator, editHandler); + + public static RazorMetaCodeSyntax RazorMetaCode( + SyntaxToken token, ISpanChunkGenerator? chunkGenerator, SpanEditHandler? editHandler) + => RazorMetaCode(new SyntaxTokenList(token), chunkGenerator, editHandler); } diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNode.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNode.cs index a648364bfe1..bfb58c8aef8 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNode.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNode.cs @@ -38,8 +38,6 @@ internal abstract partial class SyntaxNode(GreenNode green, SyntaxNode parent, i public bool ContainsDiagnostics => Green.ContainsDiagnostics; - public bool ContainsAnnotations => Green.ContainsAnnotations; - internal abstract SyntaxNode? GetNodeSlot(int index); internal abstract SyntaxNode? GetCachedSlot(int index); @@ -394,11 +392,6 @@ public RazorDiagnostic[] GetDiagnostics() return Green.GetDiagnostics(); } - public SyntaxAnnotation[] GetAnnotations() - { - return Green.GetAnnotations(); - } - public bool IsEquivalentTo(SyntaxNode other) { if (this == other) diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNodeExtensions.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNodeExtensions.cs index c4439108ff2..888fa9c3228 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNodeExtensions.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxNodeExtensions.cs @@ -12,50 +12,6 @@ namespace Microsoft.AspNetCore.Razor.Language.Syntax; internal static class SyntaxNodeExtensions { - public static TNode WithAnnotations(this TNode node, params SyntaxAnnotation[] annotations) where TNode : SyntaxNode - { - return (TNode)node.Green.SetAnnotations(annotations).CreateRed(node.Parent, node.Position); - } - - public static object GetAnnotationValue(this TNode node, string key) - where TNode : SyntaxNode - { - if (!node.ContainsAnnotations) - { - return null; - } - - var annotations = node.GetAnnotations(); - foreach (var annotation in annotations) - { - if (annotation.Kind == key) - { - return annotation.Data; - } - } - - return null; - } - - public static object GetAnnotationValue(this SyntaxToken token, string key) - { - if (!token.ContainsAnnotations) - { - return null; - } - - var annotations = token.GetAnnotations(); - foreach (var annotation in annotations) - { - if (annotation.Kind == key) - { - return annotation.Data; - } - } - - return null; - } - public static TNode WithDiagnostics(this TNode node, params RazorDiagnostic[] diagnostics) where TNode : SyntaxNode { return (TNode)node.Green.SetDiagnostics(diagnostics).CreateRed(node.Parent, node.Position); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxSerializer.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxSerializer.cs index bf639823d8a..ba11e20c6ee 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxSerializer.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxSerializer.cs @@ -178,8 +178,7 @@ private void WriteChunkGenerator(SyntaxNode node) protected virtual void WriteSpanEditHandlers(SyntaxNode node) { - var annotation = node.GetAnnotations().FirstOrDefault(a => a.Kind == SyntaxConstants.EditHandlerKind); - if (annotation?.Data is SpanEditHandler handler) + if (node.GetEditHandler() is SpanEditHandler handler) { WriteSeparator(); WriteValue(handler); diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxToken.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxToken.cs index fcc18a70ad2..9f966d7fa80 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxToken.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxToken.cs @@ -74,8 +74,6 @@ public bool IsMissing public bool ContainsDiagnostics => Node?.ContainsDiagnostics ?? false; - public bool ContainsAnnotations => Node?.ContainsAnnotations ?? false; - public string Content => Node != null ? ((InternalSyntax.SyntaxToken)Node).Content : string.Empty; public string Text => ToString(); @@ -177,41 +175,6 @@ internal SyntaxToken GetPreviousToken(Func predicate) return SyntaxNavigator.GetPreviousToken(this, predicate); } - public IEnumerable GetAnnotations() - { - if (Node == null) - { - return SpecializedCollections.EmptyEnumerable(); - } - - var annotations = Node.GetAnnotations(); - - return annotations.Length == 0 - ? SpecializedCollections.EmptyEnumerable() - : annotations; - } - - public SyntaxToken CopyAnnotationsTo(SyntaxToken token) - { - if (token.Node == null) - { - return default; - } - - if (Node == null) - { - return token; - } - - var annotations = Node.GetAnnotations(); - if (annotations?.Length > 0) - { - return new(parent: null, token.Node.WithAnnotationsGreen(annotations), position: 0, index: 0); - } - - return token; - } - /// /// Gets a list of all the diagnostics associated with this token and any related trivia. /// This method does not filter diagnostics based on #pragmas and compiler options diff --git a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxUtilities.cs b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxUtilities.cs index 0efeb668a9e..3dcd2d2ed57 100644 --- a/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxUtilities.cs +++ b/src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxUtilities.cs @@ -32,7 +32,7 @@ internal static SyntaxList GetRewrittenMarkupStartTagChildren( if (includeEditHandler) { - latestEditHandler = literal.GetEditHandler() ?? latestEditHandler; + latestEditHandler = literal.EditHandler ?? latestEditHandler; } break; @@ -46,7 +46,7 @@ internal static SyntaxList GetRewrittenMarkupStartTagChildren( if (includeEditHandler) { - latestEditHandler = contentLiteral.GetEditHandler() ?? latestEditHandler; + latestEditHandler = contentLiteral.EditHandler ?? latestEditHandler; } } else @@ -74,12 +74,7 @@ void AddLiteralIsIfNeeded() { if (literals.Count > 0) { - var mergedLiteral = MergeTextLiterals(literals.ToArrayAndClear()); - - if (includeEditHandler) - { - mergedLiteral = mergedLiteral.WithEditHandler(latestEditHandler); - } + var mergedLiteral = MergeTextLiterals(literals.ToArrayAndClear(), includeEditHandler ? latestEditHandler : null); latestEditHandler = null; newChildren.Add(mergedLiteral); @@ -87,7 +82,7 @@ void AddLiteralIsIfNeeded() } } - private static MarkupTextLiteralSyntax MergeTextLiterals(params ReadOnlySpan literals) + private static MarkupTextLiteralSyntax MergeTextLiterals(ReadOnlySpan literals, SpanEditHandler? editHandler) { SyntaxNode? parent = null; var position = 0; @@ -116,7 +111,8 @@ private static MarkupTextLiteralSyntax MergeTextLiterals(params ReadOnlySpan(), - chunkGenerator: null) + chunkGenerator: null, + editHandler: editHandler) .CreateRed(parent, position); } @@ -145,14 +141,10 @@ internal static SyntaxList GetRewrittenMarkupNodeChildren( var markupTransition = InternalSyntax.SyntaxFactory .MarkupTransition( builder.ToGreenListNode().ToGreenList(), - chunkGenerator) + chunkGenerator, + includeEditHandler ? node.GetEditHandler() : null) .CreateRed(node, node.Position); - if (includeEditHandler && node.GetEditHandler() is { } editHandler) - { - markupTransition = markupTransition.WithEditHandler(editHandler); - } - return new(markupTransition); } } diff --git a/src/Compiler/tools/RazorSyntaxGenerator/RazorSyntaxGenerator.csproj b/src/Compiler/tools/RazorSyntaxGenerator/RazorSyntaxGenerator.csproj index 2661593a3bd..0863e6b41d5 100644 --- a/src/Compiler/tools/RazorSyntaxGenerator/RazorSyntaxGenerator.csproj +++ b/src/Compiler/tools/RazorSyntaxGenerator/RazorSyntaxGenerator.csproj @@ -2,7 +2,7 @@ Generates Razor syntax nodes from xml. For internal use only. - net6.0 + net9.0 dotnet-razorsyntaxgenerator RazorSyntaxGenerator Exe diff --git a/src/Compiler/tools/RazorSyntaxGenerator/SourceWriter.cs b/src/Compiler/tools/RazorSyntaxGenerator/SourceWriter.cs index d6af72665e3..c572ffc179c 100644 --- a/src/Compiler/tools/RazorSyntaxGenerator/SourceWriter.cs +++ b/src/Compiler/tools/RazorSyntaxGenerator/SourceWriter.cs @@ -88,9 +88,9 @@ private void WriteGreenType(TreeType greenType) WriteLine($"internal abstract partial class {abstractNode.Name} : {(abstractNode.Base == "SyntaxNode" ? "GreenNode" : abstractNode.Base)}"); using (Block()) { - // ctor with diagnostics and annotations - WriteLine($"internal {abstractNode.Name}(SyntaxKind kind, RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations)"); - WriteIndentedLine(": base(kind, diagnostics, annotations)"); + // ctor with diagnostics + WriteLine($"internal {abstractNode.Name}(SyntaxKind kind, RazorDiagnostic[] diagnostics)"); + WriteIndentedLine(": base(kind, diagnostics)"); using (Block()) { if (abstractNode.Name == "DirectiveTriviaSyntax") @@ -101,7 +101,7 @@ private void WriteGreenType(TreeType greenType) WriteLine(); - // ctor without diagnostics and annotations + // ctor without diagnostics WriteLine($"internal {abstractNode.Name}(SyntaxKind kind)"); WriteIndentedLine(": base(kind)"); using (Block()) @@ -181,14 +181,14 @@ private void WriteGreenType(TreeType greenType) WriteLine($"internal readonly {field.Type} {GetFieldName(field)};"); } - // write constructor with diagnostics and annotations + // write constructor with diagnostics WriteLine(); Write($"internal {node.Name}(SyntaxKind kind"); WriteGreenNodeConstructorArgs(nodeFields, valueFields); - WriteLine(", RazorDiagnostic[] diagnostics, SyntaxAnnotation[] annotations)"); - WriteIndentedLine(": base(kind, diagnostics, annotations)"); + WriteLine(", RazorDiagnostic[] diagnostics)"); + WriteIndentedLine(": base(kind, diagnostics)"); using (Block()) { WriteCtorBody(valueFields, nodeFields); @@ -209,7 +209,7 @@ private void WriteGreenType(TreeType greenType) WriteLine(" }"); WriteLine(); */ - // write constructor without diagnostics and annotations + // write constructor without diagnostics WriteLine(); Write($"internal {node.Name}(SyntaxKind kind"); @@ -293,7 +293,6 @@ private void WriteGreenType(TreeType greenType) WriteGreenAcceptMethods(node); WriteGreenUpdateMethod(node); WriteSetDiagnostics(node); - WriteSetAnnotations(node); } break; @@ -346,22 +345,6 @@ private void WriteCtorBody(List valueFields, List nodeFields) } } - private void WriteSetAnnotations(Node node) - { - WriteLine(); - WriteLine("internal override GreenNode SetAnnotations(SyntaxAnnotation[] annotations)"); - using (Indent()) - { - Write($"=> new {node.Name}("); - WriteCommaSeparatedList( - "Kind", - node.Fields.Select(GetFieldName), - "GetDiagnostics()", - "annotations"); - WriteLine(");"); - } - } - private void WriteSetDiagnostics(Node node) { WriteLine(); @@ -372,8 +355,7 @@ private void WriteSetDiagnostics(Node node) WriteCommaSeparatedList( "Kind", node.Fields.Select(GetFieldName), - "diagnostics", - "GetAnnotations()"); + "diagnostics"); WriteLine(");"); } } @@ -431,7 +413,8 @@ private void WriteGreenUpdateMethod(Node node) int nCompared = 0; foreach (var field in node.Fields) { - if (IsDerivedOrListOfDerived("SyntaxNode", field.Type) || IsDerivedOrListOfDerived("SyntaxToken", field.Type) || field.Type == "SyntaxNodeOrTokenList") + if (IsDerivedOrListOfDerived("SyntaxNode", field.Type) || + IsDerivedOrListOfDerived("SyntaxToken", field.Type) || field.Type == "SyntaxNodeOrTokenList") { if (nCompared > 0) { @@ -456,9 +439,6 @@ private void WriteGreenUpdateMethod(Node node) WriteLine("var diags = GetDiagnostics();"); WriteLine("if (diags != null && diags.Length > 0)"); WriteIndentedLine("newNode = newNode.WithDiagnosticsGreen(diags);"); - WriteLine("var annotations = GetAnnotations();"); - WriteLine("if (annotations != null && annotations.Length > 0)"); - WriteIndentedLine("newNode = newNode.WithAnnotationsGreen(annotations);"); WriteLine("return newNode;"); } } @@ -1221,7 +1201,9 @@ private void WriteRedUpdateMethod(Node node) var nCompared = 0; foreach (var field in node.Fields) { - if (IsDerivedOrListOfDerived("SyntaxNode", field.Type) || IsDerivedOrListOfDerived("SyntaxToken", field.Type) || field.Type is "SyntaxNodeOrTokenList" or "ISpanChunkGenerator") + if (IsDerivedOrListOfDerived("SyntaxNode", field.Type) || + IsDerivedOrListOfDerived("SyntaxToken", field.Type) || + field.Type is "SyntaxNodeOrTokenList" or "ISpanChunkGenerator" or "SpanEditHandler" or "DirectiveDescriptor") { if (nCompared > 0) { @@ -1246,8 +1228,7 @@ private void WriteRedUpdateMethod(Node node) WriteLine("var diagnostics = GetDiagnostics();"); WriteLine("if (diagnostics != null && diagnostics.Length > 0)"); WriteIndentedLine("newNode = newNode.WithDiagnostics(diagnostics);"); - WriteLine("var annotations = GetAnnotations();"); - WriteLine("return annotations?.Length > 0 ? newNode.WithAnnotations(annotations) : newNode;"); + WriteLine("return newNode;"); } } @@ -1504,7 +1485,7 @@ private bool IsRequiredFactoryField(Node node, Field field) private bool IsValueField(Field field) { - return !IsNodeOrNodeList(field.Type); + return !IsNodeOrNodeList(field.Type) && field.Type != "DirectiveDescriptor"; } private int RequiredFactoryArgumentCount(Node nd, bool includeKind = true) @@ -1645,6 +1626,10 @@ private void WriteRedFactory(Node node) { return $"{GetParameterName(f)}.Node.ToGreenList()"; } + else if (f.Type == "DirectiveDescriptor") + { + return $"{GetParameterName(f)}"; + } else { return $"{GetParameterName(f)} == null ? null : (InternalSyntax.{f.Type}){GetParameterName(f)}.Green"; diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/CSharp/TypeAccessibilityCodeActionProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/CSharp/TypeAccessibilityCodeActionProvider.cs index 084995a8c8c..63849b7f8cb 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/CSharp/TypeAccessibilityCodeActionProvider.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/CSharp/TypeAccessibilityCodeActionProvider.cs @@ -251,7 +251,7 @@ static bool IsSingleLineDirectiveNode(SyntaxNode owner) // `@inject |SomeType SomeName` - true // return owner.AncestorsAndSelf().Any( - n => n is RazorDirectiveSyntax directive && directive.DirectiveDescriptor.Kind == DirectiveKind.SingleLine); + static n => n is RazorDirectiveSyntax directive && directive.IsDirectiveKind(DirectiveKind.SingleLine)); } } diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/CreateComponentCodeActionResolver.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/CreateComponentCodeActionResolver.cs index a2168949434..8820078582c 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/CreateComponentCodeActionResolver.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/CreateComponentCodeActionResolver.cs @@ -57,7 +57,7 @@ private static void TryAddNamespaceDirective(RazorCodeDocument codeDocument, Uri var syntaxRoot = codeDocument.GetRequiredSyntaxRoot(); var namespaceDirective = syntaxRoot.DescendantNodes() .OfType() - .FirstOrDefault(static n => n.DirectiveDescriptor == NamespaceDirective.Directive); + .FirstOrDefault(static n => n.IsDirective(NamespaceDirective.Directive)); if (namespaceDirective != null) { diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ExtractToCodeBehindCodeActionProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ExtractToCodeBehindCodeActionProvider.cs index ce25f540abd..1b27b7fc141 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ExtractToCodeBehindCodeActionProvider.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/ExtractToCodeBehindCodeActionProvider.cs @@ -67,8 +67,8 @@ public Task> ProvideAsync(RazorCodeAct } // Make sure we've found a @code or @functions - if (directiveNode.DirectiveDescriptor != ComponentCodeDirective.Directive && - directiveNode.DirectiveDescriptor != FunctionsDirective.Directive) + if (!directiveNode.IsDirective(ComponentCodeDirective.Directive) && + !directiveNode.IsDirective(FunctionsDirective.Directive)) { return SpecializedTasks.EmptyImmutableArray(); } diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/RazorEditHelper.TextChangeBuilder.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/RazorEditHelper.TextChangeBuilder.cs index 4361f0dde69..62860a425cb 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/RazorEditHelper.TextChangeBuilder.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/DocumentMapping/RazorEditHelper.TextChangeBuilder.cs @@ -163,10 +163,10 @@ static TextSpan FindFirstTopLevelSpotForUsing(RazorCodeDocument codeDocument) var root = codeDocument.GetRequiredSyntaxRoot(); var nodeToInsertAfter = root .DescendantNodes() - .LastOrDefault(t => t is RazorDirectiveSyntax { DirectiveDescriptor: var descriptor } - && (descriptor == ComponentPageDirective.Directive - || descriptor == NamespaceDirective.Directive - || descriptor == PageDirective.Directive)); + .LastOrDefault(t => t is RazorDirectiveSyntax directiveNode + && (directiveNode.IsDirective(ComponentPageDirective.Directive) + || directiveNode.IsDirective(NamespaceDirective.Directive) + || directiveNode.IsDirective(PageDirective.Directive))); if (nodeToInsertAfter is null) { diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs index 580fe320c1a..3228d49183a 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Extensions/RazorSyntaxNodeExtensions.cs @@ -16,8 +16,8 @@ internal static class RazorSyntaxNodeExtensions { private static bool IsDirective(SyntaxNode node, DirectiveDescriptor directive, [NotNullWhen(true)] out RazorDirectiveBodySyntax? body) { - if (node is RazorDirectiveSyntax { DirectiveDescriptor: { } descriptor, Body: RazorDirectiveBodySyntax directiveBody } && - descriptor == directive) + if (node is RazorDirectiveSyntax { HasDirectiveDescriptor: true, Body: RazorDirectiveBodySyntax directiveBody } directiveNode && + directiveNode.IsDirective(directive)) { body = directiveBody; return true; @@ -28,10 +28,10 @@ private static bool IsDirective(SyntaxNode node, DirectiveDescriptor directive, } internal static bool IsSectionDirective(this SyntaxNode node) - => (node as RazorDirectiveSyntax)?.DirectiveDescriptor?.Directive == SectionDirective.Directive.Directive; + => (node as RazorDirectiveSyntax)?.IsDirective(SectionDirective.Directive) is true; internal static bool IsCodeBlockDirective(this SyntaxNode node) - => (node as RazorDirectiveSyntax)?.DirectiveDescriptor?.Kind == DirectiveKind.CodeBlock; + => (node as RazorDirectiveSyntax)?.IsDirectiveKind(DirectiveKind.CodeBlock) is true; internal static bool IsUsingDirective(this SyntaxNode node) => node.IsUsingDirective(out _); @@ -39,7 +39,7 @@ internal static bool IsUsingDirective(this SyntaxNode node) internal static bool IsUsingDirective(this SyntaxNode node, out SyntaxTokenList tokens) { // Using directives are weird, because the directive keyword ("using") is part of the C# statement it represents - if (node is RazorDirectiveSyntax { DirectiveDescriptor: null, Body: RazorDirectiveBodySyntax body } && + if (node is RazorDirectiveSyntax { HasDirectiveDescriptor: false, Body: RazorDirectiveBodySyntax body } && body.Keyword is CSharpStatementLiteralSyntax { LiteralTokens: [{ Kind: SyntaxKind.Keyword, Content: "using" }, ..] literalTokens diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/RazorCodeBlockFoldingProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/RazorCodeBlockFoldingProvider.cs index 20fab21285e..9b7c4765232 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/RazorCodeBlockFoldingProvider.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/RazorCodeBlockFoldingProvider.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Immutable; +using System.Diagnostics; using Microsoft.AspNetCore.Razor.Language; using Microsoft.AspNetCore.Razor.Language.Syntax; @@ -11,6 +12,7 @@ internal class RazorCodeBlockFoldingProvider : AbstractSyntaxNodeFoldingProvider { protected override string GetCollapsedText(RazorDirectiveSyntax node) { + Debug.Assert(node.HasDirectiveDescriptor); return "@" + node.DirectiveDescriptor.Directive; } diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/SectionDirectiveFoldingProvider.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/SectionDirectiveFoldingProvider.cs index ac46e849c82..f0ac1317102 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/SectionDirectiveFoldingProvider.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FoldingRanges/SectionDirectiveFoldingProvider.cs @@ -2,6 +2,7 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Collections.Immutable; +using System.Diagnostics; using Microsoft.AspNetCore.Razor.Language; using Microsoft.AspNetCore.Razor.Language.Syntax; @@ -11,6 +12,7 @@ internal class SectionDirectiveFoldingProvider : AbstractSyntaxNodeFoldingProvid { protected override string GetCollapsedText(RazorDirectiveSyntax node) { + Debug.Assert(node.HasDirectiveDescriptor); return $"@{node.DirectiveDescriptor.Directive}{GetSectionName(node)}"; static string GetSectionName(RazorDirectiveSyntax node) diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/AddUsingsHelper.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/AddUsingsHelper.cs index 2213879c10e..640d3ccb741 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/AddUsingsHelper.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/AddUsingsHelper.cs @@ -234,9 +234,9 @@ private static bool IsNamespaceOrPageDirective(RazorSyntaxNode node) { if (node is RazorDirectiveSyntax directiveNode) { - return directiveNode.DirectiveDescriptor == ComponentPageDirective.Directive || - directiveNode.DirectiveDescriptor == NamespaceDirective.Directive || - directiveNode.DirectiveDescriptor == PageDirective.Directive; + return directiveNode.IsDirective(ComponentPageDirective.Directive) || + directiveNode.IsDirective(NamespaceDirective.Directive) || + directiveNode.IsDirective(PageDirective.Directive); } return false; diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingVisitor.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingVisitor.cs index bce4e83e4cb..c85e1de6aca 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingVisitor.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/FormattingVisitor.cs @@ -71,7 +71,7 @@ CSharpImplicitExpressionBodySyntax or var isInCodeBlockDirective = node.Parent?.Parent?.Parent is RazorDirectiveSyntax directive && - directive.DirectiveDescriptor.Kind == DirectiveKind.CodeBlock; + directive.IsDirectiveKind(DirectiveKind.CodeBlock); if (isInCodeBlockDirective) { diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs index 36aaa70dd34..d12c6d1eafe 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/CSharpOnTypeFormattingPass.cs @@ -635,7 +635,7 @@ private async Task> AdjustIndentationAsync(Formatting } else if (owner is CSharpTransitionSyntax && owner.Parent is RazorDirectiveSyntax containingDirective && - containingDirective.DirectiveDescriptor.Directive == SectionDirective.Directive.Directive) + containingDirective.IsDirective(SectionDirective.Directive)) { // Section directives are a challenge because they have Razor indentation (we want to indent their contents one level) // and their contents will have Html indentation, and the generated code for them is indented (contents are in a lambda) @@ -704,7 +704,7 @@ owner.Parent is RazorDirectiveSyntax containingDirective && // For @section blocks we have special handling to add a fake source mapping/significant location at the end of the // section, to return the indentation back to before the start of the section block. if (scopeOwner?.Parent?.Parent?.Parent is RazorDirectiveSyntax containingDirective && - containingDirective.DirectiveDescriptor.Directive == SectionDirective.Directive.Directive && + containingDirective.IsDirective(SectionDirective.Directive) && !sourceMappingIndentations.ContainsKey(containingDirective.EndPosition - 1)) { // We want the indentation for the end point to be whatever the indentation was before the start point. For @@ -1036,7 +1036,7 @@ bool IsInDirectiveWithNoKind() // `@using |System; // return owner.AncestorsAndSelf().Any( - n => n is RazorDirectiveSyntax { DirectiveDescriptor: null }); + n => n is RazorDirectiveSyntax { HasDirectiveDescriptor: false }); } bool IsAttributeDirective() @@ -1046,10 +1046,7 @@ bool IsAttributeDirective() // `@attribute |[System.Obsolete] // return owner.AncestorsAndSelf().Any( - n => n is RazorDirectiveSyntax directive && - directive.DirectiveDescriptor != null && - directive.DirectiveDescriptor.Kind == DirectiveKind.SingleLine && - directive.DirectiveDescriptor.Directive.Equals(AttributeDirective.Directive.Directive, StringComparison.Ordinal)); + static n => n is RazorDirectiveSyntax directive && directive.IsDirective(AttributeDirective.Directive)); } bool IsTypeParamDirective() @@ -1059,10 +1056,7 @@ bool IsTypeParamDirective() // `@typeparam |T where T : IDisposable // return owner.AncestorsAndSelf().Any( - n => n is RazorDirectiveSyntax directive && - directive.DirectiveDescriptor != null && - directive.DirectiveDescriptor.Kind == DirectiveKind.SingleLine && - directive.DirectiveDescriptor.Directive.Equals(ComponentTypeParamDirective.Directive.Directive, StringComparison.Ordinal)); + static n => n is RazorDirectiveSyntax directive && directive.IsDirective(ComponentTypeParamDirective.Directive)); } bool IsInSingleLineDirective() @@ -1072,7 +1066,7 @@ bool IsInSingleLineDirective() // `@inject |SomeType SomeName` - true // return owner.AncestorsAndSelf().Any( - n => n is RazorDirectiveSyntax directive && directive.DirectiveDescriptor.Kind == DirectiveKind.SingleLine); + static n => n is RazorDirectiveSyntax directive && directive.IsDirectiveKind(DirectiveKind.SingleLine)); } bool IsImplicitExpression() @@ -1081,7 +1075,7 @@ bool IsImplicitExpression() // // `@|foo` - true // - return owner.AncestorsAndSelf().Any(n => n is CSharpImplicitExpressionSyntax); + return owner.AncestorsAndSelf().Any(static n => n is CSharpImplicitExpressionSyntax); } bool IsSingleLineExplicitExpression() @@ -1119,7 +1113,7 @@ bool IsInSectionDirectiveOrBrace() // we effectively pretend it doesn't exist so the formatting engine can handle both forms. if (owner is CSharpStatementLiteralSyntax literal && owner.Parent?.Parent?.Parent is RazorDirectiveSyntax directive3 && - directive3.DirectiveDescriptor.Directive == SectionDirective.Directive.Directive) + directive3.IsDirective(SectionDirective.Directive)) { return true; } @@ -1136,7 +1130,7 @@ owner.Parent is CSharpCodeBlockSyntax codeBlock && (owner == codeBlock.Children[3] || owner == codeBlock.Children[^1]) && // CSharpCodeBlock -> RazorDirectiveBody -> RazorDirective codeBlock.Parent?.Parent is RazorDirectiveSyntax directive2 && - directive2.DirectiveDescriptor.Directive == SectionDirective.Directive.Directive) + directive2.IsDirective(SectionDirective.Directive)) { return true; } diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/RazorFormattingPass.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/RazorFormattingPass.cs index 3faa21c0bc5..dbcf6f45348 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/RazorFormattingPass.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Formatting/Passes/RazorFormattingPass.cs @@ -91,7 +91,7 @@ private static bool TryFormatSectionBlock(FormattingContext context, ref PooledA // } if (node is CSharpCodeBlockSyntax directiveCode && directiveCode.Children is [RazorDirectiveSyntax directive, ..] && - directive.DirectiveDescriptor?.Directive == SectionDirective.Directive.Directive && + directive.IsDirective(SectionDirective.Directive) && directive.Body is RazorDirectiveBodySyntax { CSharpCode.Children: var children }) { if (TryGetWhitespace(children, out var whitespaceBeforeSectionName, out var whitespaceAfterSectionName)) @@ -254,7 +254,7 @@ private static void TryFormatCSharpBlockStructure(FormattingContext context, ref if (node is CSharpCodeBlockSyntax code && node.Parent?.Parent is RazorDirectiveSyntax directive && !directive.ContainsDiagnostics && - directive.DirectiveDescriptor?.Kind == DirectiveKind.CodeBlock) + directive.IsDirectiveKind(DirectiveKind.CodeBlock)) { // If we're formatting a @code or @functions directive, the user might have indicated they always want a newline var forceNewLine = context.Options.CodeBlockBraceOnNextLine && diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/RazorSyntaxFacts.cs b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/RazorSyntaxFacts.cs index 47708003e9e..ccc5c6fcf3c 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/RazorSyntaxFacts.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/RazorSyntaxFacts.cs @@ -174,7 +174,7 @@ public static bool IsAnyEndTag(RazorSyntaxNode n) => n.Kind is SyntaxKind.MarkupEndTag or SyntaxKind.MarkupTagHelperEndTag; public static bool IsInCodeBlock(RazorSyntaxNode n) - => n.FirstAncestorOrSelf(n => n is RazorDirectiveSyntax { DirectiveDescriptor.Directive: "code" }) is not null; + => n.FirstAncestorOrSelf(static n => n is RazorDirectiveSyntax { DirectiveDescriptor.Directive: "code" }) is not null; internal static bool TryGetNamespaceFromDirective(RazorDirectiveSyntax directiveNode, [NotNullWhen(true)] out string? @namespace) { diff --git a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/InlayHints/RemoteInlayHintService.cs b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/InlayHints/RemoteInlayHintService.cs index 5ad40ec714c..f3aedeba00f 100644 --- a/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/InlayHints/RemoteInlayHintService.cs +++ b/src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/InlayHints/RemoteInlayHintService.cs @@ -96,7 +96,7 @@ protected override IRemoteInlayHintService CreateService(in ServiceArgs args) // Inlay hints in directives are okay, eg '@attribute [Description(description: "Desc")]', but if the hint is going to be // at the very start of the directive, we want to strip any TextEdit as it would make for an invalid document. eg: '// @page template: "/"' if (node?.SpanStart == hostDocumentIndex && - node.FirstAncestorOrSelf(n => n.DirectiveDescriptor.Kind == DirectiveKind.SingleLine) is not null) + node.FirstAncestorOrSelf(static n => n.IsDirectiveKind(DirectiveKind.SingleLine)) is not null) { hint.TextEdits = null; } diff --git a/src/Razor/test/Microsoft.VisualStudio.LegacyEditor.Razor.Test/Indentation/RazorIndentationFactsTest.cs b/src/Razor/test/Microsoft.VisualStudio.LegacyEditor.Razor.Test/Indentation/RazorIndentationFactsTest.cs index 0930ab34f32..b0157dc13ca 100644 --- a/src/Razor/test/Microsoft.VisualStudio.LegacyEditor.Razor.Test/Indentation/RazorIndentationFactsTest.cs +++ b/src/Razor/test/Microsoft.VisualStudio.LegacyEditor.Razor.Test/Indentation/RazorIndentationFactsTest.cs @@ -40,7 +40,7 @@ public void IsCSharpOpenCurlyBrace_SpanWithLeftBrace_ReturnTrue() // Arrange using PooledArrayBuilder builder = []; builder.Add(SyntaxFactory.Token(SyntaxKind.LeftBrace, "{")); - var child = SyntaxFactory.RazorMetaCode(builder.ToList(), chunkGenerator: null); + var child = SyntaxFactory.RazorMetaCode(builder.ToList()); // Act var result = RazorIndentationFacts.IsCSharpOpenCurlyBrace(child); @@ -60,7 +60,7 @@ public void IsCSharpOpenCurlyBrace_SpanWithUnsupportedSymbolType_ReturnFalse(str var symbolType = (SyntaxKind)symbolTypeObject; using PooledArrayBuilder builder = []; builder.Add(SyntaxFactory.Token(symbolType, content)); - var child = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null); + var child = SyntaxFactory.MarkupTextLiteral(builder.ToList()); // Act var result = RazorIndentationFacts.IsCSharpOpenCurlyBrace(child); @@ -76,7 +76,7 @@ public void IsCSharpOpenCurlyBrace_MultipleSymbols_ReturnFalse() using PooledArrayBuilder builder = []; builder.Add(SyntaxFactory.Token(SyntaxKind.Identifier, "hello")); builder.Add(SyntaxFactory.Token(SyntaxKind.Comma, ",")); - var child = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null); + var child = SyntaxFactory.MarkupTextLiteral(builder.ToList()); // Act var result = RazorIndentationFacts.IsCSharpOpenCurlyBrace(child); @@ -91,7 +91,7 @@ public void IsCSharpOpenCurlyBrace_SpanWithHtmlSymbol_ReturnFalse() // Arrange using PooledArrayBuilder builder = []; builder.Add(SyntaxFactory.Token(SyntaxKind.Text, "hello")); - var child = SyntaxFactory.MarkupTextLiteral(builder.ToList(), chunkGenerator: null); + var child = SyntaxFactory.MarkupTextLiteral(builder.ToList()); // Act var result = RazorIndentationFacts.IsCSharpOpenCurlyBrace(child); diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/IntegrationTests/IntegrationTestBase.cs b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/IntegrationTests/IntegrationTestBase.cs index 03361862c75..2879e04b044 100644 --- a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/IntegrationTests/IntegrationTestBase.cs +++ b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/IntegrationTests/IntegrationTestBase.cs @@ -10,6 +10,7 @@ using System.Runtime.CompilerServices; using System.Text; using System.Text.RegularExpressions; +using Microsoft.AspNetCore.Mvc.Razor.Extensions; using Microsoft.AspNetCore.Razor.Language.Intermediate; using Microsoft.AspNetCore.Razor.Language.Legacy; using Microsoft.AspNetCore.Razor.Language.Syntax; @@ -493,7 +494,8 @@ protected void AssertSourceMappingsMatchBaseline(RazorCodeDocument codeDocument, } // See https://github.com/dotnet/razor/issues/10062 - if (expectedSpan.Contains("") || span.FirstAncestorOrSelf()?.DirectiveDescriptor?.Directive == "model") + if (expectedSpan.Contains("") || + span.FirstAncestorOrSelf()?.IsDirective(ModelDirective.Directive) is true) { // Inject directives in MVC replace the TModel with a user defined model type, so we aren't able to find // the matching text in the generated document diff --git a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/TestSyntaxSerializer.cs b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/TestSyntaxSerializer.cs index 3ec488e9d20..edfe1a003d6 100644 --- a/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/TestSyntaxSerializer.cs +++ b/src/Shared/Microsoft.AspNetCore.Razor.Test.Common/Language/TestSyntaxSerializer.cs @@ -57,6 +57,6 @@ protected override void WriteSpanEditHandlers(SyntaxNode node) } // If we don't allow SpanEditHandlers, assert that there aren't any. - Assert.All(node.GetAnnotations(), a => Assert.IsNotType(a.Data)); + Assert.Null(node.GetEditHandler()); } }