#11793 Simplify tag to self-closing code action

Author: Peter-Juhasz

src/Compiler/Microsoft.CodeAnalysis.Razor.Compiler/src/Language/Syntax/SyntaxListOfT.cs

@@ -318,6 +318,19 @@ public bool Any()
         return Node != null;
     }
 
+    public bool Any(Func<TNode, bool> predicate)
+    {
+        foreach (var node in this)
+        {
+            if (predicate(node))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     public SyntaxList<TNode> Where(Func<TNode, bool> predicate)
     {
         using var _ = SyntaxListBuilderPool.GetPooledBuilder<TNode>(out var builder);

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

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

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

@@ -0,0 +1,15 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Text.Json.Serialization;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+
+internal sealed class SimplifyTagToSelfClosingCodeActionParams
+{
+    [JsonPropertyName("start")]
+    public int Start { get; set; }
+
+    [JsonPropertyName("end")]
+    public int End { get; set; }
+}

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

@@ -16,6 +16,7 @@ internal static class RazorCodeActionFactory
     private readonly static Guid s_createComponentFromTagTelemetryId = new("a28e0baa-a4d5-4953-a817-1db586035841");
     private readonly static Guid s_createExtractToCodeBehindTelemetryId = new("f63167f7-fdc6-450f-8b7b-b240892f4a27");
     private readonly static Guid s_createExtractToComponentTelemetryId = new("af67b0a3-f84b-4808-97a7-b53e85b22c64");
+    private readonly static Guid s_simplifyComponentTelemetryId = new("2207f68c-419e-4baa-8493-2e7769e5c91d");
     private readonly static Guid s_generateMethodTelemetryId = new("c14fa003-c752-45fc-bb29-3a123ae5ecef");
     private readonly static Guid s_generateAsyncMethodTelemetryId = new("9058ca47-98e2-4f11-bf7c-a16a444dd939");
     private readonly static Guid s_promoteUsingDirectiveTelemetryId = new("751f9012-e37b-444a-9211-b4ebce91d96e");
@@ -112,6 +113,19 @@ public static RazorVSInternalCodeAction CreateExtractToComponent(RazorCodeAction
         return codeAction;
     }
 
+    public static RazorVSInternalCodeAction CreateSimplifyTagToSelfClosing(RazorCodeActionResolutionParams resolutionParams)
+    {
+        var data = JsonSerializer.SerializeToElement(resolutionParams);
+        var codeAction = new RazorVSInternalCodeAction()
+        {
+            Title = SR.Simplify_Tag_To_SelfClosing_Title,
+            Data = data,
+            TelemetryId = s_simplifyComponentTelemetryId,
+            Name = LanguageServerConstants.CodeActions.SimplifyTagToSelfClosingAction,
+        };
+        return codeAction;
+    }
+
     public static RazorVSInternalCodeAction CreateGenerateMethod(VSTextDocumentIdentifier textDocument, Uri? delegatedDocumentUri, string methodName, string? eventParameterType)
     {
         var @params = new GenerateMethodCodeActionParams

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

@@ -0,0 +1,140 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.AspNetCore.Razor.Language.Components;
+using Microsoft.AspNetCore.Razor.Language.Syntax;
+using Microsoft.AspNetCore.Razor.Threading;
+using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+using Microsoft.CodeAnalysis.Razor.GoToDefinition;
+using Microsoft.CodeAnalysis.Razor.Logging;
+using Microsoft.CodeAnalysis.Razor.Protocol;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Razor;
+
+internal class SimplifyTagToSelfClosingCodeActionProvider(ILoggerFactory loggerFactory) : IRazorCodeActionProvider
+{
+    private readonly ILogger _logger = loggerFactory.GetOrCreateLogger<SimplifyTagToSelfClosingCodeActionProvider>();
+
+    private const string RenderFragmentTypeName = "Microsoft.AspNetCore.Components.RenderFragment";
+    private const string GenericRenderFragmentTypeName = "Microsoft.AspNetCore.Components.RenderFragment<";
+
+    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>();
+        }
+
+        // Caret must be inside a markup element
+        if (context.ContainsDiagnostic(ComponentDiagnosticFactory.UnexpectedMarkupElement.Id) ||
+            context.ContainsDiagnostic(ComponentDiagnosticFactory.UnexpectedClosingTag.Id))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        var syntaxTree = context.CodeDocument.GetSyntaxTree();
+        if (syntaxTree?.Root is null)
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        var owner = syntaxTree.Root.FindInnermostNode(context.StartAbsoluteIndex, includeWhitespace: !context.HasSelection)?.FirstAncestorOrSelf<MarkupTagHelperElementSyntax>();
+        if (owner is not MarkupTagHelperElementSyntax markupElementSyntax)
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Check whether the code action is applicable to the element
+        if (!IsApplicableTo(context, markupElementSyntax))
+        {
+            return SpecializedTasks.EmptyImmutableArray<RazorVSInternalCodeAction>();
+        }
+
+        // Provide code action to simplify
+        var actionParams = new SimplifyTagToSelfClosingCodeActionParams
+        {
+            Start = markupElementSyntax.StartTag.CloseAngle.SpanStart,
+            End = markupElementSyntax.EndTag.CloseAngle.EndPosition,
+        };
+
+        var resolutionParams = new RazorCodeActionResolutionParams()
+        {
+            TextDocument = context.Request.TextDocument,
+            Action = LanguageServerConstants.CodeActions.SimplifyTagToSelfClosingAction,
+            Language = RazorLanguageKind.Razor,
+            DelegatedDocumentUri = context.DelegatedDocumentUri,
+            Data = actionParams,
+        };
+
+        var codeAction = RazorCodeActionFactory.CreateSimplifyTagToSelfClosing(resolutionParams);
+        return Task.FromResult<ImmutableArray<RazorVSInternalCodeAction>>([codeAction]);
+    }
+
+    internal bool IsApplicableTo(RazorCodeActionContext context, MarkupTagHelperElementSyntax markupElementSyntax)
+    {
+        // Check whether the element is self-closing
+        if (markupElementSyntax is not (
+        { EndTag.CloseAngle.IsMissing: false } and
+        { StartTag.ForwardSlash: null } and
+        { StartTag.CloseAngle.IsMissing: false }
+        ))
+        {
+            return false;
+        }
+
+        // Check whether the element has any non-whitespace content
+        if (markupElementSyntax is { Body: { } body } && body.Any(static n => !n.ContainsOnlyWhitespace()))
+        {
+            return false;
+        }
+
+        // Get symbols for the markup element
+        if (!RazorComponentDefinitionHelpers.TryGetBoundTagHelpers(context.CodeDocument, markupElementSyntax.StartTag.Name.SpanStart, true, _logger, out var boundTagHelper, out _))
+        {
+            return false;
+        }
+
+        if (!boundTagHelper.IsComponentTagHelper)
+        {
+            return false;
+        }
+
+        // Check whether the Component must have children
+        if (boundTagHelper.BoundAttributes.Any(attribute =>
+            // Attribute has `EditorRequired` flag
+            attribute is { TypeName: string typeName, IsEditorRequired: true } &&
+
+            // It has type of a `RenderFragment`
+            (typeName == RenderFragmentTypeName || typeName.StartsWith(GenericRenderFragmentTypeName, StringComparison.Ordinal)) &&
+
+            // It is not set or bound as an attribute
+            !markupElementSyntax.TagHelperInfo!.BindingResult.Attributes.Any(a =>
+                a.Key == attribute.Name ||
+                (a.Key.StartsWith("@bind-", StringComparison.Ordinal) && a.Key.AsSpan("@bind-".Length).Equals(attribute.Name, StringComparison.Ordinal))
+            )
+        ))
+        {
+            return false;
+        }
+
+        return true;
+    }
+}

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

@@ -0,0 +1,63 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the MIT license. See License.txt in the project root for license information.
+
+using System.Text.Json;
+using System.Threading;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Razor.Language;
+using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
+using Microsoft.CodeAnalysis.Razor.Formatting;
+using Microsoft.CodeAnalysis.Razor.ProjectSystem;
+using Microsoft.CodeAnalysis.Razor.Protocol;
+using Microsoft.VisualStudio.LanguageServer.Protocol;
+
+namespace Microsoft.CodeAnalysis.Razor.CodeActions.Razor;
+
+internal class SimplifyTagToSelfClosingCodeActionResolver() : IRazorCodeActionResolver
+{
+    public string Action => LanguageServerConstants.CodeActions.SimplifyTagToSelfClosingAction;
+
+    public async Task<WorkspaceEdit?> ResolveAsync(DocumentContext documentContext, JsonElement data, RazorFormattingOptions options, CancellationToken cancellationToken)
+    {
+        if (data.ValueKind == JsonValueKind.Undefined)
+        {
+            return null;
+        }
+
+        var actionParams = JsonSerializer.Deserialize<SimplifyTagToSelfClosingCodeActionParams>(data.GetRawText());
+        if (actionParams is null)
+        {
+            return null;
+        }
+
+        var componentDocument = await documentContext.GetCodeDocumentAsync(cancellationToken).ConfigureAwait(false);
+        if (componentDocument.IsUnsupported())
+        {
+            return null;
+        }
+
+        var text = componentDocument.Source.Text;
+        var removeRange = text.GetRange(actionParams.Start, actionParams.End);
+
+        var documentChanges = new TextDocumentEdit[]
+        {
+            new TextDocumentEdit
+            {
+                TextDocument = new OptionalVersionedTextDocumentIdentifier { Uri = documentContext.Uri },
+                Edits =
+                [
+                    new TextEdit
+                    {
+                        NewText = " />",
+                        Range = removeRange,
+                    }
+                ],
+            }
+        };
+
+        return new WorkspaceEdit
+        {
+            DocumentChanges = documentChanges,
+        };
+    }
+}

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

@@ -43,6 +43,8 @@ public static class CodeActions
 
         public const string ExtractToNewComponentAction = "ExtractToNewComponent";
 
+        public const string SimplifyTagToSelfClosingAction = "SimplifyTagToSelfClosing";
+
         public const string CreateComponentFromTag = "CreateComponentFromTag";
 
         public const string AddUsing = "AddUsing";

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

@@ -211,4 +211,7 @@
   <data name="Unsupported_razor_project_info_version_encountered" xml:space="preserve">
     <value>Unsupported razor project info version encounted.</value>
   </data>
+  <data name="Simplify_Tag_To_SelfClosing_Title" xml:space="preserve">
+    <value>Simplify tag to self-closing</value>
+  </data>
 </root>