Reduce the number of allocations required to register two syntax kinds

sharwell · sharwell · commit 034cc62aea5a · 2015-10-24T15:59:38.000-05:00
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/ElementDocumentationSummaryBase.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/ElementDocumentationSummaryBase.cs
@@ -4,6 +4,7 @@
 namespace StyleCop.Analyzers.DocumentationRules
 {
     using System;
+    using System.Collections.Immutable;
     using System.Linq;
     using Microsoft.CodeAnalysis;
     using Microsoft.CodeAnalysis.CSharp;
@@ -16,6 +17,12 @@ namespace StyleCop.Analyzers.DocumentationRules
     /// </summary>
     internal abstract class ElementDocumentationSummaryBase : DiagnosticAnalyzer
     {
+        private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.EnumDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> BaseFieldDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.FieldDeclaration, SyntaxKind.EventFieldDeclaration);
+
         private readonly Action<CompilationStartAnalysisContext> compilationStartAction;
         private readonly Action<SyntaxNodeAnalysisContext> typeDeclarationAction;
         private readonly Action<SyntaxNodeAnalysisContext> methodDeclarationAction;
@@ -58,21 +65,13 @@ public override void Initialize(AnalysisContext context)
 
         private void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                this.typeDeclarationAction,
-                SyntaxKind.ClassDeclaration,
-                SyntaxKind.StructDeclaration,
-                SyntaxKind.InterfaceDeclaration,
-                SyntaxKind.EnumDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(this.typeDeclarationAction, BaseTypeDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(this.methodDeclarationAction, SyntaxKind.MethodDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(this.constructorDeclarationAction, SyntaxKind.ConstructorDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(this.destructorDeclarationAction, SyntaxKind.DestructorDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(this.propertyDeclarationAction, SyntaxKind.PropertyDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(this.indexerDeclarationAction, SyntaxKind.IndexerDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                this.fieldDeclarationAction,
-                SyntaxKind.FieldDeclaration,
-                SyntaxKind.EventFieldDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(this.fieldDeclarationAction, BaseFieldDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(this.delegateDeclarationAction, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(this.eventDeclarationAction, SyntaxKind.EventDeclaration);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1608ElementDocumentationMustNotHaveDefaultSummary.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1608ElementDocumentationMustNotHaveDefaultSummary.cs
@@ -47,6 +47,9 @@ internal class SA1608ElementDocumentationMustNotHaveDefaultSummary : DiagnosticA
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.DocumentationRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> DocumentationCommentKinds =
+            ImmutableArray.Create(SyntaxKind.SingleLineDocumentationCommentTrivia, SyntaxKind.MultiLineDocumentationCommentTrivia);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
         private static readonly Action<SyntaxNodeAnalysisContext> DocumentationAction = HandleDocumentation;
 
@@ -62,10 +65,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                DocumentationAction,
-                SyntaxKind.SingleLineDocumentationCommentTrivia,
-                SyntaxKind.MultiLineDocumentationCommentTrivia);
+            context.RegisterSyntaxNodeActionHonorExclusions(DocumentationAction, DocumentationCommentKinds);
         }
 
         private static void HandleDocumentation(SyntaxNodeAnalysisContext context)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1202ElementsMustBeOrderedByAccess.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1202ElementsMustBeOrderedByAccess.cs
@@ -50,6 +50,9 @@ internal class SA1202ElementsMustBeOrderedByAccess : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+
         private static readonly Dictionary<SyntaxKind, string> MemberNames = new Dictionary<SyntaxKind, string>
         {
             [SyntaxKind.DelegateDeclaration] = "delegates",
@@ -83,7 +86,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
         {
             context.RegisterSyntaxNodeActionHonorExclusions(HandleCompilationUnit, SyntaxKind.CompilationUnit);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);
         }
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1204StaticElementsMustAppearBeforeInstanceElements.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1204StaticElementsMustAppearBeforeInstanceElements.cs
@@ -37,6 +37,9 @@ internal class SA1204StaticElementsMustAppearBeforeInstanceElements : Diagnostic
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         private static readonly Dictionary<SyntaxKind, string> MemberNames = new Dictionary<SyntaxKind, string>
@@ -70,7 +73,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
         {
             context.RegisterSyntaxNodeActionHonorExclusions(HandleCompilationUnit, SyntaxKind.CompilationUnit);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDelcaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDelcaration, TypeDeclarationKinds);
         }
 
         private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1214StaticReadonlyElementsMustAppearBeforeStaticNonReadonlyElements.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1214StaticReadonlyElementsMustAppearBeforeStaticNonReadonlyElements.cs
@@ -35,6 +35,9 @@ internal class SA1214StaticReadonlyElementsMustAppearBeforeStaticNonReadonlyElem
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -49,10 +52,10 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(AnalyzeTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);
         }
 
-        private static void AnalyzeTypeDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
             var typeDeclaration = (TypeDeclarationSyntax)context.Node;
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1215InstanceReadonlyElementsMustAppearBeforeInstanceNonReadonlyElements.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1215InstanceReadonlyElementsMustAppearBeforeInstanceNonReadonlyElements.cs
@@ -34,6 +34,9 @@ internal class SA1215InstanceReadonlyElementsMustAppearBeforeInstanceNonReadonly
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -48,7 +51,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);
         }
 
         private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1101PrefixLocalCallsWithThis.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1101PrefixLocalCallsWithThis.cs
@@ -45,6 +45,9 @@ internal class SA1101PrefixLocalCallsWithThis : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> SimpleNameKinds =
+            ImmutableArray.Create(SyntaxKind.IdentifierName, SyntaxKind.GenericName);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -60,7 +63,7 @@ public override void Initialize(AnalysisContext context)
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
             context.RegisterSyntaxNodeActionHonorExclusions(HandleMemberAccessExpression, SyntaxKind.SimpleMemberAccessExpression);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleIdentifierName, SyntaxKind.IdentifierName, SyntaxKind.GenericName);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleSimpleName, SimpleNameKinds);
         }
 
         /// <summary>
@@ -75,7 +78,7 @@ private static void HandleMemberAccessExpression(SyntaxNodeAnalysisContext conte
             HandleIdentifierNameImpl(context, nameExpression);
         }
 
-        private static void HandleIdentifierName(SyntaxNodeAnalysisContext context)
+        private static void HandleSimpleName(SyntaxNodeAnalysisContext context)
         {
             switch (context.Node?.Parent?.Kind() ?? SyntaxKind.None)
             {
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1115ParameterMustFollowComma.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1115ParameterMustFollowComma.cs
@@ -55,6 +55,12 @@ internal class SA1115ParameterMustFollowComma : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseMethodDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration, SyntaxKind.OperatorDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> ConstructorInitializerKinds =
+            ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -69,7 +75,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration, SyntaxKind.OperatorDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocation, SyntaxKind.InvocationExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleObjectCreation, SyntaxKind.ObjectCreationExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleIndexerDeclaration, SyntaxKind.IndexerDeclaration);
@@ -80,7 +86,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(HandleAnonymousMethod, SyntaxKind.AnonymousMethodExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleLambda, SyntaxKind.ParenthesizedLambdaExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorInitializer, SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorInitializer, ConstructorInitializerKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleElementBinding, SyntaxKind.ElementBindingExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleImpliticElementAccess, SyntaxKind.ImplicitElementAccess);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1116SplitParametersMustStartOnLineAfterDeclaration.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1116SplitParametersMustStartOnLineAfterDeclaration.cs
@@ -50,6 +50,12 @@ internal class SA1116SplitParametersMustStartOnLineAfterDeclaration : Diagnostic
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseMethodDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration, SyntaxKind.OperatorDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> ConstructorInitializerKinds =
+            ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -64,14 +70,8 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                HandleBaseMethodDeclaration,
-                new[] { SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration, SyntaxKind.OperatorDeclaration });
-
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                HandleConstructorInitializer,
-                new[] { SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer });
-
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorInitializer, ConstructorInitializerKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleIndexerDeclaration, SyntaxKind.IndexerDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocation, SyntaxKind.InvocationExpression);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1117ParametersMustBeOnSameLineOrSeparateLines.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1117ParametersMustBeOnSameLineOrSeparateLines.cs
@@ -61,6 +61,12 @@ internal class SA1117ParametersMustBeOnSameLineOrSeparateLines : DiagnosticAnaly
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseMethodDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> ConstructorInitializerKinds =
+            ImmutableArray.Create(SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -75,14 +81,8 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                HandleBaseMethodDeclaration,
-                new[] { SyntaxKind.ConstructorDeclaration, SyntaxKind.MethodDeclaration });
-
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                HandleConstructorInitializer,
-                new[] { SyntaxKind.BaseConstructorInitializer, SyntaxKind.ThisConstructorInitializer });
-
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleConstructorInitializer, ConstructorInitializerKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleIndexerDeclaration, SyntaxKind.IndexerDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleInvocation, SyntaxKind.InvocationExpression);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1118ParameterMustNotSpanMultipleLines.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1118ParameterMustNotSpanMultipleLines.cs
@@ -69,6 +69,9 @@ internal class SA1118ParameterMustNotSpanMultipleLines : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseArgumentListKinds =
+            ImmutableArray.Create(SyntaxKind.ArgumentList, SyntaxKind.BracketedArgumentList);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         private static readonly SyntaxKind[] ArgumentExceptionSyntaxKinds =
@@ -90,7 +93,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleArgumentList, SyntaxKind.ArgumentList, SyntaxKind.BracketedArgumentList);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseArgumentList, BaseArgumentListKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleAttributeArgumentList, SyntaxKind.AttributeArgumentList);
         }
 
@@ -108,7 +111,7 @@ private static void HandleAttributeArgumentList(SyntaxNodeAnalysisContext contex
             }
         }
 
-        private static void HandleArgumentList(SyntaxNodeAnalysisContext context)
+        private static void HandleBaseArgumentList(SyntaxNodeAnalysisContext context)
         {
             var argumentListSyntax = (BaseArgumentListSyntax)context.Node;
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1132DoNotCombineFields.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1132DoNotCombineFields.cs
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs b/StyleCop.Analyzers/StyleCop.Analyzers/SpacingRules/SA1003SymbolsMustBeSpacedCorrectly.cs

Original file line number	Diff line number	Diff line change
`@@ -50,6 +50,9 @@ internal class SA1202ElementsMustBeOrderedByAccess : DiagnosticAnalyzer`
`50`	`50`	`private static readonly DiagnosticDescriptor Descriptor =`
`51`	`51`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`52`	`52`
	`53`	`+ private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =`
	`54`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`55`	`+`
`53`	`56`	`private static readonly Dictionary<SyntaxKind, string> MemberNames = new Dictionary<SyntaxKind, string>`
`54`	`57`	`{`
`55`	`58`	`[SyntaxKind.DelegateDeclaration] = "delegates",`
`@@ -83,7 +86,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte`
`83`	`86`	`{`
`84`	`87`	`context.RegisterSyntaxNodeActionHonorExclusions(HandleCompilationUnit, SyntaxKind.CompilationUnit);`
`85`	`88`	`context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);`
`86`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`89`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);`
`87`	`90`	`}`
`88`	`91`
`89`	`92`	`private static void HandleCompilationUnit(SyntaxNodeAnalysisContext context)`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,9 @@ internal class SA1214StaticReadonlyElementsMustAppearBeforeStaticNonReadonlyElem`
`35`	`35`	`private static readonly DiagnosticDescriptor Descriptor =`
`36`	`36`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`37`	`37`
	`38`	`+ private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =`
	`39`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`40`	`+`
`38`	`41`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`39`	`42`
`40`	`43`	`/// <inheritdoc/>`
`@@ -49,10 +52,10 @@ public override void Initialize(AnalysisContext context)`
`49`	`52`
`50`	`53`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`51`	`54`	`{`
`52`		`- context.RegisterSyntaxNodeActionHonorExclusions(AnalyzeTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`55`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);`
`53`	`56`	`}`
`54`	`57`
`55`		`- private static void AnalyzeTypeDeclaration(SyntaxNodeAnalysisContext context)`
	`58`	`+ private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)`
`56`	`59`	`{`
`57`	`60`	`var typeDeclaration = (TypeDeclarationSyntax)context.Node;`
`58`	`61`
Original file line number	Diff line number	Diff line change
`@@ -34,6 +34,9 @@ internal class SA1215InstanceReadonlyElementsMustAppearBeforeInstanceNonReadonly`
`34`	`34`	`private static readonly DiagnosticDescriptor Descriptor =`
`35`	`35`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`36`	`36`
	`37`	`+ private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =`
	`38`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`39`	`+`
`37`	`40`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`38`	`41`
`39`	`42`	`/// <inheritdoc/>`
`@@ -48,7 +51,7 @@ public override void Initialize(AnalysisContext context)`
`48`	`51`
`49`	`52`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`50`	`53`	`{`
`51`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration);`
	`54`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);`
`52`	`55`	`}`
`53`	`56`
`54`	`57`	`private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)`
Original file line number	Diff line number	Diff line change
`@@ -45,6 +45,9 @@ internal class SA1101PrefixLocalCallsWithThis : DiagnosticAnalyzer`
`45`	`45`	`private static readonly DiagnosticDescriptor Descriptor =`
`46`	`46`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.ReadabilityRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`47`	`47`
	`48`	`+ private static readonly ImmutableArray<SyntaxKind> SimpleNameKinds =`
	`49`	`+ ImmutableArray.Create(SyntaxKind.IdentifierName, SyntaxKind.GenericName);`
	`50`	`+`
`48`	`51`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`49`	`52`
`50`	`53`	`/// <inheritdoc/>`
`@@ -60,7 +63,7 @@ public override void Initialize(AnalysisContext context)`
`60`	`63`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`61`	`64`	`{`
`62`	`65`	`context.RegisterSyntaxNodeActionHonorExclusions(HandleMemberAccessExpression, SyntaxKind.SimpleMemberAccessExpression);`
`63`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleIdentifierName, SyntaxKind.IdentifierName, SyntaxKind.GenericName);`
	`66`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleSimpleName, SimpleNameKinds);`
`64`	`67`	`}`
`65`	`68`
`66`	`69`	`/// <summary>`
`@@ -75,7 +78,7 @@ private static void HandleMemberAccessExpression(SyntaxNodeAnalysisContext conte`
`75`	`78`	`HandleIdentifierNameImpl(context, nameExpression);`
`76`	`79`	`}`
`77`	`80`
`78`		`- private static void HandleIdentifierName(SyntaxNodeAnalysisContext context)`
	`81`	`+ private static void HandleSimpleName(SyntaxNodeAnalysisContext context)`
`79`	`82`	`{`
`80`	`83`	`switch (context.Node?.Parent?.Kind() ?? SyntaxKind.None)`
`81`	`84`	`{`