Use the same codepath for computing light-bulb actions to determine if hte lightbulb shoudl appear at all.

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

@@ -102,13 +102,7 @@ private async Task GetSuggestedActionsWorkerAsync(
                     // Collectors are in priority order.  So just walk them from highest to lowest.
                     foreach (var collector in collectors)
                     {
-                        var priority = collector.Priority switch
-                        {
-                            VisualStudio.Utilities.DefaultOrderings.Highest => CodeActionRequestPriority.High,
-                            VisualStudio.Utilities.DefaultOrderings.Default => CodeActionRequestPriority.Normal,
-                            VisualStudio.Utilities.DefaultOrderings.Lowest => CodeActionRequestPriority.Lowest,
-                            _ => (CodeActionRequestPriority?)null,
-                        };
+                        var priority = TryGetPriority(collector.Priority);
 
                         if (priority != null)
                         {

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

@@ -414,29 +414,45 @@ await InvokeBelowInputPriorityAsync(() =>
                 ReferenceCountedDisposable<State> state,
                 Document document,
                 SnapshotSpan range,
+                CodeActionOptions options,
                 CancellationToken cancellationToken)
             {
-                if (state.Target.Owner._codeFixService != null &&
-                    state.Target.SubjectBuffer.SupportsCodeFixes())
+                foreach (var order in s_orderings)
                 {
-                    var result = await state.Target.Owner._codeFixService.GetMostSevereFixableDiagnosticAsync(
-                            document, range.Span.ToTextSpan(), cancellationToken).ConfigureAwait(false);
+                    var priority = TryGetPriority(order);
+                    Contract.ThrowIfNull(priority);
 
-                    if (result.HasFix)
-                    {
-                        Logger.Log(FunctionId.SuggestedActions_HasSuggestedActionsAsync);
-                        return GetFixCategory(result.Diagnostic.Severity);
-                    }
+                    var result = await GetFixLevelAsync(priority.Value).ConfigureAwait(false);
+                    if (result != null)
+                        return result;
+                }
+
+                return null;
 
-                    if (result.PartialResult)
+                async Task<string?> GetFixLevelAsync(CodeActionRequestPriority priority)
+                {
+                    if (state.Target.Owner._codeFixService != null &&
+                        state.Target.SubjectBuffer.SupportsCodeFixes())
                     {
-                        // reset solution version number so that we can raise suggested action changed event
-                        Volatile.Write(ref state.Target.LastSolutionVersionReported, InvalidSolutionVersion);
-                        return null;
+                        var result = await state.Target.Owner._codeFixService.GetMostSevereFixAsync(
+                            document, range.Span.ToTextSpan(), priority, options, cancellationToken).ConfigureAwait(false);
+
+                        if (result.HasFix)
+                        {
+                            Logger.Log(FunctionId.SuggestedActions_HasSuggestedActionsAsync);
+                            return GetFixCategory(result.CodeFixCollection.FirstDiagnostic.Severity);
+                        }
+
+                        if (!result.UpToDate)
+                        {
+                            // reset solution version number so that we can raise suggested action changed event
+                            Volatile.Write(ref state.Target.LastSolutionVersionReported, InvalidSolutionVersion);
+                            return null;
+                        }
                     }
-                }
 
-                return null;
+                    return null;
+                }
             }
 
             private async Task<string?> TryGetRefactoringSuggestedActionCategoryAsync(
@@ -619,7 +635,7 @@ private void OnSuggestedActionsChanged(Workspace currentWorkspace, DocumentId? c
                 using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                 var linkedToken = linkedTokenSource.Token;
 
-                var errorTask = Task.Run(() => GetFixLevelAsync(state, document, range, linkedToken), linkedToken);
+                var errorTask = Task.Run(() => GetFixLevelAsync(state, document, range, options, linkedToken), linkedToken);
 
                 var selection = await GetSpanAsync(state, range, linkedToken).ConfigureAwait(false);
 

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

@@ -6,18 +6,18 @@
 using System.Collections.Generic;
 using System.Collections.Immutable;
 using System.ComponentModel.Composition;
+using System.Linq;
+using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeFixes;
 using Microsoft.CodeAnalysis.CodeRefactorings;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.Tags;
-using Microsoft.CodeAnalysis.ErrorReporting;
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.CodeAnalysis.Shared.Utilities;
-using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Language.Intellisense;
 using Microsoft.VisualStudio.Text;
 using Microsoft.VisualStudio.Text.Editor;
@@ -37,6 +37,21 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.Suggestions
     [SuggestedActionPriority(DefaultOrderings.Lowest)]
     internal partial class SuggestedActionsSourceProvider : ISuggestedActionsSourceProvider
     {
+        private static readonly ImmutableArray<string> s_orderings = ImmutableArray.Create(
+            DefaultOrderings.Highest,
+            DefaultOrderings.Default,
+            DefaultOrderings.Lowest);
+
+        static SuggestedActionsSourceProvider()
+        {
+            // Ensure that the list of orderings on this type matches the set we expose in s_orderings
+            var attributes = typeof(SuggestedActionsSourceProvider).GetCustomAttributes(inherit: false)
+                .OfType<SuggestedActionPriorityAttribute>()
+                .ToImmutableArray();
+            Contract.ThrowIfFalse(attributes.Length == s_orderings.Length);
+            Contract.ThrowIfFalse(attributes.Select(a => a.Priority).SetEquals(s_orderings));
+        }
+
         private static readonly Guid s_CSharpSourceGuid = new Guid("b967fea8-e2c3-4984-87d4-71a38f49e16a");
         private static readonly Guid s_visualBasicSourceGuid = new Guid("4de30e93-3e0c-40c2-a4ba-1124da4539f6");
         private static readonly Guid s_xamlSourceGuid = new Guid("a0572245-2eab-4c39-9f61-06a6d8c5ddda");
@@ -100,5 +115,14 @@ public SuggestedActionsSourceProvider(
                 ? new AsyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry)
                 : new SyncSuggestedActionsSource(_threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry);
         }
+
+        private static CodeActionRequestPriority? TryGetPriority(string priority)
+            => priority switch
+            {
+                DefaultOrderings.Highest => CodeActionRequestPriority.High,
+                DefaultOrderings.Default => CodeActionRequestPriority.Normal,
+                DefaultOrderings.Lowest => CodeActionRequestPriority.Lowest,
+                _ => (CodeActionRequestPriority?)null,
+            };
     }
 }

src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs

@@ -60,7 +60,8 @@ public async Task TestGetFirstDiagnosticWithFixAsync()
             var reference = new MockAnalyzerReference();
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
             var document = project.Documents.Single();
-            var unused = await fixService.GetMostSevereFixableDiagnosticAsync(document, TextSpan.FromBounds(0, 0), cancellationToken: CancellationToken.None);
+            var unused = await fixService.GetMostSevereFixAsync(
+                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, CodeActionOptions.Default, CancellationToken.None);
 
             var fixer1 = (MockFixer)fixers.Single().Value;
             var fixer2 = (MockFixer)reference.Fixer!;
@@ -297,7 +298,8 @@ private static async Task GetFirstDiagnosticWithFixWithExceptionValidationAsync(
             errorReportingService.OnError = message => errorReported = true;
 
             GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager);
-            var unused = await tuple.codeFixService.GetMostSevereFixableDiagnosticAsync(document, TextSpan.FromBounds(0, 0), cancellationToken: CancellationToken.None);
+            var unused = await tuple.codeFixService.GetMostSevereFixAsync(
+                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, CodeActionOptions.Default, CancellationToken.None);
             Assert.True(extensionManager.IsDisabled(codefix));
             Assert.False(extensionManager.IsIgnored(codefix));
             Assert.True(errorReported);