Implement SA1130

Author: pdelvo

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/ReadabilityResources.Designer.cs

@@ -421,7 +421,7 @@
     <value>Lambda expressions are more succinct and easier to read than anonymous methods, so they should are preferred whenever the two are functionally equivalent.</value>
   </data>
   <data name="SA1130MessageFormat" xml:space="preserve">
-    <value />
+    <value>Use lambda syntax</value>
   </data>
   <data name="SA1130Title" xml:space="preserve">
     <value>Use lambda syntax</value>

StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/ReadabilityResources.resx

@@ -3,8 +3,11 @@
 
 namespace StyleCop.Analyzers.ReadabilityRules
 {
+    using System;
     using System.Collections.Immutable;
     using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Diagnostics;
 
     /// <summary>
@@ -22,6 +25,7 @@ internal class SA1130UseLambdaSyntax : DiagnosticAnalyzer
         private static readonly LocalizableString MessageFormat = new LocalizableResourceString(nameof(ReadabilityResources.SA1130MessageFormat), ReadabilityResources.ResourceManager, typeof(ReadabilityResources));
         private static readonly LocalizableString Description = new LocalizableResourceString(nameof(ReadabilityResources.SA1130Description), ReadabilityResources.ResourceManager, typeof(ReadabilityResources));
         private static readonly string HelpLink = "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/blob/master/documentation/SA1130.md";
+        private static readonly ParameterListSyntax EmptyParameterList = SyntaxFactory.ParameterList();
 
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.DisabledNoTests, Description, HelpLink);
@@ -33,7 +37,47 @@ internal class SA1130UseLambdaSyntax : DiagnosticAnalyzer
         /// <inheritdoc/>
         public override void Initialize(AnalysisContext context)
         {
-            // TODO: Implement analysis
+            context.RegisterCompilationStartAction(HandleCompilationStart);
+        }
+
+        private static void HandleCompilationStart(CompilationStartAnalysisContext context)
+        {
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleAnonymousMethodExpression, SyntaxKind.AnonymousMethodExpression);
+        }
+
+        private static void HandleAnonymousMethodExpression(SyntaxNodeAnalysisContext context)
+        {
+            var anonymousMethod = (AnonymousMethodExpressionSyntax)context.Node;
+
+            if (anonymousMethod.Parent.IsKind(SyntaxKind.Argument))
+            {
+                // invocation -> argument list -> argument -> anonymous method
+                var originalInvocationExpression = anonymousMethod?.Parent?.Parent?.Parent as InvocationExpressionSyntax;
+
+                if (originalInvocationExpression != null)
+                {
+                    // In some cases passing a delegate as an argument to a method is required to call the right overload
+                    // When there is an other overload that takes an expression.
+                    var lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(
+                        anonymousMethod.AsyncKeyword,
+                        anonymousMethod.ParameterList ?? EmptyParameterList,
+                        SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken),
+                        anonymousMethod.Body);
+
+                    var invocationExpression = originalInvocationExpression.ReplaceNode(anonymousMethod, lambdaExpression);
+
+                    SymbolInfo originalSymbolInfo = context.SemanticModel.GetSymbolInfo(originalInvocationExpression);
+                    Location location = originalInvocationExpression.GetLocation();
+                    SymbolInfo newSymbolInfo = context.SemanticModel.GetSpeculativeSymbolInfo(location.SourceSpan.Start, invocationExpression, SpeculativeBindingOption.BindAsExpression);
+
+                    if (originalSymbolInfo.Symbol != newSymbolInfo.Symbol)
+                    {
+                        return;
+                    }
+                }
+            }
+
+            context.ReportDiagnostic(Diagnostic.Create(Descriptor, anonymousMethod.GetLocation()));
         }
     }
 }