Update SA1130 for static anonymous functions

Author: sharwell

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

@@ -18,6 +18,7 @@ namespace StyleCop.Analyzers.ReadabilityRules
     using Microsoft.CodeAnalysis.CSharp.Syntax;
     using Microsoft.CodeAnalysis.Formatting;
     using StyleCop.Analyzers.Helpers;
+    using StyleCop.Analyzers.Lightup;
 
     /// <summary>
     /// Implements a code fix for <see cref="SA1130UseLambdaSyntax"/>.
@@ -72,7 +73,7 @@ private static async Task<bool> CanFixAsync(CodeFixContext context, Diagnostic d
         private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, AnonymousMethodExpressionSyntax anonymousMethod)
         {
             var parameterList = anonymousMethod.ParameterList;
-            ExpressionSyntax lambdaExpression;
+            AnonymousFunctionExpressionSyntax lambdaExpression;
             SyntaxToken arrowToken;
 
             if (parameterList == null)
@@ -178,14 +179,21 @@ private static SyntaxNode ReplaceWithLambda(SemanticModel semanticModel, Anonymo
                 lambdaExpression = SyntaxFactory.ParenthesizedLambdaExpression(anonymousMethod.AsyncKeyword, parameterListSyntax, arrowToken, anonymousMethod.Body);
             }
 
+            var modifiers = anonymousMethod.Modifiers();
+            if (modifiers.Count > 0)
+            {
+                lambdaExpression = lambdaExpression.WithModifiers(modifiers);
+            }
+
+            ExpressionSyntax resultExpression = lambdaExpression;
             if (anonymousMethod.Parent.IsKind(SyntaxKind.CastExpression))
             {
                 // In this case, the lambda needs enclosing parenthesis to be syntactically correct
-                lambdaExpression = SyntaxFactory.ParenthesizedExpression(lambdaExpression);
+                resultExpression = SyntaxFactory.ParenthesizedExpression(resultExpression);
             }
 
             // TODO: No tests require this annotation. Can it be removed?
-            return lambdaExpression
+            return resultExpression
                 .WithAdditionalAnnotations(Formatter.Annotation);
         }
 

StyleCop.Analyzers/StyleCop.Analyzers.Test.CSharp9/ReadabilityRules/SA1130CSharp9UnitTests.cs

@@ -3,9 +3,73 @@
 
 namespace StyleCop.Analyzers.Test.CSharp9.ReadabilityRules
 {
+    using System.Threading;
+    using System.Threading.Tasks;
+    using Microsoft.CodeAnalysis.Testing;
     using StyleCop.Analyzers.Test.CSharp8.ReadabilityRules;
+    using Xunit;
+    using static StyleCop.Analyzers.Test.Verifiers.StyleCopCodeFixVerifier<
+        StyleCop.Analyzers.ReadabilityRules.SA1130UseLambdaSyntax,
+        StyleCop.Analyzers.ReadabilityRules.SA1130CodeFixProvider>;
 
     public partial class SA1130CSharp9UnitTests : SA1130CSharp8UnitTests
     {
+        [Fact]
+        [WorkItem(3973, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3973")]
+        public async Task TestStaticAnonymousMethodAsync()
+        {
+            var testCode = @"using System;
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        Action a = static {|#0:delegate|} { };
+    }
+}
+";
+
+            var fixedCode = @"using System;
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        Action a = static () => { };
+    }
+}
+";
+
+            await VerifyCSharpFixAsync(testCode, Diagnostic().WithLocation(0), fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
+
+        [Fact]
+        [WorkItem(3973, "https://github.com/DotNetAnalyzers/StyleCopAnalyzers/issues/3973")]
+        public async Task TestStaticAnonymousMethodWithParametersAsync()
+        {
+            var testCode = @"using System;
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        Func<int, int, int> sum = static {|#0:delegate|}(int x, int y) { return x + y; };
+    }
+}
+";
+
+            var fixedCode = @"using System;
+
+public class TestClass
+{
+    public void TestMethod()
+    {
+        Func<int, int, int> sum = static (x, y) => { return x + y; };
+    }
+}
+";
+
+            await VerifyCSharpFixAsync(testCode, Diagnostic().WithLocation(0), fixedCode, CancellationToken.None).ConfigureAwait(false);
+        }
     }
 }

StyleCop.Analyzers/StyleCop.Analyzers/Lightup/AnonymousFunctionExpressionSyntaxExtensions.cs

@@ -0,0 +1,31 @@
+// Copyright (c) Tunnel Vision Laboratories, LLC. All Rights Reserved.
+// Licensed under the MIT License. See LICENSE in the project root for license information.
+
+namespace StyleCop.Analyzers.Lightup
+{
+    using System;
+    using Microsoft.CodeAnalysis;
+    using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+    internal static class AnonymousFunctionExpressionSyntaxExtensions
+    {
+        private static readonly Func<AnonymousFunctionExpressionSyntax, SyntaxTokenList> ModifiersAccessor;
+        private static readonly Func<AnonymousFunctionExpressionSyntax, SyntaxTokenList, AnonymousFunctionExpressionSyntax> WithModifiersAccessor;
+
+        static AnonymousFunctionExpressionSyntaxExtensions()
+        {
+            ModifiersAccessor = LightupHelpers.CreateSyntaxPropertyAccessor<AnonymousFunctionExpressionSyntax, SyntaxTokenList>(typeof(AnonymousFunctionExpressionSyntax), nameof(Modifiers));
+            WithModifiersAccessor = LightupHelpers.CreateSyntaxWithPropertyAccessor<AnonymousFunctionExpressionSyntax, SyntaxTokenList>(typeof(AnonymousFunctionExpressionSyntax), nameof(Modifiers));
+        }
+
+        public static SyntaxTokenList Modifiers(this AnonymousFunctionExpressionSyntax syntax)
+        {
+            return ModifiersAccessor(syntax);
+        }
+
+        public static AnonymousFunctionExpressionSyntax WithModifiers(this AnonymousFunctionExpressionSyntax syntax, SyntaxTokenList modifiers)
+        {
+            return WithModifiersAccessor(syntax, modifiers);
+        }
+    }
+}

documentation/SA1130.md

@@ -33,6 +33,7 @@ For example, each of the following would produce a violation of this rule:
 Action a = delegate { x = 0; };
 Action b = delegate() { y = 0; };
 Func<int, int, int> c = delegate(int m, int n) { return m + n; };
+Action d = static delegate() { z = 0; };
 ```
 
 The following code shows the equivalent variable declarations using the more familiar lambda syntax.
@@ -41,6 +42,7 @@ The following code shows the equivalent variable declarations using the more fam
 Action a = () => { x = 0; };
 Action b = () => { y = 0; };
 Func<int, int, int> c = (m, n) => m + n;
+Action d = static () => { z = 0; };
 ```
 
 :memo: It is not always possible to replace an anonymous method with an equivalent lambda expression. For example, the