Format document after each provider

src/EditorFeatures/CSharpTest/Formatting/CSharpNewDocumentFormattingServiceTests.cs

@@ -8,6 +8,7 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.CodeStyle;
 using Microsoft.CodeAnalysis.Editor.UnitTests.Workspaces;
+using Microsoft.CodeAnalysis.Options;
 using Microsoft.CodeAnalysis.Test.Utilities.Formatting;
 using Roslyn.Test.Utilities;
 using Xunit;
@@ -171,6 +172,31 @@ internal class C
             });
         }
 
+        [Fact]
+        public async Task TestAccessibilityModifiers_FileScopedNamespace()
+        {
+            await TestAsync(testCode: @"using System;
+
+namespace Goo
+{
+    class C
+    {
+    }
+}",
+            expected: @"using System;
+
+namespace Goo;
+internal class C
+{
+}
+",
+            options: new (OptionKey, object)[]
+            {
+                (new OptionKey(CSharpCodeStyleOptions.NamespaceDeclarations), new CodeStyleOption2<NamespaceDeclarationPreference>(NamespaceDeclarationPreference.FileScoped, NotificationOption2.Error)),
+                (new OptionKey(CodeStyleOptions2.RequireAccessibilityModifiers, Language), new CodeStyleOption2<AccessibilityModifiersRequired>(AccessibilityModifiersRequired.Always, NotificationOption2.Error))
+            });
+        }
+
         [Fact]
         [WorkItem(55703, "https://github.com/dotnet/roslyn/issues/55703")]
         public async Task TestAccessibilityModifiers_IgnoresPartial()

src/EditorFeatures/TestUtilities/Formatting/AbstractNewDocumentFormattingServiceTests.cs

@@ -40,6 +40,14 @@ internal Task TestAsync<T>(string testCode, string expected, (Option2<T>, T)[]?
                 parseOptions);
         }
 
+        internal Task TestAsync(string testCode, string expected, (OptionKey, object)[]? options = null, ParseOptions? parseOptions = null)
+        {
+            return TestCoreAsync(testCode,
+                expected,
+                options,
+                parseOptions);
+        }
+
         private async Task TestCoreAsync<T>(string testCode, string expected, (OptionKey, T)[]? options, ParseOptions? parseOptions)
         {
             using (var workspace = CreateTestWorkspace(testCode, parseOptions))
@@ -60,9 +68,6 @@ private async Task TestCoreAsync<T>(string testCode, string expected, (OptionKey
                 var formattingService = document.GetRequiredLanguageService<INewDocumentFormattingService>();
                 var formattedDocument = await formattingService.FormatNewDocumentAsync(document, hintDocument: null, CancellationToken.None);
 
-                // Format to match what AbstractEditorFactory does
-                formattedDocument = await Formatter.FormatAsync(formattedDocument);
-
                 var actual = await formattedDocument.GetTextAsync();
                 AssertEx.EqualOrDiff(expected, actual.ToString());
             }

src/Features/Core/Portable/Formatting/AbstractNewDocumentFormattingService.cs

@@ -41,7 +41,14 @@ public async Task<Document> FormatNewDocumentAsync(Document document, Document?
                 // other, so this shouldn't cause problems.
                 try
                 {
+                    // First we ask the provider to "format" the document. This could be formatting in terms
+                    // of adjusting block scopes to file scopes etc., but it could also be more akin to fixers
+                    // like adding access modifiers, or adding .ConfigureAwait() calls etc.
                     document = await provider.FormatNewDocumentAsync(document, hintDocument, cancellationToken).ConfigureAwait(false);
+
+                    // Now that the above has changed the document, we need the formatter to make sure its correct
+                    // before we call the next provider, otherwise they might not see things as they are meant to be.
+                    document = await Formatter.FormatAsync(document, cancellationToken: cancellationToken).ConfigureAwait(false);
                 }
                 catch (Exception ex) when (FatalError.ReportAndCatchUnlessCanceled(ex, cancellationToken, ErrorSeverity.General))
                 {

src/VisualStudio/Core/Def/Implementation/AbstractEditorFactory.cs

@@ -327,13 +327,9 @@ private async Task FormatDocumentCreatedFromTemplateAsync(IVsHierarchy hierarchy
                 addedDocument = await formattingService.FormatNewDocumentAsync(addedDocument, hintDocument: null, cancellationToken).ConfigureAwait(true);
             }
 
-            var rootToFormat = await addedDocument.GetRequiredSyntaxRootAsync(cancellationToken).ConfigureAwait(true);
-            var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(addedDocument, cancellationToken).ConfigureAwait(true);
-
             // Format document
-            var unformattedText = await addedDocument.GetTextAsync(cancellationToken).ConfigureAwait(true);
-            var formattedRoot = Formatter.Format(rootToFormat, workspace.Services, formattingOptions, cancellationToken);
-            var formattedText = formattedRoot.GetText(unformattedText.Encoding, unformattedText.ChecksumAlgorithm);
+            var formattingOptions = await SyntaxFormattingOptions.FromDocumentAsync(addedDocument, cancellationToken).ConfigureAwait(true);
+            var formattedText = await addedDocument.GetTextAsync(cancellationToken).ConfigureAwait(true);
 
             // Ensure the line endings are normalized. The formatter doesn't touch everything if it doesn't need to.
             var targetLineEnding = formattingOptions.GetOption(FormattingOptions2.NewLine)!;