Merge pull request #1809 from sharwell/fix-1747

sharwell · sharwell · commit dc7e71a308dc · 2015-11-23T12:05:34.000-06:00
Add the systemUsingDirectivesFirst ordering option
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/OrderingRules/UsingCodeFixProvider.cs b/StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/OrderingRules/UsingCodeFixProvider.cs
@@ -74,10 +74,11 @@ private static async Task<Document> GetTransformedDocumentAsync(Document documen
         {
             var compilationUnit = (CompilationUnitSyntax)syntaxRoot;
 
+            var settings = SettingsHelper.GetStyleCopSettings(document.Project.AnalyzerOptions, cancellationToken);
             var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
             var indentationOptions = IndentationOptions.FromDocument(document);
 
-            var usingsHelper = new UsingsHelper(semanticModel, document, compilationUnit);
+            var usingsHelper = new UsingsHelper(settings, semanticModel, document, compilationUnit);
             var namespaceCount = CountNamespaces(compilationUnit.Members);
 
             // Only move using declarations inside the namespace when
@@ -436,15 +437,17 @@ public DirectiveSpan FindContainingSpan(SyntaxNode node)
 
         private class UsingsHelper
         {
+            private readonly StyleCopSettings settings;
             private readonly SemanticModel semanticModel;
             private readonly DirectiveSpan conditionalDirectiveTree;
             private readonly bool separateSystemDirectives;
 
-            public UsingsHelper(SemanticModel semanticModel, Document document, CompilationUnitSyntax compilationUnit)
+            public UsingsHelper(StyleCopSettings settings, SemanticModel semanticModel, Document document, CompilationUnitSyntax compilationUnit)
             {
+                this.settings = settings;
                 this.semanticModel = semanticModel;
                 this.conditionalDirectiveTree = DirectiveSpan.BuildConditionalDirectiveTree(compilationUnit);
-                this.separateSystemDirectives = !document.Project.CompilationOptions.IsAnalyzerSuppressed(SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.DiagnosticId);
+                this.separateSystemDirectives = settings.OrderingRules.SystemUsingDirectivesFirst;
 
                 this.ProcessUsingDirectives(compilationUnit.Usings);
                 this.ProcessMembers(compilationUnit.Members);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/OrderingRules/SA1210CombinedSystemDirectivesUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/OrderingRules/SA1210CombinedSystemDirectivesUnitTests.cs
@@ -6,15 +6,16 @@ namespace StyleCop.Analyzers.Test.OrderingRules
     using System.Collections.Generic;
     using System.Threading;
     using System.Threading.Tasks;
+    using Analyzers.OrderingRules;
+    using Analyzers.Settings.ObjectModel;
     using Microsoft.CodeAnalysis.CodeFixes;
     using Microsoft.CodeAnalysis.Diagnostics;
-    using StyleCop.Analyzers.OrderingRules;
     using TestHelper;
     using Xunit;
 
     /// <summary>
     /// Unit tests for <see cref="SA1210UsingDirectivesMustBeOrderedAlphabeticallyByNamespace"/> for the special case
-    /// where <see cref="SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives"/> is disabled.
+    /// where <see cref="OrderingSettings.SystemUsingDirectivesFirst"/> is <see langword="false"/>.
     /// </summary>
     public class SA1210CombinedSystemDirectivesUnitTests : CodeFixVerifier
     {
@@ -209,9 +210,19 @@ public async Task TestPreprocessorDirectivesAsync()
         }
 
         /// <inheritdoc/>
-        protected override IEnumerable<string> GetDisabledDiagnostics()
+        protected override string GetSettings()
         {
-            yield return SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.DiagnosticId;
+            const string CombinedUsingDirectivesTestSettings = @"
+{
+  ""settings"": {
+    ""orderingRules"": {
+      ""systemUsingDirectivesFirst"": false
+    }
+  }
+}
+";
+
+            return CombinedUsingDirectivesTestSettings;
         }
 
         /// <inheritdoc/>
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/OrderingRules/UsingCodeFixProviderCombinedSystemDirectivesUnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/OrderingRules/UsingCodeFixProviderCombinedSystemDirectivesUnitTests.cs
@@ -15,7 +15,7 @@ namespace StyleCop.Analyzers.Test.OrderingRules
 
     /// <summary>
     /// Unit tests for the <see cref="UsingCodeFixProvider"/> for the special case where
-    /// <see cref="SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives"/> is disabled.
+    /// <see cref="OrderingSettings.SystemUsingDirectivesFirst"/> is <see langword="false"/>.
     /// </summary>
     public class UsingCodeFixProviderCombinedSystemDirectivesUnitTests : CodeFixVerifier
     {
@@ -397,19 +397,14 @@ public class Bar
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
 
-        /// <inheritdoc/>
-        protected override IEnumerable<string> GetDisabledDiagnostics()
-        {
-            yield return SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.DiagnosticId;
-        }
-
         /// <inheritdoc/>
         protected override string GetSettings()
         {
             string testSettings = $@"
 {{
   ""settings"": {{
     ""orderingRules"": {{
+      ""systemUsingDirectivesFirst"": false,
       ""usingDirectivesPlacement"": ""{this.usingDirectivesPlacement}""
     }}
   }}
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.cs
@@ -10,6 +10,7 @@ namespace StyleCop.Analyzers.OrderingRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Settings.ObjectModel;
 
     /// <summary>
     /// A using directive which declares a member of the <see cref="System"/> namespace appears after a using directive
@@ -38,8 +39,8 @@ internal class SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
-        private static readonly Action<SyntaxNodeAnalysisContext> CompilationUnitAction = HandleCompilationUnit;
-        private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> CompilationUnitAction = HandleCompilationUnit;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -57,17 +58,27 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
         }
 
-        private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
+        private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
+            if (!settings.OrderingRules.SystemUsingDirectivesFirst)
+            {
+                return;
+            }
+
             var compilationUnit = context.Node as CompilationUnitSyntax;
 
             var usings = compilationUnit.Usings;
 
             ProcessUsingsAndReportDiagnostic(usings, context);
         }
 
-        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
+            if (!settings.OrderingRules.SystemUsingDirectivesFirst)
+            {
+                return;
+            }
+
             var namespaceDeclaration = context.Node as NamespaceDeclarationSyntax;
 
             var usings = namespaceDeclaration.Usings;
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1210UsingDirectivesMustBeOrderedAlphabeticallyByNamespace.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1210UsingDirectivesMustBeOrderedAlphabeticallyByNamespace.cs
@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.OrderingRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Settings.ObjectModel;
 
     /// <summary>
     /// The using directives within a C# code file are not sorted alphabetically by namespace.
@@ -40,8 +41,8 @@ internal class SA1210UsingDirectivesMustBeOrderedAlphabeticallyByNamespace : Dia
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
-        private static readonly Action<SyntaxNodeAnalysisContext> CompilationUnitAction = HandleCompilationUnit;
-        private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> CompilationUnitAction = HandleCompilationUnit;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -59,21 +60,21 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);
         }
 
-        private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
+        private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             var compilationUnit = (CompilationUnitSyntax)context.Node;
 
-            ProcessUsings(context, compilationUnit.Usings);
+            ProcessUsings(context, settings.OrderingRules, compilationUnit.Usings);
         }
 
-        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
 
-            ProcessUsings(context, namespaceDeclaration.Usings);
+            ProcessUsings(context, settings.OrderingRules, namespaceDeclaration.Usings);
         }
 
-        private static void ProcessUsings(SyntaxNodeAnalysisContext context, SyntaxList<UsingDirectiveSyntax> usings)
+        private static void ProcessUsings(SyntaxNodeAnalysisContext context, OrderingSettings orderingSettings, SyntaxList<UsingDirectiveSyntax> usings)
         {
             var usingDirectives = new List<UsingDirectiveSyntax>();
             var systemUsingDirectives = new List<UsingDirectiveSyntax>();
@@ -95,7 +96,7 @@ private static void ProcessUsings(SyntaxNodeAnalysisContext context, SyntaxList<
 
                 if (usingDirective.HasNamespaceAliasQualifier()
                     || !usingDirective.IsSystemUsingDirective()
-                    || context.IsAnalyzerSuppressed(SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.DiagnosticId))
+                    || !orderingSettings.SystemUsingDirectivesFirst)
                 {
                     usingDirectives.Add(usingDirective);
                 }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/OrderingSettings.cs b/StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/OrderingSettings.cs
@@ -8,6 +8,12 @@ namespace StyleCop.Analyzers.Settings.ObjectModel
     [JsonObject(MemberSerialization.OptIn)]
     internal class OrderingSettings
     {
+        /// <summary>
+        /// This is the backing field for the <see cref="SystemUsingDirectivesFirst"/> property.
+        /// </summary>
+        [JsonProperty("systemUsingDirectivesFirst", DefaultValueHandling = DefaultValueHandling.Include)]
+        private bool systemUsingDirectivesFirst;
+
         /// <summary>
         /// This is the backing field for the <see cref="UsingDirectivesPlacement"/> property.
         /// </summary>
@@ -20,9 +26,13 @@ internal class OrderingSettings
         [JsonConstructor]
         protected internal OrderingSettings()
         {
+            this.systemUsingDirectivesFirst = true;
             this.usingDirectivesPlacement = UsingDirectivesPlacement.InsideNamespace;
         }
 
+        public bool SystemUsingDirectivesFirst =>
+            this.systemUsingDirectivesFirst;
+
         public UsingDirectivesPlacement UsingDirectivesPlacement =>
             this.usingDirectivesPlacement;
     }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json b/StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json
@@ -29,6 +29,11 @@
           "description": "Configuration for ordering rules (SA1200-)",
           "additionalProperties": false,
           "properties": {
+            "systemUsingDirectivesFirst": {
+              "type": "boolean",
+              "description": "When true, System using directives must be placed before other using directives.",
+              "default": true
+            },
             "usingDirectivesPlacement": {
               "type": "string",
               "description": "Specifies the desired placement of using directives.\r\ninsideNamespace: Place using directives inside the namespace definition\r\noutsideNamespace: Place using directives outside the namespace definition\r\npreserve: Allow using directives inside or outside the namespace definition",
diff --git a/documentation/Configuration.md b/documentation/Configuration.md
@@ -89,6 +89,7 @@ The following properties are used to configure using directives in StyleCop Anal
 
 | Property | Default Value | Summary |
 | --- | --- | --- |
+| `systemUsingDirectivesFirst` | true | Specifies whether `System` using directives are placed before other using directives |
 | `usingDirectivesPlacement` | `"insideNamespace"` | Specifies the desired placement of using directives |
 
 #### Using Directives Placement

Original file line number	Diff line number	Diff line change
`@@ -12,6 +12,7 @@ namespace StyleCop.Analyzers.OrderingRules`
`12`	`12`	`using Microsoft.CodeAnalysis.CSharp.Syntax;`
`13`	`13`	`using Microsoft.CodeAnalysis.Diagnostics;`
`14`	`14`	`using StyleCop.Analyzers.Helpers;`
	`15`	`+ using StyleCop.Analyzers.Settings.ObjectModel;`
`15`	`16`
`16`	`17`	`/// <summary>`
`17`	`18`	`/// The using directives within a C# code file are not sorted alphabetically by namespace.`
`@@ -40,8 +41,8 @@ internal class SA1210UsingDirectivesMustBeOrderedAlphabeticallyByNamespace : Dia`
`40`	`41`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`41`	`42`
`42`	`43`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`43`		`- private static readonly Action<SyntaxNodeAnalysisContext> CompilationUnitAction = HandleCompilationUnit;`
`44`		`- private static readonly Action<SyntaxNodeAnalysisContext> NamespaceDeclarationAction = HandleNamespaceDeclaration;`
	`44`	`+ private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> CompilationUnitAction = HandleCompilationUnit;`
	`45`	`+ private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> NamespaceDeclarationAction = HandleNamespaceDeclaration;`
`45`	`46`
`46`	`47`	`/// <inheritdoc/>`
`47`	`48`	`public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =`
`@@ -59,21 +60,21 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte`
`59`	`60`	`context.RegisterSyntaxNodeActionHonorExclusions(NamespaceDeclarationAction, SyntaxKind.NamespaceDeclaration);`
`60`	`61`	`}`
`61`	`62`
`62`		`- private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)`
	`63`	`+ private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context, StyleCopSettings settings)`
`63`	`64`	`{`
`64`	`65`	`var compilationUnit = (CompilationUnitSyntax)context.Node;`
`65`	`66`
`66`		`- ProcessUsings(context, compilationUnit.Usings);`
	`67`	`+ ProcessUsings(context, settings.OrderingRules, compilationUnit.Usings);`
`67`	`68`	`}`
`68`	`69`
`69`		`- private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)`
	`70`	`+ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context, StyleCopSettings settings)`
`70`	`71`	`{`
`71`	`72`	`var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;`
`72`	`73`
`73`		`- ProcessUsings(context, namespaceDeclaration.Usings);`
	`74`	`+ ProcessUsings(context, settings.OrderingRules, namespaceDeclaration.Usings);`
`74`	`75`	`}`
`75`	`76`
`76`		`- private static void ProcessUsings(SyntaxNodeAnalysisContext context, SyntaxList<UsingDirectiveSyntax> usings)`
	`77`	`+ private static void ProcessUsings(SyntaxNodeAnalysisContext context, OrderingSettings orderingSettings, SyntaxList<UsingDirectiveSyntax> usings)`
`77`	`78`	`{`
`78`	`79`	`var usingDirectives = new List<UsingDirectiveSyntax>();`
`79`	`80`	`var systemUsingDirectives = new List<UsingDirectiveSyntax>();`
`@@ -95,7 +96,7 @@ private static void ProcessUsings(SyntaxNodeAnalysisContext context, SyntaxList<`
`95`	`96`
`96`	`97`	`if (usingDirective.HasNamespaceAliasQualifier()`
`97`	`98`	`\|\| !usingDirective.IsSystemUsingDirective()`
`98`		`- \|\| context.IsAnalyzerSuppressed(SA1208SystemUsingDirectivesMustBePlacedBeforeOtherUsingDirectives.DiagnosticId))`
	`99`	`+ \|\| !orderingSettings.SystemUsingDirectivesFirst)`
`99`	`100`	`{`
`100`	`101`	`usingDirectives.Add(usingDirective);`
`101`	`102`	`}`