Add 'priority' concept to our code actions, and code refactoring/fix providers.

src/Analyzers/CSharp/CodeFixes/RemoveUnreachableCode/CSharpRemoveUnreachableCodeCodeFixProvider.cs

@@ -40,7 +40,7 @@ public override Task RegisterCodeFixesAsync(CodeFixContext context)
             // helpful, but shouldn't interfere with anything else the uesr is doing.
             var priority = IsSubsequentSection(diagnostic)
                 ? CodeActionPriority.Low
-                : CodeActionPriority.Medium;
+                : CodeActionPriority.Default;
 
             RegisterCodeFix(context, CSharpCodeFixesResources.Remove_unreachable_code, nameof(CSharpCodeFixesResources.Remove_unreachable_code), priority);
 

src/Analyzers/CSharp/CodeFixes/UseExpressionBody/UseExpressionBodyCodeFixProvider.cs

@@ -44,7 +44,7 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
 
             var priority = diagnostic.Severity == DiagnosticSeverity.Hidden
                 ? CodeActionPriority.Low
-                : CodeActionPriority.Medium;
+                : CodeActionPriority.Default;
 
             var title = diagnostic.GetMessage();
 

src/Analyzers/Core/Analyzers/AbstractBuiltInCodeStyleDiagnosticAnalyzer_Core.cs

@@ -5,7 +5,6 @@
 using System.Collections.Immutable;
 using System.Diagnostics;
 using System.Linq;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace Microsoft.CodeAnalysis.CodeStyle
@@ -40,7 +39,7 @@ protected AbstractBuiltInCodeStyleDiagnosticAnalyzer(ImmutableArray<DiagnosticDe
             Debug.Assert(!supportedDiagnostics.Any(descriptor => descriptor.CustomTags.Any(t => t == WellKnownDiagnosticTags.Unnecessary)) || this is AbstractBuiltInUnnecessaryCodeStyleDiagnosticAnalyzer);
         }
 
-        public virtual CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+        public virtual bool IsHighPriority => false;
         public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
 
         protected static DiagnosticDescriptor CreateDescriptorWithId(

src/Analyzers/Core/Analyzers/AbstractCodeQualityDiagnosticAnalyzer.cs

@@ -3,7 +3,6 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Immutable;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Simplification;
@@ -22,7 +21,7 @@ protected AbstractCodeQualityDiagnosticAnalyzer(
             _generatedCodeAnalysisFlags = generatedCodeAnalysisFlags;
         }
 
-        public CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+        public bool IsHighPriority => false;
         public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
 
         public sealed override void Initialize(AnalysisContext context)

src/Analyzers/Core/Analyzers/Formatting/AbstractFormattingAnalyzer.cs

@@ -2,8 +2,6 @@
 // The .NET Foundation licenses this file to you under the MIT license.
 // See the LICENSE file in the project root for more information.
 
-using System.Collections.Immutable;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
 
@@ -35,7 +33,7 @@ protected sealed override void InitializeWorker(AnalysisContext context)
         /// them acting on an error reported in code, and can be computed fast as it only uses syntax not semantics.
         /// It's also the 8th most common fix that people use, and is picked almost all the times it is shown.
         /// </summary>
-        public override CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.High;
+        public override bool IsHighPriority => true;
 
         private void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context)
         {

src/Analyzers/Core/Analyzers/SimplifyTypeNames/SimplifyTypeNamesDiagnosticAnalyzerBase.cs

@@ -11,7 +11,6 @@
 using System.Linq;
 using System.Runtime.CompilerServices;
 using System.Threading;
-using Microsoft.CodeAnalysis.CodeActions;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Options;

src/Analyzers/Core/CodeFixes/AddAccessibilityModifiers/AbstractAddAccessibilityModifiersCodeFixProvider.cs

@@ -29,7 +29,7 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
 
             var priority = diagnostic.Severity == DiagnosticSeverity.Hidden
                 ? CodeActionPriority.Low
-                : CodeActionPriority.Medium;
+                : CodeActionPriority.Default;
 
             var (title, key) = diagnostic.Properties.ContainsKey(AddAccessibilityModifiersConstants.ModifiersAdded)
                 ? (AnalyzersResources.Add_accessibility_modifiers, nameof(AnalyzersResources.Add_accessibility_modifiers))

src/Analyzers/Core/CodeFixes/ConflictMarkerResolution/AbstractConflictMarkerCodeFixProvider.cs

@@ -45,12 +45,15 @@ protected AbstractResolveConflictMarkerCodeFixProvider(
         {
             FixableDiagnosticIds = ImmutableArray.Create(diagnosticId);
             _syntaxKinds = syntaxKinds;
+
+#if !CODE_STYLE
+            // Backdoor that allows this provider to use the high-priority bucket.
+            this.CustomTags = this.CustomTags.Add(CodeAction.CanBeHighPriorityTag);
+#endif
         }
 
         public override ImmutableArray<string> FixableDiagnosticIds { get; }
 
-#if !CODE_STYLE
-
         /// <summary>
         /// 'Fix merge conflict markers' gets special privileges.  A core user scenario around them is that a user does
         /// a source control merge, gets conflicts, and then wants to open and edit them in the IDE very quickly.
@@ -59,11 +62,9 @@ protected AbstractResolveConflictMarkerCodeFixProvider(
         /// them if they bring up the lightbulb on a <c>&lt;&lt;&lt;&lt;&lt;&lt;&lt;</c> line, it should run ahead of
         /// normal fix providers else so the user can quickly fix the conflict and move onto the next conflict.
         /// </summary>
-        private protected override CodeActionRequestPriority ComputeRequestPriority()
+        protected override CodeActionRequestPriority ComputeRequestPriority()
             => CodeActionRequestPriority.High;
 
-#endif
-
         public override async Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             var cancellationToken = context.CancellationToken;
@@ -298,11 +299,14 @@ private static void RegisterCodeFixes(
 
             static CodeAction CreateCodeAction(string title, Func<CancellationToken, Task<Document>> action, string equivalenceKey)
             {
-#if CODE_STYLE
-                return CodeAction.Create(title, action, equivalenceKey);
-#else
-                return CodeAction.DocumentChangeAction.Create(title, action, equivalenceKey, CodeActionPriority.High);
+                var codeAction = CodeAction.Create(title, action, equivalenceKey, CodeActionPriority.High);
+
+#if !CODE_STYLE
+                // Backdoor that allows this provider to use the high-priority bucket.
+                codeAction.CustomTags = codeAction.CustomTags.Add(CodeAction.CanBeHighPriorityTag);
 #endif
+
+                return codeAction;
             }
         }
 

src/Analyzers/Core/CodeFixes/Formatting/FormattingCodeFixProvider.cs

@@ -18,43 +18,43 @@ namespace Microsoft.CodeAnalysis.CodeStyle
 {
     internal abstract class AbstractFormattingCodeFixProvider : SyntaxEditorBasedCodeFixProvider
     {
+        protected AbstractFormattingCodeFixProvider()
+        {
+#if !CODE_STYLE
+            // Backdoor that allows this provider to use the high-priority bucket.
+            this.CustomTags = this.CustomTags.Add(CodeAction.CanBeHighPriorityTag);
+#endif
+        }
+
         public sealed override ImmutableArray<string> FixableDiagnosticIds
             => ImmutableArray.Create(IDEDiagnosticIds.FormattingDiagnosticId);
 
         protected abstract ISyntaxFormatting SyntaxFormatting { get; }
 
-#if !CODE_STYLE
-
         /// <summary>
         /// Fixing formatting is high priority.  It's something the user wants to be able to fix quickly, is driven by
         /// them acting on an error reported in code, and can be computed fast as it only uses syntax not semantics.
         /// It's also the 8th most common fix that people use, and is picked almost all the times it is shown.
         /// </summary>
-        private protected override CodeActionRequestPriority ComputeRequestPriority()
+        protected override CodeActionRequestPriority ComputeRequestPriority()
             => CodeActionRequestPriority.High;
 
-#endif
-
         public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
         {
             foreach (var diagnostic in context.Diagnostics)
             {
-#if CODE_STYLE
-                context.RegisterCodeFix(
-                    CodeAction.Create(
-                        AnalyzersResources.Fix_formatting,
-                        c => FixOneAsync(context, diagnostic, c),
-                        nameof(AbstractFormattingCodeFixProvider)),
-                    diagnostic);
-#else
-                context.RegisterCodeFix(
-                    CodeAction.DocumentChangeAction.Create(
-                        AnalyzersResources.Fix_formatting,
-                        c => FixOneAsync(context, diagnostic, c),
-                        nameof(AbstractFormattingCodeFixProvider),
-                        CodeActionPriority.High),
-                    diagnostic);
+                var codeAction = CodeAction.Create(
+                    AnalyzersResources.Fix_formatting,
+                    c => FixOneAsync(context, diagnostic, c),
+                    nameof(AbstractFormattingCodeFixProvider),
+                    CodeActionPriority.High);
+
+#if !CODE_STYLE
+                // Backdoor that allows this provider to use the high-priority bucket.
+                codeAction.CustomTags = codeAction.CustomTags.Add(CodeAction.CanBeHighPriorityTag);
 #endif
+
+                context.RegisterCodeFix(codeAction, diagnostic);
             }
 
             return Task.CompletedTask;

src/EditorFeatures/CSharpTest/Diagnostics/DiagnosticAnalyzerDriver/DiagnosticAnalyzerDriverTests.cs

@@ -186,7 +186,7 @@ private static void AccessSupportedDiagnostics(DiagnosticAnalyzer analyzer)
 
         private class ThrowingDoNotCatchDiagnosticAnalyzer<TLanguageKindEnum> : ThrowingDiagnosticAnalyzer<TLanguageKindEnum>, IBuiltInAnalyzer where TLanguageKindEnum : struct
         {
-            public CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+            public bool IsHighPriority => false;
 
             public bool OpenFileOnly(SimplifierOptions? options) => false;
 

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

@@ -8,27 +8,20 @@
 
 namespace Microsoft.CodeAnalysis.Editor.Implementation.Suggestions;
 
-internal sealed class SuggestedActionPriorityProvider : ICodeActionRequestPriorityProvider
+/// <param name="lowPriorityAnalyzers">
+/// Set of de-prioritized analyzers that were moved down from 'Normal' to 'Low' priority bucket. Note that this set is
+/// owned by the <see cref="SuggestedActionsSourceProvider.SuggestedActionsSource"/> and shared across priority buckets.
+/// </param>
+internal sealed class SuggestedActionPriorityProvider(
+    CodeActionRequestPriority priority,
+    ConcurrentSet<DiagnosticAnalyzer> lowPriorityAnalyzers)
+    : ICodeActionRequestPriorityProvider
 {
-    /// <summary>
-    /// Set of de-prioritized analyzers that were moved down from 'Normal' to 'Low'
-    /// priority bucket.
-    /// Note that this set is owned by the <see cref="SuggestedActionsSourceProvider.SuggestedActionsSource"/>
-    /// and shared across priority buckets.
-    /// </summary>
-    private readonly ConcurrentSet<DiagnosticAnalyzer> _lowPriorityAnalyzers;
-
-    public SuggestedActionPriorityProvider(CodeActionRequestPriority priority, ConcurrentSet<DiagnosticAnalyzer> lowPriorityAnalyzers)
-    {
-        Priority = priority;
-        _lowPriorityAnalyzers = lowPriorityAnalyzers;
-    }
-
-    public CodeActionRequestPriority Priority { get; }
+    public CodeActionRequestPriority? Priority { get; } = priority;
 
     public void AddDeprioritizedAnalyzerWithLowPriority(DiagnosticAnalyzer analyzer)
-        => _lowPriorityAnalyzers.Add(analyzer);
+        => lowPriorityAnalyzers.Add(analyzer);
 
     public bool IsDeprioritizedAnalyzerWithLowPriority(DiagnosticAnalyzer analyzer)
-        => _lowPriorityAnalyzers.Contains(analyzer);
+        => lowPriorityAnalyzers.Contains(analyzer);
 }

src/EditorFeatures/Core.Wpf/Suggestions/SuggestedActions/SuggestedAction.cs

@@ -65,8 +65,6 @@ internal SuggestedAction(
             CodeAction = codeAction;
         }
 
-        internal virtual CodeActionPriority Priority => CodeAction.Priority;
-
         public virtual bool TryGetTelemetryId(out Guid telemetryId)
         {
             telemetryId = CodeAction.GetTelemetryId();

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

@@ -105,7 +105,7 @@ public SuggestedActionsSourceProvider(
             => priority switch
             {
                 DefaultOrderings.Highest => CodeActionRequestPriority.High,
-                DefaultOrderings.Default => CodeActionRequestPriority.Normal,
+                DefaultOrderings.Default => CodeActionRequestPriority.Default,
                 DefaultOrderings.Low => CodeActionRequestPriority.Low,
                 DefaultOrderings.Lowest => CodeActionRequestPriority.Lowest,
                 _ => null,

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

@@ -137,7 +137,7 @@ private async Task GetSuggestedActionsWorkerAsync(
                                     {
                                         SuggestedActionSetPriority.None => CodeActionRequestPriority.Lowest,
                                         SuggestedActionSetPriority.Low => CodeActionRequestPriority.Low,
-                                        SuggestedActionSetPriority.Medium => CodeActionRequestPriority.Normal,
+                                        SuggestedActionSetPriority.Medium => CodeActionRequestPriority.Default,
                                         SuggestedActionSetPriority.High => CodeActionRequestPriority.High,
                                         _ => throw ExceptionUtilities.UnexpectedValue(set.Priority),
                                     };
@@ -233,7 +233,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
 
                 async Task<ImmutableArray<UnifiedSuggestedActionSet>> GetCodeFixesAsync()
                 {
-                    using var _ = TelemetryLogging.LogBlockTimeAggregated(FunctionId.SuggestedAction_Summary, $"Total.Pri{(int)priorityProvider.Priority}.{nameof(GetCodeFixesAsync)}");
+                    using var _ = TelemetryLogging.LogBlockTimeAggregated(FunctionId.SuggestedAction_Summary, $"Total.Pri{priorityProvider.Priority.GetPriorityInt()}.{nameof(GetCodeFixesAsync)}");
 
                     if (owner._codeFixService == null ||
                         !supportsFeatureService.SupportsCodeFixes(target.SubjectBuffer) ||
@@ -249,7 +249,7 @@ async Task<ImmutableArray<UnifiedSuggestedActionSet>> GetCodeFixesAsync()
 
                 async Task<ImmutableArray<UnifiedSuggestedActionSet>> GetRefactoringsAsync()
                 {
-                    using var _ = TelemetryLogging.LogBlockTimeAggregated(FunctionId.SuggestedAction_Summary, $"Total.Pri{(int)priorityProvider.Priority}.{nameof(GetRefactoringsAsync)}");
+                    using var _ = TelemetryLogging.LogBlockTimeAggregated(FunctionId.SuggestedAction_Summary, $"Total.Pri{priorityProvider.Priority.GetPriorityInt()}.{nameof(GetRefactoringsAsync)}");
 
                     if (!selection.HasValue)
                     {
@@ -325,7 +325,7 @@ static SuggestedActionSetPriority ConvertToSuggestedActionSetPriority(CodeAction
                     {
                         CodeActionPriority.Lowest => SuggestedActionSetPriority.None,
                         CodeActionPriority.Low => SuggestedActionSetPriority.Low,
-                        CodeActionPriority.Medium => SuggestedActionSetPriority.Medium,
+                        CodeActionPriority.Default => SuggestedActionSetPriority.Medium,
                         CodeActionPriority.High => SuggestedActionSetPriority.High,
                         _ => throw ExceptionUtilities.Unreachable(),
                     };

src/EditorFeatures/Core/EditAndContinue/EditAndContinueDiagnosticAnalyzer.cs

@@ -31,7 +31,7 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
         public DiagnosticAnalyzerCategory GetAnalyzerCategory()
             => DiagnosticAnalyzerCategory.SemanticDocumentAnalysis;
 
-        public CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+        public bool IsHighPriority => false;
 
         public bool OpenFileOnly(SimplifierOptions? options)
             => false;

src/EditorFeatures/Core/RenameTracking/RenameTrackingCodeRefactoringProvider.cs

@@ -14,14 +14,23 @@ namespace Microsoft.CodeAnalysis.Editor.Implementation.RenameTracking
 {
     [ExportCodeRefactoringProvider(LanguageNames.CSharp, LanguageNames.VisualBasic,
         Name = PredefinedCodeRefactoringProviderNames.RenameTracking), Shared]
-    [method: ImportingConstructor]
-    [method: SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
-    internal class RenameTrackingCodeRefactoringProvider(
-        ITextUndoHistoryRegistry undoHistoryRegistry,
-        [ImportMany] IEnumerable<IRefactorNotifyService> refactorNotifyServices) : CodeRefactoringProvider
+    internal class RenameTrackingCodeRefactoringProvider : CodeRefactoringProvider
     {
-        private readonly ITextUndoHistoryRegistry _undoHistoryRegistry = undoHistoryRegistry;
-        private readonly IEnumerable<IRefactorNotifyService> _refactorNotifyServices = refactorNotifyServices;
+        private readonly ITextUndoHistoryRegistry _undoHistoryRegistry;
+        private readonly IEnumerable<IRefactorNotifyService> _refactorNotifyServices;
+
+        [ImportingConstructor]
+        [SuppressMessage("RoslynDiagnosticsReliability", "RS0033:Importing constructor should be [Obsolete]", Justification = "Used in test code: https://github.com/dotnet/roslyn/issues/42814")]
+        public RenameTrackingCodeRefactoringProvider(
+            ITextUndoHistoryRegistry undoHistoryRegistry,
+            [ImportMany] IEnumerable<IRefactorNotifyService> refactorNotifyServices)
+        {
+            _undoHistoryRegistry = undoHistoryRegistry;
+            _refactorNotifyServices = refactorNotifyServices;
+
+            // Backdoor that allows this provider to use the high-priority bucket.
+            this.CustomTags = this.CustomTags.Add(CodeAction.CanBeHighPriorityTag);
+        }
 
         public override Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         {
@@ -41,7 +50,7 @@ public override Task ComputeRefactoringsAsync(CodeRefactoringContext context)
         /// change the name of something and pop up the lightbulb without having to wait for the rest to
         /// compute.
         /// </summary>
-        private protected override CodeActionRequestPriority ComputeRequestPriority()
+        protected override CodeActionRequestPriority ComputeRequestPriority()
             => CodeActionRequestPriority.High;
     }
 }