Add NEEG004 analyzer to detect ToString() on enums with [EnumExtensions] or EnumExtensions<T>

src/NetEscapades.EnumGenerators/Diagnostics/ToStringAnalyzer.cs

@@ -0,0 +1,117 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Microsoft.CodeAnalysis.Diagnostics;
+
+namespace NetEscapades.EnumGenerators.Diagnostics;
+
+[DiagnosticAnalyzer(LanguageNames.CSharp)]
+public class ToStringAnalyzer : DiagnosticAnalyzer
+{
+    public const string DiagnosticId = "NEEG004";
+    public static readonly DiagnosticDescriptor Rule = new(
+#pragma warning disable RS2008 // Enable Analyzer Release Tracking
+        id: DiagnosticId,
+#pragma warning restore RS2008
+        title: "Use ToStringFast() instead of ToString()",
+        messageFormat: "Use ToStringFast() instead of ToString() for better performance on enum '{0}'",
+        category: "Usage",
+        defaultSeverity: DiagnosticSeverity.Info,
+        isEnabledByDefault: true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterCompilationStartAction(ctx =>
+        {
+            var enumExtensionsAttr =
+                ctx.Compilation.GetTypeByMetadataName(Attributes.EnumExtensionsAttribute);
+
+            if (enumExtensionsAttr is null)
+            {
+                return;
+            }
+
+            ctx.RegisterSyntaxNodeAction(
+                c => AnalyzeInvocation(c, enumExtensionsAttr),
+                SyntaxKind.InvocationExpression);
+        });
+    }
+
+    private static void AnalyzeInvocation(SyntaxNodeAnalysisContext context, INamedTypeSymbol enumExtensionsAttr)
+    {
+        var invocation = (InvocationExpressionSyntax)context.Node;
+
+        // Check if this is a member access expression (e.g., value.ToString())
+        if (invocation.Expression is not MemberAccessExpressionSyntax memberAccess)
+        {
+            return;
+        }
+
+        // Check if the method name is "ToString"
+        if (memberAccess.Name.Identifier.Text != "ToString")
+        {
+            return;
+        }
+
+        // Check if there are too many arguments)
+        if (invocation.ArgumentList.Arguments.Count > 0)
+        {
+            return;
+        }
+
+        // Get the symbol information for the invocation
+        var symbolInfo = context.SemanticModel.GetSymbolInfo(invocation);
+        if (symbolInfo.Symbol is not IMethodSymbol methodSymbol)
+        {
+            return;
+        }
+
+        // Verify this is the ToString() method from System.Object or System.Enum
+        if (methodSymbol.Name != "ToString" ||
+            methodSymbol.Parameters.Length != 0 ||
+            (methodSymbol.ContainingType.SpecialType != SpecialType.System_Object &&
+             methodSymbol.ContainingType.SpecialType != SpecialType.System_Enum))
+        {
+            return;
+        }
+
+        // Get the type of the receiver (the thing before .ToString())
+        var receiverType = context.SemanticModel.GetTypeInfo(memberAccess.Expression).Type;
+        if (receiverType is null || receiverType.TypeKind != TypeKind.Enum)
+        {
+            return;
+        }
+
+        // Check if the enum has the [EnumExtensions] attribute
+        bool hasEnumExtensionsAttribute = false;
+        foreach (var attributeData in receiverType.GetAttributes())
+        {
+            if (SymbolEqualityComparer.Default.Equals(
+                    attributeData.AttributeClass,
+                    enumExtensionsAttr))
+            {
+                hasEnumExtensionsAttribute = true;
+                break;
+            }
+        }
+
+        if (!hasEnumExtensionsAttribute)
+        {
+            return;
+        }
+
+        // Report the diagnostic
+        var diagnostic = Diagnostic.Create(
+            Rule,
+            memberAccess.Name.GetLocation(),
+            receiverType.Name);
+
+        context.ReportDiagnostic(diagnostic);
+    }
+}

src/NetEscapades.EnumGenerators/Diagnostics/ToStringCodeFixProvider.cs

@@ -0,0 +1,69 @@
+using System.Collections.Immutable;
+using System.Composition;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CodeActions;
+using Microsoft.CodeAnalysis.CodeFixes;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace NetEscapades.EnumGenerators.Diagnostics;
+
+[ExportCodeFixProvider(LanguageNames.CSharp, Name = nameof(ToStringCodeFixProvider)), Shared]
+public class ToStringCodeFixProvider : CodeFixProvider
+{
+    private const string Title = "Replace with ToStringFast()";
+
+    public sealed override ImmutableArray<string> FixableDiagnosticIds
+        => ImmutableArray.Create(ToStringAnalyzer.DiagnosticId);
+
+    public sealed override FixAllProvider GetFixAllProvider()
+        => WellKnownFixAllProviders.BatchFixer;
+
+    public sealed override async Task RegisterCodeFixesAsync(CodeFixContext context)
+    {
+        var root = await context.Document.GetSyntaxRootAsync(context.CancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return;
+        }
+
+        var diagnostic = context.Diagnostics.First();
+        var diagnosticSpan = diagnostic.Location.SourceSpan;
+
+        // Find the ToString identifier
+        var identifierNode = root.FindToken(diagnosticSpan.Start).Parent;
+        if (identifierNode is not IdentifierNameSyntax identifierName)
+        {
+            return;
+        }
+
+        // Register a code action that will invoke the fix
+        context.RegisterCodeFix(
+            CodeAction.Create(
+                title: Title,
+                createChangedDocument: c => ReplaceToStringWithToStringFast(context.Document, identifierName, c),
+                equivalenceKey: Title),
+            context.Diagnostics);
+    }
+
+    private static async Task<Document> ReplaceToStringWithToStringFast(
+        Document document,
+        IdentifierNameSyntax identifierName,
+        CancellationToken cancellationToken)
+    {
+        var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+        if (root is null)
+        {
+            return document;
+        }
+
+        // Create the new identifier with "ToStringFast"
+        var newIdentifier = SyntaxFactory.IdentifierName("ToStringFast")
+            .WithTriviaFrom(identifierName);
+
+        // Replace the old identifier with the new one
+        var newRoot = root.ReplaceNode(identifierName, newIdentifier);
+
+        return document.WithSyntaxRoot(newRoot);
+    }
+}

tests/NetEscapades.EnumGenerators.IntegrationTests/.editorconfig

@@ -0,0 +1,7 @@
+#### .NET Coding Conventions ####
+[*.{cs,vb}]
+
+dotnet_diagnostic.NEEG001.severity = error
+dotnet_diagnostic.NEEG002.severity = error
+dotnet_diagnostic.NEEG003.severity = error
+dotnet_diagnostic.NEEG004.severity = error

tests/NetEscapades.EnumGenerators.IntegrationTests/AnalyzerTests.cs

@@ -0,0 +1,18 @@
+using System;
+using Xunit;
+
+namespace NetEscapades.EnumGenerators.Benchmarks;
+
+public class AnalyzerTests
+{
+    // These method calls should all be flagged by the analyzer
+    [Fact]
+    public void Neeg004Testing()
+    {
+#pragma warning disable NEEG004
+        var test = EnumInSystem.First;
+        _ = test.ToString();
+        _ = EnumInSystem.First.ToString();
+#pragma warning restore NEEG004
+    }
+}

tests/NetEscapades.EnumGenerators.IntegrationTests/Enums.cs

@@ -3,6 +3,8 @@
 using System.ComponentModel.DataAnnotations;
 using System.Runtime.Serialization;
 
+#pragma warning disable NEEG003
+
 [assembly:NetEscapades.EnumGenerators.EnumExtensions<DateTimeKind>()]
 [assembly:NetEscapades.EnumGenerators.EnumExtensions<System.IO.FileShare>()]
 

tests/NetEscapades.EnumGenerators.Tests/NetEscapades.EnumGenerators.Tests.csproj

@@ -10,6 +10,7 @@
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Analyzer.Testing" Version="1.1.2" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" PrivateAssets="all" />
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp.CodeFix.Testing" Version="1.1.2" />
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp.Workspaces" Version="5.0.0" PrivateAssets="all" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.11.0" />
     <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" Condition="'$(TargetFramework)' == 'net48'" />