Implemented allowConsecutiveUsings option

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1519UnitTests.cs

@@ -14,6 +14,8 @@ namespace StyleCop.Analyzers.Test.LayoutRules
 
     public class SA1519UnitTests : CodeFixVerifier
     {
+        private string consecutiveUsingsSettings;
+
         /// <summary>
         /// Gets the statements that will be used in the theory test cases.
         /// </summary>
@@ -120,13 +122,45 @@ public void Bar(int i)
             await this.VerifyCSharpFixAsync(testCode, fixedCode, cancellationToken: CancellationToken.None).ConfigureAwait(false);
         }
 
+        /// <summary>
+        /// This is a regression test for https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2184.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        public async Task TestMultipleUsingStatementsWithDefaultSettingsAsync()
+        {
+            var testCode = @"using System;
+public class Foo
+{
+    public void Bar(int i)
+    {
+        using (default(IDisposable))
+        using (default(IDisposable))
+        {
+        }
+    }
+}";
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// This is a regression test for https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2180.
         /// </summary>
         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
         [Fact]
-        public async Task TestMultipleUsingStatementsAsync()
+        public async Task TestMultipleUsingStatementsWithDisabledSettingAsync()
         {
+            this.consecutiveUsingsSettings = @"
+{
+  ""settings"": {
+    ""layoutRules"": {
+      ""allowConsecutiveUsings"": false
+    }
+  }
+}
+";
+
             var testCode = @"using System;
 public class Foo
 {
@@ -599,6 +633,11 @@ public void Bar(int i)
             await this.VerifyCSharpFixAsync(testCode, testCode).ConfigureAwait(false);
         }
 
+        protected override string GetSettings()
+        {
+            return this.consecutiveUsingsSettings ?? base.GetSettings();
+        }
+
         protected override IEnumerable<DiagnosticAnalyzer> GetCSharpDiagnosticAnalyzers()
         {
             yield return new SA1519BracesMustNotBeOmittedFromMultiLineChildStatement();

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1519BracesMustNotBeOmittedFromMultiLineChildStatement.cs

@@ -9,6 +9,7 @@ namespace StyleCop.Analyzers.LayoutRules
     using Microsoft.CodeAnalysis.CSharp;
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
+    using Settings.ObjectModel;
     using StyleCop.Analyzers.Helpers;
 
     /// <summary>
@@ -48,7 +49,7 @@ internal class SA1519BracesMustNotBeOmittedFromMultiLineChildStatement : Diagnos
         private static readonly Action<SyntaxNodeAnalysisContext> WhileStatementAction = HandleWhileStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> ForStatementAction = HandleForStatement;
         private static readonly Action<SyntaxNodeAnalysisContext> ForEachStatementAction = HandleForEachStatement;
-        private static readonly Action<SyntaxNodeAnalysisContext> UsingStatementAction = HandleUsingStatement;
+        private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> UsingStatementAction = HandleUsingStatement;
 
         /// <inheritdoc/>
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics { get; } =
@@ -108,9 +109,15 @@ private static void HandleForEachStatement(SyntaxNodeAnalysisContext context)
             CheckChildStatement(context, forEachStatement.Statement);
         }
 
-        private static void HandleUsingStatement(SyntaxNodeAnalysisContext context)
+        private static void HandleUsingStatement(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             var usingStatement = (UsingStatementSyntax)context.Node;
+
+            if (settings.LayoutRules.AllowConsecutiveUsings && (usingStatement.Statement is UsingStatementSyntax))
+            {
+                return;
+            }
+
             CheckChildStatement(context, usingStatement.Statement);
         }
 

StyleCop.Analyzers/StyleCop.Analyzers/Settings/ObjectModel/LayoutSettings.cs

@@ -14,16 +14,23 @@ internal class LayoutSettings
         [JsonProperty("newlineAtEndOfFile", DefaultValueHandling = DefaultValueHandling.Include)]
         private EndOfFileHandling newlineAtEndOfFile;
 
+        [JsonProperty("allowConsecutiveUsings", DefaultValueHandling = DefaultValueHandling.Include)]
+        private bool allowConsecutiveUsings;
+
         /// <summary>
         /// Initializes a new instance of the <see cref="LayoutSettings"/> class during JSON deserialization.
         /// </summary>
         [JsonConstructor]
         protected internal LayoutSettings()
         {
             this.newlineAtEndOfFile = EndOfFileHandling.Allow;
+            this.allowConsecutiveUsings = true;
         }
 
         public EndOfFileHandling NewlineAtEndOfFile =>
             this.newlineAtEndOfFile;
+
+        public bool AllowConsecutiveUsings =>
+            this.allowConsecutiveUsings;
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Settings/stylecop.schema.json

@@ -154,6 +154,11 @@
                 "omit"
               ],
               "default": "allow"
+            },
+            "allowConsecutiveUsings": {
+              "type": "boolean",
+              "description": "Specifies if SA1519 will allow consecutive using statements without braces",
+              "default": true
             }
           }
         },

documentation/Configuration.md

@@ -303,6 +303,7 @@ The following properties are used to configure layout rules in StyleCop Analyzer
 | Property | Default Value | Summary |
 | --- | --- | --- |
 | `newlineAtEndOfFile` | `"allow"` | Specifies the handling for newline characters which appear at the end of a file |
+| `allowConsecutiveUsings` | `true` | Specifies if SA1519 will allow consecutive using statements without braces |
 
 ### Lines at End of File
 
@@ -313,6 +314,14 @@ file are handled. The `newlineAtEndOfFile` property supports the following value
 * `"require"`: Files are required to end with a single newline character
 * `"omit"`: Files may not end with a newline character
 
+### Consecutive using statements without braces
+
+The behavior of [SA1519](SA1519.md) can be customized regarding the manner in which consecutive using statements without braces are treated.
+The `allowConsecutiveUsings` property specifies the behavior:
+
+* `true`: consecutive using statements without braces will not produce diagnostics
+* `false`: consecutive using statements without braces will produce a SA1519 diagnostic
+
 ## Documentation Rules
 
 This section describes the features of documentation rules which can be configured in **stylecop.json**. Each of the described properties are configured in the `documentationRules` object, which is shown in the following sample file.