Fixed SA1130 code fix for return statements and arrow expression clauses

Author: vweijsters

StyleCop.Analyzers/StyleCop.Analyzers.CodeFixes/ReadabilityRules/SA1130CodeFixProvider.cs

@@ -72,6 +72,7 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
         {
             var parameterList = anonymousMethod.ParameterList;
             SyntaxNode lambdaExpression;
+            SyntaxToken arrowToken;
 
             if (parameterList == null)
             {
@@ -98,6 +99,11 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
 
                     argumentList = list.Value;
                     break;
+
+                case SyntaxKind.ArrowExpressionClause:
+                case SyntaxKind.ReturnStatement:
+                    argumentList = GetMemberReturnTypeArgumentList(semanticModel, anonymousMethod);
+                    break;
                 }
 
                 List<ParameterSyntax> parameters = GenerateUniqueParameterNames(semanticModel, anonymousMethod, argumentList);
@@ -107,12 +113,17 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
                     : SyntaxFactory.SeparatedList<ParameterSyntax>();
 
                 parameterList = SyntaxFactory.ParameterList(newList)
-                    .WithLeadingTrivia(anonymousMethod.DelegateKeyword.LeadingTrivia)
+                    .WithLeadingTrivia(anonymousMethod.DelegateKeyword.LeadingTrivia);
+
+                arrowToken = SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken)
                     .WithTrailingTrivia(anonymousMethod.DelegateKeyword.TrailingTrivia);
             }
             else
             {
                 parameterList = parameterList.WithLeadingTrivia(anonymousMethod.DelegateKeyword.TrailingTrivia);
+
+                arrowToken = SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken)
+                    .WithTrailingTrivia(SyntaxFactory.ElasticSpace);
             }
 
             foreach (var parameter in parameterList.Parameters)
@@ -123,9 +134,6 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
                 }
             }
 
-            var arrowToken = SyntaxFactory.Token(SyntaxKind.EqualsGreaterThanToken)
-                .WithTrailingTrivia(SyntaxFactory.ElasticSpace);
-
             if (parameterList.Parameters.Count == 1)
             {
                 var parameterSyntax = RemoveType(parameterList.Parameters[0]);
@@ -193,6 +201,14 @@ private static ImmutableArray<string> GetEqualsArgumentList(SemanticModel semant
             return namedTypeSymbol.DelegateInvokeMethod.Parameters.Select(ps => ps.Name).ToImmutableArray();
         }
 
+        private static ImmutableArray<string> GetMemberReturnTypeArgumentList(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod)
+        {
+            var enclosingSymbol = semanticModel.GetEnclosingSymbol(anonymousMethod.Parent.SpanStart);
+            var returnType = (INamedTypeSymbol)((IMethodSymbol)enclosingSymbol).ReturnType;
+
+            return returnType.DelegateInvokeMethod.Parameters.Select(ps => ps.Name).ToImmutableArray();
+        }
+
         private static List<ParameterSyntax> GenerateUniqueParameterNames(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod, ImmutableArray<string> argumentNames)
         {
             var parameters = new List<ParameterSyntax>();

StyleCop.Analyzers/StyleCop.Analyzers.Test/ReadabilityRules/SA1130UnitTests.cs

@@ -276,7 +276,7 @@ public class TypeName
 {
     public void Test()
     {
-        Action action1 = /*a*/()/*b*/ => { };
+        Action action1 = /*a*/() =>/*b*/{ };
         Action action2 = /*a*//*b*/(/*c*/)/*d*/ => { };
         Action<int> action3 = /*a*//*b*//*c*//*d*/i/*e*//*f*/ => { };
         Action<List<int>> action4 = i => { };
@@ -710,5 +710,78 @@ static void Main(string[] args)
 
             await VerifyCSharpFixAsync(testCode, expected, testCode, CancellationToken.None).ConfigureAwait(false);
         }
+
+        [Fact]
+        [WorkItem(2902, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/2902")]
+        public async Task VerifyThatCodeFixDoesNotCrashOnDelegateReturnAsync()
+        {
+            var testCode = @"using System;
+public class TestClass
+{
+    public static EventHandler TestMethod1()
+    {
+        return delegate
+        {
+        };
+    }
+
+    public static EventHandler TestMethod2() => delegate
+    {
+    };
+
+    public static EventHandler TestProperty1
+    {
+        get
+        {
+            return delegate
+            {
+            };
+        }
+    }
+
+    public static EventHandler TestProperty2 => delegate
+    {
+    };
+}";
+
+            var fixedCode = @"using System;
+public class TestClass
+{
+    public static EventHandler TestMethod1()
+    {
+        return (sender, e) =>
+        {
+        };
+    }
+
+    public static EventHandler TestMethod2() => (sender, e) =>
+    {
+    };
+
+    public static EventHandler TestProperty1
+    {
+        get
+        {
+            return (sender, e) =>
+            {
+            };
+        }
+    }
+
+    public static EventHandler TestProperty2 => (sender, e) =>
+    {
+    };
+}";
+
+            DiagnosticResult[] expected =
+            {
+                Diagnostic().WithLocation(6, 16),
+                Diagnostic().WithLocation(11, 49),
+                Diagnostic().WithLocation(19, 20),
+                Diagnostic().WithLocation(25, 49),
+            };
+
+            await VerifyCSharpFixAsync(testCode, expected, fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }