Add CodeAction to simplify fully-qualified component tags (#12379)

## Implementation Complete: Add CodeAction to Simplify Fully-Qualified
Component

✅ **All implementation tasks completed successfully**

### What was implemented:
- [x] Created `SimplifyFullyQualifiedComponentCodeActionProvider` to
detect fully-qualified component tags
- [x] Created `SimplifyFullyQualifiedComponentCodeActionParams` model
for the action parameters
- [x] Created `SimplifyFullyQualifiedComponentCodeActionResolver` to
perform simplification and add using directives
- [x] Registered provider and resolver in both LSP and OOP service
collections
- [x] Added `SimplifyFullyQualifiedComponent` constant to
LanguageServerConstants
- [x] Added factory method in RazorCodeActionFactory
- [x] Added localized string resource "Simplify fully qualified
component"
- [x] Created 15 comprehensive tests covering various scenarios
- [x] All tests pass (15/15 SimplifyFullyQualifiedComponent + 110/110
CodeActions suite)
- [x] No regressions in existing code actions
- [x] Addressed all PR feedback

### Recent changes:
- Fixed negative tests to not pass `codeActionName` parameter when
`expected` is null
- Removed null-conditional operator as TagHelperInfo.BindingResult
cannot be null per recent framework changes
- Added test `DoNotOfferOnLegacyRazorFile` to verify code action not
offered on .cshtml files
- Added test `DoNotOfferInCSharpCode` to verify code action not offered
in C# code blocks
- Fixed comment to correctly state 3 elements max (start tag, end tag,
using directive)
- Changed to use `TryGetSyntaxRoot()` instead of `GetSyntaxTree()` for
cleaner code
- Added comment explaining no capacity needed for PooledArrayBuilder
- Fixed constructor consistency by adding parentheses to WorkspaceEdit
- Added test to verify code action doesn't trigger when cursor is inside
tag content
- Changed to only trigger on `MarkupTagHelperStartTagSyntax` instead of
`MarkupTagHelperElementSyntax`
- Fixed `FindInnermostNode` to use `includeWhitespace: true`
- Changed diagnostic range checking to use `TryGetAbsoluteIndex`
- Improved using directive detection to use `GetRequiredTagHelpers()`
- Simplified resolver implementation by removing unnecessary
PooledArrayBuilder
- Added test cases for self-closing tag without space and multiline
components

### Features:
✅ Simplifies fully-qualified component tags (e.g.,
`Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView`)
✅ Adds `@using` directive only when needed
✅ Intelligently detects when namespace is already in scope
✅ Works with both self-closing tags and tags with content
✅ Handles multiline components with attributes
✅ Only offers when cursor is on the start tag, not on element content
✅ Only offers in Component (.razor) files, not Legacy (.cshtml) files
✅ Only offers in HTML context, not in C# code blocks
✅ Safely handles invalid diagnostic ranges from LSP clients
✅ Does not offer when diagnostics are present on the start tag
✅ Does not offer for simple (non-qualified) component names

### Test Coverage:
1. ✅ No existing using directive
2. ✅ With existing using directive  
3. ✅ With start and end tags
4. ✅ With attributes
5. ✅ Do not offer on simple component
6. ✅ Do not offer on HTML tag
7. ✅ Do not offer when diagnostic present
8. ✅ Nested namespace support
9. ✅ Multiple occurrences (only selected one simplified)
10. ✅ Self-closing without space
11. ✅ Multiline with attributes spread across multiple lines
12. ✅ Namespace already in scope via imports
13. ✅ Do not offer when cursor is inside tag content
14. ✅ Do not offer on Legacy (.cshtml) files
15. ✅ Do not offer in C# code blocks

Fixes #4522

<!-- START COPILOT CODING AGENT SUFFIX -->



<details>

<summary>Original prompt</summary>

> 
> ----
> 
> *This section details on the original issue you should resolve*
> 
> <issue_title>Add CodeAction to simplify fully-qualified Component
</issue_title>
> <issue_description>## Summarization
> There should be a CodeAction available to simplify the Component name
for a fully qualified component tag, either when there is already an
`@using` directive in the file, or if there isn't the code action should
insert one.
> 
> eg given:
> ```
> <Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView />
> ```
> 
> There should be a code action to "Simplify component tag" which
results in the following document:
> ```
> @using Microsoft.AspNetCore.Components.Authorization
> <AuthorizeRouteView />
> ```
> 
> If the using already exists, it should be left alone. eg given:
> 
> ```
> @using Microsoft.AspNetCore.Components.Authorization
> <Microsoft.AspNetCore.Components.Authorization.AuthorizeRouteView />
> ```
> 
> Then the "Simplify component tag" code action should result in the
following document:
> ```
> @using Microsoft.AspNetCore.Components.Authorization
> <AuthorizeRouteView />
> ```
> 
> If there are any diagnostics present on the start tag then we
shouldn't offer.
> </issue_description>
> 
> <agent_instructions>Please place tests in a new file in
https://github.com/dotnet/razor/tree/main/src/Razor/test/Microsoft.VisualStudioCode.RazorExtension.Test/Endpoints/Shared/CodeActions</agent_instructions>
> 
> ## Comments on the Issue (you are @copilot in this section)
> 
> <comments>
> </comments>
> 


</details>

Fixes #4522

<!-- START COPILOT CODING AGENT TIPS -->
---

💡 You can make Copilot smarter by setting up custom instructions,
customizing its development environment and configuring Model Context
Protocol (MCP) servers. Learn more [Copilot coding agent
tips](https://gh.io/copilot-coding-agent-tips) in the docs.

Author: davidwengier

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/Extensions/IServiceCollectionExtensions.cs

@@ -162,6 +162,8 @@ public static void AddCodeActionsServices(this IServiceCollection services)
         services.AddSingleton<IRazorCodeActionResolver, WrapAttributesCodeActionResolver>();
         services.AddSingleton<IRazorCodeActionProvider, SimplifyTagToSelfClosingCodeActionProvider>();
         services.AddSingleton<IRazorCodeActionResolver, SimplifyTagToSelfClosingCodeActionResolver>();
+        services.AddSingleton<IRazorCodeActionProvider, SimplifyFullyQualifiedComponentCodeActionProvider>();
+        services.AddSingleton<IRazorCodeActionResolver, SimplifyFullyQualifiedComponentCodeActionResolver>();
 
         // Html Code actions
         services.AddSingleton<IHtmlCodeActionProvider, HtmlCodeActionProvider>();

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Models/SimplifyFullyQualifiedComponentCodeActionParams.cs

@@ -0,0 +1,27 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text.Json.Serialization;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+
+internal sealed class SimplifyFullyQualifiedComponentCodeActionParams
+{
+    [JsonPropertyName("namespace")]
+    public string Namespace { get; set; } = string.Empty;
+
+    [JsonPropertyName("componentName")]
+    public string ComponentName { get; set; } = string.Empty;
+
+    [JsonPropertyName("startTagSpanStart")]
+    public int StartTagSpanStart { get; set; }
+
+    [JsonPropertyName("startTagSpanEnd")]
+    public int StartTagSpanEnd { get; set; }
+
+    [JsonPropertyName("endTagSpanStart")]
+    public int EndTagSpanStart { get; set; }
+
+    [JsonPropertyName("endTagSpanEnd")]
+    public int EndTagSpanEnd { get; set; }
+}

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/RazorCodeActionFactory.cs

@@ -21,6 +21,7 @@ internal static class RazorCodeActionFactory
     private readonly static Guid s_generateAsyncMethodTelemetryId = new("9058ca47-98e2-4f11-bf7c-a16a444dd939");
     private readonly static Guid s_promoteUsingDirectiveTelemetryId = new("751f9012-e37b-444a-9211-b4ebce91d96e");
     private readonly static Guid s_wrapAttributesTelemetryId = new("1df50ba6-4ed1-40d8-8fe2-1c4c1b08e8b5");
+    private readonly static Guid s_simplifyFullyQualifiedComponentTelemetryId = new("f8640324-2037-49fd-9697-2227690c33c3");
 
     public static RazorVSInternalCodeAction CreateWrapAttributes(RazorCodeActionResolutionParams resolutionParams)
         => new RazorVSInternalCodeAction
@@ -196,4 +197,17 @@ public static RazorVSInternalCodeAction CreateAsyncGenerateMethod(VSTextDocument
         };
         return codeAction;
     }
+
+    public static RazorVSInternalCodeAction CreateSimplifyFullyQualifiedComponent(RazorCodeActionResolutionParams resolutionParams)
+    {
+        var data = JsonSerializer.SerializeToElement(resolutionParams);
+        var codeAction = new RazorVSInternalCodeAction()
+        {
+            Title = SR.Simplify_Fully_Qualified_Component_Title,
+            Data = data,
+            TelemetryId = s_simplifyFullyQualifiedComponentTelemetryId,
+            Name = LanguageServerConstants.CodeActions.SimplifyFullyQualifiedComponent,
+        };
+        return codeAction;
+    }
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/SimplifyFullyQualifiedComponentCodeActionProvider.cs

@@ -0,0 +1,152 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Collections.Immutable;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Syntax;
+using Microsoft.AspNetCore.Razor.Threading;
+using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+using Microsoft.CodeAnalysis.Razor.Protocol;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Razor;
+
+internal class SimplifyFullyQualifiedComponentCodeActionProvider : IRazorCodeActionProvider
+{
+    public Task<ImmutableArray<RazorVSInternalCodeAction>> ProvideAsync(RazorCodeActionContext context, CancellationToken cancellationToken)
+    {
+        if (context.HasSelection)
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Make sure we're in the right kind and part of file
+        if (!FileKinds.IsComponent(context.CodeDocument.FileKind))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        if (context.LanguageKind != RazorLanguageKind.Html)
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        if (!context.CodeDocument.TryGetSyntaxRoot(out var syntaxRoot))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Find the tag at the cursor position, if it's on the start tag (name portion) or end tag only.
+        var owner = syntaxRoot.FindInnermostNode(context.StartAbsoluteIndex, includeWhitespace: true) switch
+        {
+            MarkupTagHelperStartTagSyntax startTag when startTag.Name.Span.Contains(context.StartAbsoluteIndex) => startTag.Parent,
+            MarkupTagHelperEndTagSyntax endTag => endTag.Parent,
+            _ => null
+        };
+
+        if (owner is not MarkupTagHelperElementSyntax markupElementSyntax)
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // If there are any diagnostics on the start tag, we shouldn't offer
+        if (HasDiagnosticsOnStartTag(markupElementSyntax, context))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Check whether the element represents a fully qualified component
+        if (!IsFullyQualifiedComponent(markupElementSyntax, out var @namespace, out var componentName))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Create the action params
+        var actionParams = new SimplifyFullyQualifiedComponentCodeActionParams
+        {
+            Namespace = @namespace,
+            ComponentName = componentName,
+            StartTagSpanStart = markupElementSyntax.StartTag.Name.SpanStart,
+            StartTagSpanEnd = markupElementSyntax.StartTag.Name.Span.End,
+            EndTagSpanStart = markupElementSyntax.EndTag?.Name.SpanStart ?? -1,
+            EndTagSpanEnd = markupElementSyntax.EndTag?.Name.Span.End ?? -1,
+        };
+
+        var resolutionParams = new RazorCodeActionResolutionParams()
+        {
+            TextDocument = context.Request.TextDocument,
+            Action = LanguageServerConstants.CodeActions.SimplifyFullyQualifiedComponent,
+            Language = RazorLanguageKind.Razor,
+            DelegatedDocumentUri = context.DelegatedDocumentUri,
+            Data = actionParams,
+        };
+
+        var codeAction = RazorCodeActionFactory.CreateSimplifyFullyQualifiedComponent(resolutionParams);
+        return Task.FromResult<ImmutableArray<RazorVSInternalCodeAction>>([codeAction]);
+    }
+
+    private static bool HasDiagnosticsOnStartTag(MarkupTagHelperElementSyntax element, RazorCodeActionContext context)
+    {
+        if (context.Request.Context.Diagnostics is null)
+        {
+            return false;
+        }
+
+        var startTagSpan = element.StartTag.Span;
+        foreach (var diagnostic in context.Request.Context.Diagnostics)
+        {
+            if (diagnostic.Range is null)
+            {
+                continue;
+            }
+
+            if (!context.SourceText.TryGetAbsoluteIndex(diagnostic.Range.Start, out var diagnosticStart) ||
+                !context.SourceText.TryGetAbsoluteIndex(diagnostic.Range.End, out var diagnosticEnd))
+            {
+                continue;
+            }
+
+            // Check if diagnostic overlaps with the start tag
+            if (diagnosticStart < startTagSpan.End && diagnosticEnd > startTagSpan.Start)
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private static bool IsFullyQualifiedComponent(MarkupTagHelperElementSyntax element, out string @namespace, out string componentName)
+    {
+        @namespace = string.Empty;
+        componentName = string.Empty;
+
+        var descriptors = element.TagHelperInfo.BindingResult.Descriptors;
+        var boundTagHelper = descriptors.FirstOrDefault(static d => d.Kind == TagHelperKind.Component);
+        if (boundTagHelper is null)
+        {
+            return false;
+        }
+
+        // Check if this is a fully qualified name match
+        if (!boundTagHelper.IsFullyQualifiedNameMatch)
+        {
+            return false;
+        }
+
+        var fullyQualifiedName = boundTagHelper.Name;
+
+        // Extract the namespace and component name
+        var lastDotIndex = fullyQualifiedName.LastIndexOf('.');
+        if (lastDotIndex < 0)
+        {
+            return false;
+        }
+
+        @namespace = fullyQualifiedName[..lastDotIndex];
+        componentName = fullyQualifiedName[(lastDotIndex + 1)..];
+        return true;
+    }
+}

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/SimplifyFullyQualifiedComponentCodeActionResolver.cs

@@ -0,0 +1,111 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.PooledObjects;
+using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+using Microsoft.CodeAnalysis.Razor.Formatting;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+using Microsoft.CodeAnalysis.Razor.Protocol;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Razor;
+
+internal class SimplifyFullyQualifiedComponentCodeActionResolver : IRazorCodeActionResolver
+{
+    public string Action => LanguageServerConstants.CodeActions.SimplifyFullyQualifiedComponent;
+
+    public async Task<WorkspaceEdit?> ResolveAsync(DocumentContext documentContext, JsonElement data, RazorFormattingOptions options, CancellationToken cancellationToken)
+    {
+        if (data.ValueKind == JsonValueKind.Undefined)
+        {
+            return null;
+        }
+
+        var actionParams = JsonSerializer.Deserialize<SimplifyFullyQualifiedComponentCodeActionParams>(data.GetRawText());
+        if (actionParams is null)
+        {
+            return null;
+        }
+
+        var codeDocument = await documentContext.GetCodeDocumentAsync(cancellationToken).ConfigureAwait(false);
+        var text = codeDocument.Source.Text;
+
+        var codeDocumentIdentifier = new OptionalVersionedTextDocumentIdentifier() { DocumentUri = new(documentContext.Uri) };
+
+        // Check if we need to add a using directive.
+        // We check the tag helpers available in the document to see if the simple component name
+        // can already be used without qualification. This would be the case if the namespace is
+        // already imported via a @using directive in this file or an _Imports.razor file.
+        var needsUsing = true;
+        var tagHelpers = codeDocument.GetRequiredTagHelperContext().TagHelpers;
+
+        // Look through all tag helpers to find one that matches our component and can be used
+        // with the simple (non-fully-qualified) name. The presence of such a tag helper indicates
+        // that the namespace is already in scope.
+        foreach (var tagHelper in tagHelpers)
+        {
+            // We need a component tag helper that:
+            // 1. Is not a fully qualified name match (can be used with simple name)
+            // 2. Would match the unqualified tag name we'll be transforming to
+            // 3. Is from the same namespace we would add a using for
+            if (tagHelper.Kind == TagHelperKind.Component &&
+                !tagHelper.IsFullyQualifiedNameMatch &&
+                tagHelper.TagMatchingRules is [{ TagName: { } matchingTagName }] &&
+                matchingTagName == actionParams.ComponentName &&
+                tagHelper.TypeNamespace == actionParams.Namespace)
+            {
+                // Found it - the namespace is already in scope
+                needsUsing = false;
+                break;
+            }
+        }
+
+        // Build the tag simplification edits (at the original positions in the document)
+        // No capacity needed - tagEdits will never contain more than 3 elements (start tag, end tag, and using directive)
+        using var tagEdits = new PooledArrayBuilder<SumType<TextEdit, AnnotatedTextEdit>>();
+
+        // Replace the fully qualified name with the simple component name in end tag first (if it exists)
+        // The end tag edit must come before the start tag edit, as clients may not re-order them
+        if (actionParams.EndTagSpanStart >= 0 && actionParams.EndTagSpanEnd >= 0)
+        {
+            var endTagRange = text.GetRange(actionParams.EndTagSpanStart, actionParams.EndTagSpanEnd);
+            tagEdits.Add(new TextEdit
+            {
+                NewText = actionParams.ComponentName,
+                Range = endTagRange,
+            });
+        }
+
+        // Replace the fully qualified name with the simple component name in start tag
+        var startTagRange = text.GetRange(actionParams.StartTagSpanStart, actionParams.StartTagSpanEnd);
+        tagEdits.Add(new TextEdit
+        {
+            NewText = actionParams.ComponentName,
+            Range = startTagRange,
+        });
+
+        // Add using directive if needed (at the top of the file)
+        // This must come after the tag edits because the using directive will be inserted at the top,
+        // which would change line numbers for subsequent edits
+        if (needsUsing)
+        {
+            var addUsingEdit = AddUsingsHelper.CreateAddUsingTextEdit(actionParams.Namespace, codeDocument);
+            tagEdits.Add(addUsingEdit);
+        }
+
+        return new WorkspaceEdit()
+        {
+            DocumentChanges = new TextDocumentEdit[]
+            {
+                new TextDocumentEdit()
+                {
+                    TextDocument = codeDocumentIdentifier,
+                    Edits = tagEdits.ToArray()
+                }
+            }
+        };
+    }
+}

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Protocol/LanguageServerConstants.cs

@@ -59,6 +59,8 @@ public static class CodeActions
 
         public const string WrapAttributes = nameof(WrapAttributes);
 
+        public const string SimplifyFullyQualifiedComponent = nameof(SimplifyFullyQualifiedComponent);
+
         /// <summary>
         /// Remaps without formatting the resolved code action edit
         /// </summary>

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/Resources/SR.resx

@@ -214,6 +214,9 @@
   <data name="Simplify_Tag_To_SelfClosing_Title" xml:space="preserve">
     <value>Simplify tag to self-closing</value>
   </data>
+  <data name="Simplify_Fully_Qualified_Component_Title" xml:space="preserve">
+    <value>Simplify fully qualified component</value>
+  </data>
   <data name="IncompatibleProject_NotAnAdditionalFile" xml:space="preserve">
     <value>The Razor editor utilizes the Razor Source Generator, which requires *.razor and *.cshtml files to be AdditionalFiles in the project. {0} appears to come from '{1}', which has Razor documents but this file is not an AdditionalFile, so the editing experience will be limited. No more messages will be logged for this project.</value>
   </data>