Merge pull request #1186 from Maxwe11/SA1503

Fix SA1503 to report on lock, using and fixed statements without braces
DotNetAnalyzers · Aug 11, 2015 · 2088f26 · 2088f26
2 parents 70d6953 + 27d90f4
commit 2088f26
Show file tree

Hide file tree

Showing 2 changed files with 22 additions and 48 deletions.
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1503UnitTests.cs b/StyleCop.Analyzers/StyleCop.Analyzers.Test/LayoutRules/SA1503UnitTests.cs
@@ -28,6 +28,9 @@ 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 (this)" };
+                yield return new[] { "using (this)" };
+                yield return new[] { "fixed (byte* ptr = new byte[10])" };
             }
         }
 
@@ -412,29 +415,33 @@ private async Task TestCodeFixForStatementAsync(string statementText)
         private string GenerateTestStatement(string statementText)
         {
             var testCodeFormat = @"using System.Diagnostics;
-public class Foo
+public class Foo : System.IDisposable
 {
-    public void Bar(int i)
+    public unsafe void Bar(int i)
     {
         #STATEMENT#
             Debug.Assert(true);
     }
+
+    public void Dispose() {}
 }";
             return testCodeFormat.Replace("#STATEMENT#", statementText);
         }
 
         private string GenerateFixedTestStatement(string statementText)
         {
             var fixedTestCodeFormat = @"using System.Diagnostics;
-public class Foo
+public class Foo : System.IDisposable
 {
-    public void Bar(int i)
+    public unsafe void Bar(int i)
     {
         #STATEMENT#
         {
             Debug.Assert(true);
         }
     }
+
+    public void Dispose() {}
 }";
             return fixedTestCodeFormat.Replace("#STATEMENT#", statementText);
         }

diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1503CurlyBracketsMustNotBeOmitted.cs b/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1503CurlyBracketsMustNotBeOmitted.cs
@@ -80,14 +80,17 @@ public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
         /// <inheritdoc/>
         public override void Initialize(AnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleIfStatement, SyntaxKind.IfStatement);
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleDoStatement, SyntaxKind.DoStatement);
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleWhileStatement, SyntaxKind.WhileStatement);
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleForStatement, SyntaxKind.ForStatement);
-            context.RegisterSyntaxNodeActionHonorExclusions(this.HandleForEachStatement, SyntaxKind.ForEachStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleIfStatement, SyntaxKind.IfStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((DoStatementSyntax)ctx.Node).Statement), SyntaxKind.DoStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((WhileStatementSyntax)ctx.Node).Statement), SyntaxKind.WhileStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((ForStatementSyntax)ctx.Node).Statement), SyntaxKind.ForStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((ForEachStatementSyntax)ctx.Node).Statement), SyntaxKind.ForEachStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((FixedStatementSyntax)ctx.Node).Statement), SyntaxKind.FixedStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((UsingStatementSyntax)ctx.Node).Statement), SyntaxKind.UsingStatement);
+            context.RegisterSyntaxNodeActionHonorExclusions(ctx => CheckChildStatement(ctx, ((LockStatementSyntax)ctx.Node).Statement), SyntaxKind.LockStatement);
         }
 
-        private void HandleIfStatement(SyntaxNodeAnalysisContext context)
+        private static void HandleIfStatement(SyntaxNodeAnalysisContext context)
         {
             var ifStatement = (IfStatementSyntax)context.Node;
             if (ifStatement.Parent.IsKind(SyntaxKind.ElseClause))
@@ -117,47 +120,11 @@ private void HandleIfStatement(SyntaxNodeAnalysisContext context)
 
             foreach (StatementSyntax clause in clauses)
             {
-                this.CheckChildStatement(context, clause);
+                CheckChildStatement(context, clause);
             }
         }
 
-        private void HandleDoStatement(SyntaxNodeAnalysisContext context)
-        {
-            var doStatement = context.Node as DoStatementSyntax;
-            if (doStatement != null)
-            {
-                this.CheckChildStatement(context, doStatement.Statement);
-            }
-        }
-
-        private void HandleWhileStatement(SyntaxNodeAnalysisContext context)
-        {
-            var whileStatement = context.Node as WhileStatementSyntax;
-            if (whileStatement != null)
-            {
-                this.CheckChildStatement(context, whileStatement.Statement);
-            }
-        }
-
-        private void HandleForStatement(SyntaxNodeAnalysisContext context)
-        {
-            var forStatement = context.Node as ForStatementSyntax;
-            if (forStatement != null)
-            {
-                this.CheckChildStatement(context, forStatement.Statement);
-            }
-        }
-
-        private void HandleForEachStatement(SyntaxNodeAnalysisContext context)
-        {
-            var forEachStatement = context.Node as ForEachStatementSyntax;
-            if (forEachStatement != null)
-            {
-                this.CheckChildStatement(context, forEachStatement.Statement);
-            }
-        }
-
-        private void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
+        private static void CheckChildStatement(SyntaxNodeAnalysisContext context, StatementSyntax childStatement)
         {
             if (childStatement is BlockSyntax)
             {