Add 'Make anonymous function static' feature

src/Analyzers/CSharp/Analyzers/CSharpAnalyzers.projitems

@@ -29,6 +29,7 @@
     <Compile Include="$(MSBuildThisFileDirectory)ConvertTypeofToNameof\CSharpConvertTypeOfToNameOfDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)ForEachCast\CSharpForEachCastDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)Formatting\CSharpFormattingAnalyzer.cs" />
+    <Compile Include="$(MSBuildThisFileDirectory)MakeAnonymousFunctionStatic\MakeAnonymousFunctionStaticDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MakeFieldReadonly\CSharpMakeFieldReadonlyDiagnosticAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)MakeStructMemberReadOnly\CSharpMakeStructMemberReadOnlyAnalyzer.cs" />
     <Compile Include="$(MSBuildThisFileDirectory)NewLines\ArrowExpressionClausePlacement\ArrowExpressionClausePlacementDiagnosticAnalyzer.cs" />

src/Analyzers/CSharp/Analyzers/CSharpAnalyzersResources.resx

@@ -412,4 +412,10 @@
   <data name="Use_primary_constructor" xml:space="preserve">
     <value>Use primary constructor</value>
   </data>
+  <data name="Anonymous_function_can_be_made_static" xml:space="preserve">
+    <value>Anonymous function can be made static</value>
+  </data>
+  <data name="Make_anonymous_function_static" xml:space="preserve">
+    <value>Make anonymous function static</value>
+  </data>
 </root>

src/Analyzers/CSharp/Analyzers/CodeStyle/CSharpAnalyzerOptionsProvider.cs

@@ -92,6 +92,7 @@ internal CSharpCodeGenerationOptions GetCodeGenerationOptions()
     public CodeStyleOption2<bool> PreferReadOnlyStruct => GetOption(CSharpCodeStyleOptions.PreferReadOnlyStruct, FallbackCodeStyleOptions.PreferReadOnlyStruct);
     public CodeStyleOption2<bool> PreferReadOnlyStructMember => GetOption(CSharpCodeStyleOptions.PreferReadOnlyStructMember, FallbackCodeStyleOptions.PreferReadOnlyStructMember);
     public CodeStyleOption2<bool> PreferStaticLocalFunction => GetOption(CSharpCodeStyleOptions.PreferStaticLocalFunction, FallbackCodeStyleOptions.PreferStaticLocalFunction);
+    public CodeStyleOption2<bool> PreferStaticAnonymousFunction => GetOption(CSharpCodeStyleOptions.PreferStaticAnonymousFunction, FallbackCodeStyleOptions.PreferStaticAnonymousFunction);
 
     private TValue GetOption<TValue>(Option2<TValue> option, TValue defaultValue)
         => _options.GetOption(option, defaultValue);

src/Analyzers/CSharp/Analyzers/MakeAnonymousFunctionStatic/MakeAnonymousFunctionStaticDiagnosticAnalyzer.cs

@@ -0,0 +1,68 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.CodeAnalysis.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.CodeStyle;
+using Microsoft.CodeAnalysis.CSharp.Extensions;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace Microsoft.CodeAnalysis.CSharp.MakeAnonymousFunctionStatic;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+internal sealed class MakeAnonymousFunctionStaticDiagnosticAnalyzer : AbstractBuiltInCodeStyleDiagnosticAnalyzer
+{
+    public MakeAnonymousFunctionStaticDiagnosticAnalyzer()
+        : base(IDEDiagnosticIds.MakeAnonymousFunctionStaticDiagnosticId,
+               EnforceOnBuildValues.MakeAnonymousFunctionStatic,
+               CSharpCodeStyleOptions.PreferStaticAnonymousFunction,
+               new LocalizableResourceString(nameof(CSharpAnalyzersResources.Make_anonymous_function_static), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)),
+               new LocalizableResourceString(nameof(CSharpAnalyzersResources.Anonymous_function_can_be_made_static), CSharpAnalyzersResources.ResourceManager, typeof(CSharpAnalyzersResources)))
+    {
+    }
+
+    public override DiagnosticAnalyzerCategory GetAnalyzerCategory()
+        => DiagnosticAnalyzerCategory.SemanticSpanAnalysis;
+
+    protected override void InitializeWorker(AnalysisContext context)
+    {
+        context.RegisterCompilationStartAction(context =>
+        {
+            if (context.Compilation.LanguageVersion() < LanguageVersion.CSharp9)
+                return;
+
+            context.RegisterSyntaxNodeAction(AnalyzeSyntax, SyntaxKind.SimpleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression, SyntaxKind.AnonymousMethodExpression);
+        });
+    }
+
+    private void AnalyzeSyntax(SyntaxNodeAnalysisContext context)
+    {
+        var option = context.GetCSharpAnalyzerOptions().PreferStaticAnonymousFunction;
+        if (!option.Value || ShouldSkipAnalysis(context, option.Notification))
+            return;
+
+        var anonymousFunction = (AnonymousFunctionExpressionSyntax)context.Node;
+        if (anonymousFunction.Modifiers.Any(SyntaxKind.StaticKeyword))
+            return;
+
+        if (CanAnonymousFunctionByMadeStatic(anonymousFunction, context.SemanticModel))
+        {
+            context.ReportDiagnostic(
+                Diagnostic.Create(
+                    Descriptor,
+                    anonymousFunction.GetLocation()));
+        }
+    }
+
+    private static bool CanAnonymousFunctionByMadeStatic(AnonymousFunctionExpressionSyntax anonymousFunction, SemanticModel semanticModel)
+    {
+        var dataFlow = semanticModel.AnalyzeDataFlow(anonymousFunction);
+        if (dataFlow is not { Succeeded: true })
+        {
+            return false;
+        }
+
+        return dataFlow.Captured.IsEmpty;
+    }
+}