AV1000: Switched to syntax (2x faster)

Author: Bart Koelman

src/CSharpGuidelinesAnalyzer/CSharpGuidelinesAnalyzer/Rules/ClassDesign/TypeShouldHaveASinglePurposeAnalyzer.cs

@@ -3,6 +3,8 @@
 using CSharpGuidelinesAnalyzer.Extensions;
 using JetBrains.Annotations;
 using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Microsoft.CodeAnalysis.Diagnostics;
 
 namespace CSharpGuidelinesAnalyzer.Rules.ClassDesign
@@ -29,35 +31,74 @@ public sealed class TypeShouldHaveASinglePurposeAnalyzer : DiagnosticAnalyzer
         private const string BlacklistWord = "and";
 
         [NotNull]
-        private static readonly Action<SymbolAnalysisContext> AnalyzeNamedTypeAction =
-            context => context.SkipEmptyName(AnalyzeNamedType);
+        private static readonly Action<SyntaxNodeAnalysisContext> AnalyzeTypeDeclarationAction = AnalyzeTypeDeclaration;
+
+        [NotNull]
+        private static readonly SyntaxKind[] TypeDeclarationKinds =
+        {
+            SyntaxKind.ClassDeclaration,
+            SyntaxKind.StructDeclaration,
+            SyntaxKind.InterfaceDeclaration,
+            SyntaxKind.EnumDeclaration,
+            SyntaxKind.DelegateDeclaration
+        };
+
+        [NotNull]
+        private static readonly TypeIdentifierResolver IdentifierResolver = new TypeIdentifierResolver();
 
         public override void Initialize([NotNull] AnalysisContext context)
         {
             context.EnableConcurrentExecution();
             context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
 
-            context.RegisterSymbolAction(AnalyzeNamedTypeAction, SymbolKind.NamedType);
+            context.RegisterSyntaxNodeAction(AnalyzeTypeDeclarationAction, TypeDeclarationKinds);
         }
 
-        private static void AnalyzeNamedType(SymbolAnalysisContext context)
+        private static void AnalyzeTypeDeclaration(SyntaxNodeAnalysisContext context)
         {
-            var type = (INamedTypeSymbol)context.Symbol;
-
-            if (type.IsSynthesized())
+            SyntaxToken identifier = IdentifierResolver.Visit(context.Node);
+            if (identifier == default)
             {
                 return;
             }
 
-            if (ContainsBlacklistedWord(type.Name))
+            if (ContainsBlacklistedWord(identifier.ValueText))
             {
-                context.ReportDiagnostic(Diagnostic.Create(Rule, type.Locations[0], type.Name));
+                context.ReportDiagnostic(Diagnostic.Create(Rule, identifier.GetLocation(), identifier.ValueText));
             }
         }
 
         private static bool ContainsBlacklistedWord([NotNull] string name)
         {
             return name.ContainsWordInTheMiddle(BlacklistWord);
         }
+
+        private sealed class TypeIdentifierResolver : CSharpSyntaxVisitor<SyntaxToken>
+        {
+            public override SyntaxToken VisitClassDeclaration([NotNull] ClassDeclarationSyntax node)
+            {
+                return node.Identifier;
+            }
+
+            public override SyntaxToken VisitStructDeclaration([NotNull] StructDeclarationSyntax node)
+            {
+                return node.Identifier;
+            }
+
+            public override SyntaxToken VisitInterfaceDeclaration([NotNull] InterfaceDeclarationSyntax node)
+            {
+                return node.Identifier;
+            }
+
+            public override SyntaxToken VisitEnumDeclaration([NotNull] EnumDeclarationSyntax node)
+            {
+                return node.Identifier;
+            }
+
+            public override SyntaxToken VisitDelegateDeclaration([NotNull] DelegateDeclarationSyntax node)
+            {
+                return node.Identifier;
+            }
+        }
     }
 }