AV1532: Fixed: do not descend into local functions

Author: Bart Koelman

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Maintainability/AvoidNestedLoopsSpecs.cs

@@ -1,3 +1,4 @@
+using System.Linq;
 using CSharpGuidelinesAnalyzer.Rules.Maintainability;
 using CSharpGuidelinesAnalyzer.Test.TestDataBuilders;
 using Microsoft.CodeAnalysis.Diagnostics;
@@ -101,6 +102,54 @@ void M()
                 "Loop statement contains nested loop.");
         }
 
+        [Fact]
+        internal void When_method_contains_single_deconstructing_foreach_loop_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .Using(typeof(Enumerable).Namespace)
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        foreach (var (outer1, outer2) in Enumerable.Empty<(int, int)>())
+                        {
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
+        [Fact]
+        internal void When_method_contains_nested_deconstructing_foreach_loop_it_must_be_reported()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .Using(typeof(Enumerable).Namespace)
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        foreach (var (outer1, outer2) in Enumerable.Empty<(int, int)>())
+                        {
+                            [|foreach|] (var (inner1, inner2) in Enumerable.Empty<(int, int)>())
+                            {
+                                [|foreach|] (var (nestedInner1, nestedInner2) in Enumerable.Empty<(int, int)>())
+                                {
+                                }
+                            }
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source,
+                "Loop statement contains nested loop.",
+                "Loop statement contains nested loop.");
+        }
+
         [Fact]
         internal void When_method_contains_single_while_loop_it_must_be_skipped()
         {
@@ -197,6 +246,106 @@ void M()
                 "Loop statement contains nested loop.");
         }
 
+        [Fact]
+        internal void When_method_contains_nested_loop_in_local_function_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        for (int i = 0; i < 10; i++)
+                        {
+                            void Local()
+                            {
+                                for (int j = 0; j < 10; j++)
+                                {
+                                }
+                            }
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
+        [Fact]
+        internal void When_method_contains_nested_loop_in_lambda_block_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        for (int i = 0; i < 10; i++)
+                        {
+                            Action<int> action = x =>
+                            {
+                                for (int j = 0; j < 10; j++)
+                                {
+                                }
+                            };
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
+        [Fact]
+        internal void When_method_contains_nested_loop_in_parenthesized_lambda_block_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        for (int i = 0; i < 10; i++)
+                        {
+                            Action action = () =>
+                            {
+                                for (int j = 0; j < 10; j++)
+                                {
+                                }
+                            };
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
+        [Fact]
+        internal void When_method_contains_nested_loop_in_anonymous_method_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        for (int i = 0; i < 10; i++)
+                        {
+                            Action action = delegate
+                            {
+                                for (int j = 0; j < 10; j++)
+                                {
+                                }
+                            };
+                        }
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
         protected override DiagnosticAnalyzer CreateAnalyzer()
         {
             return new AvoidNestedLoopsAnalyzer();

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

@@ -73,6 +73,10 @@ public override void VisitForEachLoop([NotNull] IForEachLoopOperation operation)
             {
                 LoopStatementLocation = operation.TryGetLocationForKeyword();
             }
+
+            public override void VisitLocalFunction([NotNull] ILocalFunctionOperation operation)
+            {
+            }
         }
     }
 }