Reduce the number of allocations required to register three syntax kinds

sharwell · sharwell · commit d8e858be0e26 · 2015-10-24T15:59:41.000-05:00
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/PartialElementDocumentationSummaryBase.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/PartialElementDocumentationSummaryBase.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;
@@ -17,14 +18,17 @@ namespace StyleCop.Analyzers.DocumentationRules
     /// </summary>
     internal abstract class PartialElementDocumentationSummaryBase : DiagnosticAnalyzer
     {
+        private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
+
         private readonly Action<CompilationStartAnalysisContext> compilationStartAction;
-        private readonly Action<SyntaxNodeAnalysisContext> typeDeclarationAction;
+        private readonly Action<SyntaxNodeAnalysisContext> baseTypeDeclarationAction;
         private readonly Action<SyntaxNodeAnalysisContext> methodDeclarationAction;
 
         protected PartialElementDocumentationSummaryBase()
         {
             this.compilationStartAction = this.HandleCompilationStart;
-            this.typeDeclarationAction = this.HandleTypeDeclaration;
+            this.baseTypeDeclarationAction = this.HandleBaseTypeDeclaration;
             this.methodDeclarationAction = this.HandleMethodDeclaration;
         }
 
@@ -45,15 +49,11 @@ public override void Initialize(AnalysisContext context)
 
         private void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                this.typeDeclarationAction,
-                SyntaxKind.ClassDeclaration,
-                SyntaxKind.StructDeclaration,
-                SyntaxKind.InterfaceDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(this.baseTypeDeclarationAction, BaseTypeDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(this.methodDeclarationAction, SyntaxKind.MethodDeclaration);
         }
 
-        private void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
+        private void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
             var node = (BaseTypeDeclarationSyntax)context.Node;
             if (node.Identifier.IsMissing)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1601PartialElementsMustBeDocumented.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1601PartialElementsMustBeDocumented.cs
@@ -82,6 +82,9 @@ internal class SA1601PartialElementsMustBeDocumented : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.DocumentationRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -97,11 +100,7 @@ public override void Initialize(AnalysisContext context)
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
             Analyzer analyzer = new Analyzer(context.Options);
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                analyzer.HandleTypeDeclaration,
-                SyntaxKind.ClassDeclaration,
-                SyntaxKind.InterfaceDeclaration,
-                SyntaxKind.StructDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(analyzer.HandleBaseTypeDeclaration, BaseTypeDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(analyzer.HandleMethodDeclaration, SyntaxKind.MethodDeclaration);
         }
 
@@ -115,7 +114,7 @@ public Analyzer(AnalyzerOptions options)
                 this.documentationSettings = settings.DocumentationRules;
             }
 
-            public void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
+            public void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)
             {
                 if (context.GetDocumentationMode() != DocumentationMode.Diagnose)
                 {
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1618GenericTypeParametersMustBeDocumented.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1618GenericTypeParametersMustBeDocumented.cs
@@ -40,6 +40,9 @@ internal class SA1618GenericTypeParametersMustBeDocumented : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.DocumentationRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
         private static readonly Action<SyntaxNodeAnalysisContext> TypeDeclarationAction = HandleTypeDeclaration;
         private static readonly Action<SyntaxNodeAnalysisContext> MethodDeclarationAction = HandleMethodDeclaration;
@@ -57,12 +60,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                TypeDeclarationAction,
-                SyntaxKind.ClassDeclaration,
-                SyntaxKind.StructDeclaration,
-                SyntaxKind.InterfaceDeclaration);
-
+            context.RegisterSyntaxNodeActionHonorExclusions(TypeDeclarationAction, TypeDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(MethodDeclarationAction, SyntaxKind.MethodDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(DelegateDeclarationAction, SyntaxKind.DelegateDeclaration);
         }
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1619GenericTypeParametersMustBeDocumentedPartialClass.cs b/StyleCop.Analyzers/StyleCop.Analyzers/DocumentationRules/SA1619GenericTypeParametersMustBeDocumentedPartialClass.cs
@@ -90,6 +90,9 @@ internal class SA1619GenericTypeParametersMustBeDocumentedPartialClass : Diagnos
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.DocumentationRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
         private static readonly Action<SyntaxNodeAnalysisContext> TypeDeclarationAction = HandleTypeDeclaration;
 
@@ -105,11 +108,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(
-                TypeDeclarationAction,
-                SyntaxKind.ClassDeclaration,
-                SyntaxKind.StructDeclaration,
-                SyntaxKind.InterfaceDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(TypeDeclarationAction, TypeDeclarationKinds);
         }
 
         private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1500CurlyBracketsForMultiLineStatementsMustNotShareLine.cs b/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1500CurlyBracketsForMultiLineStatementsMustNotShareLine.cs
@@ -70,6 +70,9 @@ internal class SA1500CurlyBracketsForMultiLineStatementsMustNotShareLine : Diagn
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.LayoutRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> InitializerExpressionKinds =
+            ImmutableArray.Create(SyntaxKind.ObjectInitializerExpression, SyntaxKind.ArrayInitializerExpression, SyntaxKind.CollectionInitializerExpression);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -92,7 +95,7 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(HandleAccessorListSyntax, SyntaxKind.AccessorList);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleBlockSyntax, SyntaxKind.Block);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleSwitchStatementSyntax, SyntaxKind.SwitchStatement);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleInitializerExpressionSyntax, SyntaxKind.ObjectInitializerExpression, SyntaxKind.ArrayInitializerExpression, SyntaxKind.CollectionInitializerExpression);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleInitializerExpressionSyntax, InitializerExpressionKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleAnonymousObjectCreationExpressionSyntax, SyntaxKind.AnonymousObjectCreationExpression);
         }
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1502ElementMustNotBeOnASingleLine.cs b/StyleCop.Analyzers/StyleCop.Analyzers/LayoutRules/SA1502ElementMustNotBeOnASingleLine.cs
@@ -51,6 +51,15 @@ internal class SA1502ElementMustNotBeOnASingleLine : DiagnosticAnalyzer
         private static readonly DiagnosticDescriptor Descriptor =
             new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.LayoutRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);
 
+        private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.EnumDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> BasePropertyDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);
+
+        private static readonly ImmutableArray<SyntaxKind> BaseMethodDeclarationKinds =
+            ImmutableArray.Create(SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -65,19 +74,19 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclarations, SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandlePropertyLikeDeclarations, SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodLikeDeclarations, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclarations, SyntaxKind.NamespaceDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclaration, BaseTypeDeclarationKinds);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBasePropertyDeclaration, BasePropertyDeclarationKinds);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);
         }
 
-        private static void HandleBaseTypeDeclarations(SyntaxNodeAnalysisContext context)
+        private static void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
             var typeDeclaration = (BaseTypeDeclarationSyntax)context.Node;
             CheckViolation(context, typeDeclaration.OpenBraceToken, typeDeclaration.CloseBraceToken);
         }
 
-        private static void HandlePropertyLikeDeclarations(SyntaxNodeAnalysisContext context)
+        private static void HandleBasePropertyDeclaration(SyntaxNodeAnalysisContext context)
         {
             var basePropertyDeclaration = (BasePropertyDeclarationSyntax)context.Node;
 
@@ -92,7 +101,7 @@ private static void HandlePropertyLikeDeclarations(SyntaxNodeAnalysisContext con
             }
         }
 
-        private static void HandleMethodLikeDeclarations(SyntaxNodeAnalysisContext context)
+        private static void HandleBaseMethodDeclaration(SyntaxNodeAnalysisContext context)
         {
             var baseMethodDeclaration = (BaseMethodDeclarationSyntax)context.Node;
 
@@ -103,7 +112,7 @@ private static void HandleMethodLikeDeclarations(SyntaxNodeAnalysisContext conte
             }
         }
 
-        private static void HandleNamespaceDeclarations(SyntaxNodeAnalysisContext context)
+        private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)
         {
             var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;
             CheckViolation(context, namespaceDeclaration.OpenBraceToken, namespaceDeclaration.CloseBraceToken);
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1205PartialElementsMustDeclareAccess.cs b/StyleCop.Analyzers/StyleCop.Analyzers/OrderingRules/SA1205PartialElementsMustDeclareAccess.cs
@@ -33,6 +33,9 @@ internal class SA1205PartialElementsMustDeclareAccess : 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, SyntaxKind.InterfaceDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -47,10 +50,10 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleElementDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);
         }
 
-        private static void HandleElementDeclaration(SyntaxNodeAnalysisContext context)
+        private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
             var typeDeclarationNode = (TypeDeclarationSyntax)context.Node;
 
diff --git a/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1114ParameterListMustFollowDeclaration.cs b/StyleCop.Analyzers/StyleCop.Analyzers/ReadabilityRules/SA1114ParameterListMustFollowDeclaration.cs
@@ -54,6 +54,9 @@ internal class SA1114ParameterListMustFollowDeclaration : 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.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.OperatorDeclaration, SyntaxKind.ConversionOperatorDeclaration);
+
         private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;
 
         /// <inheritdoc/>
@@ -68,7 +71,7 @@ public override void Initialize(AnalysisContext context)
 
         private static void HandleCompilationStart(CompilationStartAnalysisContext context)
         {
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.OperatorDeclaration);
+            context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodInvocation, SyntaxKind.InvocationExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleObjectCreation, SyntaxKind.ObjectCreationExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleIndexerDeclaration, SyntaxKind.IndexerDeclaration);
@@ -79,13 +82,6 @@ private static void HandleCompilationStart(CompilationStartAnalysisContext conte
             context.RegisterSyntaxNodeActionHonorExclusions(HandleDelegateDeclaration, SyntaxKind.DelegateDeclaration);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleAnonymousMethod, SyntaxKind.AnonymousMethodExpression);
             context.RegisterSyntaxNodeActionHonorExclusions(HandleLambdaExpression, SyntaxKind.ParenthesizedLambdaExpression);
-            context.RegisterSyntaxNodeActionHonorExclusions(HandleConversionOperatorDeclaration, SyntaxKind.ConversionOperatorDeclaration);
-        }
-
-        private static void HandleConversionOperatorDeclaration(SyntaxNodeAnalysisContext context)
-        {
-            var conversionOperatorDeclaration = (ConversionOperatorDeclarationSyntax)context.Node;
-            AnalyzeParametersList(context, conversionOperatorDeclaration.ParameterList);
         }
 
         private static void HandleLambdaExpression(SyntaxNodeAnalysisContext context)

Original file line number	Diff line number	Diff line change
`@@ -82,6 +82,9 @@ internal class SA1601PartialElementsMustBeDocumented : DiagnosticAnalyzer`
`82`	`82`	`private static readonly DiagnosticDescriptor Descriptor =`
`83`	`83`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.DocumentationRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`84`	`84`
	`85`	`+ private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =`
	`86`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);`
	`87`	`+`
`85`	`88`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`86`	`89`
`87`	`90`	`/// <inheritdoc/>`
`@@ -97,11 +100,7 @@ public override void Initialize(AnalysisContext context)`
`97`	`100`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`98`	`101`	`{`
`99`	`102`	`Analyzer analyzer = new Analyzer(context.Options);`
`100`		`- context.RegisterSyntaxNodeActionHonorExclusions(`
`101`		`- analyzer.HandleTypeDeclaration,`
`102`		`- SyntaxKind.ClassDeclaration,`
`103`		`- SyntaxKind.InterfaceDeclaration,`
`104`		`- SyntaxKind.StructDeclaration);`
	`103`	`+ context.RegisterSyntaxNodeActionHonorExclusions(analyzer.HandleBaseTypeDeclaration, BaseTypeDeclarationKinds);`
`105`	`104`	`context.RegisterSyntaxNodeActionHonorExclusions(analyzer.HandleMethodDeclaration, SyntaxKind.MethodDeclaration);`
`106`	`105`	`}`
`107`	`106`
`@@ -115,7 +114,7 @@ public Analyzer(AnalyzerOptions options)`
`115`	`114`	`this.documentationSettings = settings.DocumentationRules;`
`116`	`115`	`}`
`117`	`116`
`118`		`- public void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)`
	`117`	`+ public void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)`
`119`	`118`	`{`
`120`	`119`	`if (context.GetDocumentationMode() != DocumentationMode.Diagnose)`
`121`	`120`	`{`
Original file line number	Diff line number	Diff line change
`@@ -51,6 +51,15 @@ internal class SA1502ElementMustNotBeOnASingleLine : DiagnosticAnalyzer`
`51`	`51`	`private static readonly DiagnosticDescriptor Descriptor =`
`52`	`52`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.LayoutRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`53`	`53`
	`54`	`+ private static readonly ImmutableArray<SyntaxKind> BaseTypeDeclarationKinds =`
	`55`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.EnumDeclaration);`
	`56`	`+`
	`57`	`+ private static readonly ImmutableArray<SyntaxKind> BasePropertyDeclarationKinds =`
	`58`	`+ ImmutableArray.Create(SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);`
	`59`	`+`
	`60`	`+ private static readonly ImmutableArray<SyntaxKind> BaseMethodDeclarationKinds =`
	`61`	`+ ImmutableArray.Create(SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);`
	`62`	`+`
`54`	`63`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`55`	`64`
`56`	`65`	`/// <inheritdoc/>`
`@@ -65,19 +74,19 @@ public override void Initialize(AnalysisContext context)`
`65`	`74`
`66`	`75`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`67`	`76`	`{`
`68`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclarations, SyntaxKind.ClassDeclaration, SyntaxKind.InterfaceDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.EnumDeclaration);`
`69`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandlePropertyLikeDeclarations, SyntaxKind.PropertyDeclaration, SyntaxKind.EventDeclaration, SyntaxKind.IndexerDeclaration);`
`70`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleMethodLikeDeclarations, SyntaxKind.MethodDeclaration, SyntaxKind.ConstructorDeclaration, SyntaxKind.DestructorDeclaration);`
`71`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclarations, SyntaxKind.NamespaceDeclaration);`
	`77`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseTypeDeclaration, BaseTypeDeclarationKinds);`
	`78`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleBasePropertyDeclaration, BasePropertyDeclarationKinds);`
	`79`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleBaseMethodDeclaration, BaseMethodDeclarationKinds);`
	`80`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleNamespaceDeclaration, SyntaxKind.NamespaceDeclaration);`
`72`	`81`	`}`
`73`	`82`
`74`		`- private static void HandleBaseTypeDeclarations(SyntaxNodeAnalysisContext context)`
	`83`	`+ private static void HandleBaseTypeDeclaration(SyntaxNodeAnalysisContext context)`
`75`	`84`	`{`
`76`	`85`	`var typeDeclaration = (BaseTypeDeclarationSyntax)context.Node;`
`77`	`86`	`CheckViolation(context, typeDeclaration.OpenBraceToken, typeDeclaration.CloseBraceToken);`
`78`	`87`	`}`
`79`	`88`
`80`		`- private static void HandlePropertyLikeDeclarations(SyntaxNodeAnalysisContext context)`
	`89`	`+ private static void HandleBasePropertyDeclaration(SyntaxNodeAnalysisContext context)`
`81`	`90`	`{`
`82`	`91`	`var basePropertyDeclaration = (BasePropertyDeclarationSyntax)context.Node;`
`83`	`92`
`@@ -92,7 +101,7 @@ private static void HandlePropertyLikeDeclarations(SyntaxNodeAnalysisContext con`
`92`	`101`	`}`
`93`	`102`	`}`
`94`	`103`
`95`		`- private static void HandleMethodLikeDeclarations(SyntaxNodeAnalysisContext context)`
	`104`	`+ private static void HandleBaseMethodDeclaration(SyntaxNodeAnalysisContext context)`
`96`	`105`	`{`
`97`	`106`	`var baseMethodDeclaration = (BaseMethodDeclarationSyntax)context.Node;`
`98`	`107`
`@@ -103,7 +112,7 @@ private static void HandleMethodLikeDeclarations(SyntaxNodeAnalysisContext conte`
`103`	`112`	`}`
`104`	`113`	`}`
`105`	`114`
`106`		`- private static void HandleNamespaceDeclarations(SyntaxNodeAnalysisContext context)`
	`115`	`+ private static void HandleNamespaceDeclaration(SyntaxNodeAnalysisContext context)`
`107`	`116`	`{`
`108`	`117`	`var namespaceDeclaration = (NamespaceDeclarationSyntax)context.Node;`
`109`	`118`	`CheckViolation(context, namespaceDeclaration.OpenBraceToken, namespaceDeclaration.CloseBraceToken);`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,9 @@ internal class SA1205PartialElementsMustDeclareAccess : DiagnosticAnalyzer`
`33`	`33`	`private static readonly DiagnosticDescriptor Descriptor =`
`34`	`34`	`new DiagnosticDescriptor(DiagnosticId, Title, MessageFormat, AnalyzerCategory.OrderingRules, DiagnosticSeverity.Warning, AnalyzerConstants.EnabledByDefault, Description, HelpLink);`
`35`	`35`
	`36`	`+ private static readonly ImmutableArray<SyntaxKind> TypeDeclarationKinds =`
	`37`	`+ ImmutableArray.Create(SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);`
	`38`	`+`
`36`	`39`	`private static readonly Action<CompilationStartAnalysisContext> CompilationStartAction = HandleCompilationStart;`
`37`	`40`
`38`	`41`	`/// <inheritdoc/>`
`@@ -47,10 +50,10 @@ public override void Initialize(AnalysisContext context)`
`47`	`50`
`48`	`51`	`private static void HandleCompilationStart(CompilationStartAnalysisContext context)`
`49`	`52`	`{`
`50`		`- context.RegisterSyntaxNodeActionHonorExclusions(HandleElementDeclaration, SyntaxKind.ClassDeclaration, SyntaxKind.StructDeclaration, SyntaxKind.InterfaceDeclaration);`
	`53`	`+ context.RegisterSyntaxNodeActionHonorExclusions(HandleTypeDeclaration, TypeDeclarationKinds);`
`51`	`54`	`}`
`52`	`55`
`53`		`- private static void HandleElementDeclaration(SyntaxNodeAnalysisContext context)`
	`56`	`+ private static void HandleTypeDeclaration(SyntaxNodeAnalysisContext context)`
`54`	`57`	`{`
`55`	`58`	`var typeDeclarationNode = (TypeDeclarationSyntax)context.Node;`
`56`	`59`