Add AssemblyNameFilter to allow to scan multiple assemblies (#34)

* AssemblyNameFilter

* Update README

* Do not allow FromAssemblyOf and AssemblyNameFilter in the same attribute

* simplify ReferencedAssemblySymbols

Author: Dreamescaper

README.md

@@ -139,7 +139,8 @@ public static partial class ServiceCollectionExtensions
 `GenerateServiceRegistrations` attribute has the following properties:
 | Property | Description |
 | --- | --- |
-| **FromAssemblyOf** | Set the assembly containing the given type as the source of types to register. If not specified, all referenced projects are scanned.|
+| **FromAssemblyOf** | Set the assembly containing the given type as the source of types to register. If not specified, the assembly containing the method with this attribute will be used. |
+| **AssemblyNameFilter** | Set this value to filter scanned assemblies by assembly name. It allows to apply an attribute to multiple assemblies. For example, this allows to scan all assemblies from your solution. You can use '\*' wildcards. You can also use ',' to separate multiple filters. *Be careful to include limited amount of assemblies, as it can affect build and editor performance.* |
 | **AssignableTo** | Set the type that the registered types must be assignable to. Types will be registered with this type as the service type, unless `AsImplementedInterfaces` or `AsSelf` is set. |
 | **Lifetime** | Set the lifetime of the registered services. `ServiceLifetime.Transient` is used if not specified. |
 | **AsImplementedInterfaces** | If true, the registered types will be registered as implemented interfaces instead of their actual type. |

ServiceScan.SourceGenerator.Tests/AddServicesTests.cs

@@ -60,30 +60,30 @@ public void AddServicesFromAnotherAssembly()
     }
 
     [Fact]
-    public void AddServicesFromReferencedCompilationsByDefault()
+    public void AddServicesFromReferencedAssembliesByAssemblyNameFilter()
     {
         var coreCompilation = CreateCompilation(
             """
             namespace Core;
             public interface IService { }
             """)
-            .WithAssemblyName("Core");
+            .WithAssemblyName("MyProduct.Core");
 
         var implementation1Compilation = CreateCompilation(["""
             namespace Module1;
             public class MyService1 : Core.IService { }
             """],
             [coreCompilation])
-            .WithAssemblyName("Module1");
+            .WithAssemblyName("MyProduct.Module1");
 
         var implementation2Compilation = CreateCompilation(["""
             namespace Module2;
             public class MyService2 : Core.IService { }
             """],
             [coreCompilation])
-            .WithAssemblyName("Module2");
+            .WithAssemblyName("MyProduct.Module2");
 
-        var attribute = $"[GenerateServiceRegistrations(AssignableTo = typeof(Core.IService), Lifetime = ServiceLifetime.Scoped)]";
+        var attribute = """[GenerateServiceRegistrations(AssignableTo = typeof(Core.IService), Lifetime = ServiceLifetime.Scoped, AssemblyNameFilter="MyProduct.*")]""";
         var registrationsCompilation = CreateCompilation(
             [Sources.MethodWithAttribute(attribute)],
             [coreCompilation, implementation1Compilation, implementation2Compilation]);

ServiceScan.SourceGenerator/DependencyInjectionGenerator.FilterTypes.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Text.RegularExpressions;
 using Microsoft.CodeAnalysis;
@@ -12,13 +13,7 @@ public partial class DependencyInjectionGenerator
     private static IEnumerable<(INamedTypeSymbol Type, INamedTypeSymbol? MatchedAssignableType)> FilterTypes
         (Compilation compilation, AttributeModel attribute, INamedTypeSymbol containingType)
     {
-        var assemblyOfType = attribute.AssemblyOfTypeName is null
-            ? null
-            : compilation.GetTypeByMetadataName(attribute.AssemblyOfTypeName);
-
-        var assemblies = assemblyOfType is not null
-            ? [assemblyOfType.ContainingAssembly]
-            : GetSolutionAssemblies(compilation);
+        var assemblies = GetAssembliesToScan(compilation, attribute, containingType);
 
         var assignableToType = attribute.AssignableToTypeName is null
             ? null
@@ -139,6 +134,29 @@ private static bool IsAssignableTo(INamedTypeSymbol type, INamedTypeSymbol assig
         return false;
     }
 
+    private static IEnumerable<IAssemblySymbol> GetAssembliesToScan(Compilation compilation, AttributeModel attribute, INamedTypeSymbol containingType)
+    {
+        var assemblyOfType = attribute.AssemblyOfTypeName is null
+            ? null
+            : compilation.GetTypeByMetadataName(attribute.AssemblyOfTypeName);
+
+        if (assemblyOfType is not null)
+        {
+            return [assemblyOfType.ContainingAssembly];
+        }
+
+        if (attribute.AssemblyNameFilter is not null)
+        {
+            var assemblyNameRegex = BuildWildcardRegex(attribute.AssemblyNameFilter);
+
+            return new[] { compilation.Assembly }
+                .Concat(compilation.SourceModule.ReferencedAssemblySymbols)
+                .Where(assembly => assemblyNameRegex.IsMatch(assembly.Name));
+        }
+
+        return [containingType.ContainingAssembly];
+    }
+
     private static IEnumerable<IAssemblySymbol> GetSolutionAssemblies(Compilation compilation)
     {
         yield return compilation.Assembly;
@@ -177,6 +195,7 @@ static IEnumerable<INamedTypeSymbol> GetTypesFromNamespaceOrType(INamespaceOrTyp
         }
     }
 
+    [return: NotNullIfNotNull(nameof(wildcard))]
     private static Regex? BuildWildcardRegex(string? wildcard)
     {
         return wildcard is null

ServiceScan.SourceGenerator/DependencyInjectionGenerator.ParseMethodModel.cs

@@ -30,6 +30,9 @@ public partial class DependencyInjectionGenerator
             if (hasCustomHandlers && attribute.CustomHandler == null)
                 return Diagnostic.Create(CantMixRegularAndCustomHandlerRegistrations, attribute.Location);
 
+            if (attribute.AssemblyOfTypeName != null && attribute.AssemblyNameFilter != null)
+                return Diagnostic.Create(CantUseBothFromAssemblyOfAndAssemblyNameFilter, attribute.Location);
+
             if (attribute.KeySelector != null)
             {
                 var keySelectorMethod = method.ContainingType.GetMembers().OfType<IMethodSymbol>()

ServiceScan.SourceGenerator/DiagnosticDescriptors.cs

@@ -73,4 +73,11 @@ public static class DiagnosticDescriptors
         "Usage",
         DiagnosticSeverity.Error,
         true);
+
+    public static readonly DiagnosticDescriptor CantUseBothFromAssemblyOfAndAssemblyNameFilter = new("DI0012",
+        "Only one assembly selection criteria allowed",
+        "It is not allowed to use both FromAssemblyOf and AssemblyNameFilter in the same attribute",
+        "Usage",
+        DiagnosticSeverity.Error,
+        true);
 }

ServiceScan.SourceGenerator/GenerateAttributeSource.cs

@@ -17,10 +17,21 @@ internal class GenerateServiceRegistrationsAttribute : Attribute
         {
             /// <summary>
             /// Set the assembly containing the given type as the source of types to register.
-            /// If not specified, all referenced projects are scanned.
+            /// If not specified, the assembly containing the method with this attribute will be used.
             /// </summary>
             public Type? FromAssemblyOf { get; set; }
         
+            /// <summary>
+            /// Set this value to filter scanned assemblies by assembly name.
+            /// It allows to apply an attribute to multiple assemblies.
+            /// For example, this allows to scan all assemblies from your solution.
+            /// This option is incompatible with <see cref="FromAssemblyOf"/>.
+            /// You can use '*' wildcards. You can also use ',' to separate multiple filters.
+            /// </summary>
+            /// <remarks>Be careful to include limited amount of assemblies, as it can affect build and editor performance.</remarks>
+            /// <example>My.Product.*</example>
+            public string? AssemblyNameFilter { get; set; }
+        
             /// <summary>
             /// Set the type that the registered types must be assignable to.
             /// Types will be registered with this type as the service type,

ServiceScan.SourceGenerator/Model/AttributeModel.cs

@@ -7,6 +7,7 @@ enum KeySelectorType { Method, GenericMethod, TypeMember };
 
 record AttributeModel(
     string? AssignableToTypeName,
+    string? AssemblyNameFilter,
     EquatableArray<string>? AssignableToGenericArguments,
     string? AssemblyOfTypeName,
     string Lifetime,
@@ -29,6 +30,7 @@ record AttributeModel(
     public static AttributeModel Create(AttributeData attribute, IMethodSymbol method)
     {
         var assemblyType = attribute.NamedArguments.FirstOrDefault(a => a.Key == "FromAssemblyOf").Value.Value as INamedTypeSymbol;
+        var assemblyNameFilter = attribute.NamedArguments.FirstOrDefault(a => a.Key == "AssemblyNameFilter").Value.Value as string;
         var assignableTo = attribute.NamedArguments.FirstOrDefault(a => a.Key == "AssignableTo").Value.Value as INamedTypeSymbol;
         var asImplementedInterfaces = attribute.NamedArguments.FirstOrDefault(a => a.Key == "AsImplementedInterfaces").Value.Value is true;
         var asSelf = attribute.NamedArguments.FirstOrDefault(a => a.Key == "AsSelf").Value.Value is true;
@@ -63,6 +65,9 @@ public static AttributeModel Create(AttributeData attribute, IMethodSymbol metho
         if (string.IsNullOrWhiteSpace(excludeByTypeName))
             excludeByTypeName = null;
 
+        if (string.IsNullOrWhiteSpace(assemblyNameFilter))
+            assemblyNameFilter = null;
+
         var attributeFilterTypeName = attributeFilterType?.ToFullMetadataName();
         var excludeByAttributeTypeName = excludeByAttributeType?.ToFullMetadataName();
         var assemblyOfTypeName = assemblyType?.ToFullMetadataName();
@@ -92,6 +97,7 @@ public static AttributeModel Create(AttributeData attribute, IMethodSymbol metho
 
         return new(
             assignableToTypeName,
+            assemblyNameFilter,
             assignableToGenericArguments,
             assemblyOfTypeName,
             lifetime,