Merge pull request #2608 from sharwell/allow-single-line-arrays

Allow single-line ArrayCreationExpression syntax

Author: sharwell

StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1500/SA1500UnitTests.ArrayInitializers.cs

@@ -25,6 +25,8 @@ public partial class SA1500UnitTests
         public async Task TestArrayInitializersValidAsync()
         {
             var testCode = @"
+using System;
+
 public class TestClass
 {
     private int[] array1 = { };
@@ -33,6 +35,8 @@ public class TestClass
 
     private int[] array3 = new[] { 0, 1 };
 
+    private int[] array3b = new int[] { 0, 1 };
+
     private int[] array4 =
     {
     };
@@ -70,18 +74,22 @@ public void TestMethod()
         {
             0,
         };
+
+        Console.WriteLine(new[] { 0, 1 });
+        Console.WriteLine(new int[] { 0, 1 });
+        Console.WriteLine(new int[] { });
     }
 }";
 
             await this.VerifyCSharpDiagnosticAsync(testCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
         }
 
         /// <summary>
-        /// Verifies that diagnostics will be reported for all invalid array initializer definitions.
+        /// Verifies that diagnostics will be reported for all invalid implicit array initializer definitions.
         /// </summary>
         /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
         [Fact]
-        public async Task TestArrayInitializersInvalidAsync()
+        public async Task TestImplicitArrayInitializersInvalidAsync()
         {
             var testCode = @"
 public class TestClass
@@ -243,5 +251,96 @@ public void TestMethod()
             await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
             await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
         }
+
+        /// <summary>
+        /// Verifies that diagnostics will be reported for all invalid array initializer definitions.
+        /// </summary>
+        /// <returns>A <see cref="Task"/> representing the asynchronous unit test.</returns>
+        [Fact]
+        [WorkItem(2607, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2607")]
+        public async Task TestArrayInitializersInvalidAsync()
+        {
+            var testCode = @"
+public class TestClass
+{
+    private int[] invalidArray5 = new int[]
+        { 0, 1 };
+
+    private int[] invalidArray6 = new int[]
+        { 0, 1
+        };
+
+    private int[] invalidArray7 = new int[]
+        {
+            0, 1 };
+
+    public void TestMethod()
+    {
+        var invalidArray12 = new int[]
+            { 0, 1 };
+
+        var invalidArray13 = new int[]
+            { 0, 1
+            };
+
+        var invalidArray14 = new int[]
+            {
+                0, 1 };
+    }
+}";
+
+            var fixedTestCode = @"
+public class TestClass
+{
+    private int[] invalidArray5 = new int[]
+        {
+            0, 1
+        };
+
+    private int[] invalidArray6 = new int[]
+        {
+            0, 1
+        };
+
+    private int[] invalidArray7 = new int[]
+        {
+            0, 1
+        };
+
+    public void TestMethod()
+    {
+        var invalidArray12 = new int[]
+            {
+                0, 1
+            };
+
+        var invalidArray13 = new int[]
+            {
+                0, 1
+            };
+
+        var invalidArray14 = new int[]
+            {
+                0, 1
+            };
+    }
+}";
+
+            DiagnosticResult[] expectedDiagnostics =
+            {
+                this.CSharpDiagnostic().WithLocation(5, 9),
+                this.CSharpDiagnostic().WithLocation(5, 16),
+                this.CSharpDiagnostic().WithLocation(8, 9),
+                this.CSharpDiagnostic().WithLocation(13, 18),
+                this.CSharpDiagnostic().WithLocation(18, 13),
+                this.CSharpDiagnostic().WithLocation(18, 20),
+                this.CSharpDiagnostic().WithLocation(21, 13),
+                this.CSharpDiagnostic().WithLocation(26, 22),
+            };
+
+            await this.VerifyCSharpDiagnosticAsync(testCode, expectedDiagnostics, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpDiagnosticAsync(fixedTestCode, EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+            await this.VerifyCSharpFixAsync(testCode, fixedTestCode).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1500BracesForMultiLineStatementsMustNotShareLine.cs

@@ -155,6 +155,14 @@ private static void CheckBraces(SyntaxNodeAnalysisContext context, SyntaxToken o
 
                         break;
 
+                    case SyntaxKind.ArrayCreationExpression:
+                        if (GetStartLine(((ArrayCreationExpressionSyntax)context.Node.Parent).NewKeyword) == GetStartLine(openBraceToken))
+                        {
+                            return;
+                        }
+
+                        break;
+
                     case SyntaxKind.ImplicitArrayCreationExpression:
                         if (GetStartLine(((ImplicitArrayCreationExpressionSyntax)context.Node.Parent).NewKeyword) == GetStartLine(openBraceToken))
                         {