feat: Enhance MissingExpressiveAnalyzer with enum handling and add related tests

Author: koenbeuk

src/ExpressiveSharp.CodeFixers/MissingExpressiveAnalyzer.cs

@@ -126,7 +126,14 @@ private static void AnalyzeDescendants(SyntaxNodeAnalysisContext context, Syntax
             if (node is InvocationExpressionSyntax invocation)
             {
                 var info = context.SemanticModel.GetSymbolInfo(invocation, context.CancellationToken);
-                referencedSymbol = info.Symbol;
+                if (info.Symbol is not IMethodSymbol invokedMethod)
+                    continue;
+
+                // Skip enum method calls — the generator expands these via TryEmitEnumMethodExpansion
+                if (HasEnumReceiver(invokedMethod, invocation, context.SemanticModel, context.CancellationToken))
+                    continue;
+
+                referencedSymbol = invokedMethod;
                 location = invocation.Expression is MemberAccessExpressionSyntax memberAccess
                     ? memberAccess.Name.GetLocation()
                     : invocation.Expression.GetLocation();
@@ -162,6 +169,47 @@ identifier.Parent is not MemberAccessExpressionSyntax &&
         }
     }
 
+    /// <summary>
+    /// Returns true when the invocation's receiver (or first extension-method arg) is an enum
+    /// or Nullable&lt;Enum&gt;. The generator already expands these via TryEmitEnumMethodExpansion,
+    /// so EXP0013 would be a false positive.
+    /// </summary>
+    private static bool HasEnumReceiver(
+        IMethodSymbol method,
+        InvocationExpressionSyntax invocation,
+        SemanticModel semanticModel,
+        System.Threading.CancellationToken ct)
+    {
+        ITypeSymbol? receiverType = null;
+
+        if (!method.IsStatic && method.ReceiverType is not null)
+        {
+            receiverType = method.ReceiverType;
+        }
+        else if (method.IsExtensionMethod)
+        {
+            var original = method.ReducedFrom ?? method;
+            if (original.Parameters.Length > 0)
+                receiverType = original.Parameters[0].Type;
+        }
+
+        return receiverType is not null && IsEnumOrNullableEnum(receiverType);
+    }
+
+    private static bool IsEnumOrNullableEnum(ITypeSymbol type)
+    {
+        if (type.TypeKind == TypeKind.Enum)
+            return true;
+
+        if (type is INamedTypeSymbol { IsGenericType: true } namedType &&
+            namedType.OriginalDefinition.SpecialType == SpecialType.System_Nullable_T &&
+            namedType.TypeArguments.Length == 1 &&
+            namedType.TypeArguments[0].TypeKind == TypeKind.Enum)
+            return true;
+
+        return false;
+    }
+
     // ── Core logic (matches ExpressionTreeEmitter.WarnIfMissingExpressive) ──
 
     private static void WarnIfMissingExpressive(

tests/ExpressiveSharp.Generator.Tests/ExpressiveGenerator/MissingExpressiveDiagnosticTests.cs

@@ -95,6 +95,50 @@ class C {
             "Expected EXP0013 for method call to block-body method without [Expressive]");
     }
 
+    [TestMethod]
+    public async Task ExtensionMethod_OnNonEnumReceiver_WarnsEXP0013()
+    {
+        var diagnostics = await RunAnalyzerAsync(
+            """
+            namespace Foo {
+                public static class StringExtensions {
+                    public static string Shout(this string value) => value.ToUpper() + "!";
+                }
+
+                class C {
+                    public string Name { get; set; } = "";
+
+                    [Expressive]
+                    public string Loud => Name.Shout();
+                }
+            }
+            """);
+
+        Assert.IsTrue(diagnostics.Any(d => d.Id == "EXP0013"),
+            "Expected EXP0013 for non-enum extension method without [Expressive]");
+    }
+
+    [TestMethod]
+    public async Task PropertyWithoutExpressive_ReferencedInExpressive_WarnsEXP0013()
+    {
+        var diagnostics = await RunAnalyzerAsync(
+            """
+            namespace Foo {
+                class Order {
+                    public double Price { get; set; }
+                    public int Quantity { get; set; }
+                    public double Total => Price * Quantity;
+
+                    [Expressive]
+                    public string? Label => Total >= 0 ? "Positive" : "Negative";
+                }
+            }
+            """);
+
+        Assert.IsTrue(diagnostics.Any(d => d.Id == "EXP0013"),
+            "Expected EXP0013 for property without [Expressive] referenced in [Expressive] member");
+    }
+
     [TestMethod]
     public async Task EXP0013_HasAdditionalLocation_PointingToDeclaration()
     {
@@ -197,6 +241,35 @@ class C {
             "Should not warn when referenced property already has [Expressive]");
     }
 
+    [TestMethod]
+    public async Task ExtensionMethod_OnEnumReceiver_NoWarning()
+    {
+        var diagnostics = await RunAnalyzerAsync(
+            """
+            namespace Foo {
+                public enum OrderStatus { Pending, Approved, Rejected }
+
+                public static class OrderStatusExtensions {
+                    public static string GetDescription(this OrderStatus value) => value switch {
+                        OrderStatus.Pending => "Awaiting processing",
+                        OrderStatus.Approved => "Order approved",
+                        _ => value.ToString(),
+                    };
+                }
+
+                class Order {
+                    public OrderStatus Status { get; set; }
+
+                    [Expressive]
+                    public string StatusDescription => Status.GetDescription();
+                }
+            }
+            """);
+
+        Assert.IsFalse(diagnostics.Any(d => d.Id == "EXP0013"),
+            "Should not warn for enum extension method — generator expands these via TryEmitEnumMethodExpansion");
+    }
+
     // ── Helper ──────────────────────────────────────────────────────────────
 
     private async Task<ImmutableArray<Diagnostic>> RunAnalyzerAsync(string source)