Handle enums nested in generic types (#159)

Fixes #115

Author: andrewlock

src/NetEscapades.EnumGenerators/Diagnostics/EnumInGenericTypeAnalyzer.cs

@@ -0,0 +1,88 @@
+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 EnumInGenericTypeAnalyzer : DiagnosticAnalyzer
+{
+    public const string DiagnosticId = "NEEG002";
+    public static readonly DiagnosticDescriptor Rule = new(
+#pragma warning disable RS2008 // Enable Analyzer Release Tracking
+        id: DiagnosticId,
+#pragma warning restore RS2008
+        title: "Enum in generic type not supported",
+        messageFormat: "The enum '{0}' is nested inside a generic type. [EnumExtension] attribute is not supported.",
+        category: "Usage",
+        defaultSeverity: DiagnosticSeverity.Warning,
+        isEnabledByDefault: true);
+
+    public override ImmutableArray<DiagnosticDescriptor> SupportedDiagnostics
+        => ImmutableArray.Create(Rule);
+
+    public override void Initialize(AnalysisContext context)
+    {
+        context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.None);
+        context.EnableConcurrentExecution();
+        context.RegisterSyntaxNodeAction(AnalyzeEnumDeclaration, SyntaxKind.EnumDeclaration);
+    }
+
+    private static void AnalyzeEnumDeclaration(SyntaxNodeAnalysisContext context)
+    {
+        var enumDeclaration = (EnumDeclarationSyntax)context.Node;
+        
+        // Check if enum has [EnumExtensions] attribute and capture its location
+        AttributeSyntax? enumExtensionsAttribute = null;
+        foreach (var attributeList in enumDeclaration.AttributeLists)
+        {
+            foreach (var attribute in attributeList.Attributes)
+            {
+                // Check attribute name syntactically first
+                var attributeName = attribute.Name.ToString();
+                if (attributeName == "EnumExtensions" || attributeName == "EnumExtensionsAttribute")
+                {
+                    // Verify with semantic model if needed for precision
+                    var symbolInfo = context.SemanticModel.GetSymbolInfo(attribute);
+                    if (symbolInfo.Symbol is IMethodSymbol method &&
+                        method.ContainingType.ToDisplayString() == Attributes.EnumExtensionsAttribute)
+                    {
+                        enumExtensionsAttribute = attribute;
+                        break;
+                    }
+                }
+            }
+
+            if (enumExtensionsAttribute is not null)
+            {
+                break;
+            }
+        }
+
+        if (enumExtensionsAttribute is null)
+        {
+            return;
+        }
+
+        // Get the enum symbol
+        var enumSymbol = context.SemanticModel.GetDeclaredSymbol(enumDeclaration);
+        if (enumSymbol is null)
+        {
+            return;
+        }
+
+        // Check if nested in generic type
+        if (SymbolHelpers.IsNestedInGenericType(enumSymbol))
+        {
+            var diagnostic = Diagnostic.Create(
+                Rule,
+                enumExtensionsAttribute.GetLocation(),
+                enumSymbol.Name);
+            
+            context.ReportDiagnostic(diagnostic);
+        }
+    }
+
+}

src/NetEscapades.EnumGenerators/EnumGenerator.cs

@@ -129,6 +129,12 @@ static void Execute(in EnumToGenerate enumToGenerate, bool csharp14IsSupported,
 
         ct.ThrowIfCancellationRequested();
 
+        // Skip enums in generic types as they won't be valid - error will be raised from analyzer
+        if (SymbolHelpers.IsNestedInGenericType(enumSymbol))
+        {
+            return null;
+        }
+
         var hasFlags = false;
         string? nameSpace = null;
         string? name = null;
@@ -253,4 +259,5 @@ internal static string GetEnumExtensionName(INamedTypeSymbol enumSymbol)
             names: members,
             isDisplayAttributeUsed: displayNames?.Count > 0);
     }
+
 }

src/NetEscapades.EnumGenerators/SymbolHelpers.cs

@@ -0,0 +1,20 @@
+using Microsoft.CodeAnalysis;
+
+namespace NetEscapades.EnumGenerators;
+
+internal static class SymbolHelpers
+{
+    public static bool IsNestedInGenericType(INamedTypeSymbol enumSymbol)
+    {
+        var containingType = enumSymbol.ContainingType;
+        while (containingType is not null)
+        {
+            if (containingType.IsGenericType)
+            {
+                return true;
+            }
+            containingType = containingType.ContainingType;
+        }
+        return false;
+    }
+}

tests/NetEscapades.EnumGenerators.Tests/EnumGeneratorTests.cs

@@ -1,5 +1,6 @@
 using System.Linq;
 using System.Threading.Tasks;
+using FluentAssertions;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using NetEscapades.EnumGenerators.Interceptors;
@@ -583,4 +584,45 @@ public enum MyEnum
         Assert.Empty(diagnostics);
         return Verifier.Verify(output, Settings());
     }
+
+    [Fact]
+    public void DoesNotGenerateWithoutAttribute()
+    {
+        const string input =
+            """
+            public enum MyEnum
+            {
+                First,
+                Second,
+            }
+            """;
+        var (diagnostics, output) = TestHelpers.GetGeneratedOutput(Generators(), new(stages: [], input));
+
+        diagnostics.Should().BeEmpty();
+        output.Should().BeEmpty();
+    }
+
+    [Fact]
+    public void DoesNotGenerateInNestedGenericClass()
+    {
+        const string input =
+            """
+            using NetEscapades.EnumGenerators;
+
+            public class Nested<T>
+            {
+                [EnumExtensions]
+                public enum MyEnum
+                {
+                    First,
+                    Second,
+                }
+            }
+            """;
+
+        var (diagnostics, output) = TestHelpers.GetGeneratedOutput(Generators(), new(stages: [], input));
+
+        diagnostics.Should().BeEmpty();
+        output.Should().BeEmpty();
+    }
 }