Diagnostics

Author: ejsmith

src/Foundatio.Mediator.SourceGenerator/CallSiteAnalyzer.cs

@@ -1,5 +1,4 @@
 using Foundatio.Mediator.Models;
-using Foundatio.Mediator.Utility;
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;

src/Foundatio.Mediator.SourceGenerator/HandlerGenerator.cs

@@ -11,6 +11,8 @@ public static void Execute(SourceProductionContext context, List<HandlerInfo> ha
         if (handlers.Count == 0)
             return;
 
+        Validate(context, handlers);
+
         foreach (var handler in handlers)
         {
             try
@@ -572,4 +574,31 @@ public static string GetHandlerMethodName(HandlerInfo handler)
     {
         return handler.IsAsync ? "HandleAsync" : "Handle";
     }
+
+    private static void Validate(SourceProductionContext context, List<HandlerInfo> handlers)
+    {
+        // TODO: Error for invoke or invokeasync call with more than one handler
+        // TODO: Error for no handler found for invoke or invokeasync call
+        // TODO: Error for calling sync invoke on async handler, tell them to use InvokeAsync instead
+        // TODO: Error for calling sync invoke on handler that has async middleware, tell them to use InvokeAsync instead
+        // TODO: Error for calling sync invoke on handler that returns tuple, tell them to use InvokeAsync instead because it needs to publish cascading messages
+
+        var processedMiddleware = new HashSet<MiddlewareInfo>();
+
+        foreach (var handler in handlers)
+        {
+            foreach (var middleware in handler.Middleware)
+            {
+                if (processedMiddleware.Contains(middleware))
+                    continue;
+
+                processedMiddleware.Add(middleware);
+
+                foreach (var diagnostic in middleware.Diagnostics)
+                {
+                    context.ReportDiagnostic(diagnostic.ToDiagnostic());
+                }
+            }
+        }
+    }
 }

src/Foundatio.Mediator.SourceGenerator/MiddlewareAnalyzer.cs

@@ -42,14 +42,91 @@ public static bool IsMatch(SyntaxNode node)
         if (beforeMethods.Count == 0 && afterMethods.Count == 0 && finallyMethods.Count == 0)
             return null;
 
-        // TODO: Diagnostic if multiple methods for the same lifecycle stage
-        // TODO: Diagnostic if there are mixed static and instance methods
-        // TODO: Diagnostic if all message types are not the same
+        var diagnostics = new List<DiagnosticInfo>();
+
+        if (beforeMethods.Count > 1)
+        {
+            diagnostics.Add(new DiagnosticInfo
+            {
+                Identifier = "FMED001",
+                Title = "Multiple Before Methods in Middleware",
+                Message = $"Middleware '{classSymbol.Name}' has multiple Before methods. Only one Before/BeforeAsync method is allowed per middleware class.",
+                Severity = DiagnosticSeverity.Error,
+                Location = LocationInfo.CreateFrom(classDeclaration)
+            });
+        }
+
+        if (afterMethods.Count > 1)
+        {
+            diagnostics.Add(new DiagnosticInfo
+            {
+                Identifier = "FMED002",
+                Title = "Multiple After Methods in Middleware",
+                Message = $"Middleware '{classSymbol.Name}' has multiple After methods. Only one After/AfterAsync method is allowed per middleware class.",
+                Severity = DiagnosticSeverity.Error,
+                Location = LocationInfo.CreateFrom(classDeclaration)
+            });
+        }
+
+        if (finallyMethods.Count > 1)
+        {
+            diagnostics.Add(new DiagnosticInfo
+            {
+                Identifier = "FMED003",
+                Title = "Multiple Finally Methods in Middleware",
+                Message = $"Middleware '{classSymbol.Name}' has multiple Finally methods. Only one Finally/FinallyAsync method is allowed per middleware class.",
+                Severity = DiagnosticSeverity.Error,
+                Location = LocationInfo.CreateFrom(classDeclaration)
+            });
+        }
 
         var beforeMethod = beforeMethods.FirstOrDefault();
         var afterMethod = afterMethods.FirstOrDefault();
         var finallyMethod = finallyMethods.FirstOrDefault();
 
+        var allMethods = new[] { beforeMethod, afterMethod, finallyMethod }.Where(m => m != null).ToList();
+
+        // Validate mixed static and instance methods
+        if (allMethods.Any() && !classSymbol.IsStatic)
+        {
+            var staticMethods = allMethods.Where(m => m!.IsStatic).ToList();
+            var instanceMethods = allMethods.Where(m => !m!.IsStatic).ToList();
+
+            if (staticMethods.Any() && instanceMethods.Any())
+            {
+                diagnostics.Add(new DiagnosticInfo
+                {
+                    Identifier = "FMED004",
+                    Title = "Mixed Static and Instance Middleware Methods",
+                    Message = $"Middleware '{classSymbol.Name}' has both static and instance methods. All middleware methods must be either static or instance methods consistently.",
+                    Severity = DiagnosticSeverity.Error,
+                    Location = LocationInfo.CreateFrom(classDeclaration)
+                });
+            }
+        }
+
+        // Validate all message types are the same
+        if (allMethods.Count > 1)
+        {
+            var messageTypes = allMethods
+                .Where(m => m!.Parameters.Length > 0)
+                .Select(m => m!.Parameters[0].Type)
+                .Distinct(SymbolEqualityComparer.Default)
+                .ToList();
+
+            if (messageTypes.Count > 1)
+            {
+                diagnostics.Add(new DiagnosticInfo
+                {
+                    Identifier = "FMED005",
+                    Title = "Middleware Message Type Mismatch",
+                    Message = $"Middleware '{classSymbol.Name}' handles different message types. All middleware methods in the same class must handle the same message type.",
+                    Severity = DiagnosticSeverity.Error,
+                    Location = LocationInfo.CreateFrom(classDeclaration)
+                });
+            }
+        }
+
         ITypeSymbol? messageType = beforeMethod?.Parameters[0].Type
             ?? afterMethod?.Parameters[0].Type
             ?? finallyMethod?.Parameters[0].Type;
@@ -84,6 +161,7 @@ public static bool IsMatch(SyntaxNode node)
             FinallyMethod = finallyMethod != null ? CreateMiddlewareMethodInfo(finallyMethod, context.SemanticModel.Compilation) : null,
             IsStatic = isStatic,
             Order = order,
+            Diagnostics = new(diagnostics.ToArray()),
         };
     }
 

src/Foundatio.Mediator.SourceGenerator/Models/DiagnosticInfo.cs

@@ -0,0 +1,16 @@
+using Foundatio.Mediator.Models;
+using Microsoft.CodeAnalysis;
+
+internal readonly record struct DiagnosticInfo
+{
+    public string Identifier { get; init; }
+    public string Title { get; init; }
+    public string Message { get; init; }
+    public DiagnosticSeverity Severity { get; init; }
+    public LocationInfo? Location { get; init; }
+
+    public Diagnostic ToDiagnostic()
+    {
+        return Diagnostic.Create(new DiagnosticDescriptor(Identifier, Title, Message, "Usage", Severity, true), Location?.ToLocation());
+    }
+}

src/Foundatio.Mediator.SourceGenerator/Models/MiddlewareInfo.cs

@@ -13,6 +13,7 @@ internal readonly record struct MiddlewareInfo
     public bool IsStatic { get; init; }
     public bool IsAsync => BeforeMethod?.IsAsync == true || AfterMethod?.IsAsync == true || FinallyMethod?.IsAsync == true;
     public int? Order { get; init; }
+    public EquatableArray<DiagnosticInfo> Diagnostics { get; init; }
 }
 
 internal readonly record struct MiddlewareMethodInfo