Avoid calling Reducer APIs that take OptionSet; CodeCleanupOptions

src/Analyzers/CSharp/CodeFixes/MisplacedUsingDirectives/MisplacedUsingDirectivesCodeFixProvider.cs

@@ -16,6 +16,7 @@
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Simplification;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Formatting;
@@ -65,14 +66,17 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
 
 #if CODE_STYLE
             var options = document.Project.AnalyzerOptions.GetAnalyzerOptionSet(syntaxRoot.SyntaxTree, cancellationToken);
+            var simplifierOptions = CSharpSimplifierOptions.Create(options, fallbackOptions: null);
 #else
             var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
+            var simplifierOptions = await SimplifierOptions.FromDocumentAsync(document, fallbackOptions: context.Options(document.Project.LanguageServices).SimplifierOptions, cancellationToken).ConfigureAwait(false);
 #endif
+            var codeStyleOption = options.GetOption(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement);
 
             // Read the preferred placement option and verify if it can be applied to this code file.
             // There are cases where we will not be able to fix the diagnostic and the user will need to resolve
             // it manually.
-            var (placement, preferPreservation) = DeterminePlacement(compilationUnit, options);
+            var (placement, preferPreservation) = DeterminePlacement(compilationUnit, codeStyleOption);
             if (preferPreservation)
                 return;
 
@@ -81,24 +85,22 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         CSharpAnalyzersResources.Move_misplaced_using_directives,
-                        token => GetTransformedDocumentAsync(document, compilationUnit, GetAllUsingDirectives(compilationUnit), placement, token),
+                        token => GetTransformedDocumentAsync(document, compilationUnit, GetAllUsingDirectives(compilationUnit), placement, simplifierOptions, token),
                         nameof(CSharpAnalyzersResources.Move_misplaced_using_directives)),
                     diagnostic);
             }
         }
 
-        internal static async Task<Document> TransformDocumentIfRequiredAsync(Document document, CancellationToken cancellationToken)
+        internal static async Task<Document> TransformDocumentIfRequiredAsync(
+            Document document,
+            SimplifierOptions simplifierOptions,
+            CodeStyleOption2<AddImportPlacement> importPlacementStyleOption,
+            CancellationToken cancellationToken)
         {
             var syntaxRoot = await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
             var compilationUnit = (CompilationUnitSyntax)syntaxRoot;
 
-#if CODE_STYLE
-            var options = document.Project.AnalyzerOptions.GetAnalyzerOptionSet(syntaxRoot.SyntaxTree, cancellationToken);
-#else
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-#endif
-
-            var (placement, preferPreservation) = DeterminePlacement(compilationUnit, options);
+            var (placement, preferPreservation) = DeterminePlacement(compilationUnit, importPlacementStyleOption);
             if (preferPreservation)
             {
                 return document;
@@ -112,7 +114,7 @@ internal static async Task<Document> TransformDocumentIfRequiredAsync(Document d
                 return document;
             }
 
-            return await GetTransformedDocumentAsync(document, compilationUnit, allUsingDirectives, placement, cancellationToken).ConfigureAwait(false);
+            return await GetTransformedDocumentAsync(document, compilationUnit, allUsingDirectives, placement, simplifierOptions, cancellationToken).ConfigureAwait(false);
         }
 
         private static ImmutableList<UsingDirectiveSyntax> GetAllUsingDirectives(CompilationUnitSyntax compilationUnit)
@@ -127,6 +129,7 @@ private static async Task<Document> GetTransformedDocumentAsync(
             CompilationUnitSyntax compilationUnit,
             IEnumerable<UsingDirectiveSyntax> allUsingDirectives,
             AddImportPlacement placement,
+            SimplifierOptions simplifierOptions,
             CancellationToken cancellationToken)
         {
             var bannerService = document.GetRequiredLanguageService<IFileBannerFactsService>();
@@ -149,8 +152,13 @@ private static async Task<Document> GetTransformedDocumentAsync(
             var newDocument = document.WithSyntaxRoot(newCompilationUnitWithHeader);
 
             // Simplify usings now that they have been moved and are in the proper context.
-            var options = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
-            return await Simplifier.ReduceAsync(newDocument, Simplifier.Annotation, options, cancellationToken).ConfigureAwait(false);
+#if CODE_STYLE
+#pragma warning disable RS0030 // Do not used banned APIs
+            return await Simplifier.ReduceAsync(newDocument, Simplifier.Annotation, optionSet: null, cancellationToken).ConfigureAwait(false);
+#pragma warning restore
+#else
+            return await Simplifier.ReduceAsync(newDocument, Simplifier.Annotation, simplifierOptions, cancellationToken).ConfigureAwait(false);
+#endif
         }
 
         private static async Task<CompilationUnitSyntax> ExpandUsingDirectivesAsync(Document document, CompilationUnitSyntax containerNode, IEnumerable<UsingDirectiveSyntax> allUsingDirectives, CancellationToken cancellationToken)
@@ -360,12 +368,10 @@ private static TSyntaxNode EnsureLeadingBlankLineBeforeFirstMember<TSyntaxNode>(
             return node.ReplaceNode(firstMember, newFirstMember);
         }
 
-        private static (AddImportPlacement placement, bool preferPreservation) DeterminePlacement(CompilationUnitSyntax compilationUnit, OptionSet options)
+        private static (AddImportPlacement placement, bool preferPreservation) DeterminePlacement(CompilationUnitSyntax compilationUnit, CodeStyleOption2<AddImportPlacement> styleOption)
         {
-            var codeStyleOption = options.GetOption(CSharpCodeStyleOptions.PreferredUsingDirectivePlacement);
-
-            var placement = codeStyleOption.Value;
-            var preferPreservation = codeStyleOption.Notification == NotificationOption2.None;
+            var placement = styleOption.Value;
+            var preferPreservation = styleOption.Notification == NotificationOption2.None;
 
             if (preferPreservation || placement == AddImportPlacement.OutsideNamespace)
                 return (placement, preferPreservation);

src/Deployment/RoslynDeployment.csproj

@@ -15,6 +15,7 @@
     <IncludeDebugSymbolsInLocalVSIXDeployment>false</IncludeDebugSymbolsInLocalVSIXDeployment>
   </PropertyGroup>
   <ItemGroup>
+    <None Include="..\..\.editorconfig" Link=".editorconfig" />
     <None Include="source.extension.vsixmanifest">
       <SubType>Designer</SubType>
     </None>

src/EditorFeatures/CSharp/EventHookup/EventHookupCommandHandler_TabKeyCommand.cs

@@ -168,8 +168,9 @@ private Solution CreateSolutionWithEventHandler(
             }
 
             var formattingOptions = SyntaxFormattingOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken);
+            var simplifierOptions = document.GetSimplifierOptionsAsync(_globalOptions, cancellationToken).WaitAndGetResult(cancellationToken);
 
-            var simplifiedDocument = Simplifier.ReduceAsync(documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, cancellationToken: cancellationToken).WaitAndGetResult(cancellationToken);
+            var simplifiedDocument = Simplifier.ReduceAsync(documentWithNameAndAnnotationsAdded.WithSyntaxRoot(updatedRoot), Simplifier.Annotation, simplifierOptions, cancellationToken).WaitAndGetResult(cancellationToken);
             var formattedDocument = Formatter.FormatAsync(simplifiedDocument, Formatter.Annotation, formattingOptions, cancellationToken).WaitAndGetResult(cancellationToken);
 
             var newRoot = formattedDocument.GetSyntaxRootSynchronously(cancellationToken);

src/EditorFeatures/Core/AddImports/AbstractAddImportsPasteCommandHandler.cs

@@ -4,6 +4,7 @@
 
 using System;
 using Microsoft.CodeAnalysis.AddMissingImports;
+using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.Completion;
 using Microsoft.CodeAnalysis.Editor.Shared.Extensions;
 using Microsoft.CodeAnalysis.Editor.Shared.Options;
@@ -125,11 +126,11 @@ private void ExecuteCommandWorker(
 #pragma warning disable VSTHRD102 // Implement internal logic asynchronously
             var updatedDocument = _threadingContext.JoinableTaskFactory.Run(async () =>
             {
-                var placement = await AddImportPlacementOptions.FromDocumentAsync(document, cancellationToken).ConfigureAwait(false);
+                var cleanupOptions = await CodeCleanupOptions.FromDocumentAsync(document, fallbackOptions: null, cancellationToken).ConfigureAwait(false);
 
                 var options = new AddMissingImportsOptions(
-                    HideAdvancedMembers: _globalOptions.GetOption(CompletionOptionsStorage.HideAdvancedMembers, document.Project.Language),
-                    placement);
+                    CleanupOptions: cleanupOptions,
+                    HideAdvancedMembers: _globalOptions.GetOption(CompletionOptionsStorage.HideAdvancedMembers, document.Project.Language));
 
                 return await addMissingImportsService.AddMissingImportsAsync(document, textSpan, options, cancellationToken).ConfigureAwait(false);
             });

src/EditorFeatures/Test/CodeGeneration/CodeGenerationTests.cs

@@ -13,6 +13,7 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CodeGeneration;
 using Microsoft.CodeAnalysis.CSharp.Formatting;
+using Microsoft.CodeAnalysis.CSharp.Simplification;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
@@ -22,6 +23,7 @@
 using Microsoft.CodeAnalysis.Test.Utilities;
 using Microsoft.CodeAnalysis.Text;
 using Microsoft.CodeAnalysis.VisualBasic.Formatting;
+using Microsoft.CodeAnalysis.VisualBasic.Simplification;
 using Roslyn.Test.Utilities;
 using Roslyn.Utilities;
 using Xunit;
@@ -885,8 +887,9 @@ public void Dispose()
                         this.Document = this.Result;
 
                         var formattingOptions = IsVisualBasic ? (SyntaxFormattingOptions)VisualBasicSyntaxFormattingOptions.Default : CSharpSyntaxFormattingOptions.Default;
+                        var simplifierOptions = IsVisualBasic ? (SimplifierOptions)VisualBasicSimplifierOptions.Default : CSharpSimplifierOptions.Default;
 
-                        var simplified = Simplifier.ReduceAsync(this.Document, Simplifier.Annotation).Result;
+                        var simplified = Simplifier.ReduceAsync(this.Document, Simplifier.Annotation, simplifierOptions, CancellationToken.None).Result;
                         var actual = Formatter.FormatAsync(simplified, Formatter.Annotation, formattingOptions, CancellationToken.None).Result.GetSyntaxRootAsync().Result.ToFullString();
 
                         Assert.Equal(_expected, actual);

src/EditorFeatures/Test2/Expansion/AbstractExpansionTest.vb

@@ -27,6 +27,9 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Expansion
 
                 Dim root = Await document.GetSyntaxRootAsync()
 
+                Dim formattingOptions = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
+                Dim simplifyOptions = Await SimplifierOptions.FromDocumentAsync(document, fallbackOptions:=Nothing, CancellationToken.None)
+
                 If (hostDocument.AnnotatedSpans.ContainsKey("Expand")) Then
                     For Each span In hostDocument.AnnotatedSpans("Expand")
                         Dim node = GetExpressionSyntaxWithSameSpan(root.FindToken(span.Start).Parent, span.End)
@@ -37,13 +40,11 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Expansion
                         Dim node = GetExpressionSyntaxWithSameSpan(root.FindToken(span.Start).Parent, span.End)
                         root = root.ReplaceNode(node, Await Simplifier.ExpandAsync(node, document, expandInsideNode:=Nothing, expandParameter:=expandParameter))
                         document = document.WithSyntaxRoot(root)
-                        document = Await Simplifier.ReduceAsync(document, Simplifier.Annotation)
+                        document = Await Simplifier.ReduceAsync(document, Simplifier.Annotation, simplifyOptions, CancellationToken.None)
                         root = Await document.GetSyntaxRootAsync()
                     Next
                 End If
 
-                Dim formattingOptions = Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None)
-
                 document = document.WithSyntaxRoot(root)
                 document = Await Formatter.FormatAsync(document, FormattingOptions, CancellationToken.None)
 

src/EditorFeatures/Test2/Simplification/AbstractSimplificationTests.vb

@@ -114,12 +114,14 @@ Namespace Microsoft.CodeAnalysis.Editor.UnitTests.Simplification
 
             document = document.WithSyntaxRoot(root)
 
+#Disable Warning RS0030 ' Do Not used banned APIs
             Dim simplifiedDocument As Document
             If Not explicitSpansToSimplifyWithin.IsDefaultOrEmpty Then
                 simplifiedDocument = Await Simplifier.ReduceAsync(document, explicitSpansToSimplifyWithin, optionSet)
             Else
                 simplifiedDocument = Await Simplifier.ReduceAsync(document, Simplifier.Annotation, optionSet)
             End If
+#Enable Warning RS0030
 
             Return simplifiedDocument
         End Function

src/EditorFeatures/TestUtilities/Formatting/AbstractNewDocumentFormattingServiceTests.cs

@@ -5,6 +5,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.CodeAnalysis.Options;
@@ -66,8 +67,8 @@ private async Task TestCoreAsync<T>(string testCode, string expected, (OptionKey
                 var document = workspace.CurrentSolution.Projects.First().Documents.First();
 
                 var formattingService = document.GetRequiredLanguageService<INewDocumentFormattingService>();
-                var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None).ConfigureAwait(false);
-                var formattedDocument = await formattingService.FormatNewDocumentAsync(document, hintDocument: null, formattingOptions, CancellationToken.None);
+                var cleanupOptions = await CodeCleanupOptions.FromDocumentAsync(document, fallbackOptions: null, CancellationToken.None).ConfigureAwait(false);
+                var formattedDocument = await formattingService.FormatNewDocumentAsync(document, hintDocument: null, cleanupOptions, CancellationToken.None);
 
                 var actual = await formattedDocument.GetTextAsync();
                 AssertEx.EqualOrDiff(expected, actual.ToString());

src/EditorFeatures/VisualBasic/LineCommit/CommitFormatter.vb

@@ -5,6 +5,7 @@
 Imports System.Collections.Immutable
 Imports System.ComponentModel.Composition
 Imports System.Threading
+Imports Microsoft.CodeAnalysis.AddImport
 Imports Microsoft.CodeAnalysis.CodeCleanup
 Imports Microsoft.CodeAnalysis.CodeCleanup.Providers
 Imports Microsoft.CodeAnalysis.Formatting
@@ -90,7 +91,8 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.LineCommit
 
                 Dim cleanupService = document.GetRequiredLanguageService(Of ICodeCleanerService)
                 Dim simplifierOptions = document.GetSimplifierOptionsAsync(_globalOptions, cancellationToken).WaitAndGetResult(cancellationToken)
-                Dim cleanupOptions = New CodeCleanupOptions(formattingOptions, simplifierOptions)
+                Dim addImportOptions = AddImportPlacementOptions.FromDocumentAsync(document, cancellationToken).WaitAndGetResult(cancellationToken)
+                Dim cleanupOptions = New CodeCleanupOptions(formattingOptions, simplifierOptions, addImportOptions)
 
                 Dim finalDocument As Document
                 If useSemantics OrElse isExplicitFormat Then

src/EditorFeatures/VisualBasicTest/CaseCorrecting/CaseCorrectionServiceTests.vb

@@ -4,14 +4,11 @@
 
 Imports System.Collections.Immutable
 Imports System.Threading
-Imports System.Xml.Linq
 Imports Microsoft.CodeAnalysis
 Imports Microsoft.CodeAnalysis.CodeCleanup
 Imports Microsoft.CodeAnalysis.CodeCleanup.Providers
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Extensions
 Imports Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces
-Imports Microsoft.CodeAnalysis.Formatting
-Imports Microsoft.CodeAnalysis.Simplification
 
 Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CaseCorrecting
     <[UseExportProvider]>
@@ -36,9 +33,7 @@ Namespace Microsoft.CodeAnalysis.Editor.VisualBasic.UnitTests.CaseCorrecting
             Dim document = workspace.CurrentSolution.GetDocument(hostDocument.Id)
             Dim span = (Await document.GetSyntaxRootAsync()).FullSpan
 
-            Dim options = New CodeCleanupOptions(
-                Await SyntaxFormattingOptions.FromDocumentAsync(document, CancellationToken.None),
-                Await SimplifierOptions.FromDocumentAsync(document, fallbackOptions:=Nothing, CancellationToken.None))
+            Dim options = Await CodeCleanupOptions.FromDocumentAsync(document, fallbackOptions:=Nothing, CancellationToken.None)
 
             Dim service = document.GetLanguageService(Of ICodeCleanerService)
             Dim newDocument = Await service.CleanupAsync(

src/Features/CSharp/Portable/Formatting/CSharpAccessibilityModifiersNewDocumentFormattingProvider.cs

@@ -8,6 +8,7 @@
 using System.Threading;
 using System.Threading.Tasks;
 using Microsoft.CodeAnalysis.AddAccessibilityModifiers;
+using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.CodeStyle;
 using Microsoft.CodeAnalysis.CSharp.LanguageServices;
 using Microsoft.CodeAnalysis.Editing;
@@ -26,7 +27,7 @@ public CSharpAccessibilityModifiersNewDocumentFormattingProvider()
         {
         }
 
-        public async Task<Document> FormatNewDocumentAsync(Document document, Document? hintDocument, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+        public async Task<Document> FormatNewDocumentAsync(Document document, Document? hintDocument, CodeCleanupOptions options, CancellationToken cancellationToken)
         {
             var documentOptions = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var accessibilityPreferences = documentOptions.GetOption(CodeStyleOptions2.RequireAccessibilityModifiers, document.Project.Language);

src/Features/CSharp/Portable/Formatting/CSharpNamespaceDeclarationNewDocumentFormattingProvider.cs

@@ -8,6 +8,7 @@
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
+using Microsoft.CodeAnalysis.CodeCleanup;
 using Microsoft.CodeAnalysis.CSharp.ConvertNamespace;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Formatting;
@@ -27,7 +28,7 @@ public CSharpNamespaceDeclarationNewDocumentFormattingProvider()
         {
         }
 
-        public async Task<Document> FormatNewDocumentAsync(Document document, Document? hintDocument, SyntaxFormattingOptions options, CancellationToken cancellationToken)
+        public async Task<Document> FormatNewDocumentAsync(Document document, Document? hintDocument, CodeCleanupOptions options, CancellationToken cancellationToken)
         {
             var optionSet = await document.GetOptionsAsync(cancellationToken).ConfigureAwait(false);
             var root = (CompilationUnitSyntax)await document.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
@@ -36,7 +37,7 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
             if (namespaces.Count != 1)
                 return document;
 
-            return await ConvertNamespaceTransform.ConvertAsync(document, namespaces[0], options, cancellationToken).ConfigureAwait(false);
+            return await ConvertNamespaceTransform.ConvertAsync(document, namespaces[0], options.FormattingOptions, cancellationToken).ConfigureAwait(false);
         }
 
         private static IEnumerable<BaseNamespaceDeclarationSyntax> GetNamespacesToReplace(Document document, CompilationUnitSyntax root, DocumentOptionSet optionSet)