Options Refactoring - Round 3

src/Analyzers/CSharp/Analyzers/RemoveUnreachableCode/CSharpRemoveUnreachableCodeDiagnosticAnalyzer.cs

@@ -7,7 +7,6 @@
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Fading;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Utilities;
 using Roslyn.Utilities;
@@ -41,8 +40,11 @@ protected override void InitializeWorker(AnalysisContext context)
 
         private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
         {
-            var fadeCode = context.GetOption(FadingOptions.FadeOutUnreachableCode, LanguageNames.CSharp);
-
+#if CODE_STYLE
+            var fadeCode = true;
+#else
+            var fadeCode = context.GetOption(Fading.FadingOptions.FadeOutUnreachableCode, LanguageNames.CSharp);
+#endif
             var semanticModel = context.SemanticModel;
             var cancellationToken = context.CancellationToken;
 

src/Analyzers/Core/Analyzers/RemoveUnnecessaryImports/AbstractRemoveUnnecessaryImportsDiagnosticAnalyzer.cs

@@ -9,7 +9,6 @@
 using System.Threading;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Fading;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Roslyn.Utilities;
@@ -165,7 +164,11 @@ private void AnalyzeSemanticModel(SemanticModelAnalysisContext context)
 
             static bool ShouldFade(AnalyzerOptions options, SyntaxTree tree, string language, CancellationToken cancellationToken)
             {
-                return options.GetOption(FadingOptions.FadeOutUnusedImports, language, tree, cancellationToken);
+#if CODE_STYLE
+                return true;
+#else
+                return options.GetOption(Fading.FadingOptions.FadeOutUnusedImports, language, tree, cancellationToken);
+#endif
             }
         }
 

src/EditorFeatures/CSharp/AddImports/CSharpAddImportsPasteCommandHandler.cs

@@ -7,6 +7,7 @@
 using Microsoft.CodeAnalysis.Editor.Implementation.AddImports;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Utilities;
 
@@ -28,7 +29,8 @@ internal class CSharpAddImportsPasteCommandHandler : AbstractAddImportsPasteComm
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CSharpAddImportsPasteCommandHandler(IThreadingContext threadingContext) : base(threadingContext)
+        public CSharpAddImportsPasteCommandHandler(IThreadingContext threadingContext, IGlobalOptionService globalOptions)
+            : base(threadingContext, globalOptions)
         {
         }
 

src/EditorFeatures/CSharp/AutomaticCompletion/AutomaticLineEnderCommandHandler.cs

@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.VisualStudio.Commanding;
@@ -55,8 +56,9 @@ internal partial class AutomaticLineEnderCommandHandler : AbstractAutomaticLineE
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public AutomaticLineEnderCommandHandler(
             ITextUndoHistoryRegistry undoRegistry,
-            IEditorOperationsFactoryService editorOperations)
-            : base(undoRegistry, editorOperations)
+            IEditorOperationsFactoryService editorOperations,
+            IGlobalOptionService globalOptions)
+            : base(undoRegistry, editorOperations, globalOptions)
         {
         }
 

src/EditorFeatures/CSharp/BlockCommentEditing/BlockCommentEditingCommandHandler.cs

@@ -11,6 +11,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
@@ -33,18 +34,21 @@ internal sealed class BlockCommentEditingCommandHandler : ICommandHandler<Return
     {
         private readonly ITextUndoHistoryRegistry _undoHistoryRegistry;
         private readonly IEditorOperationsFactoryService _editorOperationsFactoryService;
+        private readonly IGlobalOptionService _globalOptions;
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
         public BlockCommentEditingCommandHandler(
             ITextUndoHistoryRegistry undoHistoryRegistry,
-            IEditorOperationsFactoryService editorOperationsFactoryService)
+            IEditorOperationsFactoryService editorOperationsFactoryService,
+            IGlobalOptionService globalOptions)
         {
             Contract.ThrowIfNull(undoHistoryRegistry);
             Contract.ThrowIfNull(editorOperationsFactoryService);
 
             _undoHistoryRegistry = undoHistoryRegistry;
             _editorOperationsFactoryService = editorOperationsFactoryService;
+            _globalOptions = globalOptions;
         }
 
         public string DisplayName => EditorFeaturesResources.Block_Comment_Editing;
@@ -57,7 +61,7 @@ public bool ExecuteCommand(ReturnKeyCommandArgs args, CommandExecutionContext co
 
         private bool TryHandleReturnKey(ITextBuffer subjectBuffer, ITextView textView)
         {
-            if (!subjectBuffer.GetFeatureOnOffOption(FeatureOnOffOptions.AutoInsertBlockCommentStartString))
+            if (!_globalOptions.GetOption(FeatureOnOffOptions.AutoInsertBlockCommentStartString, LanguageNames.CSharp))
                 return false;
 
             var caretPosition = textView.GetCaretPoint(subjectBuffer);

src/EditorFeatures/CSharp/BlockCommentEditing/CloseBlockCommentCommandHandler.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Host.Mef;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text.Editor.Commanding.Commands;
@@ -22,10 +23,13 @@ namespace Microsoft.CodeAnalysis.Editor.CSharp.BlockCommentEditing
     [Order(After = nameof(BlockCommentEditingCommandHandler))]
     internal sealed class CloseBlockCommentCommandHandler : ICommandHandler<TypeCharCommandArgs>
     {
+        private readonly IGlobalOptionService _globalOptions;
+
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CloseBlockCommentCommandHandler()
+        public CloseBlockCommentCommandHandler(IGlobalOptionService globalOptions)
         {
+            _globalOptions = globalOptions;
         }
 
         public string DisplayName => EditorFeaturesResources.Block_Comment_Editing;
@@ -49,7 +53,7 @@ public bool ExecuteCommand(TypeCharCommandArgs args, CommandExecutionContext exe
                         if (line.End == position &&
                             line.IsEmptyOrWhitespace(0, line.Length - 2))
                         {
-                            if (args.SubjectBuffer.GetFeatureOnOffOption(FeatureOnOffOptions.AutoInsertBlockCommentStartString) &&
+                            if (_globalOptions.GetOption(FeatureOnOffOptions.AutoInsertBlockCommentStartString, LanguageNames.CSharp) &&
                                 BlockCommentEditingCommandHandler.IsCaretInsideBlockCommentSyntax(caret.Value, out _, out _))
                             {
                                 args.SubjectBuffer.Replace(new VisualStudio.Text.Span(position - 1, 1), "/");

src/EditorFeatures/CSharp/BraceMatching/StringLiteralBraceMatcher.cs

@@ -25,7 +25,7 @@ public StringLiteralBraceMatcher()
         {
         }
 
-        public async Task<BraceMatchingResult?> FindBracesAsync(Document document, int position, CancellationToken cancellationToken)
+        public async Task<BraceMatchingResult?> FindBracesAsync(Document document, int position, BraceMatchingOptions options, CancellationToken cancellationToken)
         {
             var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var token = root.FindToken(position);

src/EditorFeatures/CSharp/CompleteStatement/CompleteStatementCommandHandler.cs

@@ -18,6 +18,7 @@
 using Microsoft.CodeAnalysis.Host.Mef;
 using Microsoft.CodeAnalysis.Internal.Log;
 using Microsoft.CodeAnalysis.LanguageServices;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.Extensions;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
@@ -42,15 +43,20 @@ internal sealed class CompleteStatementCommandHandler : IChainedCommandHandler<T
     {
         private readonly ITextUndoHistoryRegistry _textUndoHistoryRegistry;
         private readonly IEditorOperationsFactoryService _editorOperationsFactoryService;
+        private readonly IGlobalOptionService _globalOptions;
 
         public CommandState GetCommandState(TypeCharCommandArgs args, Func<CommandState> nextCommandHandler) => nextCommandHandler();
 
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CompleteStatementCommandHandler(ITextUndoHistoryRegistry textUndoHistoryRegistry, IEditorOperationsFactoryService editorOperationsFactoryService)
+        public CompleteStatementCommandHandler(
+            ITextUndoHistoryRegistry textUndoHistoryRegistry,
+            IEditorOperationsFactoryService editorOperationsFactoryService,
+            IGlobalOptionService globalOptions)
         {
             _textUndoHistoryRegistry = textUndoHistoryRegistry;
             _editorOperationsFactoryService = editorOperationsFactoryService;
+            _globalOptions = globalOptions;
         }
 
         public string DisplayName => CSharpEditorResources.Complete_statement_on_semicolon;
@@ -76,7 +82,7 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextCommandHandler,
             transaction.Complete();
         }
 
-        private static bool BeforeExecuteCommand(bool speculative, TypeCharCommandArgs args, CommandExecutionContext executionContext)
+        private bool BeforeExecuteCommand(bool speculative, TypeCharCommandArgs args, CommandExecutionContext executionContext)
         {
             if (args.TypedChar != ';' || !args.TextView.Selection.IsEmpty)
             {
@@ -89,7 +95,7 @@ private static bool BeforeExecuteCommand(bool speculative, TypeCharCommandArgs a
                 return false;
             }
 
-            if (!args.SubjectBuffer.GetFeatureOnOffOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon))
+            if (!_globalOptions.GetOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon))
             {
                 return false;
             }

src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler.cs

@@ -8,6 +8,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Threading;
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Utilities;
@@ -41,6 +42,7 @@ internal partial class EventHookupCommandHandler : ForegroundThreadAffinitizedOb
     {
         private readonly IInlineRenameService _inlineRenameService;
         private readonly IAsynchronousOperationListener _asyncListener;
+        private readonly IGlobalOptionService _globalOptions;
 
         internal readonly EventHookupSessionManager EventHookupSessionManager;
 
@@ -52,12 +54,14 @@ internal partial class EventHookupCommandHandler : ForegroundThreadAffinitizedOb
         public EventHookupCommandHandler(
             IThreadingContext threadingContext,
             IInlineRenameService inlineRenameService,
-            IAsynchronousOperationListenerProvider listenerProvider,
-            EventHookupSessionManager eventHookupSessionManager)
+            EventHookupSessionManager eventHookupSessionManager,
+            IGlobalOptionService globalOptions,
+            IAsynchronousOperationListenerProvider listenerProvider)
             : base(threadingContext)
         {
             _inlineRenameService = inlineRenameService;
             _asyncListener = listenerProvider.GetListener(FeatureAttribute.EventHookup);
+            _globalOptions = globalOptions;
 
             this.EventHookupSessionManager = eventHookupSessionManager;
         }

src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs

@@ -35,7 +35,7 @@ internal partial class EventHookupCommandHandler : IChainedCommandHandler<TabKey
         public void ExecuteCommand(TabKeyCommandArgs args, Action nextHandler, CommandExecutionContext context)
         {
             AssertIsForeground();
-            if (!args.SubjectBuffer.GetFeatureOnOffOption(InternalFeatureOnOffOptions.EventHookup))
+            if (!_globalOptions.GetOption(InternalFeatureOnOffOptions.EventHookup))
             {
                 nextHandler();
                 return;

src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TypeCharCommand.cs

@@ -23,7 +23,7 @@ public void ExecuteCommand(TypeCharCommandArgs args, Action nextHandler, Command
             AssertIsForeground();
             nextHandler();
 
-            if (!args.SubjectBuffer.GetFeatureOnOffOption(InternalFeatureOnOffOptions.EventHookup))
+            if (!_globalOptions.GetOption(InternalFeatureOnOffOptions.EventHookup))
             {
                 EventHookupSessionManager.CancelAndDismissExistingSessions();
                 return;

src/EditorFeatures/CSharp/SplitStringLiteral/SplitStringLiteralOptions.cs

@@ -11,23 +11,20 @@
 
 namespace Microsoft.CodeAnalysis.Editor.CSharp.SplitStringLiteral
 {
-    internal class SplitStringLiteralOptions
-    {
-        public static PerLanguageOption2<bool> Enabled =
-            new(nameof(SplitStringLiteralOptions), nameof(Enabled), defaultValue: true,
-                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.SplitStringLiterals"));
-    }
-
-    [ExportOptionProvider(LanguageNames.CSharp), Shared]
-    internal class SplitStringLiteralOptionsProvider : IOptionProvider
+    [ExportGlobalOptionProvider(LanguageNames.CSharp), Shared]
+    internal sealed class SplitStringLiteralOptions : IOptionProvider
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public SplitStringLiteralOptionsProvider()
+        public SplitStringLiteralOptions()
         {
         }
 
-        public ImmutableArray<IOption> Options { get; } = ImmutableArray.Create<IOption>(
-            SplitStringLiteralOptions.Enabled);
+        ImmutableArray<IOption> IOptionProvider.Options { get; } = ImmutableArray.Create<IOption>(
+            Enabled);
+
+        public static PerLanguageOption2<bool> Enabled =
+            new(nameof(SplitStringLiteralOptions), nameof(Enabled), defaultValue: true,
+                storageLocation: new RoamingProfileStorageLocation("TextEditor.%LANGUAGE%.Specific.SplitStringLiterals"));
     }
 }

src/EditorFeatures/CSharpTest/BlockCommentEditing/CloseBlockCommentTests.cs

@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.UnitTests;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.VisualStudio.Commanding;
 using Microsoft.VisualStudio.Text;
@@ -282,8 +283,8 @@ public void NotClosedAfterAsteriskSpaceWithOptionOff()
 ";
             Verify(code, expected, workspace =>
             {
-                workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(
-                    workspace.CurrentSolution.Options.WithChangedOption(FeatureOnOffOptions.AutoInsertBlockCommentStartString, LanguageNames.CSharp, false)));
+                var globalOptions = workspace.GetService<IGlobalOptionService>();
+                globalOptions.SetGlobalOption(new OptionKey(FeatureOnOffOptions.AutoInsertBlockCommentStartString, LanguageNames.CSharp), false);
             });
         }
 

src/EditorFeatures/CSharpTest/Classification/SemanticClassifierTests.cs

@@ -2608,13 +2608,13 @@ public async Task TestCreateWithBufferNotInWorkspace()
             WpfTestRunner.RequireWpfFact($"Creates an {nameof(IWpfTextView)} explicitly with an unrelated buffer");
             using var disposableView = workspace.ExportProvider.GetExportedValue<ITextEditorFactoryService>().CreateDisposableTextView(extraBuffer);
             var listenerProvider = workspace.ExportProvider.GetExportedValue<IAsynchronousOperationListenerProvider>();
-            var globalOptionsService = workspace.ExportProvider.GetExportedValue<IGlobalOptionService>();
+            var globalOptions = workspace.ExportProvider.GetExportedValue<IGlobalOptionService>();
 
             var provider = new SemanticClassificationViewTaggerProvider(
-                workspace.ExportProvider.GetExportedValue<IThreadingContext>(),
-                workspace.ExportProvider.GetExportedValue<ClassificationTypeMap>(),
-                listenerProvider,
-                globalOptionsService);
+                workspace.GetService<IThreadingContext>(),
+                workspace.GetService<ClassificationTypeMap>(),
+                globalOptions,
+                listenerProvider);
 
             using var tagger = (IDisposable)provider.CreateTagger<IClassificationTag>(disposableView.TextView, extraBuffer);
             using (var edit = extraBuffer.CreateEdit())

src/EditorFeatures/CSharpTest/Classification/SyntacticTaggerTests.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Utilities;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Shared.TestHooks;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text.Shared.Extensions;
 using Microsoft.VisualStudio.Text;
@@ -42,8 +43,9 @@ public async Task TestTagsChangedForPortionThatChanged()
 
             var tagComputer = new SyntacticClassificationTaggerProvider.TagComputer(
                 new SyntacticClassificationTaggerProvider(
-                    workspace.ExportProvider.GetExportedValue<IThreadingContext>(),
+                    workspace.GetService<IThreadingContext>(),
                     typeMap: null,
+                    workspace.GetService<IGlobalOptionService>(),
                     AsynchronousOperationListenerProvider.NullProvider),
                 subjectBuffer,
                 AsynchronousOperationListenerProvider.NullListener,
@@ -99,8 +101,9 @@ public async Task TestTagsChangedAfterDelete()
 
             var tagComputer = new SyntacticClassificationTaggerProvider.TagComputer(
                 new SyntacticClassificationTaggerProvider(
-                    workspace.ExportProvider.GetExportedValue<IThreadingContext>(),
+                    workspace.GetService<IThreadingContext>(),
                     typeMap,
+                    workspace.GetService<IGlobalOptionService>(),
                     AsynchronousOperationListenerProvider.NullProvider),
                 subjectBuffer,
                 AsynchronousOperationListenerProvider.NullListener,

src/EditorFeatures/CSharpTest/CompleteStatement/CSharpCompleteStatementCommandHandlerTests.cs

@@ -9,6 +9,7 @@
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
 using Microsoft.CodeAnalysis.Editor.UnitTests.CompleteStatement;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.VisualStudio.Commanding;
 using Roslyn.Test.Utilities;
@@ -4180,7 +4181,8 @@ public int XValue
             Verify(code, expected, ExecuteTest,
                 setOptionsOpt: workspace =>
                 {
-                    workspace.SetOptions(workspace.Options.WithChangedOption(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon, false));
+                    var globalOptions = workspace.GetService<IGlobalOptionService>();
+                    globalOptions.SetGlobalOption(new OptionKey(FeatureOnOffOptions.AutomaticallyCompleteStatementOnSemicolon), false);
                 });
         }
         protected override TestWorkspace CreateTestWorkspace(string code)