Update SA1201 for file-scoped namespaces

Author: sharwell

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

@@ -3,9 +3,51 @@
 
 namespace StyleCop.Analyzers.Test.CSharp10.OrderingRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp9.OrderingRules;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.OrderingRules.SA1201ElementsMustAppearInTheCorrectOrder,
+        StyleCop.Analyzers.OrderingRules.ElementOrderCodeFixProvider>;
 
     public class SA1201CSharp10UnitTests : SA1201CSharp9UnitTests
     {
+        [Fact]
+        public async Task TestOuterOrderCorrectOrderWithFileScopedNamespaceAsync()
+        {
+            string testCode = @"namespace Foo;
+
+public delegate void bar();
+public enum TestEnum { }
+public interface IFoo { }
+public struct FooStruct { }
+public class FooClass { }
+";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestOuterOrderWrongOrderWithFileScopedNamespaceAsync()
+        {
+            string testCode = @"
+namespace Foo;
+
+public enum TestEnum { }
+public delegate void {|#0:bar|}();
+public interface IFoo { }
+public class FooClass { }
+public struct {|#1:FooStruct|} { }
+";
+            var expected = new[]
+            {
+                Diagnostic().WithLocation(0).WithArguments("delegate", "enum"),
+                Diagnostic().WithLocation(1).WithArguments("struct", "class"),
+            };
+
+            await VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1201ElementsMustAppearInTheCorrectOrder.cs

@@ -123,6 +123,7 @@ internal class SA1201ElementsMustAppearInTheCorrectOrder : DiagnosticAnalyzer
 
         // extern alias and usings are missing here because the compiler itself is enforcing the right order.
         private static readonly ImmutableArray<SyntaxKind> OuterOrder = ImmutableArray.Create(
+            SyntaxKindEx.FileScopedNamespaceDeclaration,
             SyntaxKind.NamespaceDeclaration,
             SyntaxKind.DelegateDeclaration,
             SyntaxKind.EnumDeclaration,
@@ -149,6 +150,7 @@ internal class SA1201ElementsMustAppearInTheCorrectOrder : DiagnosticAnalyzer
         private static readonly Dictionary<SyntaxKind, string> MemberNames = new Dictionary<SyntaxKind, string>
         {
             [SyntaxKind.NamespaceDeclaration] = "namespace",
+            [SyntaxKindEx.FileScopedNamespaceDeclaration] = "namespace",
             [SyntaxKind.DelegateDeclaration] = "delegate",
             [SyntaxKind.EnumDeclaration] = "enum",
             [SyntaxKind.InterfaceDeclaration] = "interface",
@@ -172,7 +174,7 @@ internal class SA1201ElementsMustAppearInTheCorrectOrder : DiagnosticAnalyzer
         };
 
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> CompilationUnitAction = HandleCompilationUnit;
-        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> BaseNamespaceDeclarationAction = HandleBaseNamespaceDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> TypeDeclarationAction = HandleTypeDeclaration;
 
         /// <inheritdoc/>
@@ -186,7 +188,7 @@ public override void Initialize(AnalysisContext context)
             context.EnableConcurrentExecution();
 
             context.RegisterSyntaxNodeAction(CompilationUnitAction, SyntaxKind.CompilationUnit);
-            context.RegisterSyntaxNodeAction(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
+            context.RegisterSyntaxNodeAction(BaseNamespaceDeclarationAction, SyntaxKinds.BaseNamespaceDeclaration);
             context.RegisterSyntaxNodeAction(TypeDeclarationAction, SyntaxKinds.TypeDeclaration);
         }
 
@@ -218,7 +220,7 @@ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, Sty
             HandleMemberList(context, elementOrder, kindIndex, compilationUnit.Members, OuterOrder);
         }
 
-        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
+        private static void HandleBaseNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             var elementOrder = settings.OrderingRules.ElementOrder;
             int kindIndex = elementOrder.IndexOf(OrderingTrait.Kind);
@@ -227,9 +229,9 @@ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context
                 return;
             }
 
-            var compilationUnit = (NamespaceDeclarationSyntax)context.Node;
+            var baseNamespaceDeclaration = (BaseNamespaceDeclarationSyntaxWrapper)context.Node;
 
-            HandleMemberList(context, elementOrder, kindIndex, compilationUnit.Members, OuterOrder);
+            HandleMemberList(context, elementOrder, kindIndex, baseNamespaceDeclaration.Members, OuterOrder);
         }
 
         private static void HandleMemberList(SyntaxNodeAnalysisContext context, ImmutableArray<OrderingTrait> elementOrder, int kindIndex, SyntaxList<MemberDeclarationSyntax> members, ImmutableArray<SyntaxKind> order)