Ensure low-pri fixes go in the right async lightbulb bucket.

Author: CyrusNajmabadi

src/EditorFeatures/Core.Wpf/Suggestions/AsyncSuggestedActionsSource.cs

@@ -97,6 +97,8 @@ private async Task GetSuggestedActionsWorkerAsync(
                     // items should be pushed higher up, and less important items shouldn't take up that much space.
                     var currentActionCount = 0;
 
+                    using var _ = ArrayBuilder<SuggestedActionSet>.GetInstance(out var lowPrioritySets);
+
                     // Collectors are in priority order.  So just walk them from highest to lowest.
                     foreach (var collector in collectors)
                     {
@@ -122,8 +124,27 @@ private async Task GetSuggestedActionsWorkerAsync(
 
                             await foreach (var set in allSets)
                             {
-                                currentActionCount += set.Actions.Count();
-                                collector.Add(set);
+                                if (priority == CodeActionRequestPriority.High && set.Priority == SuggestedActionSetPriority.Low)
+                                {
+                                    // if we're processing the high pri bucket, but we get action sets for lower pri
+                                    // groups, then keep track of them and add them in later when we get to that group.
+                                    lowPrioritySets.Add(set);
+                                }
+                                else
+                                {
+                                    currentActionCount += set.Actions.Count();
+                                    collector.Add(set);
+                                }
+                            }
+
+                            if (priority == CodeActionRequestPriority.Normal)
+                            {
+                                // now, add any low pri items we've been waiting on to the final group.
+                                foreach (var set in lowPrioritySets)
+                                {
+                                    currentActionCount += set.Actions.Count();
+                                    collector.Add(set);
+                                }
                             }
                         }
 

src/VisualStudio/IntegrationTest/IntegrationTests/CSharp/CSharpCodeActions.cs

@@ -4,8 +4,6 @@
 
 #nullable disable
 
-using System;
-using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.Linq;
 using System.Threading;
@@ -19,7 +17,6 @@
 using Microsoft.VisualStudio.IntegrationTest.Utilities.Input;
 using Roslyn.Test.Utilities;
 using Xunit;
-using Xunit.Abstractions;
 using ProjectUtils = Microsoft.VisualStudio.IntegrationTest.Utilities.Common.ProjectUtils;
 
 namespace Roslyn.VisualStudio.IntegrationTests.CSharp
@@ -574,6 +571,38 @@ static void Main(string[] args)
             VisualStudio.Editor.Verify.TextContains("implicit");
         }
 
+        [WorkItem(57157, "https://github.com/dotnet/roslyn/issues/57157")]
+        [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsAddImport)]
+        public void AddFuzzyUsingAfterGenerateVariable()
+        {
+            SetUpEditor(@"
+namespace X
+{
+    class Formatter
+    {
+    }
+}
+class Program
+{
+    void Main()
+    {
+        $$formatter = new GooFormatter();
+    }
+}
+class GooFormatter
+{
+}");
+
+            VisualStudio.Editor.InvokeCodeActionList();
+            var expectedItems = new[]
+            {
+                "Generate variable 'formatter'",
+                "Formatter - using X;",
+            };
+
+            VisualStudio.Editor.Verify.CodeActions(expectedItems, ensureExpectedItemsAreOrdered: true);
+        }
+
         [WpfFact, Trait(Traits.Feature, Traits.Features.CodeActionsAddImport)]
         public void OrderFixesByCursorProximityLeft()
         {