Make SA1519 work with lock and fixed (fix #2885)

Author: pantosha

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

@@ -29,6 +29,7 @@ public static IEnumerable<object[]> TestStatements
                 yield return new[] { "while (i == 0)" };
                 yield return new[] { "for (var j = 0; j < i; j++)" };
                 yield return new[] { "foreach (var j in new[] { 1, 2, 3 })" };
+                yield return new[] { "lock (new object())" };
                 yield return new[] { "using (default(System.IDisposable))" };
             }
         }
@@ -363,6 +364,84 @@ public void Bar(int i)
             await VerifyCSharpDiagnosticAsync(testCode, expected, CancellationToken.None).ConfigureAwait(false);
         }
 
+        [Fact]
+        public async Task TestSingleLineFixedStatementWithoutBracesAsync()
+        {
+            var testCode = @"public class C {
+    unsafe private static void TestMethod()
+    {
+        var a = new int[] { 1, 2, 3 };
+        fixed (int* n = &a[0])
+            *n = a[1] + a[2];
+    }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestMultiLineFixedStatementWithoutBracesAsync()
+        {
+            var testCode = @"public class C {
+    unsafe private static void TestMethod()
+    {
+        var a = new int[] { 1, 2, 3 };
+        fixed (int* n = &a[0])
+            *n = a[1]
+                + a[2];
+    }
+}";
+            var fixedCode = @"public class C {
+    unsafe private static void TestMethod()
+    {
+        var a = new int[] { 1, 2, 3 };
+        fixed (int* n = &a[0])
+        {
+            *n = a[1]
+                + a[2];
+        }
+    }
+}";
+
+            var expected = Diagnostic().WithLocation(6, 13);
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestSingleLineFixedStatementWithBracesAsync()
+        {
+            var testCode = @"public class C {
+    unsafe private static void TestMethod()
+    {
+        var a = new int[] { 1, 2, 3 };
+        fixed (int* n = &a[0])
+        {
+            *n = a[1] + a[2];
+        }
+    }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        public async Task TestMultiLineFixedStatementWithBracesAsync()
+        {
+            var testCode = @"public class C {
+    unsafe private static void TestMethod()
+    {
+        var a = new int[] { 1, 2, 3 };
+        fixed (int* n = &a[0])
+        {
+            *n = a[1]
+                + a[2];
+        }
+    }
+}";
+
+            await VerifyCSharpDiagnosticAsync(testCode, DiagnosticResult.EmptyDiagnosticResults, CancellationToken.None).ConfigureAwait(false);
+        }
+
         /// <summary>
         /// Verifies that the code fix provider will work properly for a statement.
         /// </summary>

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

@@ -52,6 +52,8 @@ 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> LockStatementAction = HandleLockStatement;
+        private static readonly Action<SyntaxNodeAnalysisContext> FixedStatementAction = HandleFixedStatement;
         private static readonly Action<SyntaxNodeAnalysisContext, StyleCopSettings> UsingStatementAction = HandleUsingStatement;
 
         /// <inheritdoc/>
@@ -69,6 +71,8 @@ public override void Initialize(AnalysisContext context)
             context.RegisterSyntaxNodeAction(WhileStatementAction, SyntaxKind.WhileStatement);
             context.RegisterSyntaxNodeAction(ForStatementAction, SyntaxKind.ForStatement);
             context.RegisterSyntaxNodeAction(ForEachStatementAction, SyntaxKind.ForEachStatement);
+            context.RegisterSyntaxNodeAction(LockStatementAction, SyntaxKind.LockStatement);
+            context.RegisterSyntaxNodeAction(FixedStatementAction, SyntaxKind.FixedStatement);
             context.RegisterSyntaxNodeAction(UsingStatementAction, SyntaxKind.UsingStatement);
         }
 
@@ -112,6 +116,18 @@ private static void HandleForEachStatement(SyntaxNodeAnalysisContext context)
             CheckChildStatement(context, forEachStatement.Statement);
         }
 
+        private static void HandleLockStatement(SyntaxNodeAnalysisContext context)
+        {
+            var lockStatement = (LockStatementSyntax)context.Node;
+            CheckChildStatement(context, lockStatement.Statement);
+        }
+
+        private static void HandleFixedStatement(SyntaxNodeAnalysisContext context)
+        {
+            var fixedStatement = (FixedStatementSyntax)context.Node;
+            CheckChildStatement(context, fixedStatement.Statement);
+        }
+
         private static void HandleUsingStatement(SyntaxNodeAnalysisContext context, StyleCopSettings settings)
         {
             var usingStatement = (UsingStatementSyntax)context.Node;