Update SA1200 to simply ignore global using directive placement

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/OrderingRules/UsingCodeFixProvider.cs

@@ -69,10 +69,15 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                     continue;
                 }
 
+                // Force preserving the placement of using directives when we are fixing a diagnostic not directly
+                // related to placement of using directives inside/outside namespaces, and also when there are global
+                // usings present.
+                bool forcePreservePlacement = !isSA1200 || compilationUnit.Usings.Any(static syntax => syntax.GlobalKeyword().IsKind(SyntaxKind.GlobalKeyword));
+
                 context.RegisterCodeFix(
                     CodeAction.Create(
                         OrderingResources.UsingCodeFix,
-                        cancellationToken => GetTransformedDocumentAsync(context.Document, syntaxRoot, !isSA1200, cancellationToken),
+                        cancellationToken => GetTransformedDocumentAsync(context.Document, syntaxRoot, forcePreservePlacement, cancellationToken),
                         nameof(UsingCodeFixProvider)),
                     diagnostic);
             }
@@ -513,9 +518,14 @@ protected override async Task<SyntaxNode> FixAllInDocumentAsync(FixAllContext fi
                     return null;
                 }
 
-                var forcePreserve = diagnostics.All(d => d.Id != SA1200UsingDirectivesMustBePlacedCorrectly.DiagnosticId);
-
                 var syntaxRoot = await document.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
+
+                // Force preserving the placement of using directives when we are fixing any diagnostic not directly
+                // related to placement of using directives inside/outside namespaces, and also when there are global
+                // usings present.
+                var forcePreserve = diagnostics.All(d => d.Id != SA1200UsingDirectivesMustBePlacedCorrectly.DiagnosticId)
+                     || ((CompilationUnitSyntax)syntaxRoot).Usings.Any(static syntax => syntax.GlobalKeyword().IsKind(SyntaxKind.GlobalKeyword));
+
                 Document newDocument = await GetTransformedDocumentAsync(document, syntaxRoot, forcePreserve, fixAllContext.CancellationToken).ConfigureAwait(false);
                 return await newDocument.GetSyntaxRootAsync(fixAllContext.CancellationToken).ConfigureAwait(false);
             }

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp10/OrderingRules/SA1200CSharp10UnitTests.cs

@@ -55,13 +55,36 @@ public async Task TestOnlyGlobalUsingStatementInFileAsync(string leadingTrivia)
         [WorkItem(3875, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3875")]
         public async Task TestGlobalUsingStatementInFileWithNamespaceAsync()
         {
-            var testCode = @"[|global using System;|]
+            var testCode = @"global using System;
 
 namespace TestNamespace
 {
 }";
 
             await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        [WorkItem(3875, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3875")]
+        public async Task TestGlobalUsingStatementInFileWithOtherUsingDirectivesAsync()
+        {
+            var testCode = @"global using System;
+[|using System.Linq;|]
+
+namespace TestNamespace
+{
+}";
+
+            await new CSharpTest
+            {
+                TestCode = testCode,
+
+                // UsingCodeFixProvider currently leaves all using directives in the same location (either inside or
+                // outside the namespace) when the file contains any global using directives.
+                FixedCode = testCode,
+                NumberOfIncrementalIterations = 1,
+                NumberOfFixAllIterations = 1,
+            }.RunAsync(CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1200UsingDirectivesMustBePlacedCorrectly.cs

@@ -216,7 +216,6 @@ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, Sty
             CompilationUnitSyntax syntax = (CompilationUnitSyntax)context.Node;
 
             List<SyntaxNode> usingDirectives = new List<SyntaxNode>();
-            bool containsOnlyGlobalUsingDirectives = true;
             foreach (SyntaxNode child in syntax.ChildNodes())
             {
                 switch (child.Kind())
@@ -238,26 +237,22 @@ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, Sty
                     return;
 
                 case SyntaxKind.UsingDirective:
-                    usingDirectives.Add(child);
-                    bool isGlobalUsing = ((UsingDirectiveSyntax)child).GlobalKeyword().IsKind(SyntaxKind.GlobalKeyword);
-                    containsOnlyGlobalUsingDirectives = containsOnlyGlobalUsingDirectives && isGlobalUsing;
+                    // Global using directives are only allowed at the top level, so ignore those
+                    if (!((UsingDirectiveSyntax)child).GlobalKeyword().IsKind(SyntaxKind.GlobalKeyword))
+                    {
+                        usingDirectives.Add(child);
+                    }
+
                     continue;
 
                 case SyntaxKind.NamespaceDeclaration:
                 case SyntaxKindEx.FileScopedNamespaceDeclaration:
                 case SyntaxKind.ExternAliasDirective:
                 default:
-                    containsOnlyGlobalUsingDirectives = false;
                     continue;
                 }
             }
 
-            if (containsOnlyGlobalUsingDirectives)
-            {
-                // Suppress SA1200 if file only contains global using directives
-                return;
-            }
-
             foreach (var directive in usingDirectives)
             {
                 // Using directive should appear within a namespace declaration