Allow code actions to retrieve options for any language

src/EditorFeatures/CSharpTest/Diagnostics/Suppression/SuppressionTests.cs

@@ -468,7 +468,7 @@ void Method()
                     Assert.Equal(2, diagnostics.Where(d => d.Id == "CS0219").Count());
 
                     var options = CodeActionOptions.Default;
-                    var allFixes = (await fixService.GetFixesAsync(document, span, options, CancellationToken.None))
+                    var allFixes = (await fixService.GetFixesAsync(document, span, _ => options, CancellationToken.None))
                         .SelectMany(fixCollection => fixCollection.Fixes);
 
                     var cs0219Fixes = allFixes.Where(fix => fix.PrimaryDiagnostic.Id == "CS0219").ToArray();

src/EditorFeatures/CSharpTest/Formatting/CodeCleanupTests.cs

@@ -659,7 +659,7 @@ private protected static async Task AssertCodeCleanupResult(string expected, str
             var enabledDiagnostics = codeCleanupService.GetAllDiagnostics();
 
             var newDoc = await codeCleanupService.CleanupAsync(
-                document, enabledDiagnostics, new ProgressTracker(), options, formattingOptions, CancellationToken.None);
+                document, enabledDiagnostics, new ProgressTracker(), _ => options, formattingOptions, CancellationToken.None);
 
             var actual = await newDoc.GetTextAsync();
 

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

@@ -162,7 +162,7 @@ private async IAsyncEnumerable<SuggestedActionSet> GetCodeFixesAndRefactoringsAs
                 var workspace = document.Project.Solution.Workspace;
                 var supportsFeatureService = workspace.Services.GetRequiredService<ITextBufferSupportsFeatureService>();
 
-                var options = GlobalOptions.GetCodeActionOptions(document.Project.Language);
+                var options = GlobalOptions.GetCodeActionOptionsProvider();
 
                 var fixesTask = GetCodeFixesAsync(
                     state, supportsFeatureService, requestedActionCategories, workspace, document, range,

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

@@ -177,7 +177,7 @@ public bool TryGetTelemetryId(out Guid telemetryId)
                     Func<string, IDisposable?> addOperationScope =
                         description => operationContext?.AddScope(allowCancellation: true, string.Format(EditorFeaturesResources.Gathering_Suggestions_0, description));
 
-                    var options = GlobalOptions.GetBlockingCodeActionOptions(document.Project.Language);
+                    var options = GlobalOptions.GetBlockingCodeActionOptionsProvider();
 
                     // We convert the code fixes and refactorings to UnifiedSuggestedActionSets instead of
                     // SuggestedActionSets so that we can share logic between local Roslyn and LSP.
@@ -266,7 +266,7 @@ protected static Task<ImmutableArray<UnifiedSuggestedActionSet>> GetCodeFixesAsy
                 SnapshotSpan range,
                 Func<string, IDisposable?> addOperationScope,
                 CodeActionRequestPriority priority,
-                CodeActionOptions options,
+                CodeActionOptionsProvider options,
                 CancellationToken cancellationToken)
             {
                 if (state.Target.Owner._codeFixService == null ||
@@ -306,7 +306,7 @@ protected static Task<ImmutableArray<UnifiedSuggestedActionSet>> GetRefactorings
                 TextSpan? selection,
                 Func<string, IDisposable?> addOperationScope,
                 CodeActionRequestPriority priority,
-                CodeActionOptions options,
+                CodeActionOptionsProvider options,
                 CancellationToken cancellationToken)
             {
                 if (!selection.HasValue)
@@ -414,7 +414,7 @@ await InvokeBelowInputPriorityAsync(() =>
                 ReferenceCountedDisposable<State> state,
                 Document document,
                 SnapshotSpan range,
-                CodeActionOptions options,
+                CodeActionOptionsProvider options,
                 CancellationToken cancellationToken)
             {
                 foreach (var order in Orderings)
@@ -458,7 +458,7 @@ await InvokeBelowInputPriorityAsync(() =>
             private async Task<string?> TryGetRefactoringSuggestedActionCategoryAsync(
                 Document document,
                 TextSpan? selection,
-                CodeActionOptions options,
+                CodeActionOptionsProvider options,
                 CancellationToken cancellationToken)
             {
                 using var state = _state.TryAddReference();
@@ -630,7 +630,7 @@ private void OnSuggestedActionsChanged(Workspace currentWorkspace, DocumentId? c
                 if (document == null)
                     return null;
 
-                var options = GlobalOptions.GetCodeActionOptions(document.Project.Language);
+                var options = GlobalOptions.GetCodeActionOptionsProvider();
 
                 using var linkedTokenSource = CancellationTokenSource.CreateLinkedTokenSource(cancellationToken);
                 var linkedToken = linkedTokenSource.Token;

src/EditorFeatures/Core/CodeActions/CodeActionOptionsStorage.cs

@@ -32,5 +32,11 @@ internal static CodeActionOptionsProvider GetCodeActionOptionsProvider(this IGlo
             var cache = ImmutableDictionary<string, CodeActionOptions>.Empty;
             return language => ImmutableInterlocked.GetOrAdd(ref cache, language, (language, options) => GetCodeActionOptions(options, language), globalOptions);
         }
+
+        internal static CodeActionOptionsProvider GetBlockingCodeActionOptionsProvider(this IGlobalOptionService globalOptions)
+        {
+            var cache = ImmutableDictionary<string, CodeActionOptions>.Empty;
+            return language => ImmutableInterlocked.GetOrAdd(ref cache, language, (language, options) => GetBlockingCodeActionOptions(options, language), globalOptions);
+        }
     }
 }

src/EditorFeatures/Core/LanguageServer/Handlers/CodeActions/CodeActionHelpers.cs

@@ -35,7 +35,7 @@ public static async Task<VSInternalCodeAction[]> GetVSCodeActionsAsync(
             CodeActionParams request,
             CodeActionsCache codeActionsCache,
             Document document,
-            CodeActionOptions options,
+            CodeActionOptionsProvider options,
             ICodeFixService codeFixService,
             ICodeRefactoringService codeRefactoringService,
             CancellationToken cancellationToken)
@@ -186,7 +186,7 @@ public static async Task<ImmutableArray<CodeAction>> GetCodeActionsAsync(
             CodeActionsCache codeActionsCache,
             Document document,
             LSP.Range selection,
-            CodeActionOptions options,
+            CodeActionOptionsProvider options,
             ICodeFixService codeFixService,
             ICodeRefactoringService codeRefactoringService,
             CancellationToken cancellationToken)
@@ -242,7 +242,7 @@ private static CodeAction GetNestedActionsFromActionSet(IUnifiedSuggestedAction
 
         private static async ValueTask<ImmutableArray<UnifiedSuggestedActionSet>> GetActionSetsAsync(
             Document document,
-            CodeActionOptions options,
+            CodeActionOptionsProvider options,
             ICodeFixService codeFixService,
             ICodeRefactoringService codeRefactoringService,
             LSP.Range selection,

src/EditorFeatures/Core/LanguageServer/Handlers/CodeActions/CodeActionResolveHandler.cs

@@ -66,7 +66,7 @@ public CodeActionResolveHandler(
             var data = ((JToken)codeAction.Data!).ToObject<CodeActionResolveData>();
             Assumes.Present(data);
 
-            var options = _globalOptions.GetCodeActionOptions(document.Project.Language);
+            var options = _globalOptions.GetCodeActionOptionsProvider();
 
             var codeActions = await CodeActionHelpers.GetCodeActionsAsync(
                 _codeActionsCache,

src/EditorFeatures/Core/LanguageServer/Handlers/CodeActions/CodeActionsHandler.cs

@@ -57,7 +57,7 @@ public CodeActionsHandler(
             var document = context.Document;
             Contract.ThrowIfNull(document);
 
-            var options = _globalOptions.GetCodeActionOptions(document.Project.Language);
+            var options = _globalOptions.GetCodeActionOptionsProvider();
 
             var codeActions = await CodeActionHelpers.GetVSCodeActionsAsync(
                 request, _codeActionsCache, document, options, _codeFixService, _codeRefactoringService, cancellationToken).ConfigureAwait(false);

src/EditorFeatures/Core/LanguageServer/Handlers/CodeActions/RunCodeActionHandler.cs

@@ -74,7 +74,7 @@ public override async Task<object> HandleRequestAsync(LSP.ExecuteCommandParams r
             var runRequest = ((JToken)request.Arguments.Single()).ToObject<CodeActionResolveData>();
             Assumes.Present(runRequest);
 
-            var options = _globalOptions.GetCodeActionOptions(document.Project.Language);
+            var options = _globalOptions.GetCodeActionOptionsProvider();
 
             var codeActions = await CodeActionHelpers.GetCodeActionsAsync(
                 _codeActionsCache, document, runRequest.Range, options, _codeFixService, _codeRefactoringService, cancellationToken).ConfigureAwait(false);

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/AbstractCodeActionTest.cs

@@ -56,7 +56,7 @@ internal async Task<CodeRefactoring> GetCodeRefactoringAsync(
             var span = documentsWithSelections.Single().SelectedSpans.Single();
             var actions = ArrayBuilder<(CodeAction, TextSpan?)>.GetInstance();
             var document = workspace.CurrentSolution.GetDocument(documentsWithSelections.Single().Id);
-            var context = new CodeRefactoringContext(document, span, (a, t) => actions.Add((a, t)), parameters.codeActionOptions, CancellationToken.None);
+            var context = new CodeRefactoringContext(document, span, (a, t) => actions.Add((a, t)), _ => parameters.codeActionOptions, CancellationToken.None);
             await provider.ComputeRefactoringsAsync(context);
 
             var result = actions.Count > 0 ? new CodeRefactoring(provider, actions.ToImmutable()) : null;

src/EditorFeatures/DiagnosticsTestUtilities/CodeActions/CSharpCodeFixVerifier`2+Test.cs

@@ -109,7 +109,7 @@ protected override AnalyzerOptions GetAnalyzerOptions(Project project)
                 => new WorkspaceAnalyzerOptions(base.GetAnalyzerOptions(project), project.Solution, _sharedState.IdeAnalyzerOptions);
 
             protected override CodeFixContext CreateCodeFixContext(Document document, TextSpan span, ImmutableArray<Diagnostic> diagnostics, Action<CodeAction, ImmutableArray<Diagnostic>> registerCodeFix, CancellationToken cancellationToken)
-                => new(document, span, diagnostics, registerCodeFix, _sharedState.CodeActionOptions, cancellationToken);
+                => new(document, span, diagnostics, registerCodeFix, _ => _sharedState.CodeActionOptions, cancellationToken);
 
             protected override FixAllContext CreateFixAllContext(
                 Document? document,

src/EditorFeatures/DiagnosticsTestUtilities/Diagnostics/AbstractUserDiagnosticTest.cs

@@ -210,7 +210,7 @@ protected static Document GetDocumentAndAnnotatedSpan(TestWorkspace workspace, o
                     diagnostic.Location.SourceSpan,
                     ImmutableArray.Create(diagnostic),
                     (a, d) => fixes.Add(new CodeFix(document.Project, a, d)),
-                    options,
+                    _ => options,
                     CancellationToken.None);
 
                 await fixer.RegisterCodeFixesAsync(context);

src/EditorFeatures/Test/CodeFixes/CodeFixServiceTests.cs

@@ -62,7 +62,7 @@ public async Task TestGetFirstDiagnosticWithFixAsync()
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
             var document = project.Documents.Single();
             var unused = await fixService.GetMostSevereFixAsync(
-                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, CodeActionOptions.Default, CancellationToken.None);
+                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, _ => CodeActionOptions.Default, CancellationToken.None);
 
             var fixer1 = (MockFixer)fixers.Single().Value;
             var fixer2 = (MockFixer)reference.Fixer!;
@@ -91,7 +91,7 @@ public async Task TestGetFixesAsyncWithDuplicateDiagnostics()
             // Verify that we do not crash when computing fixes.
             var options = CodeActionOptions.Default;
 
-            _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
 
             // Verify that code fix is invoked with both the diagnostics in the context,
             // i.e. duplicate diagnostics are not silently discarded by the CodeFixService.
@@ -118,7 +118,7 @@ public async Task TestGetFixesAsyncHasNoDuplicateConfigurationActions()
 
             // Verify registered configuration code actions do not have duplicates.
             var options = CodeActionOptions.Default;
-            var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            var fixCollections = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
             var codeActions = fixCollections.SelectMany(c => c.Fixes.Select(f => f.Action)).ToImmutableArray();
             Assert.Equal(7, codeActions.Length);
             var uniqueTitles = new HashSet<string>();
@@ -152,14 +152,14 @@ public async Task TestGetFixesAsyncForFixableAndNonFixableAnalyzersAsync()
 
             // Verify only analyzerWithFix is executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Normal'.
             _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
-                priority: CodeActionRequestPriority.Normal, options,
+                priority: CodeActionRequestPriority.Normal, _ => options,
                 addOperationScope: _ => null, cancellationToken: CancellationToken.None);
             Assert.True(analyzerWithFix.ReceivedCallback);
             Assert.False(analyzerWithoutFix.ReceivedCallback);
 
             // Verify both analyzerWithFix and analyzerWithoutFix are executed when GetFixesAsync is invoked with 'CodeActionRequestPriority.Lowest'.
             _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
-                priority: CodeActionRequestPriority.Lowest, options,
+                priority: CodeActionRequestPriority.Lowest, _ => options,
                 addOperationScope: _ => null, cancellationToken: CancellationToken.None);
             Assert.True(analyzerWithFix.ReceivedCallback);
             Assert.True(analyzerWithoutFix.ReceivedCallback);
@@ -190,7 +190,7 @@ public async Task TestGetFixesAsyncForDocumentDiagnosticAnalyzerAsync()
             var options = CodeActionOptions.Default;
 
             _ = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0),
-                priority: CodeActionRequestPriority.Normal, options,
+                priority: CodeActionRequestPriority.Normal, _ => options,
                 addOperationScope: _ => null, cancellationToken: CancellationToken.None);
             Assert.True(documentDiagnosticAnalyzer.ReceivedCallback);
         }
@@ -275,7 +275,7 @@ private static async Task<ImmutableArray<CodeFixCollection>> GetAddedFixesAsync(
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
             document = project.Documents.Single();
             var options = CodeActionOptions.Default;
-            var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            var fixes = await tuple.codeFixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
 
             if (exception)
             {
@@ -300,7 +300,7 @@ private static async Task GetFirstDiagnosticWithFixWithExceptionValidationAsync(
 
             GetDocumentAndExtensionManager(tuple.analyzerService, workspace, out var document, out var extensionManager);
             var unused = await tuple.codeFixService.GetMostSevereFixAsync(
-                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, CodeActionOptions.Default, CancellationToken.None);
+                document, TextSpan.FromBounds(0, 0), CodeActionRequestPriority.None, _ => CodeActionOptions.Default, CancellationToken.None);
             Assert.True(extensionManager.IsDisabled(codefix));
             Assert.False(extensionManager.IsIgnored(codefix));
             Assert.True(errorReported);
@@ -692,7 +692,7 @@ private static async Task<ImmutableArray<CodeFixCollection>> GetNuGetAndVsixCode
             var document = project.Documents.Single();
             var options = CodeActionOptions.Default;
 
-            return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            return await fixService.GetFixesAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
         }
 
         private sealed class NuGetCodeFixProvider : AbstractNuGetOrVsixCodeFixProvider

src/EditorFeatures/Test/CodeRefactorings/CodeRefactoringServiceTest.cs

@@ -45,7 +45,7 @@ public async Task TestProjectRefactoringAsync()
             var project = workspace.CurrentSolution.Projects.Single().AddAnalyzerReference(reference);
             var document = project.Documents.Single();
             var options = CodeActionOptions.Default;
-            var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            var refactorings = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
 
             var stubRefactoringAction = refactorings.Single(refactoring => refactoring.CodeActions.FirstOrDefault().action?.Title == nameof(StubRefactoring));
             Assert.True(stubRefactoringAction is object);
@@ -69,7 +69,7 @@ private static async Task VerifyRefactoringDisabledAsync<T>()
             var document = project.Documents.Single();
             var extensionManager = (EditorLayerExtensionManager.ExtensionManager)document.Project.Solution.Workspace.Services.GetRequiredService<IExtensionManager>();
             var options = CodeActionOptions.Default;
-            var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), options, CancellationToken.None);
+            var result = await refactoringService.GetRefactoringsAsync(document, TextSpan.FromBounds(0, 0), _ => options, CancellationToken.None);
             Assert.True(extensionManager.IsDisabled(codeRefactoring));
             Assert.False(extensionManager.IsIgnored(codeRefactoring));
 

src/EditorFeatures/Test2/CodeFixes/CodeFixServiceTests.vb

@@ -77,7 +77,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 Dim fixes = Await codefixService.GetFixesAsync(
                     document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    options,
+                    Function(language) options,
                     CancellationToken.None)
 
                 Assert.Equal(0, fixes.Count())
@@ -93,7 +93,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 fixes = Await codefixService.GetFixesAsync(
                     document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    options,
+                    Function(language) options,
                     CancellationToken.None)
                 Assert.Equal(1, fixes.Count())
 
@@ -103,7 +103,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 fixes = Await codefixService.GetFixesAsync(
                     document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    options,
+                    Function(language) options,
                     CancellationToken.None)
 
                 Assert.Equal(0, fixes.Count())
@@ -154,7 +154,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 Dim fixes = Await codefixService.GetFixesAsync(
                     document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    options,
+                    Function(language) options,
                     CancellationToken.None)
 
                 Assert.Equal(0, fixes.Count())
@@ -170,7 +170,7 @@ Namespace Microsoft.CodeAnalysis.Editor.Implementation.CodeFixes.UnitTests
                 fixes = Await codefixService.GetFixesAsync(
                     document,
                     (Await document.GetSyntaxRootAsync()).FullSpan,
-                    options,
+                    Function(language) options,
                     CancellationToken.None)
 
                 Assert.Equal(0, fixes.Count())