Create system to register LiteralConverters

This will make it much easier for extensions to register their
literal converters.

Also, refactor `DefaultTypeSerializerEnricher` to implement
`IResourceFileEnricher` executed by the
`ResourceFileCompilationEnricher`.

src/main/Yardarm/Enrichment/Compilation/CompilationEnricherServiceCollectionExtensions.cs

@@ -13,8 +13,9 @@ public static IServiceCollection AddDefaultCompilationEnrichers(this IServiceCol
                 .AddCompilationEnricher<ResourceFileCompilationEnricher>()
                 .AddCompilationEnricher<SyntaxTreeCompilationEnricher>()
                 .AddCompilationEnricher<OpenApiCompilationEnricher>()
-                .AddCompilationEnricher<DefaultTypeSerializersEnricher>()
-                .AddCompilationEnricher<FormatCompilationEnricher>();
+                .AddCompilationEnricher<FormatCompilationEnricher>()
+                .AddResourceFileEnricher<DefaultTypeSerializersEnricher>()
+                .AddResourceFileEnricher<DefaultLiteralConvertersEnricher>();
 
         public static IServiceCollection AddAssemblyInfoEnricher<T>(this IServiceCollection services)
             where T : class, IAssemblyInfoEnricher =>

src/main/Yardarm/Enrichment/Compilation/DefaultLiteralConvertersEnricher.cs

@@ -0,0 +1,39 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Yardarm.Enrichment.Compilation;
+
+public class DefaultLiteralConvertersEnricher(
+    IEnumerable<IDefaultLiteralConverterEnricher> createDefaultRegistryEnrichers)
+    : IResourceFileEnricher
+{
+    public bool ShouldEnrich(string resourceName) =>
+        resourceName == "Yardarm.Client.Serialization.Literals.LiteralConverterRegistry.cs";
+
+    public CompilationUnitSyntax Enrich(CompilationUnitSyntax target, ResourceFileEnrichmentContext context)
+    {
+        ClassDeclarationSyntax? classDeclaration = target
+            .DescendantNodes()
+            .OfType<ClassDeclarationSyntax>()
+            .FirstOrDefault(p => p.Identifier.ValueText == "LiteralConverterRegistry");
+
+        MethodDeclarationSyntax? methodDeclaration = classDeclaration?
+            .ChildNodes()
+            .OfType<MethodDeclarationSyntax>()
+            .FirstOrDefault(p => p.Identifier.ValueText == "CreateDefaultRegistry");
+
+        if (methodDeclaration?.ExpressionBody != null)
+        {
+            MethodDeclarationSyntax newMethodDeclaration = methodDeclaration.WithExpressionBody(
+                methodDeclaration.ExpressionBody.WithExpression(
+                    methodDeclaration.ExpressionBody.Expression.Enrich(createDefaultRegistryEnrichers)));
+
+            target = target.ReplaceNode(methodDeclaration, newMethodDeclaration);
+        }
+
+        return target;
+    }
+}

src/main/Yardarm/Enrichment/Compilation/DefaultTypeSerializersEnricher.cs

@@ -1,62 +1,38 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Linq;
-using System.Threading;
-using System.Threading.Tasks;
 using Microsoft.CodeAnalysis;
-using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 
-namespace Yardarm.Enrichment.Compilation
+namespace Yardarm.Enrichment.Compilation;
+
+public class DefaultTypeSerializersEnricher(
+    IEnumerable<ICreateDefaultRegistryEnricher> createDefaultRegistryEnrichers) :
+    IResourceFileEnricher
 {
-    public class DefaultTypeSerializersEnricher : ICompilationEnricher
-    {
-        private readonly IList<ICreateDefaultRegistryEnricher> _createDefaultRegistryEnrichers;
+    public bool ShouldEnrich(string resourceName) =>
+        resourceName == "Yardarm.Client.Serialization.TypeSerializerRegistry.cs";
 
-        public Type[] ExecuteAfter { get; } =
-        {
-            typeof(SyntaxTreeCompilationEnricher)
-        };
+    public CompilationUnitSyntax Enrich(CompilationUnitSyntax target, ResourceFileEnrichmentContext context)
+    {
+        ClassDeclarationSyntax? classDeclaration = target
+            .DescendantNodes()
+            .OfType<ClassDeclarationSyntax>()
+            .FirstOrDefault(p => p.Identifier.ValueText == "TypeSerializerRegistry");
 
-        public DefaultTypeSerializersEnricher(
-            IEnumerable<ICreateDefaultRegistryEnricher> createDefaultRegistryEnrichers)
-        {
-            _createDefaultRegistryEnrichers = createDefaultRegistryEnrichers.ToArray();
-        }
+        MethodDeclarationSyntax? methodDeclaration = classDeclaration?
+            .ChildNodes()
+            .OfType<MethodDeclarationSyntax>()
+            .FirstOrDefault(p => p.Identifier.ValueText == "CreateDefaultRegistry");
 
-        public async ValueTask<CSharpCompilation> EnrichAsync(CSharpCompilation target,
-            CancellationToken cancellationToken = default)
+        if (methodDeclaration?.ExpressionBody != null)
         {
-            foreach (SyntaxTree syntaxTree in target.SyntaxTrees)
-            {
-                SyntaxNode rootNode = await syntaxTree.GetRootAsync(cancellationToken)
-                    .ConfigureAwait(false);
+            MethodDeclarationSyntax newMethodDeclaration = methodDeclaration.WithExpressionBody(
+                methodDeclaration.ExpressionBody.WithExpression(
+                    methodDeclaration.ExpressionBody.Expression.Enrich(createDefaultRegistryEnrichers)));
 
-                ClassDeclarationSyntax? classDeclaration = rootNode
-                    .DescendantNodes()
-                    .OfType<ClassDeclarationSyntax>()
-                    .FirstOrDefault(p => p.Identifier.ValueText == "TypeSerializerRegistry");
-
-                MethodDeclarationSyntax? methodDeclaration = classDeclaration?
-                    .ChildNodes()
-                    .OfType<MethodDeclarationSyntax>()
-                    .FirstOrDefault(p => p.Identifier.ValueText == "CreateDefaultRegistry");
-
-                if (methodDeclaration?.ExpressionBody != null)
-                {
-                    MethodDeclarationSyntax newMethodDeclaration = methodDeclaration.WithExpressionBody(
-                        methodDeclaration.ExpressionBody.WithExpression(
-                            methodDeclaration.ExpressionBody.Expression.Enrich(_createDefaultRegistryEnrichers)));
-
-                    rootNode = rootNode.ReplaceNode(methodDeclaration, newMethodDeclaration);
-
-                    // Break once we've found what we're looking for
-                    return target.ReplaceSyntaxTree(syntaxTree,
-                        syntaxTree.WithRootAndOptions(rootNode, syntaxTree.Options));
-                }
-            }
-
-            return target;
+            target = target.ReplaceNode(methodDeclaration, newMethodDeclaration);
         }
+
+        return target;
     }
 }

src/main/Yardarm/Enrichment/Compilation/FormatCompilationEnricher.cs

@@ -9,7 +9,6 @@
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.Formatting;
 using Microsoft.Extensions.Logging;
-using Yardarm.Generation;
 
 namespace Yardarm.Enrichment.Compilation
 {
@@ -27,13 +26,12 @@ public class FormatCompilationEnricher : ICompilationEnricher
         private readonly ILogger<FormatCompilationEnricher> _logger;
 
         public Type[] ExecuteAfter { get; } =
-        {
+        [
             typeof(VersionAssemblyInfoEnricher),
             typeof(SyntaxTreeCompilationEnricher),
-            typeof(DefaultTypeSerializersEnricher),
             typeof(OpenApiCompilationEnricher),
             typeof(ResourceFileCompilationEnricher)
-        };
+        ];
 
         public FormatCompilationEnricher(YardarmGenerationSettings settings,
             ILogger<FormatCompilationEnricher> logger)

src/main/Yardarm/Enrichment/Compilation/OpenApiCompilationEnricher.cs

@@ -25,9 +25,9 @@ public class OpenApiCompilationEnricher : ICompilationEnricher
         private readonly ConcurrentBag<SyntaxTree> _toAdd = [];
 
         public Type[] ExecuteAfter { get; } =
-        {
-            typeof(DefaultTypeSerializersEnricher)
-        };
+        [
+            typeof(ResourceFileCompilationEnricher),
+        ];
 
         public OpenApiCompilationEnricher(IOpenApiElementRegistry elementRegistry,
             IEnumerable<IOpenApiSyntaxNodeEnricher> enrichers)

src/main/Yardarm/Enrichment/EnricherServiceCollectionExtensions.cs

@@ -25,6 +25,10 @@ public static IServiceCollection AddCreateDefaultRegistryEnricher<T>(this IServi
             where T : class, ICreateDefaultRegistryEnricher =>
             services.AddTransient<ICreateDefaultRegistryEnricher, T>();
 
+        public static IServiceCollection AddDefaultLiteralConverterEnricher<T>(this IServiceCollection services)
+            where T : class, IDefaultLiteralConverterEnricher =>
+            services.AddTransient<IDefaultLiteralConverterEnricher, T>();
+
         public static IServiceCollection AddOpenApiSyntaxNodeEnricher<T>(this IServiceCollection services)
             where T : class, IOpenApiSyntaxNodeEnricher =>
             services.AddTransient<IOpenApiSyntaxNodeEnricher, T>();

src/main/Yardarm/Enrichment/IDefaultLiteralConverterEnricher.cs

@@ -0,0 +1,10 @@
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+
+namespace Yardarm.Enrichment;
+
+/// <summary>
+/// Enriches the body of the CreateDefaultRegistry method in the LiteralConverterRegistry class.
+/// </summary>
+public interface IDefaultLiteralConverterEnricher : IEnricher<ExpressionSyntax>
+{
+}