Eliminate new API methods for opting in to compiler-generated types

- We can simplify this to re-using existing methods in the API.

Author: Stanley Gehman

src/Scrutor/IImplementationTypeFilter.cs

@@ -31,22 +31,6 @@ public interface IImplementationTypeFilter : IFluentInterface
     /// <param name="types">The types that should be assignable from the matching types.</param>
     /// <exception cref="ArgumentNullException">If the <paramref name="types"/> argument is <c>null</c>.</exception>
     IImplementationTypeFilter AssignableToAny(IEnumerable<Type> types);
-    
-    /// <summary>
-    /// Will include all compiler-generated types that derive from any of the specified <paramref name="types"/>.
-    /// This can be useful to include statically-compiled views with some UI frameworks.
-    /// </summary>
-    /// <param name="types">The base types for which to allow compiler-generated subclasses</param>
-    /// <returns></returns>
-    IImplementationTypeFilter IncludeCompilerGeneratedSubclassesOf(params Type[] types);
-    
-    /// <summary>
-    /// Will include all compiler-generated types that derive from any of the specified <paramref name="types"/>.
-    /// This can be useful to include statically-compiled views with some UI frameworks.
-    /// </summary>
-    /// <param name="types">The base types for which to allow compiler-generated subclasses</param>
-    /// <returns></returns>
-    IImplementationTypeFilter IncludeCompilerGeneratedSubclassesOf(IEnumerable<Type> types);
 
     /// <summary>
     /// Will match all types that has an attribute of type <typeparamref name="T"/> defined.

src/Scrutor/ImplementationTypeFilter.cs

@@ -14,7 +14,7 @@ public ImplementationTypeFilter(ISet<Type> types)
 
     internal ISet<Type> Types { get; private set; }
 
-    internal ISet<Type> CompilerGeneratedBases { get; private set; } = new HashSet<Type>();
+    internal bool IncludeCompilerGeneratedTypes { get; private set; }
 
     public IImplementationTypeFilter AssignableTo<T>()
     {
@@ -42,22 +42,6 @@ public IImplementationTypeFilter AssignableToAny(IEnumerable<Type> types)
         return Where(t => types.Any(t.IsBasedOn));
     }
 
-    public IImplementationTypeFilter IncludeCompilerGeneratedSubclassesOf(params Type[] types)
-    {
-        Preconditions.NotNull(types, nameof(types));
-
-        return IncludeCompilerGeneratedSubclassesOf(types.AsEnumerable());
-    }
-
-    public IImplementationTypeFilter IncludeCompilerGeneratedSubclassesOf(IEnumerable<Type> types)
-    {
-        Preconditions.NotNull(types, nameof(types));
-
-        var typesList = types.ToList();
-        typesList.ForEach(t => CompilerGeneratedBases.Add(t));
-        return Where(t => !t.HasAttribute<CompilerGeneratedAttribute>() || typesList.Any(t.IsBasedOn));
-    }
-
     public IImplementationTypeFilter WithAttribute<T>() where T : Attribute
     {
         return WithAttribute(typeof(T));
@@ -67,6 +51,7 @@ public IImplementationTypeFilter WithAttribute(Type attributeType)
     {
         Preconditions.NotNull(attributeType, nameof(attributeType));
 
+        IncludeCompilerGeneratedTypes |= attributeType == typeof(CompilerGeneratedAttribute);
         return Where(t => t.HasAttribute(attributeType));
     }
 

src/Scrutor/ImplementationTypeSelector.cs

@@ -3,6 +3,7 @@
 using System.Diagnostics.CodeAnalysis;
 using System.Linq;
 using System.Reflection;
+using System.Runtime.CompilerServices;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyModel;
 
@@ -49,8 +50,8 @@ public IServiceTypeSelector AddClasses(Action<IImplementationTypeFilter> action,
 
         action(filter);
 
-        if (!filter.CompilerGeneratedBases.Any())
-            filter.IncludeCompilerGeneratedSubclassesOf(Enumerable.Empty<Type>());
+        if (!filter.IncludeCompilerGeneratedTypes)
+            filter.WithoutAttribute<CompilerGeneratedAttribute>();
 
         return AddSelector(filter.Types);
     }

test/Scrutor.Tests/ScanningTests.cs

@@ -571,15 +571,15 @@ public void AsSelfWithInterfacesHandlesOpenGenericTypes()
         }
 
         [Fact]
-        public void ScanShouldIncludeSpecifiedCompilerGeneratedClasses()
+        public void ShouldAllowOptInToCompilerGeneratedTypes()
         {
             var provider = ConfigureProvider(services =>
             {
                 services.Scan(scan => scan
                     .FromAssemblyOf<AllowedCompilerGeneratedSubclass>()
                     .AddClasses(classes => classes
+                        .WithAttribute<CompilerGeneratedAttribute>()
                         .AssignableTo<AllowedCompilerGeneratedBase>()
-                        .IncludeCompilerGeneratedSubclassesOf(typeof(AllowedCompilerGeneratedBase))
                     )
                     .AsSelf()
                     .WithTransientLifetime());