Change ECUI tab title from 'formatting' to 'whitespace'

src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/Formatting/CSharpFormattingSettingsLanguageServiceFactory.cs → src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/Whitespace/CSharpWhitespaceSettingsLanguageServiceFactory.cs

@@ -10,21 +10,21 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 
-namespace Microsoft.VisualStudio.LanguageServices.CSharp.EditorConfigSettings.DataProvider.Formatting
+namespace Microsoft.VisualStudio.LanguageServices.CSharp.EditorConfigSettings.DataProvider.Whitespace
 {
-    [ExportLanguageServiceFactory(typeof(ILanguageSettingsProviderFactory<FormattingSetting>), LanguageNames.CSharp), Shared]
-    internal class CSharpFormattingSettingsLanguageServiceFactory : ILanguageServiceFactory
+    [ExportLanguageServiceFactory(typeof(ILanguageSettingsProviderFactory<WhitespaceSetting>), LanguageNames.CSharp), Shared]
+    internal class CSharpWhitespaceSettingsLanguageServiceFactory : ILanguageServiceFactory
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CSharpFormattingSettingsLanguageServiceFactory()
+        public CSharpWhitespaceSettingsLanguageServiceFactory()
         {
         }
 
         public ILanguageService CreateLanguageService(HostLanguageServices languageServices)
         {
             var workspace = languageServices.WorkspaceServices.Workspace;
-            return new CSharpFormattingSettingsProviderFactory(workspace);
+            return new CSharpWhitespaceSettingsProviderFactory(workspace);
         }
     }
 }

src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/Formatting/CSharpFormattingSettingsProviderFactory.cs → src/EditorFeatures/CSharp/EditorConfigSettings/DataProvider/Whitespace/CSharpWhitespaceSettingsProviderFactory.cs

@@ -7,21 +7,21 @@
 using Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider;
 using Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Updater;
 
-namespace Microsoft.VisualStudio.LanguageServices.CSharp.EditorConfigSettings.DataProvider.Formatting
+namespace Microsoft.VisualStudio.LanguageServices.CSharp.EditorConfigSettings.DataProvider.Whitespace
 {
-    internal class CSharpFormattingSettingsProviderFactory : ILanguageSettingsProviderFactory<FormattingSetting>
+    internal class CSharpWhitespaceSettingsProviderFactory : ILanguageSettingsProviderFactory<WhitespaceSetting>
     {
         private readonly Workspace _workspace;
 
-        public CSharpFormattingSettingsProviderFactory(Workspace workspace)
+        public CSharpWhitespaceSettingsProviderFactory(Workspace workspace)
         {
             _workspace = workspace;
         }
 
-        public ISettingsProvider<FormattingSetting> GetForFile(string filePath)
+        public ISettingsProvider<WhitespaceSetting> GetForFile(string filePath)
         {
             var updaterService = new OptionUpdater(_workspace, filePath);
-            return new CSharpFormattingSettingsProvider(filePath, updaterService, _workspace);
+            return new CSharpWhitespaceSettingsProvider(filePath, updaterService, _workspace);
         }
     }
 }

src/EditorFeatures/CSharpTest/EditorConfigSettings/Aggregator/SettingsAggregatorTests.cs

@@ -48,6 +48,6 @@ private static void TestGettingProvider<T>()
         public void TestGettingAnalyzerProvider() => TestGettingProvider<AnalyzerSetting>();
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
-        public void TestGettingFormattingProvider() => TestGettingProvider<FormattingSetting>();
+        public void TestGettingWhitespaceProvider() => TestGettingProvider<WhitespaceSetting>();
     }
 }

src/EditorFeatures/CSharpTest/EditorConfigSettings/DataProvider/DataProviderTests.cs

@@ -67,10 +67,10 @@ public void TestGettingCodeStyleSettingsProvider()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
-        public void TestGettingFormattingSettingsProvider()
+        public void TestGettingWhitespaceSettingsProvider()
         {
-            TestGettingSettingsProviderFromWorkspace<FormattingSetting>();
-            TestGettingSettingsProviderFromLanguageService<FormattingSetting>();
+            TestGettingSettingsProviderFromWorkspace<WhitespaceSetting>();
+            TestGettingSettingsProviderFromLanguageService<WhitespaceSetting>();
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
@@ -112,9 +112,9 @@ public void TestGettingCodeStyleSettingsProviderLanguageServiceAsync()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
-        public void TestGettingFormattingSettingProviderWorkspaceServiceAsync()
+        public void TestGettingWhitespaceSettingProviderWorkspaceServiceAsync()
         {
-            var settingsProviderFactory = GettingSettingsProviderFactoryFromWorkspace<FormattingSetting>();
+            var settingsProviderFactory = GettingSettingsProviderFactoryFromWorkspace<WhitespaceSetting>();
             var settingsProvider = settingsProviderFactory.GetForFile("/a/b/config");
             var model = new TestViewModel();
             settingsProvider.RegisterViewModel(model);
@@ -123,9 +123,9 @@ public void TestGettingFormattingSettingProviderWorkspaceServiceAsync()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
-        public void TestGettingFormattingSettingProviderLanguageServiceAsync()
+        public void TestGettingWhitespaceSettingProviderLanguageServiceAsync()
         {
-            var settingsProviderFactory = GettingSettingsProviderFactoryFromLanguageService<FormattingSetting>(LanguageNames.CSharp);
+            var settingsProviderFactory = GettingSettingsProviderFactoryFromLanguageService<WhitespaceSetting>(LanguageNames.CSharp);
             var settingsProvider = settingsProviderFactory.GetForFile("/a/b/config");
             var model = new TestViewModel();
             settingsProvider.RegisterViewModel(model);

src/EditorFeatures/CSharpTest/EditorConfigSettings/Updater/SettingsUpdaterTests.cs

@@ -364,11 +364,11 @@ public async Task TestCodeStyleSettingUpdaterService()
         }
 
         [Fact, Trait(Traits.Feature, Traits.Features.EditorConfigUI)]
-        public async Task TestFormattingSettingUpdaterService()
+        public async Task TestWhitespaceSettingUpdaterService()
         {
             var workspace = CreateWorkspaceWithProjectAndDocuments();
             var updater = new OptionUpdater(workspace, "/a/b/config");
-            var setting = FormattingSetting.Create(CSharpFormattingOptions2.NewLineForElse, "", TestAnalyzerConfigOptions.Instance, workspace.Options, updater, null!);
+            var setting = WhitespaceSetting.Create(CSharpFormattingOptions2.NewLineForElse, "", TestAnalyzerConfigOptions.Instance, workspace.Options, updater, null!);
             setting.SetValue(false);
             var updates = await updater.GetChangedEditorConfigAsync(default);
             var update = Assert.Single(updates);

src/EditorFeatures/Core/EditorConfigSettings/Aggregator/SettingsAggregator.cs

@@ -15,14 +15,14 @@ internal partial class SettingsAggregator : ISettingsAggregator
     {
         private readonly Workspace _workspace;
         private readonly ISettingsProviderFactory<AnalyzerSetting> _analyzerProvider;
-        private ISettingsProviderFactory<FormattingSetting> _formattingProvider;
+        private ISettingsProviderFactory<WhitespaceSetting> _whitespaceProvider;
         private ISettingsProviderFactory<CodeStyleSetting> _codeStyleProvider;
 
         public SettingsAggregator(Workspace workspace)
         {
             _workspace = workspace;
             _workspace.WorkspaceChanged += UpdateProviders;
-            _formattingProvider = GetOptionsProviderFactory<FormattingSetting>(_workspace);
+            _whitespaceProvider = GetOptionsProviderFactory<WhitespaceSetting>(_workspace);
             _codeStyleProvider = GetOptionsProviderFactory<CodeStyleSetting>(_workspace);
             _analyzerProvider = GetOptionsProviderFactory<AnalyzerSetting>(_workspace);
         }
@@ -39,7 +39,7 @@ private void UpdateProviders(object? sender, WorkspaceChangeEventArgs e)
                 case WorkspaceChangeKind.ProjectAdded:
                 case WorkspaceChangeKind.ProjectRemoved:
                 case WorkspaceChangeKind.ProjectChanged:
-                    _formattingProvider = GetOptionsProviderFactory<FormattingSetting>(_workspace);
+                    _whitespaceProvider = GetOptionsProviderFactory<WhitespaceSetting>(_workspace);
                     _codeStyleProvider = GetOptionsProviderFactory<CodeStyleSetting>(_workspace);
                     break;
                 default:
@@ -54,9 +54,9 @@ private void UpdateProviders(object? sender, WorkspaceChangeEventArgs e)
                 return (ISettingsProvider<TData>)_analyzerProvider.GetForFile(fileName);
             }
 
-            if (typeof(TData) == typeof(FormattingSetting))
+            if (typeof(TData) == typeof(WhitespaceSetting))
             {
-                return (ISettingsProvider<TData>)_formattingProvider.GetForFile(fileName);
+                return (ISettingsProvider<TData>)_whitespaceProvider.GetForFile(fileName);
             }
 
             if (typeof(TData) == typeof(CodeStyleSetting))

src/EditorFeatures/Core/EditorConfigSettings/Data/Formatting/PerLanguageFormattingSetting.cs → src/EditorFeatures/Core/EditorConfigSettings/Data/Whitespace/PerLanguageWhitespaceSetting.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Data
 {
-    internal sealed class PerLanguageFormattingSetting<T> : FormattingSetting
+    internal sealed class PerLanguageWhitespaceSetting<T> : WhitespaceSetting
         where T : notnull
     {
         private bool _isValueSet;
@@ -46,7 +46,7 @@ private set
         private readonly AnalyzerConfigOptions _editorConfigOptions;
         private readonly OptionSet _visualStudioOptions;
 
-        public PerLanguageFormattingSetting(PerLanguageOption2<T> option,
+        public PerLanguageWhitespaceSetting(PerLanguageOption2<T> option,
                                             string description,
                                             AnalyzerConfigOptions editorConfigOptions,
                                             OptionSet visualStudioOptions,

src/EditorFeatures/Core/EditorConfigSettings/Data/Formatting/FormattingSetting.cs → src/EditorFeatures/Core/EditorConfigSettings/Data/Whitespace/WhitespaceSetting.cs

@@ -9,12 +9,12 @@
 
 namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Data
 {
-    internal abstract class FormattingSetting
+    internal abstract class WhitespaceSetting
     {
         protected OptionUpdater Updater { get; }
         protected string? Language { get; }
 
-        protected FormattingSetting(string description, OptionUpdater updater, SettingLocation location, string? language = null)
+        protected WhitespaceSetting(string description, OptionUpdater updater, SettingLocation location, string? language = null)
         {
             Description = description ?? throw new ArgumentNullException(nameof(description));
             Updater = updater;
@@ -31,21 +31,20 @@ protected FormattingSetting(string description, OptionUpdater updater, SettingLo
         public abstract bool IsDefinedInEditorConfig { get; }
         public SettingLocation Location { get; protected set; }
 
-        public static PerLanguageFormattingSetting<TOption> Create<TOption>(PerLanguageOption2<TOption> option,
+        public static PerLanguageWhitespaceSetting<TOption> Create<TOption>(PerLanguageOption2<TOption> option,
                                                                             string description,
                                                                             AnalyzerConfigOptions editorConfigOptions,
                                                                             OptionSet visualStudioOptions,
                                                                             OptionUpdater updater,
                                                                             string fileName)
             where TOption : notnull
         {
-
             var isDefinedInEditorConfig = editorConfigOptions.TryGetEditorConfigOption<TOption>(option, out _);
             var location = new SettingLocation(isDefinedInEditorConfig ? LocationKind.EditorConfig : LocationKind.VisualStudio, fileName);
-            return new PerLanguageFormattingSetting<TOption>(option, description, editorConfigOptions, visualStudioOptions, updater, location);
+            return new PerLanguageWhitespaceSetting<TOption>(option, description, editorConfigOptions, visualStudioOptions, updater, location);
         }
 
-        public static FormattingSetting<TOption> Create<TOption>(Option2<TOption> option,
+        public static WhitespaceSetting<TOption> Create<TOption>(Option2<TOption> option,
                                                                  string description,
                                                                  AnalyzerConfigOptions editorConfigOptions,
                                                                  OptionSet visualStudioOptions,
@@ -55,7 +54,7 @@ public static FormattingSetting<TOption> Create<TOption>(Option2<TOption> option
         {
             var isDefinedInEditorConfig = editorConfigOptions.TryGetEditorConfigOption<TOption>(option, out _);
             var location = new SettingLocation(isDefinedInEditorConfig ? LocationKind.EditorConfig : LocationKind.VisualStudio, fileName);
-            return new FormattingSetting<TOption>(option, description, editorConfigOptions, visualStudioOptions, updater, location);
+            return new WhitespaceSetting<TOption>(option, description, editorConfigOptions, visualStudioOptions, updater, location);
         }
     }
 }

src/EditorFeatures/Core/EditorConfigSettings/Data/Formatting/FormattingSetting`1.cs → src/EditorFeatures/Core/EditorConfigSettings/Data/Whitespace/WhitespaceSetting`1.cs

@@ -9,7 +9,7 @@
 
 namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Data
 {
-    internal sealed class FormattingSetting<T> : FormattingSetting
+    internal sealed class WhitespaceSetting<T> : WhitespaceSetting
         where T : notnull
     {
         public override bool IsDefinedInEditorConfig => _options.TryGetEditorConfigOption<T>(_option, out _);
@@ -53,7 +53,7 @@ private set
         private readonly AnalyzerConfigOptions _options;
         private readonly OptionSet _visualStudioOptions;
 
-        public FormattingSetting(Option2<T> option,
+        public WhitespaceSetting(Option2<T> option,
                                  string description,
                                  AnalyzerConfigOptions options,
                                  OptionSet visualStudioOptions,

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Formatting/CommonFormattingSettingsProvider.cs → src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Whitespace/CommonWhitespaceSettingsProvider.cs

@@ -10,11 +10,11 @@
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
 
-namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Formatting
+namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Whitespace
 {
-    internal class CommonFormattingSettingsProvider : SettingsProviderBase<FormattingSetting, OptionUpdater, IOption2, object>
+    internal class CommonWhitespaceSettingsProvider : SettingsProviderBase<WhitespaceSetting, OptionUpdater, IOption2, object>
     {
-        public CommonFormattingSettingsProvider(string fileName, OptionUpdater settingsUpdater, Workspace workspace)
+        public CommonWhitespaceSettingsProvider(string fileName, OptionUpdater settingsUpdater, Workspace workspace)
             : base(fileName, settingsUpdater, workspace)
         {
             Update();
@@ -26,13 +26,13 @@ protected override void UpdateOptions(AnalyzerConfigOptions editorConfigOptions,
             AddRange(defaultOptions);
         }
 
-        private IEnumerable<FormattingSetting> GetDefaultOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updater)
+        private IEnumerable<WhitespaceSetting> GetDefaultOptions(AnalyzerConfigOptions editorConfigOptions, OptionSet visualStudioOptions, OptionUpdater updater)
         {
-            yield return FormattingSetting.Create(FormattingOptions2.UseTabs, EditorFeaturesResources.Use_Tabs, editorConfigOptions, visualStudioOptions, updater, FileName);
-            yield return FormattingSetting.Create(FormattingOptions2.TabSize, EditorFeaturesResources.Tab_Size, editorConfigOptions, visualStudioOptions, updater, FileName);
-            yield return FormattingSetting.Create(FormattingOptions2.IndentationSize, EditorFeaturesResources.Indentation_Size, editorConfigOptions, visualStudioOptions, updater, FileName);
-            yield return FormattingSetting.Create(FormattingOptions2.NewLine, EditorFeaturesResources.New_Line, editorConfigOptions, visualStudioOptions, updater, FileName);
-            yield return FormattingSetting.Create(FormattingOptions2.InsertFinalNewLine, EditorFeaturesResources.Insert_Final_Newline, editorConfigOptions, visualStudioOptions, updater, FileName);
+            yield return WhitespaceSetting.Create(FormattingOptions2.UseTabs, EditorFeaturesResources.Use_Tabs, editorConfigOptions, visualStudioOptions, updater, FileName);
+            yield return WhitespaceSetting.Create(FormattingOptions2.TabSize, EditorFeaturesResources.Tab_Size, editorConfigOptions, visualStudioOptions, updater, FileName);
+            yield return WhitespaceSetting.Create(FormattingOptions2.IndentationSize, EditorFeaturesResources.Indentation_Size, editorConfigOptions, visualStudioOptions, updater, FileName);
+            yield return WhitespaceSetting.Create(FormattingOptions2.NewLine, EditorFeaturesResources.New_Line, editorConfigOptions, visualStudioOptions, updater, FileName);
+            yield return WhitespaceSetting.Create(FormattingOptions2.InsertFinalNewLine, EditorFeaturesResources.Insert_Final_Newline, editorConfigOptions, visualStudioOptions, updater, FileName);
         }
     }
 }

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Formatting/CommonFormattingSettingsProviderFactory.cs → src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Whitespace/CommonWhitespaceSettingsProviderFactory.cs

@@ -5,16 +5,16 @@
 using Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Data;
 using Microsoft.CodeAnalysis.Editor.EditorConfigSettings.Updater;
 
-namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Formatting
+namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Whitespace
 {
-    internal class CommonFormattingSettingsProviderFactory : IWorkspaceSettingsProviderFactory<FormattingSetting>
+    internal class CommonWhitespaceSettingsProviderFactory : IWorkspaceSettingsProviderFactory<WhitespaceSetting>
     {
         private readonly Workspace _workspace;
 
-        public CommonFormattingSettingsProviderFactory(Workspace workspace) => _workspace = workspace;
+        public CommonWhitespaceSettingsProviderFactory(Workspace workspace) => _workspace = workspace;
 
-        public ISettingsProvider<FormattingSetting> GetForFile(string filePath)
-            => new CommonFormattingSettingsProvider(filePath, new OptionUpdater(_workspace, filePath), _workspace);
+        public ISettingsProvider<WhitespaceSetting> GetForFile(string filePath)
+            => new CommonWhitespaceSettingsProvider(filePath, new OptionUpdater(_workspace, filePath), _workspace);
 
     }
 }

src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Formatting/CommonFormattingSettingsWorkspaceServiceFactory.cs → src/EditorFeatures/Core/EditorConfigSettings/DataProvider/Whitespace/CommonWhitespaceSettingsWorkspaceServiceFactory.cs

@@ -8,16 +8,16 @@
 using Microsoft.CodeAnalysis.Host;
 using Microsoft.CodeAnalysis.Host.Mef;
 
-namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Formatting
+namespace Microsoft.CodeAnalysis.Editor.EditorConfigSettings.DataProvider.Whitespace
 {
-    [ExportWorkspaceServiceFactory(typeof(IWorkspaceSettingsProviderFactory<FormattingSetting>)), Shared]
-    internal class CommonFormattingSettingsWorkspaceServiceFactory : IWorkspaceServiceFactory
+    [ExportWorkspaceServiceFactory(typeof(IWorkspaceSettingsProviderFactory<WhitespaceSetting>)), Shared]
+    internal class CommonWhitespaceSettingsWorkspaceServiceFactory : IWorkspaceServiceFactory
     {
         [ImportingConstructor]
         [Obsolete(MefConstruction.ImportingConstructorMessage, error: true)]
-        public CommonFormattingSettingsWorkspaceServiceFactory() { }
+        public CommonWhitespaceSettingsWorkspaceServiceFactory() { }
 
         public IWorkspaceService CreateService(HostWorkspaceServices workspaceServices)
-            => new CommonFormattingSettingsProviderFactory(workspaceServices.Workspace);
+            => new CommonWhitespaceSettingsProviderFactory(workspaceServices.Workspace);
     }
 }

src/VisualStudio/CSharp/Impl/EditorConfigSettings/BinaryOperatorSpacingOptionsViewModel.cs

@@ -12,9 +12,9 @@ namespace Microsoft.VisualStudio.LanguageServices.CSharp.EditorConfigSettings
 {
     internal class BinaryOperatorSpacingOptionsViewModel : EnumSettingViewModel<BinaryOperatorSpacingOptions>
     {
-        private readonly FormattingSetting _setting;
+        private readonly WhitespaceSetting _setting;
 
-        public BinaryOperatorSpacingOptionsViewModel(FormattingSetting setting)
+        public BinaryOperatorSpacingOptionsViewModel(WhitespaceSetting setting)
         {
             _setting = setting;
         }

src/VisualStudio/CSharp/Impl/EditorConfigSettings/BinaryOperatorSpacingOptionsViewModelFactory.cs

@@ -21,7 +21,7 @@ public BinaryOperatorSpacingOptionsViewModelFactory()
         {
         }
 
-        public IEnumSettingViewModel CreateViewModel(FormattingSetting setting)
+        public IEnumSettingViewModel CreateViewModel(WhitespaceSetting setting)
         {
             return new BinaryOperatorSpacingOptionsViewModel(setting);
         }