Support tagged registrations of handlers (#374)

Author: viceroypenguin

Immediate.Handlers.sln.DotSettings

@@ -186,6 +186,16 @@ Calling this `AddXxxHandlers()` method will register all classes in the assembly
 In your `Program.cs`, add a call to `services.AddXxxBehaviors()`, where `Xxx` is the application identifier described above.
 Calling this method will register all behaviors referenced in any `[Behaviors]` attribute.
 
+#### `Tags`
+
+Assigns string tags to the registration. When `AddXxxHandlers` is called with tag arguments, only registrations that share at
+least one tag (or registrations with no tags) are included.
+
+```csharp
+[Handler(Tags = ["worker", "background"])]
+public sealed class BackgroundWorker { }
+```
+
 ### Streaming Handlers
 
 Immediate.Handlers supports streaming handlers that return `IAsyncEnumerable<TResponse>` for scenarios where

readme.md

@@ -0,0 +1,52 @@
+using System.Collections.Immutable;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+
+namespace Immediate.Handlers;
+
+internal static class TypedConstantExtensions
+{
+	public static TypedConstant? GetArgumentValue(this ImmutableArray<KeyValuePair<string, TypedConstant>> arguments, string name)
+	{
+		foreach (var argument in arguments)
+		{
+			if (string.Equals(name, argument.Key, StringComparison.Ordinal))
+				return argument.Value;
+		}
+
+		return null;
+	}
+
+	public static string? GetEnumArgumentValue(this ImmutableArray<KeyValuePair<string, TypedConstant>> arguments, string name) =>
+		arguments.GetArgumentValue(name)?.GetEnumValueName();
+
+	extension(TypedConstant constant)
+	{
+		public string GetEnumValueName()
+		{
+			var fullName = constant.ToCSharpString();
+			var start = fullName.LastIndexOf('.');
+			return fullName[(start + 1)..];
+		}
+
+		public string? GetStringArray()
+		{
+			if (constant.Kind != TypedConstantKind.Array)
+				return null;
+
+			return string.Join(
+				", ",
+				constant.Values
+					.Select(tc => tc.ToCSharpString())
+					.OrderBy(x => x, StringComparer.Ordinal)
+			);
+		}
+
+		public INamedTypeSymbol? ArgumentType =>
+			constant switch
+			{
+				{ Kind: TypedConstantKind.Type, Value: INamedTypeSymbol type } => type,
+				_ => null,
+			};
+	}
+}

src/Common/TypedConstantExtensions.cs

@@ -1,3 +1,5 @@
+using Microsoft.CodeAnalysis;
+
 namespace Immediate.Handlers;
 
 internal static class Utility
@@ -7,4 +9,7 @@ internal static class Utility
 
 	public static IEnumerable<T> WhereNotNull<T>(this IEnumerable<T?> values)
 		where T : class => values.Where(x => x is not null)!;
+
+	public static IncrementalValuesProvider<T> WhereNotNull<T>(this IncrementalValuesProvider<T?> values)
+		where T : class => values.Where(x => x is not null)!;
 }

src/Common/Utility.cs

@@ -15,8 +15,12 @@ public sealed partial class ImmediateHandlersGenerator : IIncrementalGenerator
 {
 	public void Initialize(IncrementalGeneratorInitializationContext context)
 	{
-		var assemblyName = context.CompilationProvider
-			.Select((cp, _) => cp.GetAssemblyIdentifier())
+		var assemblyDefaults = context.CompilationProvider
+			.Select((cp, _) => new AssemblyDefaults
+			{
+				AssemblyName = cp.GetAssemblyIdentifier(),
+				LanguageVersion = (cp.SyntaxTrees.FirstOrDefault()?.Options as CSharpParseOptions)?.LanguageVersion ?? LanguageVersion.CSharp12,
+			})
 			.WithTrackingName("AssemblyName");
 
 		var @namespace = context
@@ -44,6 +48,8 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 				predicate: (node, _) => node is TypeDeclarationSyntax,
 				TransformHandler.ParseHandler
 			)
+			.WhereNotNull()
+			.Where(h => h.DisplayName is { } && !(h.OverrideBehaviors?.Any(b => b is null) ?? false))
 			.WithTrackingName("Handlers");
 
 		var handlerNodes = handlers
@@ -62,11 +68,10 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 		);
 
 		var registrationNodes = handlers
-			.Select((h, _) => (h?.DisplayName, h?.ServiceLifetime, h?.OverrideBehaviors))
 			.Collect()
 			.Combine(behaviors)
 			.Combine(@namespace
-				.Combine(assemblyName)
+				.Combine(assemblyDefaults)
 			)
 			.WithTrackingName("Registrations");
 
@@ -77,28 +82,22 @@ public void Initialize(IncrementalGeneratorInitializationContext context)
 				handlers: node.Left.Left,
 				behaviors: node.Left.Right,
 				@namespace: node.Right.Left,
-				assemblyName: node.Right.Right
+				assemblyDefaults: node.Right.Right
 			)
 		);
 	}
 
 	private static void RenderServiceCollectionExtension(
 		SourceProductionContext context,
-		ImmutableArray<(string? DisplayName, string? ServiceLifetime, EquatableReadOnlyList<Behavior?>? Behaviors)> handlers,
+		ImmutableArray<Handler> handlers,
 		ImmutableArray<Behavior?> behaviors,
 		string? @namespace,
-		string assemblyName
+		AssemblyDefaults assemblyDefaults
 	)
 	{
 		var cancellationToken = context.CancellationToken;
 		cancellationToken.ThrowIfCancellationRequested();
 
-		if (!handlers.Any())
-			return;
-
-		if (handlers.Any(h => h.DisplayName is null || (h.Behaviors?.Any(b => b is null) ?? false)))
-			return;
-
 		if (behaviors.Any(b => b is null))
 			return;
 
@@ -112,16 +111,22 @@ string assemblyName
 		so.Import(
 			new
 			{
+				assemblyDefaults.AssemblyName,
+				assemblyDefaults.LanguageVersion,
 				Namespace = @namespace,
-				AssemblyName = assemblyName,
-				Handlers = handlers.Select(x => new { x.DisplayName, x.ServiceLifetime }),
+				Version = ThisAssembly.InformationalVersion,
+
 				Behaviors = behaviors
-					.Concat(handlers.SelectMany(h => h.Behaviors ?? []))
+					.Concat(handlers.SelectMany(h => h.OverrideBehaviors ?? []))
 					.WhereNotNull()
 					.Select(b => new { b.RegistrationType })
 					.Distinct(),
 
-				Version = ThisAssembly.InformationalVersion,
+				HandlersByTag = handlers
+					.GroupBy(
+						h => h.Tags,
+						StringComparer.Ordinal
+					),
 			}
 		);
 
@@ -140,17 +145,14 @@ string assemblyName
 
 	private static void RenderHandler(
 		SourceProductionContext context,
-		Handler? handler,
+		Handler handler,
 		ImmutableArray<Behavior?> behaviors,
 		Template template
 	)
 	{
 		var cancellationToken = context.CancellationToken;
 		cancellationToken.ThrowIfCancellationRequested();
 
-		if (handler == null)
-			return;
-
 		var responseType = handler.ResponseType ?? new()
 		{
 			Name = "global::System.ValueTuple",
@@ -204,10 +206,11 @@ Template template
 	private static List<Behavior?> BuildPipeline(
 			GenericType requestType,
 			GenericType responseType,
-			IEnumerable<Behavior?> enumerable) =>
-		[
-			.. enumerable.Where(b => b.IsValid(requestType, responseType)),
-		];
+			IEnumerable<Behavior?> enumerable
+	) =>
+	[
+		.. enumerable.Where(b => b.IsValid(requestType, responseType)),
+	];
 
 	private sealed record RenderBehavior
 	{

src/Immediate.Handlers.Generators/ImmediateHandlersGenerator.cs

@@ -1,9 +1,15 @@
 using System.Diagnostics.CodeAnalysis;
-
-// ReSharper disable UnusedAutoPropertyAccessor.Local
+using Microsoft.CodeAnalysis.CSharp;
 
 namespace Immediate.Handlers.Generators;
 
+[ExcludeFromCodeCoverage]
+public sealed record AssemblyDefaults
+{
+	public required string AssemblyName { get; init; }
+	public required LanguageVersion LanguageVersion { get; init; }
+}
+
 [ExcludeFromCodeCoverage]
 public sealed record Behavior
 {
@@ -43,6 +49,7 @@ public sealed record Handler
 	public required bool UseToken { get; init; }
 
 	public required string? ServiceLifetime { get; init; }
+	public required string? Tags { get; init; }
 
 	public required GenericType RequestType { get; init; }
 	public required GenericType? ResponseType { get; init; }

src/Immediate.Handlers.Generators/Models.cs

@@ -2,11 +2,11 @@
   "profiles": {
     "Normal": {
       "commandName": "DebugRoslynComponent",
-      "targetProject": "..\\..\\samples\\Normal\\Normal.csproj"
+      "targetProject": "../../samples/Normal/Normal.csproj"
     },
-    "Benchmark.Simple": {
+    "Immediate.Handlers.FunctionalTests": {
       "commandName": "DebugRoslynComponent",
-      "targetProject": "..\\..\\benchmarks\\Benchmark.Simple\\Benchmark.Simple.csproj"
+      "targetProject": "../../tests/Immediate.Handlers.FunctionalTests/Immediate.Handlers.FunctionalTests.csproj"
     }
   }
-}
+}

src/Immediate.Handlers.Generators/Properties/launchSettings.json

@@ -23,13 +23,41 @@ public static class HandlerServiceCollectionExtensions
 
 	public static global::Microsoft.Extensions.DependencyInjection.IServiceCollection Add{{ assembly_name }}Handlers(
 		this global::Microsoft.Extensions.DependencyInjection.IServiceCollection services,
-		global::Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime = global::Microsoft.Extensions.DependencyInjection.ServiceLifetime.Scoped
+		global::Microsoft.Extensions.DependencyInjection.ServiceLifetime lifetime = global::Microsoft.Extensions.DependencyInjection.ServiceLifetime.Scoped,
+		params {{ if language_version <= 1200 }}string[]{{ else }}global::System.ReadOnlySpan<string>{{ end }} tags
 	)
 	{
-		{{~ for h in handlers ~}}
+		{{~ for g in handlers_by_tag ~}}
+		{{~ if g.key != null ~}}
+		if (tags is [] || Intersects(tags, [{{ g.key }}]))
+		{
+		{{~ end ~}}
+		{{~ for h in g ~}}
 		{{ h.display_name }}.AddHandlers(services, {{ if h.service_lifetime != null; "global::" + h.service_lifetime; else; "lifetime"; end }});
 		{{~ end ~}}
-		
+		{{~ if g.key != null ~}}
+		}
+		{{~ end ~}}
+
+		{{~ end ~}}
 		return services;
 	}
+
+	// old-fashioned inner-loop; should be fine since neither tags list will ever be large
+	private static bool Intersects(
+		global::System.ReadOnlySpan<string> first,
+		global::System.ReadOnlySpan<string> second
+	)
+	{
+		foreach (var f in first)
+		{
+			foreach (var s in second)
+			{
+				if (string.Equals(f, s, global::System.StringComparison.Ordinal))
+					return true;
+			}
+		}
+
+		return false;
+	}
 }

src/Immediate.Handlers.Generators/Templates/ServiceCollectionExtensions.sbntxt

@@ -22,6 +22,8 @@ CancellationToken cancellationToken
 		var displayName = symbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
 		var serviceLifetime = context.Attributes[0].GetServiceLifetime();
 
+		var tags = context.Attributes[0].NamedArguments.GetArgumentValue("Tags")?.GetStringArray();
+
 		var handleMethod = symbol.GetHandleMethod();
 
 		if (handleMethod
@@ -82,7 +84,9 @@ is null
 			Parameters = parameters,
 			IsStatic = isStatic,
 			UseToken = useToken,
+
 			ServiceLifetime = serviceLifetime,
+			Tags = tags,
 
 			RequestType = requestType,
 			ResponseType = responseType,

src/Immediate.Handlers.Generators/TransformHandler.cs

@@ -36,4 +36,9 @@ public HandlerAttribute(ServiceLifetime serviceLifetime)
 	///	</para>
 	/// </summary>
 	public ServiceLifetime? ServiceLifetime { get; }
+
+	/// <summary>
+	///		An optional list of tags which can be used to filter the generated handlers to be registered at runtime.
+	/// </summary>
+	public string[]? Tags { get; init; }
 }