refactor(source-generators): simplify and restructure code generation logic

src/MinimalLambda.SourceGenerators/Diagnostics/DiagnosticGenerator.cs

@@ -1,6 +1,5 @@
 using System.Collections.Generic;
 using System.Linq;
-using LayeredCraft.SourceGeneratorTools.Types;
 using Microsoft.CodeAnalysis;
 using MinimalLambda.SourceGenerators.Models;
 
@@ -12,90 +11,30 @@ internal static List<Diagnostic> GenerateDiagnostics(CompilationInfo compilation
     {
         var diagnostics = new List<Diagnostic>();
 
-        var delegateInfos = compilationInfo.MapHandlerInvocationInfos;
-
-        // Validate parameters
-        foreach (var invocationInfo in delegateInfos)
-            // check for multiple parameters that use the `[FromEvent]` attribute
-            if (
-                invocationInfo.DelegateInfo.Parameters.Count(p => p.Source == ParameterSource.Event)
-                > 1
-            )
-                diagnostics.AddRange(
-                    invocationInfo
-                        .DelegateInfo.Parameters.Where(p => p.Source == ParameterSource.Event)
-                        .Select(p =>
-                            Diagnostic.Create(
-                                Diagnostics.MultipleParametersUseAttribute,
-                                p.LocationInfo?.ToLocation(),
-                                AttributeConstants.FromEventAttribute
-                            )
-                        )
-                );
-
-        // check for invalid keyed service usage - MapHandler
         diagnostics.AddRange(
-            compilationInfo.MapHandlerInvocationInfos.GenerateKeyedServiceKeyDiagnostics()
+            compilationInfo
+                .MapHandlerInvocationInfos.SelectMany(m => m.DiagnosticInfos)
+                .Select(d => d.ToDiagnostic())
         );
 
-        // check for invalid keyed service usage - OnShutdown
         diagnostics.AddRange(
-            compilationInfo.OnShutdownInvocationInfos.GenerateKeyedServiceKeyDiagnostics()
+            compilationInfo
+                .OnInitInvocationInfos.SelectMany(m => m.DiagnosticInfos)
+                .Select(d => d.ToDiagnostic())
         );
 
-        foreach (var useMiddlewareTInfo in compilationInfo.UseMiddlewareTInfos)
-        {
-            // ensure middleware class is concrete
-            if (useMiddlewareTInfo.ClassInfo.TypeKind is "interface" or "abstract class")
-            {
-                diagnostics.Add(
-                    Diagnostic.Create(
-                        Diagnostics.MustBeConcreteType,
-                        useMiddlewareTInfo.GenericTypeArgumentLocation?.ToLocation(),
-                        useMiddlewareTInfo.ClassInfo.ShortName
-                    )
-                );
-            }
+        diagnostics.AddRange(
+            compilationInfo
+                .OnShutdownInvocationInfos.SelectMany(m => m.DiagnosticInfos)
+                .Select(d => d.ToDiagnostic())
+        );
 
-            // validate that middleware class constructors only use `[MiddlewareConstructor]` once
-            diagnostics.AddRange(
-                useMiddlewareTInfo
-                    .ClassInfo.ConstructorInfos.Where(c =>
-                        c.AttributeInfos.Any(a =>
-                            a.FullName == AttributeConstants.MiddlewareConstructor
-                        )
-                    )
-                    .Skip(1)
-                    .Select(c =>
-                        Diagnostic.Create(
-                            Diagnostics.MultipleConstructorsWithAttribute,
-                            c.AttributeInfos.First(a =>
-                                    a.FullName == AttributeConstants.MiddlewareConstructor
-                                )
-                                .LocationInfo?.ToLocation(),
-                            AttributeConstants.MiddlewareConstructor
-                        )
-                    )
-            );
-        }
+        diagnostics.AddRange(
+            compilationInfo
+                .UseMiddlewareTInfos.SelectMany(m => m.DiagnosticInfos)
+                .Select(d => d.ToDiagnostic())
+        );
 
         return diagnostics;
     }
-
-    private static Diagnostic[] GenerateKeyedServiceKeyDiagnostics(
-        this EquatableArray<HigherOrderMethodInfo> methodNameInfos
-    ) =>
-        methodNameInfos
-            .SelectMany(onShutdownInvocationInfo =>
-                onShutdownInvocationInfo.DelegateInfo.Parameters
-            )
-            .Where(parameterInfo => parameterInfo.KeyedServiceKey is { DisplayValue: null })
-            .Select(parameterInfo =>
-                Diagnostic.Create(
-                    Diagnostics.InvalidAttributeArgument,
-                    parameterInfo.KeyedServiceKey!.Value.LocationInfo?.ToLocation(),
-                    parameterInfo.KeyedServiceKey.Value.Type
-                )
-            )
-            .ToArray();
 }

src/MinimalLambda.SourceGenerators/Diagnostics/DiagnosticInfo.cs

@@ -0,0 +1,40 @@
+using LayeredCraft.SourceGeneratorTools.Utilities;
+using Microsoft.CodeAnalysis;
+
+namespace MinimalLambda.SourceGenerators.Models;
+
+internal sealed record DiagnosticInfo(
+    DiagnosticDescriptor DiagnosticDescriptor,
+    LocationInfo? LocationInfo = null,
+    params object?[] MessageArgs
+)
+{
+    public bool Equals(DiagnosticInfo? other) =>
+        other is not null
+        && Equals(DiagnosticDescriptor.Id, other.DiagnosticDescriptor.Id)
+        && Equals(LocationInfo, other.LocationInfo);
+
+    public override int GetHashCode() => HashCode.Combine(DiagnosticDescriptor, LocationInfo);
+}
+
+internal static class DiagnosticInfoExtensions
+{
+    extension(DiagnosticInfo diagnosticInfo)
+    {
+        internal static DiagnosticInfo Create(
+            DiagnosticDescriptor diagnosticDescriptor,
+            LocationInfo? locationInfo,
+            object?[] messageArgs
+        ) => new(diagnosticDescriptor, locationInfo, messageArgs);
+
+        internal Diagnostic ToDiagnostic() =>
+            Diagnostic.Create(
+                diagnosticInfo.DiagnosticDescriptor,
+                diagnosticInfo.LocationInfo?.ToLocation(),
+                diagnosticInfo.MessageArgs
+            );
+
+        internal void ReportDiagnostic(SourceProductionContext context) =>
+            context.ReportDiagnostic(diagnosticInfo.ToDiagnostic());
+    }
+}

src/MinimalLambda.SourceGenerators/Diagnostics/DiagnosticResult.cs

@@ -0,0 +1,54 @@
+using System;
+using Microsoft.CodeAnalysis;
+using MinimalLambda.SourceGenerators.Models;
+
+// ReSharper disable MemberCanBePrivate.Global
+
+namespace MinimalLambda.SourceGenerators;
+
+internal sealed class DiagnosticResult<T>
+{
+    internal bool IsSuccess { get; }
+    internal T? Value { get; }
+    internal DiagnosticInfo? Error { get; }
+
+    private DiagnosticResult(bool isSuccess, T? value, DiagnosticInfo? error)
+    {
+        IsSuccess = isSuccess;
+        Value = value;
+        Error = error;
+    }
+
+    public static DiagnosticResult<T> Success(T value) => new(true, value, null);
+
+    public static implicit operator DiagnosticResult<T>(T value) => Success(value);
+
+    public static DiagnosticResult<T> Failure(DiagnosticInfo error) => new(false, default, error);
+
+    public static DiagnosticResult<T> Failure(
+        DiagnosticDescriptor diagnosticDescriptor,
+        LocationInfo? locationInfo = null,
+        params object?[] messageArgs
+    ) => new(false, default, new DiagnosticInfo(diagnosticDescriptor, locationInfo, messageArgs));
+
+    public DiagnosticResult<TNew> Map<TNew>(Func<T, TNew> map) =>
+        IsSuccess
+            ? DiagnosticResult<TNew>.Success(map(Value!))
+            : DiagnosticResult<TNew>.Failure(Error!);
+
+    public DiagnosticResult<TNew> Bind<TNew>(Func<T, DiagnosticResult<TNew>> bind) =>
+        IsSuccess ? bind(Value!) : DiagnosticResult<TNew>.Failure(Error!);
+
+    public TResult Match<TResult>(
+        Func<T, TResult> onSuccess,
+        Func<DiagnosticInfo, TResult> onFailure
+    ) => IsSuccess ? onSuccess(Value!) : onFailure(Error!);
+
+    public void Switch(Action<T> onSuccess, Action<DiagnosticInfo> onFailure)
+    {
+        if (IsSuccess)
+            onSuccess(Value!);
+        else
+            onFailure(Error!);
+    }
+}

src/MinimalLambda.SourceGenerators/OutputGenerators/LambdaHostOutputGenerator.cs → src/MinimalLambda.SourceGenerators/Emitters/MinimalLambdaEmitter.cs

@@ -1,30 +1,22 @@
+using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 using Microsoft.CodeAnalysis;
 using MinimalLambda.SourceGenerators.Models;
 
-namespace MinimalLambda.SourceGenerators;
+namespace MinimalLambda.SourceGenerators.Emitters;
 
-internal static class LambdaHostOutputGenerator
+internal static class MinimalLambdaEmitter
 {
-    internal static string GeneratedCodeAttribute
+    internal static readonly Lazy<string> GeneratedCodeAttribute = new(() =>
     {
-        get
-        {
-            if (field is null)
-            {
-                var assembly = Assembly.GetExecutingAssembly();
-                var generatorName = assembly.GetName().Name;
-                var generatorVersion = assembly.GetName().Version.ToString();
-
-                field =
-                    $"""[global::System.CodeDom.Compiler.GeneratedCode("{generatorName}", "{generatorVersion}")]""";
-            }
+        var assembly = Assembly.GetExecutingAssembly();
+        var generatorName = assembly.GetName().Name;
+        var generatorVersion = assembly.GetName().Version;
 
-            return field;
-        }
-    }
+        return $"""[global::System.CodeDom.Compiler.GeneratedCode("{generatorName}", "{generatorVersion}")]""";
+    });
 
     internal static void Generate(SourceProductionContext context, CompilationInfo compilationInfo)
     {
@@ -41,7 +33,10 @@ internal static void Generate(SourceProductionContext context, CompilationInfo c
 
         List<string?> outputs =
         [
-            CommonSources.Generate(),
+            TemplateHelper.Render(
+                GeneratorConstants.InterceptsLocationAttributeTemplateFile,
+                new { GeneratedCodeAttribute }
+            ),
             """
                 namespace MinimalLambda.Generated
                 {
@@ -59,37 +54,50 @@ namespace MinimalLambda.Generated
         // if MapHandler calls found, generate the source code.
         if (compilationInfo.MapHandlerInvocationInfos.Count >= 1)
             outputs.Add(
-                MapHandlerSources.Generate(
-                    compilationInfo.MapHandlerInvocationInfos,
-                    compilationInfo.BuilderInfos
+                TemplateHelper.Render(
+                    GeneratorConstants.LambdaHostMapHandlerExtensionsTemplateFile,
+                    new
+                    {
+                        GeneratedCodeAttribute,
+                        MapHandlerCalls = compilationInfo.MapHandlerInvocationInfos,
+                    }
                 )
             );
 
         // add UseMiddleware<T> interceptors
         if (compilationInfo.UseMiddlewareTInfos.Count >= 1)
-            outputs.Add(UseMiddlewareTSource.Generate(compilationInfo.UseMiddlewareTInfos));
+            outputs.Add(
+                TemplateHelper.Render(
+                    GeneratorConstants.UseMiddlewareTTemplateFile,
+                    new { GeneratedCodeAttribute, Calls = compilationInfo.UseMiddlewareTInfos }
+                )
+            );
 
         // add OnInit interceptors
         if (compilationInfo.OnInitInvocationInfos.Count >= 1)
             outputs.Add(
-                GenericHandlerSources.Generate(
-                    compilationInfo.OnInitInvocationInfos,
-                    "OnInit",
-                    "bool",
-                    "true",
-                    "ILambdaOnInitBuilder"
+                TemplateHelper.Render(
+                    GeneratorConstants.GenericHandlerTemplateFile,
+                    new
+                    {
+                        Name = compilationInfo.OnInitInvocationInfos.First().MethodType,
+                        Calls = compilationInfo.OnInitInvocationInfos,
+                        GeneratedCodeAttribute,
+                    }
                 )
             );
 
         // add OnShutdown interceptors
         if (compilationInfo.OnShutdownInvocationInfos.Count >= 1)
             outputs.Add(
-                GenericHandlerSources.Generate(
-                    compilationInfo.OnShutdownInvocationInfos,
-                    "OnShutdown",
-                    null,
-                    null,
-                    "ILambdaOnShutdownBuilder"
+                TemplateHelper.Render(
+                    GeneratorConstants.GenericHandlerTemplateFile,
+                    new
+                    {
+                        Name = compilationInfo.OnShutdownInvocationInfos.First().MethodType,
+                        Calls = compilationInfo.OnShutdownInvocationInfos,
+                        GeneratedCodeAttribute,
+                    }
                 )
             );