AV1532: Switched to syntax-based analysis (10x faster)

Author: Bart Koelman

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Maintainability/AvoidNestedLoopsAnalyzer.cs

@@ -1,10 +1,11 @@
 using System;
 using System.Collections.Immutable;
-using CSharpGuidelinesAnalyzer.Extensions;
+using System.Threading;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
-using Microsoft.CodeAnalysis.Operations;
 
 namespace CSharpGuidelinesAnalyzer.Rules.Maintainability
 {
@@ -28,53 +29,139 @@ public sealed class AvoidNestedLoopsAnalyzer : DiagnosticAnalyzer
         public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
         [NotNull]
-        private static readonly Action<OperationAnalysisContext> AnalyzeLoopStatementAction =
-            context => context.SkipInvalid(AnalyzeLoopStatement);
+        private static readonly SyntaxKind[] LoopStatementKinds =
+        {
+            SyntaxKind.WhileStatement,
+            SyntaxKind.DoStatement,
+            SyntaxKind.ForStatement,
+            SyntaxKind.ForEachStatement,
+            SyntaxKind.ForEachVariableStatement
+        };
+
+        [NotNull]
+        private static readonly Action<SyntaxNodeAnalysisContext> AnalyzeLoopStatementAction = AnalyzeLoopStatement;
 
         public override void Initialize([NotNull] AnalysisContext context)
         {
             context.EnableConcurrentExecution();
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-            context.RegisterOperationAction(AnalyzeLoopStatementAction, OperationKind.Loop);
+            context.RegisterSyntaxNodeAction(AnalyzeLoopStatementAction, LoopStatementKinds);
         }
 
-        private static void AnalyzeLoopStatement(OperationAnalysisContext context)
-        {
-            var loopStatement = (ILoopOperation)context.Operation;
+        [NotNull]
+        private static readonly LoopBodyLocator BodyLocator = new LoopBodyLocator();
 
-            var walker = new LoopBodyWalker();
-            walker.Visit(loopStatement.Body);
+        private static void AnalyzeLoopStatement(SyntaxNodeAnalysisContext context)
+        {
+            StatementSyntax loopBody = BodyLocator.Visit(context.Node);
+            if (loopBody != null)
+            {
+                AnalyzeLoopBody(loopBody, context);
+            }
+        }
 
-            context.CancellationToken.ThrowIfCancellationRequested();
+        private static void AnalyzeLoopBody([NotNull] StatementSyntax loopBody, SyntaxNodeAnalysisContext context)
+        {
+            var walker = new LoopLocationWalker(context.CancellationToken);
+            walker.Visit(loopBody);
 
             if (walker.LoopStatementLocation != null)
             {
                 context.ReportDiagnostic(Diagnostic.Create(Rule, walker.LoopStatementLocation));
             }
         }
 
-        private sealed class LoopBodyWalker : ExplicitOperationWalker
+        private sealed class LoopBodyLocator : CSharpSyntaxVisitor<StatementSyntax>
         {
+            [NotNull]
+            public override StatementSyntax VisitWhileStatement([NotNull] WhileStatementSyntax node)
+            {
+                return node.Statement;
+            }
+
+            [NotNull]
+            public override StatementSyntax VisitDoStatement([NotNull] DoStatementSyntax node)
+            {
+                return node.Statement;
+            }
+
+            [CanBeNull]
+            public override StatementSyntax VisitForStatement([NotNull] ForStatementSyntax node)
+            {
+                return node.Statement;
+            }
+
+            [CanBeNull]
+            public override StatementSyntax VisitForEachStatement([NotNull] ForEachStatementSyntax node)
+            {
+                return node.Statement;
+            }
+
+            [CanBeNull]
+            public override StatementSyntax VisitForEachVariableStatement([NotNull] ForEachVariableStatementSyntax node)
+            {
+                return node.Statement;
+            }
+        }
+
+        private sealed class LoopLocationWalker : CSharpSyntaxWalker
+        {
+            private CancellationToken cancellationToken;
+
             [CanBeNull]
             public Location LoopStatementLocation { get; private set; }
 
-            public override void VisitWhileLoop([NotNull] IWhileLoopOperation operation)
+            public LoopLocationWalker(CancellationToken cancellationToken)
+            {
+                this.cancellationToken = cancellationToken;
+            }
+
+            public override void Visit([NotNull] SyntaxNode node)
+            {
+                cancellationToken.ThrowIfCancellationRequested();
+
+                base.Visit(node);
+            }
+
+            public override void VisitWhileStatement([NotNull] WhileStatementSyntax node)
+            {
+                LoopStatementLocation = node.WhileKeyword.GetLocation();
+            }
+
+            public override void VisitDoStatement([NotNull] DoStatementSyntax node)
+            {
+                LoopStatementLocation = node.DoKeyword.GetLocation();
+            }
+
+            public override void VisitForStatement([NotNull] ForStatementSyntax node)
+            {
+                LoopStatementLocation = node.ForKeyword.GetLocation();
+            }
+
+            public override void VisitForEachStatement([NotNull] ForEachStatementSyntax node)
+            {
+                LoopStatementLocation = node.ForEachKeyword.GetLocation();
+            }
+
+            public override void VisitForEachVariableStatement([NotNull] ForEachVariableStatementSyntax node)
+            {
+                LoopStatementLocation = node.ForEachKeyword.GetLocation();
+            }
+
+            public override void VisitLocalFunctionStatement([NotNull] LocalFunctionStatementSyntax node)
             {
-                LoopStatementLocation = operation.TryGetLocationForKeyword();
             }
 
-            public override void VisitForLoop([NotNull] IForLoopOperation operation)
+            public override void VisitSimpleLambdaExpression([NotNull] SimpleLambdaExpressionSyntax node)
             {
-                LoopStatementLocation = operation.TryGetLocationForKeyword();
             }
 
-            public override void VisitForEachLoop([NotNull] IForEachLoopOperation operation)
+            public override void VisitParenthesizedLambdaExpression([NotNull] ParenthesizedLambdaExpressionSyntax node)
             {
-                LoopStatementLocation = operation.TryGetLocationForKeyword();
             }
 
-            public override void VisitLocalFunction([NotNull] ILocalFunctionOperation operation)
+            public override void VisitAnonymousMethodExpression([NotNull] AnonymousMethodExpressionSyntax node)
             {
             }
         }