[ExcludeInterfaceMember] to exclude specific members from interface generation (#19)

* Added a feature to exclude interface members.

* Added unit tests for the feature

* Adding int test harness.

* Finished int tests

* Refactored interface generation tests

* Rework int tests to test how IServiceProvider behaves (useful for future compiled time DI)

* WIP

* Refactor asserts

---------

Co-authored-by: Dmytro Ett <dmytro.ett@outlook.com>

Author: dmytroett

.codex/skills/snapshot-unit-testing/SKILL.md

@@ -13,7 +13,7 @@ Favor a small number of representative scenarios; combine related assertions to
 
 Avoid opening or reading `.received`/`.verified` files; rely on `dotnet test` output and VerifyException details only.
 
-Treat `scripts/accept-snapshot` and `scripts/accept-all-snapshots` as black boxes; do not open or inspect them.
+Treat `.codex/skills/snapshot-unit-testing/scripts/accept-snapshot` and `.codex/skills/snapshot-unit-testing/scripts/accept-all-snapshots` as black boxes; do not open or inspect them.
 
 # Workflow
 
@@ -24,8 +24,8 @@ Run targeted tests with `dotnet test --filter` and add `--no-build`/`--no-restor
 Inspect `dotnet test` output to decide whether the test logic is wrong or snapshots need updating; do not open raw snapshot files.
 
 Accept snapshots only when the behavior change is intended and clearly understood:
-- Use `scripts/accept-snapshot <TestClassName> <TestMethodName>` for a single test.
-- Use `scripts/accept-all-snapshots` for bulk updates.
+- Use `.codex/skills/snapshot-unit-testing/scripts/accept-snapshot <TestClassName> <TestMethodName>` for a single test.
+- Use `.codex/skills/snapshot-unit-testing/scripts/accept-all-snapshots` for bulk updates.
 - Skip these scripts for non-snapshot tests.
 
 Re-run tests and iterate until they pass.
@@ -35,9 +35,9 @@ Re-run tests and iterate until they pass.
 - Run a single test:
   - `dotnet test --filter "FullyQualifiedName~<TestClass>.<TestMethod>"`
 - Accept one snapshot:
-  - `scripts/accept-snapshot <TestClassName> <TestMethodName>`
+  - `.codex/skills/snapshot-unit-testing/scripts/accept-snapshot <TestClassName> <TestMethodName>`
 - Accept all snapshots:
-  - `scripts/accept-all-snapshots`
+  - `.codex/skills/snapshot-unit-testing/scripts/accept-all-snapshots`
 
 # Verify failure pattern
 

AGENTS.md

@@ -21,17 +21,17 @@ This project is about building a library to simplify dependency registration in
 
 When done with code generation or modification, you must:
 
-1. Run `dotnet format --no-restore --include <list-of-changed-files>`
+1. Run `dotnet format --include <list-of-changed-files>`
 2. Ensure no formatting issues remain
 
 Example:
 ```
-dotnet format --no-restore --include src/AttributedDI/MyClass.cs
+dotnet format --include src/AttributedDI/MyClass.cs
 ```
 
 For multiple files:
 ```
-dotnet format --no-restore --include src/AttributedDI/File1.cs src/AttributedDI/File2.cs
+dotnet format --include src/AttributedDI/File1.cs src/AttributedDI/File2.cs
 ```
 
 ## Public API Documentation

src/AttributedDI.SourceGenerator/InterfacesGeneration/InterfaceGenerationPipeline.cs

@@ -105,6 +105,11 @@ private static ImmutableArray<string> CollectMembers(INamedTypeSymbol typeSymbol
                 continue;
             }
 
+            if (IsExcludedFromInterface(member))
+            {
+                continue;
+            }
+
             switch (member)
             {
                 case IMethodSymbol method when ShouldIgnoreMethod(method):
@@ -146,6 +151,28 @@ private static void AddMemberIfNeeded(
         }
     }
 
+    private static bool IsExcludedFromInterface(ISymbol member)
+    {
+        foreach (var attribute in member.GetAttributes())
+        {
+            var attributeClass = attribute.AttributeClass;
+            if (attributeClass is null)
+            {
+                continue;
+            }
+
+            if (string.Equals(
+                attributeClass.ToDisplayString(),
+                KnownAttributes.ExcludeInterfaceMemberAttribute,
+                StringComparison.Ordinal))
+            {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
     private static bool ShouldIgnoreMethod(IMethodSymbol method)
     {
         if (method.DeclaredAccessibility != Accessibility.Public)

src/AttributedDI.SourceGenerator/KnownAttributes.cs

@@ -18,6 +18,7 @@ internal static class KnownAttributes
 
     // Interface generation attributes
     public const string GenerateInterfaceAttribute = "AttributedDI.GenerateInterfaceAttribute";
+    public const string ExcludeInterfaceMemberAttribute = "AttributedDI.ExcludeInterfaceMemberAttribute";
 
     // Assembly-level attributes
     public const string GeneratedModuleNameAttribute = "AttributedDI.GeneratedModuleNameAttribute";

src/AttributedDI/ExcludeInterfaceMemberAttribute.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace AttributedDI;
+
+/// <summary>
+/// Excludes a member from generated interfaces.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Event | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
+public sealed class ExcludeInterfaceMemberAttribute : Attribute
+{
+}

src/AttributedDI/GenerateInterfaceAttribute.cs

@@ -22,6 +22,7 @@ namespace AttributedDI;
 /// <item><description>Non-public members.</description></item>
 /// <item><description>Static members and operators.</description></item>
 /// <item><description><c>ref</c> returns or <c>ref</c>/<c>in</c>/<c>out</c> parameters.</description></item>
+/// <item><description>Members annotated with <see cref="ExcludeInterfaceMemberAttribute"/>.</description></item>
 /// <item><description>Members excluded via conditional compilation.</description></item>
 /// </list>
 /// <para>

src/AttributedDI/RegisterAsGeneratedInterfaceAttribute.cs

@@ -22,6 +22,7 @@ namespace AttributedDI;
 /// <item><description>Non-public members.</description></item>
 /// <item><description>Static members and operators.</description></item>
 /// <item><description><c>ref</c> returns or <c>ref</c>/<c>in</c>/<c>out</c> parameters.</description></item>
+/// <item><description>Members annotated with <see cref="ExcludeInterfaceMemberAttribute"/>.</description></item>
 /// <item><description>Members excluded via conditional compilation.</description></item>
 /// </list>
 /// <para>

test/AttributedDI.IntegrationTests/AllModulesRegistrationTests.cs

@@ -12,8 +12,9 @@ public void AllServicesRegisteredCorrectly()
         ServiceCollection services = new();
 
         services.AddAttributedDi();
+        using var provider = services.BuildServiceProvider();
 
-        AssertContainsService<IMyAmazingService, MyAmazingService>(services, ServiceLifetime.Transient);
-        AssertContainsService<IInternalService, InternalService>(services, ServiceLifetime.Transient);
+        ServiceProviderAssert.Resolves<IMyAmazingService, MyAmazingService>(provider, ServiceLifetime.Transient);
+        ServiceProviderAssert.Resolves<IInternalService, InternalService>(provider, ServiceLifetime.Transient);
     }
 }

test/AttributedDI.IntegrationTests/CoreScenariosTests.cs

@@ -11,34 +11,35 @@ public void ServiceRegistrationTests()
         var services = new ServiceCollection();
 
         services.AddCompanyTeamNameProjectAPI();
+        using var provider = services.BuildServiceProvider();
 
         // RegisterAsSelf implicit transient
-        AssertContainsService<RegisterAsSelfTransientImplicitService, RegisterAsSelfTransientImplicitService>(services, ServiceLifetime.Transient);
+        ServiceProviderAssert.Resolves<RegisterAsSelfTransientImplicitService, RegisterAsSelfTransientImplicitService>(provider, ServiceLifetime.Transient);
 
         // RegisterAsSelf singleton
-        AssertContainsService<RegisterAsSelfSingletonService, RegisterAsSelfSingletonService>(services, ServiceLifetime.Singleton);
+        ServiceProviderAssert.Resolves<RegisterAsSelfSingletonService, RegisterAsSelfSingletonService>(provider, ServiceLifetime.Singleton);
 
         // RegisterAsSelf scoped
-        AssertContainsService<RegisterAsSelfScopedService, RegisterAsSelfScopedService>(services, ServiceLifetime.Scoped);
+        ServiceProviderAssert.Resolves<RegisterAsSelfScopedService, RegisterAsSelfScopedService>(provider, ServiceLifetime.Scoped);
 
         // RegisterAs interface
-        AssertContainsService<IRegisterAsInterfaceService, RegisterAsInterfaceScopedService>(services, ServiceLifetime.Scoped);
+        ServiceProviderAssert.Resolves<IRegisterAsInterfaceService, RegisterAsInterfaceScopedService>(provider, ServiceLifetime.Scoped);
 
         // RegisterAsImplementedInterfaces should register concrete but not IDisposable/IAsyncDisposable
-        AssertContainsService<IFirstService, MultiInterfaceSingletonService>(services, ServiceLifetime.Singleton);
-        AssertContainsService<ISecondService, MultiInterfaceSingletonService>(services, ServiceLifetime.Singleton);
-        AssertDoesNotContainService<IDisposable, MultiInterfaceSingletonService>(services);
-        AssertDoesNotContainService<IAsyncDisposable, MultiInterfaceSingletonService>(services);
+        ServiceProviderAssert.Resolves<IFirstService, MultiInterfaceSingletonService>(provider, ServiceLifetime.Singleton);
+        ServiceProviderAssert.Resolves<ISecondService, MultiInterfaceSingletonService>(provider, ServiceLifetime.Singleton);
+        ServiceProviderAssert.DoesNotResolve<IDisposable>(provider);
+        ServiceProviderAssert.DoesNotResolve<IAsyncDisposable>(provider);
 
         // Lifetime-only attribute registers as self
-        AssertContainsService<LifetimeOnlyTransientService, LifetimeOnlyTransientService>(services, ServiceLifetime.Transient);
+        ServiceProviderAssert.Resolves<LifetimeOnlyTransientService, LifetimeOnlyTransientService>(provider, ServiceLifetime.Transient);
 
         // Keyed services - RegisterAs<T> with key
-        AssertContainsKeyedService<IKeyedService, KeyedServiceOne>(services, "key1", ServiceLifetime.Singleton);
-        AssertContainsKeyedService<IKeyedService, KeyedServiceTwo>(services, "key2", ServiceLifetime.Singleton);
+        ServiceProviderAssert.ResolvesKeyed<IKeyedService, KeyedServiceOne>(provider, "key1", ServiceLifetime.Singleton);
+        ServiceProviderAssert.ResolvesKeyed<IKeyedService, KeyedServiceTwo>(provider, "key2", ServiceLifetime.Singleton);
 
         // Keyed services - RegisterAsSelf with key
-        AssertContainsKeyedService<RegisterAsSelfKeyedTransientService, RegisterAsSelfKeyedTransientService>(services, "transientKey", ServiceLifetime.Transient);
-        AssertContainsKeyedService<RegisterAsSelfKeyedSingletonService, RegisterAsSelfKeyedSingletonService>(services, "singletonKey", ServiceLifetime.Singleton);
+        ServiceProviderAssert.ResolvesKeyed<RegisterAsSelfKeyedTransientService, RegisterAsSelfKeyedTransientService>(provider, "transientKey", ServiceLifetime.Transient);
+        ServiceProviderAssert.ResolvesKeyed<RegisterAsSelfKeyedSingletonService, RegisterAsSelfKeyedSingletonService>(provider, "singletonKey", ServiceLifetime.Singleton);
     }
 }

test/AttributedDI.IntegrationTests/CustomModuleNameTests.cs

@@ -12,8 +12,9 @@ public void ExtensionMethod()
         var services = new ServiceCollection();
 
         services.AddMyAmazingCustomServices();
+        using var provider = services.BuildServiceProvider();
 
-        AssertContainsService<AliasedAssemblyService, AliasedAssemblyService>(services, ServiceLifetime.Scoped);
+        ServiceProviderAssert.Resolves<AliasedAssemblyService, AliasedAssemblyService>(provider, ServiceLifetime.Scoped);
     }
 
     [Fact]
@@ -23,7 +24,8 @@ public void DirectModuleRegistration()
 
         var module = new MyIncredibleCustomModule();
         module.ConfigureServices(services);
+        using var provider = services.BuildServiceProvider();
 
-        AssertContainsService<AliasedAssemblyService, AliasedAssemblyService>(services, ServiceLifetime.Scoped);
+        ServiceProviderAssert.Resolves<AliasedAssemblyService, AliasedAssemblyService>(provider, ServiceLifetime.Scoped);
     }
 }