Removed cached delegates (the compiler does it since C# 11)

bkoelman · Apr 22, 2024 · 664553f · 664553f
1 parent 0c3e9cd
commit 664553f
Show file tree

Hide file tree

Showing 56 changed files with 210 additions and 505 deletions.
diff --git a/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.csproj b/src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer.csproj
@@ -5,6 +5,7 @@
     <IncludeBuildOutput>false</IncludeBuildOutput>
     <GeneratePackageOnBuild>True</GeneratePackageOnBuild>
     <BaseOutputPath>$(SolutionDir)..\bin</BaseOutputPath>
+    <NoWarn>$(NoWarn);RS1012</NoWarn>
   </PropertyGroup>
 
   <PropertyGroup>

diff --git a/...CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/AnalysisContextExtensions.cs b/...CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Extensions/AnalysisContextExtensions.cs
@@ -1,40 +1,128 @@
 using System;
+using System.Collections.Immutable;
 using System.Linq;
 using JetBrains.Annotations;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace CSharpGuidelinesAnalyzer.Extensions;
 
-/// <summary />
+/// <summary>
+/// Replaces the built-in registration methods to not run on broken code.
+/// </summary>
 internal static class AnalysisContextExtensions
 {
-    public static void SkipInvalid(this OperationAnalysisContext context, [NotNull] Action<OperationAnalysisContext> action)
+    public static void SafeRegisterOperationAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<OperationAnalysisContext> action,
+        [NotNull] params OperationKind[] operationKinds)
+    {
+        analysisContext.RegisterOperationAction(context => SkipInvalid(context, action), operationKinds);
+    }
+
+    public static void SafeRegisterOperationAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<OperationAnalysisContext> action,
+        ImmutableArray<OperationKind> operationKinds)
+    {
+        analysisContext.RegisterOperationAction(context => SkipInvalid(context, action), operationKinds);
+    }
+
+    public static void SafeRegisterOperationBlockAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<OperationBlockAnalysisContext> action)
+    {
+        analysisContext.RegisterOperationBlockAction(context => SkipInvalid(context, action));
+    }
+
+    public static void SafeRegisterSymbolAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<SymbolAnalysisContext> action,
+        [NotNull] params SymbolKind[] symbolKinds)
+    {
+        analysisContext.RegisterSymbolAction(context => SkipEmptyName(context, action), symbolKinds);
+    }
+
+    public static void SafeRegisterSymbolAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<SymbolAnalysisContext> action,
+        ImmutableArray<SymbolKind> symbolKinds)
+    {
+        analysisContext.RegisterSymbolAction(context => SkipEmptyName(context, action), symbolKinds);
+    }
+
+    public static void SafeRegisterSyntaxNodeAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<SymbolAnalysisContext> action,
+        [NotNull] params SyntaxKind[] syntaxKinds)
+    {
+        analysisContext.RegisterSyntaxNodeAction(context => SkipEmptyName(context, action), syntaxKinds);
+    }
+
+    public static void SafeRegisterSyntaxNodeAction([NotNull] this AnalysisContext analysisContext, [NotNull] Action<SymbolAnalysisContext> action,
+        ImmutableArray<SyntaxKind> syntaxKinds)
+    {
+        analysisContext.RegisterSyntaxNodeAction(context => SkipEmptyName(context, action), syntaxKinds);
+    }
+
+    public static void SafeRegisterOperationAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<OperationAnalysisContext> action, [NotNull] params OperationKind[] operationKinds)
+    {
+        compilationStartAnalysisContext.RegisterOperationAction(context => SkipInvalid(context, action), operationKinds);
+    }
+
+    public static void SafeRegisterOperationAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<OperationAnalysisContext> action, ImmutableArray<OperationKind> operationKinds)
+    {
+        compilationStartAnalysisContext.RegisterOperationAction(context => SkipInvalid(context, action), operationKinds);
+    }
+
+    public static void SafeRegisterOperationBlockAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<OperationBlockAnalysisContext> action)
+    {
+        compilationStartAnalysisContext.RegisterOperationBlockAction(context => SkipInvalid(context, action));
+    }
+
+    public static void SafeRegisterSymbolAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<SymbolAnalysisContext> action, [NotNull] params SymbolKind[] symbolKinds)
+    {
+        compilationStartAnalysisContext.RegisterSymbolAction(context => SkipEmptyName(context, action), symbolKinds);
+    }
+
+    public static void SafeRegisterSymbolAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<SymbolAnalysisContext> action, ImmutableArray<SymbolKind> symbolKinds)
+    {
+        compilationStartAnalysisContext.RegisterSymbolAction(context => SkipEmptyName(context, action), symbolKinds);
+    }
+
+    public static void SafeRegisterSyntaxNodeAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<SymbolAnalysisContext> action, [NotNull] params SyntaxKind[] syntaxKinds)
+    {
+        compilationStartAnalysisContext.RegisterSyntaxNodeAction(context => SkipEmptyName(context, action), syntaxKinds);
+    }
+
+    public static void SafeRegisterSyntaxNodeAction([NotNull] this CompilationStartAnalysisContext compilationStartAnalysisContext,
+        [NotNull] Action<SymbolAnalysisContext> action, ImmutableArray<SyntaxKind> syntaxKinds)
+    {
+        compilationStartAnalysisContext.RegisterSyntaxNodeAction(context => SkipEmptyName(context, action), syntaxKinds);
+    }
+
+    private static void SkipInvalid(OperationAnalysisContext context, [NotNull] Action<OperationAnalysisContext> action)
     {
         if (!context.Operation.HasErrors(context.Compilation, context.CancellationToken))
         {
             action(context);
         }
     }
 
-    public static void SkipInvalid(this OperationBlockAnalysisContext context, [NotNull] Action<OperationBlockAnalysisContext> action)
+    private static void SkipInvalid(OperationBlockAnalysisContext context, [NotNull] Action<OperationBlockAnalysisContext> action)
     {
         if (!context.OperationBlocks.Any(block => block.HasErrors(context.Compilation, context.CancellationToken)))
         {
             action(context);
         }
     }
 
-    public static void SkipEmptyName(this SymbolAnalysisContext context, [NotNull] Action<SymbolAnalysisContext> action)
+    private static void SkipEmptyName(SymbolAnalysisContext context, [NotNull] Action<SymbolAnalysisContext> action)
     {
         if (!string.IsNullOrEmpty(context.Symbol.Name))
         {
             action(context);
         }
     }
 
-    public static void SkipEmptyName(this SyntaxNodeAnalysisContext context, [NotNull] Action<SymbolAnalysisContext> action)
+    private static void SkipEmptyName(SyntaxNodeAnalysisContext context, [NotNull] Action<SymbolAnalysisContext> action)
     {
         SymbolAnalysisContext symbolContext = context.ToSymbolContext();
-        symbolContext.SkipEmptyName(_ => action(symbolContext));
+        SkipEmptyName(symbolContext, _ => action(symbolContext));
     }
 }
diff --git a/...GuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/AvoidStaticClassAnalyzer.cs b/...GuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/AvoidStaticClassAnalyzer.cs
@@ -31,9 +31,6 @@ public sealed class AvoidStaticClassAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor MemberRule = new(DiagnosticId, Title, MemberMessageFormat, Category.DisplayName, DiagnosticSeverity.Info, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<SymbolAnalysisContext> AnalyzeNamedTypeAction = context => context.SkipEmptyName(AnalyzeNamedType);
-
     [ItemNotNull]
     private static readonly ImmutableArray<string> PlatformInvokeWrapperTypeNames =
         ImmutableArray.Create("NativeMethods", "SafeNativeMethods", "UnsafeNativeMethods");
@@ -46,7 +43,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSymbolAction(AnalyzeNamedTypeAction, SymbolKind.NamedType);
+        context.SafeRegisterSymbolAction(AnalyzeNamedType, SymbolKind.NamedType);
     }
 
     private static void AnalyzeNamedType(SymbolAnalysisContext context)

diff --git a/...esAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/DoNotHideInheritedMemberAnalyzer.cs b/...esAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/DoNotHideInheritedMemberAnalyzer.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Immutable;
 using CSharpGuidelinesAnalyzer.Extensions;
 using JetBrains.Annotations;
@@ -26,9 +25,6 @@ public sealed class DoNotHideInheritedMemberAnalyzer : DiagnosticAnalyzer
     private static readonly ImmutableArray<SymbolKind> MemberSymbolKinds = ImmutableArray.Create(SymbolKind.Field,
         SymbolKind.Property, SymbolKind.Method, SymbolKind.Event, SymbolKind.NamedType);
 
-    [NotNull]
-    private static readonly Action<SymbolAnalysisContext> AnalyzeMemberAction = context => context.SkipEmptyName(AnalyzeMember);
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -37,7 +33,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSymbolAction(AnalyzeMemberAction, MemberSymbolKinds);
+        context.SafeRegisterSymbolAction(AnalyzeMember, MemberSymbolKinds);
     }
 
     private static void AnalyzeMember(SymbolAnalysisContext context)

diff --git a/...alyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/TypeShouldHaveASinglePurposeAnalyzer.cs b/...alyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/TypeShouldHaveASinglePurposeAnalyzer.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Immutable;
 using CSharpGuidelinesAnalyzer.Extensions;
 using JetBrains.Annotations;
@@ -26,9 +25,6 @@ public sealed class TypeShouldHaveASinglePurposeAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category.DisplayName, DiagnosticSeverity.Warning, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<SyntaxNodeAnalysisContext> AnalyzeTypeDeclarationAction = AnalyzeTypeDeclaration;
-
     [NotNull]
     private static readonly SyntaxKind[] TypeDeclarationKinds =
     [
@@ -50,7 +46,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSyntaxNodeAction(AnalyzeTypeDeclarationAction, TypeDeclarationKinds);
+        context.RegisterSyntaxNodeAction(AnalyzeTypeDeclaration, TypeDeclarationKinds);
     }
 
     private static void AnalyzeTypeDeclaration(SyntaxNodeAnalysisContext context)

diff --git a/...elinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/AvoidInlineCommentAnalyzer.cs b/...elinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/AvoidInlineCommentAnalyzer.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Immutable;
 using System.Linq;
 using JetBrains.Annotations;
@@ -28,9 +27,6 @@ public sealed class AvoidInlineCommentAnalyzer : DiagnosticAnalyzer
     [ItemNotNull]
     private static readonly ImmutableArray<string> ArrangeActAssertLines = ImmutableArray.Create("// Arrange", "// Act", "// Assert", "// Act and assert");
 
-    [NotNull]
-    private static readonly Action<CodeBlockAnalysisContext> AnalyzeCodeBlockAction = AnalyzeCodeBlock;
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -39,7 +35,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterCodeBlockAction(AnalyzeCodeBlockAction);
+        context.RegisterCodeBlockAction(AnalyzeCodeBlock);
     }
 
     private static void AnalyzeCodeBlock(CodeBlockAnalysisContext context)

diff --git a/...idelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/AvoidToDoCommentAnalyzer.cs b/...idelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/AvoidToDoCommentAnalyzer.cs
@@ -25,9 +25,6 @@ public sealed class AvoidToDoCommentAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category.DisplayName, DiagnosticSeverity.Info, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<SyntaxTreeAnalysisContext> AnalyzeTodoCommentsAction = AnalyzeTodoComments;
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -36,7 +33,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSyntaxTreeAction(AnalyzeTodoCommentsAction);
+        context.RegisterSyntaxTreeAction(AnalyzeTodoComments);
     }
 
     private static void AnalyzeTodoComments(SyntaxTreeAnalysisContext context)

diff --git a/...esAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/DocumentInternalMemberAnalyzer.cs b/...esAnalyzer/CSharpGuidelinesAnalyzer/Rules/Documentation/DocumentInternalMemberAnalyzer.cs
@@ -44,12 +44,6 @@ public sealed class DocumentInternalMemberAnalyzer : DiagnosticAnalyzer
     [ItemNotNull]
     private static readonly HashSet<string> EmptyHashSet = [];
 
-    [NotNull]
-    private static readonly Action<SymbolAnalysisContext> AnalyzeNamedTypeAction = context => context.SkipEmptyName(AnalyzeNamedType);
-
-    [NotNull]
-    private static readonly Action<SymbolAnalysisContext> AnalyzeMemberAction = context => context.SkipEmptyName(AnalyzeMember);
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics =>
         ImmutableArray.Create(MissingTypeOrMemberRule, MissingParameterRule, ExtraParameterRule);
@@ -59,8 +53,8 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSymbolAction(AnalyzeNamedTypeAction, SymbolKind.NamedType);
-        context.RegisterSymbolAction(AnalyzeMemberAction, MemberSymbolKinds);
+        context.SafeRegisterSymbolAction(AnalyzeNamedType, SymbolKind.NamedType);
+        context.SafeRegisterSymbolAction(AnalyzeMember, MemberSymbolKinds);
     }
 
     private static void AnalyzeNamedType(SymbolAnalysisContext context)

diff --git a/...r/CSharpGuidelinesAnalyzer/Rules/Framework/AvoidQuerySyntaxForSimpleExpressionAnalyzer.cs b/...r/CSharpGuidelinesAnalyzer/Rules/Framework/AvoidQuerySyntaxForSimpleExpressionAnalyzer.cs
@@ -25,9 +25,6 @@ public sealed class AvoidQuerySyntaxForSimpleExpressionAnalyzer : DiagnosticAnal
     private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category.DisplayName, DiagnosticSeverity.Info, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<SyntaxNodeAnalysisContext> AnalyzeQueryExpressionAction = AnalyzeQueryExpression;
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -36,7 +33,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterSyntaxNodeAction(AnalyzeQueryExpressionAction, SyntaxKind.QueryExpression);
+        context.RegisterSyntaxNodeAction(AnalyzeQueryExpression, SyntaxKind.QueryExpression);
     }
 
     private static void AnalyzeQueryExpression(SyntaxNodeAnalysisContext context)

diff --git a/...lyzer/CSharpGuidelinesAnalyzer/Rules/Framework/BuildWithTheHighestWarningLevelAnalyzer.cs b/...lyzer/CSharpGuidelinesAnalyzer/Rules/Framework/BuildWithTheHighestWarningLevelAnalyzer.cs
@@ -1,4 +1,3 @@
-using System;
 using System.Collections.Immutable;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
@@ -22,9 +21,6 @@ public sealed class BuildWithTheHighestWarningLevelAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category.DisplayName, DiagnosticSeverity.Warning, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<CompilationAnalysisContext> AnalyzeCompilationOptionsAction = AnalyzeCompilationOptions;
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -33,7 +29,7 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterCompilationAction(AnalyzeCompilationOptionsAction);
+        context.RegisterCompilationAction(AnalyzeCompilationOptions);
     }
 
     private static void AnalyzeCompilationOptions(CompilationAnalysisContext context)

diff --git a/...lyzer/CSharpGuidelinesAnalyzer/Rules/Framework/DoNotImplicitlyConvertToDynamicAnalyzer.cs b/...lyzer/CSharpGuidelinesAnalyzer/Rules/Framework/DoNotImplicitlyConvertToDynamicAnalyzer.cs
@@ -24,21 +24,6 @@ public sealed class DoNotImplicitlyConvertToDynamicAnalyzer : DiagnosticAnalyzer
     private static readonly DiagnosticDescriptor Rule = new(DiagnosticId, Title, MessageFormat, Category.DisplayName, DiagnosticSeverity.Warning, true,
         Description, Category.GetHelpLinkUri(DiagnosticId));
 
-    [NotNull]
-    private static readonly Action<CompilationStartAnalysisContext> RegisterCompilationStartAction = RegisterCompilationStart;
-
-#pragma warning disable RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
-    [NotNull]
-    private static readonly Action<OperationAnalysisContext, INamedTypeSymbol> AnalyzeConversionAction = (context, objectHandleType) =>
-        context.SkipInvalid(_ => AnalyzeConversion(context, objectHandleType));
-#pragma warning restore RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
-
-#pragma warning disable RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
-    [NotNull]
-    private static readonly Action<OperationAnalysisContext, INamedTypeSymbol> AnalyzeCompoundAssignmentAction = (context, objectHandleType) =>
-        context.SkipInvalid(_ => AnalyzeCompoundAssignment(context, objectHandleType));
-#pragma warning restore RS1008 // Avoid storing per-compilation data into the fields of a diagnostic analyzer.
-
     [ItemNotNull]
     public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics => ImmutableArray.Create(Rule);
 
@@ -47,15 +32,15 @@ public override void Initialize([NotNull] AnalysisContext context)
         context.EnableConcurrentExecution();
         context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-        context.RegisterCompilationStartAction(RegisterCompilationStartAction);
+        context.RegisterCompilationStartAction(RegisterCompilationStart);
     }
 
     private static void RegisterCompilationStart([NotNull] CompilationStartAnalysisContext startContext)
     {
         INamedTypeSymbol objectHandleType = KnownTypes.SystemRuntimeRemotingObjectHandle(startContext.Compilation);
 
-        startContext.RegisterOperationAction(context => AnalyzeConversionAction(context, objectHandleType), OperationKind.Conversion);
-        startContext.RegisterOperationAction(context => AnalyzeCompoundAssignmentAction(context, objectHandleType), OperationKind.CompoundAssignment);
+        startContext.SafeRegisterOperationAction(context => AnalyzeConversion(context, objectHandleType), OperationKind.Conversion);
+        startContext.SafeRegisterOperationAction(context => AnalyzeCompoundAssignment(context, objectHandleType), OperationKind.CompoundAssignment);
     }
 
     private static void AnalyzeConversion(OperationAnalysisContext context, [CanBeNull] INamedTypeSymbol objectHandleType)