Improves attribute markup span creation

Uses a `SourceSpanComputer` to efficiently create markup spans for
attributes, avoiding unnecessary string allocations and improving
performance of the `ClassifiedSpanVisitor`.

Author: DustinCampbell

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/ClassifiedSpanVisitor.cs

@@ -204,10 +204,19 @@ public override void VisitMarkupAttributeBlock(MarkupAttributeBlockSyntax node)
     {
         using (MarkupBlock(node))
         {
-            var equalsSyntax = SyntaxFactory.MarkupTextLiteral(new SyntaxTokenList(node.EqualsToken), chunkGenerator: null);
-            var mergedAttributePrefix = SyntaxUtilities.MergeTextLiterals(node.NamePrefix, node.Name, node.NameSuffix, equalsSyntax, node.ValuePrefix);
+            // For attributes, we add a single span from the start of the name prefix to the end of the value prefix.
+            var spanComputer = new SourceSpanComputer(_source);
+            spanComputer.Add(node.NamePrefix);
+            spanComputer.Add(node.Name);
+            spanComputer.Add(node.NameSuffix);
+            spanComputer.Add(node.EqualsToken);
+            spanComputer.Add(node.ValuePrefix);
 
-            Visit(mergedAttributePrefix);
+            var sourceSpan = spanComputer.ToSourceSpan();
+
+            AddSpan(sourceSpan, SpanKindInternal.Markup, AcceptedCharactersInternal.Any);
+
+            // Visit the value and value suffix separately.
             Visit(node.Value);
             Visit(node.ValueSuffix);
         }
@@ -235,8 +244,14 @@ public override void VisitMarkupMinimizedAttributeBlock(MarkupMinimizedAttribute
     {
         using (MarkupBlock(node))
         {
-            var mergedAttributePrefix = SyntaxUtilities.MergeTextLiterals(node.NamePrefix, node.Name);
-            Visit(mergedAttributePrefix);
+            // For minimized attributes, we add a single span for the attribute name along with the name prefix.
+            var spanComputer = new SourceSpanComputer(_source);
+            spanComputer.Add(node.NamePrefix);
+            spanComputer.Add(node.Name);
+
+            var sourceSpan = spanComputer.ToSourceSpan();
+
+            AddSpan(sourceSpan, SpanKindInternal.Markup, AcceptedCharactersInternal.Any);
         }
     }
 

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/SourceSpanComputer.cs

@@ -0,0 +1,117 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Diagnostics;
+using Microsoft.AspNetCore.Razor.Language.Syntax;
+
+namespace Microsoft.AspNetCore.Razor.Language;
+
+/// <summary>
+///  Helper that can be used to efficiently build up a <see cref="SourceSpan"/> from a set of syntax tokens.
+/// </summary>
+internal ref struct SourceSpanComputer(RazorSourceDocument source)
+{
+    private readonly RazorSourceDocument _source = source;
+
+    private SyntaxToken _firstToken;
+    private SyntaxToken _lastToken;
+
+    public void Add(SyntaxToken token)
+    {
+        if (token.Kind == SyntaxKind.None)
+        {
+            return;
+        }
+
+        if (_firstToken.Kind == SyntaxKind.None)
+        {
+            _firstToken = token;
+        }
+
+        _lastToken = token;
+    }
+
+    public void Add(SyntaxTokenList tokenList)
+    {
+        if (tokenList.Count == 0)
+        {
+            return;
+        }
+
+        if (_firstToken.Kind == SyntaxKind.None)
+        {
+            _firstToken = tokenList[0];
+        }
+
+        _lastToken = tokenList[^1];
+    }
+
+    public void Add(SyntaxTokenList? tokenList)
+    {
+        if (tokenList is not [_, ..] tokens)
+        {
+            return;
+        }
+
+        if (_firstToken.Kind == SyntaxKind.None)
+        {
+            _firstToken = tokens[0];
+        }
+
+        _lastToken = tokens[^1];
+    }
+
+    public void Add(CSharpEphemeralTextLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public void Add(CSharpExpressionLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public void Add(CSharpStatementLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public void Add(MarkupEphemeralTextLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public void Add(MarkupTextLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public void Add(UnclassifiedTextLiteralSyntax? literal)
+    {
+        Add(literal?.LiteralTokens);
+    }
+
+    public readonly SourceSpan ToSourceSpan()
+    {
+        if (_firstToken.Kind == SyntaxKind.None)
+        {
+            return default;
+        }
+
+        Debug.Assert(_lastToken.Kind != SyntaxKind.None, "Last token should not be None when first token is set.");
+
+        var start = _firstToken.Span.Start;
+        var end = _lastToken.Span.End;
+
+        Debug.Assert(start <= end, "Start position should not be greater than end position.");
+
+        var length = end - start;
+
+        var text = _source.Text;
+        var startLinePosition = text.Lines.GetLinePosition(start);
+        var endLinePosition = text.Lines.GetLinePosition(end);
+        var lineCount = endLinePosition.Line - startLinePosition.Line;
+
+        return new SourceSpan(_source.FilePath, absoluteIndex: start, startLinePosition.Line, startLinePosition.Character, length, lineCount, endLinePosition.Character);
+    }
+}