AV1739: Updated for anonymous methods

Author: Bart Koelman

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.Test/Specs/Naming/UseUnderscoreForUnusedLambdaParameterSpecs.cs

@@ -9,6 +9,105 @@ public sealed class UseUnderscoreForUnusedLambdaParameterSpecs : CSharpGuideline
     {
         protected override string DiagnosticId => UseUnderscoreForUnusedLambdaParameterAnalyzer.DiagnosticId;
 
+        [Fact]
+        internal void When_anonymous_method_parameter_is_unused_in_body_it_must_be_reported()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        N(delegate(int [|x|])
+                        {
+                            return true;
+                        });
+                    }
+
+                    void N(Func<int, bool> f)
+                    {
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source,
+                "Unused anonymous method parameter 'x' should be renamed to underscore(s).");
+        }
+
+        [Fact]
+        internal void When_anonymous_method_parameters_are_unused_in_body_it_must_be_reported()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        N(delegate(int [|x|], int [|y|])
+                        {
+                            return true;
+                        });
+                    }
+
+                    void N(Func<int, int, bool> f)
+                    {
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source,
+                "Unused anonymous method parameter 'x' should be renamed to underscore(s).",
+                "Unused anonymous method parameter 'y' should be renamed to underscore(s).");
+        }
+
+        [Fact]
+        internal void When_unused_anonymous_method_parameter_is_named_underscore_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        N(delegate(int _)
+                        {
+                            return true;
+                        });
+                    }
+
+                    void N(Func<int, bool> f)
+                    {
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
+        [Fact]
+        internal void When_unused_anonymous_method_parameters_are_named_with_underscores_it_must_be_skipped()
+        {
+            // Arrange
+            ParsedSourceCode source = new MemberSourceCodeBuilder()
+                .InDefaultClass(@"
+                    void M()
+                    {
+                        N(delegate(int _, int __)
+                        {
+                            return true;
+                        });
+                    }
+
+                    void N(Func<int, int, bool> f)
+                    {
+                    }
+                ")
+                .Build();
+
+            // Act and assert
+            VerifyGuidelineDiagnostic(source);
+        }
+
         [Fact]
         internal void When_lambda_parameter_is_unused_in_body_it_must_be_reported()
         {

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Naming/UseUnderscoreForUnusedLambdaParameterAnalyzer.cs

@@ -4,6 +4,7 @@
 using CSharpGuidelinesAnalyzer.Extensions;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 using Microsoft.CodeAnalysis.Operations;
 
@@ -15,7 +16,7 @@ public sealed class UseUnderscoreForUnusedLambdaParameterAnalyzer : DiagnosticAn
         public const string DiagnosticId = "AV1739";
 
         private const string Title = "Unused lambda parameter should be renamed to underscore(s)";
-        private const string MessageFormat = "Unused lambda parameter '{0}' should be renamed to underscore(s).";
+        private const string MessageFormat = "Unused {0} parameter '{1}' should be renamed to underscore(s).";
         private const string Description = "Use an underscore for irrelevant lambda parameters.";
 
         [NotNull]
@@ -71,7 +72,10 @@ private static void AnalyzeParameterUsage([ItemNotNull] ImmutableArray<IParamete
             {
                 if (IsRegularParameter(parameter) && !IsParameterUsed(parameter, dataFlowAnalysis))
                 {
-                    context.ReportDiagnostic(Diagnostic.Create(Rule, parameter.Locations[0], parameter.Name));
+                    string functionKind = context.Operation.Syntax is AnonymousMethodExpressionSyntax
+                        ? "anonymous method"
+                        : "lambda";
+                    context.ReportDiagnostic(Diagnostic.Create(Rule, parameter.Locations[0], functionKind, parameter.Name));
                 }
             }
         }
@@ -81,19 +85,6 @@ private static bool IsRegularParameter([NotNull] IParameterSymbol parameter)
             return !parameter.IsSynthesized() && !ConsistsOfUnderscoresOnly(parameter.Name);
         }
 
-        [CanBeNull]
-        private static DataFlowAnalysis TryAnalyzeDataFlow([NotNull] SyntaxNode bodySyntax, [NotNull] Compilation compilation)
-        {
-            SemanticModel model = compilation.GetSemanticModel(bodySyntax.SyntaxTree);
-            return model.SafeAnalyzeDataFlow(bodySyntax);
-        }
-
-        private static bool IsParameterUsed([NotNull] IParameterSymbol parameter, [NotNull] DataFlowAnalysis dataFlowAnalysis)
-        {
-            return dataFlowAnalysis.ReadInside.Contains(parameter) || dataFlowAnalysis.WrittenInside.Contains(parameter) ||
-                dataFlowAnalysis.Captured.Contains(parameter);
-        }
-
         private static bool ConsistsOfUnderscoresOnly([NotNull] string identifierName)
         {
             foreach (char ch in identifierName)
@@ -106,5 +97,18 @@ private static bool ConsistsOfUnderscoresOnly([NotNull] string identifierName)
 
             return true;
         }
+
+        [CanBeNull]
+        private static DataFlowAnalysis TryAnalyzeDataFlow([NotNull] SyntaxNode bodySyntax, [NotNull] Compilation compilation)
+        {
+            SemanticModel model = compilation.GetSemanticModel(bodySyntax.SyntaxTree);
+            return model.SafeAnalyzeDataFlow(bodySyntax);
+        }
+
+        private static bool IsParameterUsed([NotNull] IParameterSymbol parameter, [NotNull] DataFlowAnalysis dataFlowAnalysis)
+        {
+            return dataFlowAnalysis.ReadInside.Contains(parameter) || dataFlowAnalysis.WrittenInside.Contains(parameter) ||
+                dataFlowAnalysis.Captured.Contains(parameter);
+        }
     }
 }