Group code actions so Razor shows first (#9588)

Author: davidwengier

src/Razor/src/Microsoft.AspNetCore.Razor.LanguageServer/CodeActions/CodeActionEndpoint.cs

@@ -98,12 +98,15 @@ public CodeActionEndpoint(
 
         using var _ = ArrayBuilderPool<SumType<Command, CodeAction>>.GetPooledObject(out var commandsOrCodeActions);
 
-        ConvertCodeActionsToSumType(razorCodeActions);
-        ConvertCodeActionsToSumType(delegatedCodeActions);
+        // Grouping the code actions causes VS to sort them into groups, rather than just alphabetically sorting them
+        // by title. The latter is bad for us because it can put "Remove <div>" at the top in some locales, and our fully
+        // qualify component code action at the bottom, depending on the users namespace.
+        ConvertCodeActionsToSumType(razorCodeActions, "A-Razor");
+        ConvertCodeActionsToSumType(delegatedCodeActions, "B-Delegated");
 
         return commandsOrCodeActions.ToArray();
 
-        void ConvertCodeActionsToSumType(ImmutableArray<RazorVSInternalCodeAction> codeActions)
+        void ConvertCodeActionsToSumType(ImmutableArray<RazorVSInternalCodeAction> codeActions, string groupName)
         {
             // We must cast the RazorCodeAction into a platform compliant code action
             // For VS (SupportsCodeActionResolve = true) this means just encapsulating the RazorCodeAction in the `CommandOrCodeAction` struct
@@ -112,6 +115,8 @@ void ConvertCodeActionsToSumType(ImmutableArray<RazorVSInternalCodeAction> codeA
             {
                 foreach (var action in codeActions)
                 {
+                    // Make sure we honour the grouping that a delegated server may have created
+                    action.Group = groupName + (action.Group ?? string.Empty);
                     commandsOrCodeActions.Add(action);
                 }
             }

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/CodeActions/CodeActionEndpointTest.cs

@@ -478,6 +478,59 @@ public async Task Handle_MultipleMixedProvider_SupportsCodeActionResolveTrue()
             });
     }
 
+    [Fact]
+    public async Task Handle_MixedProvider_SupportsCodeActionResolveTrue_UsesGroups()
+    {
+        // Arrange
+        var documentPath = new Uri("C:/path/to/Page.razor");
+        var codeDocument = CreateCodeDocument("@code {}");
+        var documentContext = CreateDocumentContext(documentPath, codeDocument);
+        var documentMappingService = CreateDocumentMappingService();
+        var languageServer = CreateLanguageServer();
+        var codeActionEndpoint = new CodeActionEndpoint(
+            documentMappingService,
+            new IRazorCodeActionProvider[] {
+                    new MockRazorCodeActionProvider(),
+            },
+            new ICSharpCodeActionProvider[] {
+                    new MockCSharpCodeActionProvider()
+            },
+            Array.Empty<IHtmlCodeActionProvider>(),
+            languageServer,
+            _languageServerFeatureOptions,
+            telemetryReporter: null)
+        {
+            _supportsCodeActionResolve = true
+        };
+
+        var request = new VSCodeActionParams()
+        {
+            TextDocument = new VSTextDocumentIdentifier { Uri = documentPath },
+            Range = new Range { Start = new Position(0, 1), End = new Position(0, 1) },
+            Context = new VSInternalCodeActionContext()
+        };
+        var requestContext = CreateRazorRequestContext(documentContext);
+
+        // Act
+        var commandOrCodeActionContainer = await codeActionEndpoint.HandleRequestAsync(request, requestContext, default);
+
+        // Assert
+        Assert.NotNull(commandOrCodeActionContainer);
+        Assert.Collection(commandOrCodeActionContainer,
+            c =>
+            {
+                Assert.True(c.TryGetSecond(out var codeAction));
+                Assert.True(codeAction is VSInternalCodeAction);
+                Assert.Equal("A-Razor", ((VSInternalCodeAction)codeAction).Group);
+            },
+            c =>
+            {
+                Assert.True(c.TryGetSecond(out var codeAction));
+                Assert.True(codeAction is VSInternalCodeAction);
+                Assert.Equal("B-Delegated", ((VSInternalCodeAction)codeAction).Group);
+            });
+    }
+
     [Fact]
     public async Task Handle_MultipleMixedProvider_SupportsCodeActionResolveFalse()
     {

src/Razor/test/Microsoft.VisualStudio.Razor.IntegrationTests/RazorCodeActionsTests.cs

@@ -1,6 +1,7 @@
 // Copyright (c) .NET Foundation. All rights reserved.
 // Licensed under the MIT license. See License.txt in the project root for license information.
 
+using System.Linq;
 using System.Threading.Tasks;
 using Xunit;
 using Xunit.Abstractions;
@@ -26,7 +27,11 @@ public async Task RazorCodeActions_AddUsing()
         var codeActions = await TestServices.Editor.InvokeCodeActionListAsync(ControlledHangMitigatingCancellationToken);
 
         // Assert
-        var codeActionSet = Assert.Single(codeActions);
+
+        // We expect two groups, one for Razor, one for Html
+        Assert.Equal(2, codeActions.Count());
+        // Razor should be first
+        var codeActionSet = codeActions.First();
         var usingString = $"@using {RazorProjectConstants.BlazorProjectName}.Shared";
         var codeAction = Assert.Single(codeActionSet.Actions, a => a.DisplayText.Equals(usingString));