Add host-aware module registration support

Author: pwelter34

.gitattributes

@@ -0,0 +1 @@
+*.verified.txt text eol=lf working-tree-encoding=UTF-8

Directory.Packages.props

@@ -5,11 +5,12 @@
   </PropertyGroup>
   <ItemGroup>
     <PackageVersion Include="AssemblyMetadata.Generators" Version="2.2.0" />
-    <PackageVersion Include="AwesomeAssertions" Version="9.5.0" />
+    <PackageVersion Include="AwesomeAssertions" Version="9.6.0" />
     <PackageVersion Include="coverlet.MTP" Version="10.0.1" />
     <PackageVersion Include="Microsoft.CodeAnalysis.Analyzers" Version="5.3.0" />
     <PackageVersion Include="Microsoft.CodeAnalysis.CSharp" Version="[4.14.0]" />
     <PackageVersion Include="Microsoft.Extensions.DependencyInjection" Version="10.0.11" />
+    <PackageVersion Include="Microsoft.Extensions.Hosting.Abstractions" Version="10.0.11" />
     <PackageVersion Include="MinVer" Version="7.0.0" />
     <PackageVersion Include="Verify.XunitV3" Version="31.28.0" />
     <PackageVersion Include="xunit.v3.mtp-v2" Version="4.0.0" />

README.md

@@ -15,6 +15,7 @@ Source generator that helps register attribute marked services in the dependency
 - Transient, Singleton, Scoped service registration
 - Factory registration
 - Module method registration
+- Host-aware module registration with `IHostApplicationBuilder`
 - Duplicate Strategy - Skip,Replace,Append
 - Registration Strategy - Self, Implemented Interfaces, Self With Interfaces
 - Decorator registration (`RegisterDecorator`) — no runtime dependencies
@@ -332,7 +333,7 @@ public class FrontEndLoggingDecorator : IService
 
 #### Register Method
 
-When the service registration is complex, use the `RegisterServices` attribute on a method that has a parameter of `IServiceCollection` or `ServiceCollection`
+When the service registration is complex, use the `RegisterServices` attribute on a method whose first parameter is `IServiceCollection`, `ServiceCollection`, or `IHostApplicationBuilder`. The method may optionally receive a supported string tag collection as its second parameter.
 
 ```c#
 public class RegistrationModule
@@ -351,15 +352,58 @@ public class RegistrationModule
 }
 ```
 
+Register methods can inspect the tags passed to the generated extension method and conditionally add services. Supported tag parameters include `IEnumerable<string>`, `IReadOnlySet<string>`, `IReadOnlyCollection<string>`, `ICollection<string>`, `ISet<string>`, and `HashSet<string>`.
+
+```c#
+public static class TaggedRegistrationModule
+{
+    [RegisterServices]
+    public static void Register(IServiceCollection services, IReadOnlySet<string> tags)
+    {
+        if (tags.Contains("Client"))
+        {
+            services.AddSingleton<ClientService>();
+        }
+    }
+}
+
+var services = new ServiceCollection();
+services.AddInjectioTestsConsole("Client");
+```
+
+Host-aware modules can configure the full application builder:
+
+```c#
+public static class HostRegistrationModule
+{
+    [RegisterServices]
+    public static void Register(IHostApplicationBuilder builder)
+    {
+        builder.Configuration.AddJsonFile("feature.json", optional: true);
+    }
+}
+```
+
 #### Add to container
 
-The source generator creates an extension method with all the discovered services registered.  Call the generated extension method to add the services to the container.  The extension method will be called `Add[AssemblyName]`.  The assembly name will have the dots removed.
+The source generator creates an `IServiceCollection` extension method named `Add[AssemblyName]`, with dots removed from the assembly name. This extension registers discovered services and decorators, then invokes registration methods whose first parameter is `IServiceCollection` or `ServiceCollection`.
 
 ```c#
 var services = new ServiceCollection();
 services.AddInjectioTestsConsole();
 ```
 
+When the consuming project references `Microsoft.Extensions.Hosting.Abstractions`, the generator also creates an overload for `IHostApplicationBuilder`. Injectio does not add this dependency to DI-only projects.
+
+The host extension first calls the service collection extension through `builder.Services`, then invokes registration methods whose first parameter is `IHostApplicationBuilder`. Calling the host extension is therefore sufficient to run both service and host registrations.
+
+```c#
+var builder = Host.CreateApplicationBuilder(args);
+builder.AddInjectioTestsConsole();
+```
+
+Generated registration methods are idempotent. Service collection registrations and host registrations are tracked independently, so calling the service extension before the host extension still runs each portion once. For each portion, the tags supplied to its first invocation determine the registrations; later invocations are ignored.
+
 Override the extension method name by using the `InjectioName` MSBuild property.
 
 ```xml

src/Injectio.Generators/KnownTypes.cs

@@ -29,6 +29,8 @@ public static class KnownTypes
     public const string ModuleAttributeTypeName = $"{ModuleAttributeShortName}Attribute";
     public const string ModuleAttributeFullName = $"{AbstractionNamespace}.{ModuleAttributeTypeName}";
 
+    public const string HostApplicationBuilderFullName = "Microsoft.Extensions.Hosting.IHostApplicationBuilder";
+
     public const string DecoratorAttributeShortName = "RegisterDecorator";
     public const string DecoratorAttributeTypeName = $"{DecoratorAttributeShortName}Attribute";
     public const string DecoratorAttributeFullName = $"{AbstractionNamespace}.{DecoratorAttributeTypeName}";

src/Injectio.Generators/Models/ModuleRegistration.cs

@@ -1,8 +1,15 @@
 namespace Injectio.Generators.Models;
 
+public enum ModuleParameterType
+{
+    ServiceCollection,
+    HostApplicationBuilder
+}
+
 public record ModuleRegistration(
     string ClassName,
     string MethodName,
     bool IsStatic,
-    bool HasTagCollection
+    bool HasTagCollection,
+    ModuleParameterType ParameterType = ModuleParameterType.ServiceCollection
 );

src/Injectio.Generators/Models/RegistrationContext.cs

@@ -7,5 +7,6 @@ public record RegistrationContext(
     EquatableArray<ModuleRegistration> ModuleRegistrations,
     EquatableArray<DecoratorRegistration> DecoratorRegistrations,
     string? AssemblyName,
-    MethodOptions? MethodOptions
+    MethodOptions? MethodOptions,
+    bool HasHostApplicationBuilder
 );

src/Injectio.Generators/ServiceRegistrationAnalyzer.cs

@@ -107,9 +107,10 @@ private static void ValidateMethod(
             return;
         }
 
-        var hasServiceCollection = SymbolHelpers.IsServiceCollection(methodSymbol.Parameters[0]);
+        var hasSupportedParameter = SymbolHelpers.IsServiceCollection(methodSymbol.Parameters[0])
+            || SymbolHelpers.IsHostApplicationBuilder(methodSymbol.Parameters[0]);
 
-        if (!hasServiceCollection)
+        if (!hasSupportedParameter)
         {
             Diagnostic diagnostic = Diagnostic.Create(
                 DiagnosticDescriptors.InvalidMethodSignature,

src/Injectio.Generators/ServiceRegistrationGenerator.cs

@@ -132,6 +132,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Select(static (c, _) => c.AssemblyName)
             .WithTrackingName("AssemblyName");
 
+        var hasHostApplicationBuilder = context.CompilationProvider
+            .Select(static (c, _) => c.GetTypeByMetadataName(KnownTypes.HostApplicationBuilderFullName) is not null)
+            .WithTrackingName("HasHostApplicationBuilder");
+
         // include config options
         var methodOptions = context.AnalyzerConfigOptionsProvider
             .Select(static (c, _) =>
@@ -177,16 +181,18 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
             .Combine(allDecoratorRegistrations)
             .Combine(assemblyName)
             .Combine(methodOptions)
+            .Combine(hasHostApplicationBuilder)
             .Select(static (combined, _) =>
             {
-                var ((((services, modules), decorators), assemblyName), options) = combined;
+                var (((((services, modules), decorators), assemblyName), options), hasHostApplicationBuilder) = combined;
 
                 return new RegistrationContext(
                     ServiceRegistrations: services,
                     ModuleRegistrations: CreateModuleRegistrations(modules),
                     DecoratorRegistrations: decorators,
                     AssemblyName: assemblyName,
-                    MethodOptions: options
+                    MethodOptions: options,
+                    HasHostApplicationBuilder: hasHostApplicationBuilder
                 );
             })
             .WithTrackingName("Generation");
@@ -223,7 +229,8 @@ private void ExecuteGeneration(SourceProductionContext sourceContext, Registrati
             decoratorRegistrations,
             source.AssemblyName,
             methodName,
-            methodInternal);
+            methodInternal,
+            source.HasHostApplicationBuilder);
 
         // add source file
         sourceContext.AddSource("Injectio.g.cs", SourceText.From(result, Encoding.UTF8));
@@ -287,15 +294,16 @@ private static EquatableArray<DecoratorRegistration> TransformDecoratorRegistrat
         if (context.TargetSymbol is not IMethodSymbol methodSymbol)
             return null;
 
-        var (isValid, hasTagCollection) = ValidateMethod(methodSymbol);
+        var (isValid, hasTagCollection, parameterType) = ValidateMethod(methodSymbol);
         if (!isValid)
             return null;
 
         return new ModuleRegistration(
             ClassName: methodSymbol.ContainingType.ToDisplayString(SymbolHelpers.FullyQualifiedNullableFormat),
             MethodName: methodSymbol.Name,
             IsStatic: methodSymbol.IsStatic,
-            HasTagCollection: hasTagCollection
+            HasTagCollection: hasTagCollection,
+            ParameterType: parameterType
         );
     }
 
@@ -408,32 +416,41 @@ private static EquatableArray<DecoratorRegistration> TransformDecoratorRegistrat
             IsOpenGeneric: isOpenGeneric);
     }
 
-    private static (bool isValid, bool hasTagCollection) ValidateMethod(IMethodSymbol methodSymbol)
+    private static (bool isValid, bool hasTagCollection, ModuleParameterType parameterType) ValidateMethod(IMethodSymbol methodSymbol)
     {
-        var hasServiceCollection = false;
+        var parameterType = ModuleParameterType.ServiceCollection;
+        var hasSupportedParameter = false;
 
-        // validate first parameter should be service collection
+        // validate first parameter should be service collection or host application builder
         if (methodSymbol.Parameters.Length is 1 or 2)
         {
             var parameterSymbol = methodSymbol.Parameters[0];
-            hasServiceCollection = SymbolHelpers.IsServiceCollection(parameterSymbol);
+            if (SymbolHelpers.IsServiceCollection(parameterSymbol))
+            {
+                hasSupportedParameter = true;
+            }
+            else if (SymbolHelpers.IsHostApplicationBuilder(parameterSymbol))
+            {
+                hasSupportedParameter = true;
+                parameterType = ModuleParameterType.HostApplicationBuilder;
+            }
         }
 
         if (methodSymbol.Parameters.Length is 1)
-            return (hasServiceCollection, false);
+            return (hasSupportedParameter, false, parameterType);
 
         // validate second parameter should be string collection
         if (methodSymbol.Parameters.Length is 2)
         {
             var parameterSymbol = methodSymbol.Parameters[1];
             bool hasTagCollection = SymbolHelpers.IsStringCollection(parameterSymbol);
 
-            // to be valid, parameter 0 must be service collection and parameter 1 must be string collection,
-            return (hasServiceCollection && hasTagCollection, hasTagCollection);
+            // to be valid, parameter 0 must be supported and parameter 1 must be string collection
+            return (hasSupportedParameter && hasTagCollection, hasTagCollection, parameterType);
         }
 
         // invalid method
-        return (false, false);
+        return (false, false, parameterType);
     }
 
     private static ServiceRegistration? CreateServiceRegistration(INamedTypeSymbol classSymbol, AttributeData attribute, string serviceLifetime)