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

@@ -40,7 +40,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 CodeActionRequestPriorityInternal RequestPriority => CodeActionRequestPriorityInternal.Normal;
         public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
 
         protected static DiagnosticDescriptor CreateDescriptorWithId(

src/Analyzers/Core/Analyzers/AbstractCodeQualityDiagnosticAnalyzer.cs

@@ -22,7 +22,7 @@ protected AbstractCodeQualityDiagnosticAnalyzer(
             _generatedCodeAnalysisFlags = generatedCodeAnalysisFlags;
         }
 
-        public CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+        public CodeActionRequestPriorityInternal RequestPriority => CodeActionRequestPriorityInternal.Normal;
         public sealed override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; }
 
         public sealed override void Initialize(AnalysisContext context)

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

@@ -35,7 +35,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 CodeActionRequestPriorityInternal RequestPriority => CodeActionRequestPriorityInternal.High;
 
         private void AnalyzeSyntaxTree(SyntaxTreeAnalysisContext context)
         {

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

@@ -59,8 +59,8 @@ 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()
-            => CodeActionRequestPriority.High;
+        private protected override CodeActionRequestPriorityInternal ComputeRequestPriorityInternal()
+            => CodeActionRequestPriorityInternal.High;
 
 #endif
 
@@ -301,7 +301,7 @@ static CodeAction CreateCodeAction(string title, Func<CancellationToken, Task<Do
 #if CODE_STYLE
                 return CodeAction.Create(title, action, equivalenceKey);
 #else
-                return CodeAction.DocumentChangeAction.Create(title, action, equivalenceKey, CodeActionPriority.High);
+                return CodeAction.DocumentChangeAction.Create(title, action, equivalenceKey, CodeActionPriorityInternal.High);
 #endif
             }
         }

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

@@ -30,8 +30,8 @@ public sealed override ImmutableArray<string> FixableDiagnosticIds
         /// 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()
-            => CodeActionRequestPriority.High;
+        private protected override CodeActionRequestPriorityInternal ComputeRequestPriorityInternal()
+            => CodeActionRequestPriorityInternal.High;
 
 #endif
 
@@ -52,7 +52,7 @@ public sealed override Task RegisterCodeFixesAsync(CodeFixContext context)
                         AnalyzersResources.Fix_formatting,
                         c => FixOneAsync(context, diagnostic, c),
                         nameof(AbstractFormattingCodeFixProvider),
-                        CodeActionPriority.High),
+                        CodeActionPriorityInternal.High),
                     diagnostic);
 #endif
             }

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

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

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

@@ -18,13 +18,13 @@ internal sealed class SuggestedActionPriorityProvider : ICodeActionRequestPriori
     /// </summary>
     private readonly ConcurrentSet<DiagnosticAnalyzer> _lowPriorityAnalyzers;
 
-    public SuggestedActionPriorityProvider(CodeActionRequestPriority priority, ConcurrentSet<DiagnosticAnalyzer> lowPriorityAnalyzers)
+    public SuggestedActionPriorityProvider(CodeActionRequestPriorityInternal priority, ConcurrentSet<DiagnosticAnalyzer> lowPriorityAnalyzers)
     {
         Priority = priority;
         _lowPriorityAnalyzers = lowPriorityAnalyzers;
     }
 
-    public CodeActionRequestPriority Priority { get; }
+    public CodeActionRequestPriorityInternal Priority { get; }
 
     public void AddDeprioritizedAnalyzerWithLowPriority(DiagnosticAnalyzer analyzer)
         => _lowPriorityAnalyzers.Add(analyzer);

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

@@ -64,7 +64,7 @@ internal SuggestedAction(
             CodeAction = codeAction;
         }
 
-        internal virtual CodeActionPriority Priority => CodeAction.Priority;
+        internal virtual CodeActionPriorityInternal Priority => CodeAction.PriorityInternal;
 
         public virtual bool TryGetTelemetryId(out Guid telemetryId)
         {

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

@@ -101,13 +101,13 @@ public SuggestedActionsSourceProvider(
                 _threadingContext, _globalOptions, this, textView, textBuffer, _suggestedActionCategoryRegistry, this.OperationListener);
         }
 
-        private static CodeActionRequestPriority? TryGetPriority(string priority)
+        private static CodeActionRequestPriorityInternal? TryGetPriority(string priority)
             => priority switch
             {
-                DefaultOrderings.Highest => CodeActionRequestPriority.High,
-                DefaultOrderings.Default => CodeActionRequestPriority.Normal,
-                DefaultOrderings.Low => CodeActionRequestPriority.Low,
-                DefaultOrderings.Lowest => CodeActionRequestPriority.Lowest,
+                DefaultOrderings.Highest => CodeActionRequestPriorityInternal.High,
+                DefaultOrderings.Default => CodeActionRequestPriorityInternal.Normal,
+                DefaultOrderings.Low => CodeActionRequestPriorityInternal.Low,
+                DefaultOrderings.Lowest => CodeActionRequestPriorityInternal.Lowest,
                 _ => null,
             };
     }

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

@@ -102,7 +102,7 @@ private async Task GetSuggestedActionsWorkerAsync(
                     // items should be pushed higher up, and less important items shouldn't take up that much space.
                     var currentActionCount = 0;
 
-                    var pendingActionSets = new MultiDictionary<CodeActionRequestPriority, SuggestedActionSet>();
+                    var pendingActionSets = new MultiDictionary<CodeActionRequestPriorityInternal, SuggestedActionSet>();
 
                     // Keep track of the diagnostic analyzers that have been deprioritized across calls to the
                     // diagnostic engine.  We'll run them once we get around to the low-priority bucket.  We want to
@@ -113,7 +113,7 @@ private async Task GetSuggestedActionsWorkerAsync(
                     // Collectors are in priority order.  So just walk them from highest to lowest.
                     foreach (var collector in collectors)
                     {
-                        if (TryGetPriority(collector.Priority) is CodeActionRequestPriority priority)
+                        if (TryGetPriority(collector.Priority) is CodeActionRequestPriorityInternal priority)
                         {
                             var allSets = GetCodeFixesAndRefactoringsAsync(
                                 state, requestedActionCategories, document,
@@ -128,10 +128,10 @@ private async Task GetSuggestedActionsWorkerAsync(
                                 // group the set says it wants to be in.
                                 var actualSetPriority = set.Priority switch
                                 {
-                                    SuggestedActionSetPriority.None => CodeActionRequestPriority.Lowest,
-                                    SuggestedActionSetPriority.Low => CodeActionRequestPriority.Low,
-                                    SuggestedActionSetPriority.Medium => CodeActionRequestPriority.Normal,
-                                    SuggestedActionSetPriority.High => CodeActionRequestPriority.High,
+                                    SuggestedActionSetPriority.None => CodeActionRequestPriorityInternal.Lowest,
+                                    SuggestedActionSetPriority.Low => CodeActionRequestPriorityInternal.Low,
+                                    SuggestedActionSetPriority.Medium => CodeActionRequestPriorityInternal.Normal,
+                                    SuggestedActionSetPriority.High => CodeActionRequestPriorityInternal.High,
                                     _ => throw ExceptionUtilities.UnexpectedValue(set.Priority),
                                 };
 
@@ -246,7 +246,7 @@ Task<ImmutableArray<UnifiedSuggestedActionSet>> GetRefactoringsAsync()
 
                     // 'CodeActionRequestPriority.Lowest' is reserved for suppression/configuration code fixes.
                     // No code refactoring should have this request priority.
-                    if (priorityProvider.Priority == CodeActionRequestPriority.Lowest)
+                    if (priorityProvider.Priority == CodeActionRequestPriorityInternal.Lowest)
                         return SpecializedTasks.EmptyImmutableArray<UnifiedSuggestedActionSet>();
 
                     // If we are computing refactorings outside the 'Refactoring' context, i.e. for example, from the lightbulb under a squiggle or selection,
@@ -299,13 +299,13 @@ ISuggestedAction ConvertToSuggestedAction(IUnifiedSuggestedAction unifiedSuggest
                         };
                 }
 
-                static SuggestedActionSetPriority ConvertToSuggestedActionSetPriority(CodeActionPriority priority)
+                static SuggestedActionSetPriority ConvertToSuggestedActionSetPriority(CodeActionPriorityInternal priority)
                     => priority switch
                     {
-                        CodeActionPriority.Lowest => SuggestedActionSetPriority.None,
-                        CodeActionPriority.Low => SuggestedActionSetPriority.Low,
-                        CodeActionPriority.Medium => SuggestedActionSetPriority.Medium,
-                        CodeActionPriority.High => SuggestedActionSetPriority.High,
+                        CodeActionPriorityInternal.Lowest => SuggestedActionSetPriority.None,
+                        CodeActionPriorityInternal.Low => SuggestedActionSetPriority.Low,
+                        CodeActionPriorityInternal.Medium => SuggestedActionSetPriority.Medium,
+                        CodeActionPriorityInternal.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 CodeActionRequestPriorityInternal RequestPriority => CodeActionRequestPriorityInternal.Normal;
 
         public bool OpenFileOnly(SimplifierOptions? options)
             => false;

src/EditorFeatures/Core/RenameTracking/RenameTrackingCodeRefactoringProvider.cs

@@ -47,7 +47,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()
-            => CodeActionRequestPriority.High;
+        private protected override CodeActionRequestPriorityInternal ComputeRequestPriorityInternal()
+            => CodeActionRequestPriorityInternal.High;
     }
 }

src/EditorFeatures/Core/RenameTracking/RenameTrackingTaggerProvider.RenameTrackingCodeAction.cs

@@ -47,7 +47,7 @@ public RenameTrackingCodeAction(
             }
 
             public override string Title => _title;
-            internal override CodeActionPriority Priority => CodeActionPriority.High;
+            internal override CodeActionPriorityInternal PriorityInternal => CodeActionPriorityInternal.High;
 
             protected override Task<IEnumerable<CodeActionOperation>> ComputeOperationsAsync(CancellationToken cancellationToken)
             {

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionOrUserDiagnosticTest.cs

@@ -61,7 +61,7 @@ public sealed class TestParameters
             internal readonly ParseOptions parseOptions;
             internal readonly CompilationOptions compilationOptions;
             internal readonly int index;
-            internal readonly CodeActionPriority? priority;
+            internal readonly CodeActionPriorityInternal? priority;
             internal readonly bool retainNonFixableDiagnostics;
             internal readonly bool includeDiagnosticsOutsideSelection;
             internal readonly bool includeNonLocalDocumentDiagnostics;
@@ -74,7 +74,7 @@ internal TestParameters(
                 OptionsCollection globalOptions = null,
                 object fixProviderData = null,
                 int index = 0,
-                CodeActionPriority? priority = null,
+                CodeActionPriorityInternal? priority = null,
                 bool retainNonFixableDiagnostics = false,
                 bool includeDiagnosticsOutsideSelection = false,
                 string title = null,
@@ -406,7 +406,7 @@ internal Task TestInRegularAndScriptAsync(
             string initialMarkup,
             string expectedMarkup,
             int index = 0,
-            CodeActionPriority? priority = null,
+            CodeActionPriorityInternal? priority = null,
             CompilationOptions compilationOptions = null,
             OptionsCollection options = null,
             OptionsCollection globalOptions = null,
@@ -452,7 +452,7 @@ internal Task TestAsync(
             OptionsCollection options = null,
             OptionsCollection globalOptions = null,
             object fixProviderData = null,
-            CodeActionPriority? priority = null,
+            CodeActionPriorityInternal? priority = null,
             TestHost testHost = TestHost.InProcess)
         {
             return TestAsync(
@@ -779,7 +779,7 @@ internal async Task<ImmutableArray<CodeActionOperation>> VerifyActionAndGetOpera
 
             if (parameters.priority != null)
             {
-                Assert.Equal(parameters.priority.Value, action.Priority);
+                Assert.Equal(parameters.priority.Value, action.PriorityInternal);
             }
 
             if (parameters.title != null)

src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractSuppressionAllCodeTests.cs

@@ -144,7 +144,7 @@ internal class Analyzer : DiagnosticAnalyzer, IBuiltInAnalyzer
             private readonly DiagnosticDescriptor _descriptor =
                 new DiagnosticDescriptor("TestId", "Test", "Test", "Test", DiagnosticSeverity.Warning, isEnabledByDefault: true);
 
-            public CodeActionRequestPriority RequestPriority => CodeActionRequestPriority.Normal;
+            public CodeActionRequestPriorityInternal RequestPriority => CodeActionRequestPriorityInternal.Normal;
 
             public bool OpenFileOnly(SimplifierOptions options) => false;