Generate interfaces for RegisterAsGeneratedInterface (#14)

* Making some items visible in solution

* First pass

* Small simplifications where makes sense

* Refactoring

* Move between folders

* cleanup comments

* Added a bit more of the tests

* Adding code for testing purposes

* finishing with integration tests

* Auto implement interfaces

* Updating one other test

* Small refactoring

* Added generic method calls

* Apparently my tests were not working properly this whole time!

* Fixing test errors

* Rerunning tests

* fixes

* I assume all is fixed.

* Apparently interface generation is not that simple as I thought it would be.

* Tightening public contract

* Getting progress

* Finished with the tests actually

* Make tests tfm dependand

* trying out codex

* Adding file name to snapshot output

* Improving generic naming

* Rerun the tests after adjustments to the way they are generated.

* Refactoring

* Added couple more tests

* Excluded some more well known interfaces

* Fixing the bug with events

* Adding some more test cases

* Adding more tests to cover some of the edge cases

* Adding tests for known interfaces

* Added more coverage around known interfaces.

---------

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

Author: dmytroett

.editorconfig

@@ -3,7 +3,7 @@ root = true
 
 [*.*]
 # New line preferences
-end_of_line = crlf
+end_of_line = lf
 insert_final_newline = false
 indent_style = space
 

.gitattributes

@@ -1,7 +1,7 @@
 ###############################################################################
 # Set default behavior to automatically normalize line endings.
 ###############################################################################
-* text=auto
+* text=auto eol=lf
 
 ###############################################################################
 # Set default behavior for command prompt diff.

AGENTS.md

@@ -0,0 +1,61 @@
+# Codex Instructions for AttributedDI
+
+## General Guidelines
+
+- When uncertain about APIs, best practices, or modern implementation patterns, consult Microsoft documentation.
+- When usage is unclear, search GitHub source code for referenced open source projects.
+- Prefer the configured MCP servers (GitHub, Microsoft Docs) as your first reference sources.
+
+## Code Quality Guidelines
+
+- Make sure code is maintainable and easy to understand. Suggest refactoring when beneficial.
+- If refactoring is challenging, complicated, or the user explicitly declined, add strategic comments to improve maintainability instead.
+- Do not overuse comments; place them only where they add real value.
+- Minimize public surface area: Use `private` or `internal` access modifiers by default unless the API is intentionally designed to be public. A smaller public API is easier to maintain and reduces breaking change concerns in future versions.
+
+## Code Style & Formatting
+
+When done with code generation or modification, you must:
+
+1. Run `dotnet format --include <list-of-changed-files>`
+2. Ensure no formatting issues remain
+
+Example:
+```
+dotnet format --include src/AttributedDI/MyClass.cs
+```
+
+For multiple files:
+```
+dotnet format --include src/AttributedDI/File1.cs src/AttributedDI/File2.cs
+```
+
+## Public API Documentation
+
+This is a library. **All** public methods, properties, classes, and interfaces in library code **must** have XML documentation (///).
+
+**Scope**: This requirement applies to library code only (`src/AttributedDI/`, `src/AttributedDI.SourceGenerator/`). Test projects are exempt.
+
+### Required XML Tags
+
+- `<summary>`: What it does
+- `<param>`: Each parameter's purpose and constraints
+- `<returns>`: Return value description
+- `<exception>`: Any exceptions thrown
+- `<example>`: Usage examples (for complex/frequently-used APIs)
+- `<remarks>`: Edge cases or important notes (when needed)
+
+### Example
+
+```csharp
+/// <summary>Registers a service with the DI container.</summary>
+/// <param name="serviceType">The service type to register.</param>
+/// <param name="implementationType">The implementation type.</param>
+/// <exception cref="ArgumentNullException">Thrown when parameters are null.</exception>
+public void RegisterService(Type serviceType, Type implementationType)
+```
+
+### Documentation Rules
+
+- Document only public APIs in library projects
+- Update documentation when signatures change

AttributedDI.slnx

@@ -7,6 +7,7 @@
   <Folder Name="/Solution Items/">
     <File Path=".editorconfig" />
     <File Path=".github/copilot-instructions.md" />
+    <File Path=".github/instructions/source-generators.instructions.md" />
     <File Path=".github/workflows/pr.yml" />
     <File Path=".github/workflows/release.yml" />
     <File Path="README.md" />
@@ -22,5 +23,6 @@
   <Folder Name="/test/assets/">
     <Project Path="test/assets/Company.TeamName.Project.API/Company.TeamName.Project.API.csproj" />
     <Project Path="test/assets/CustomModuleName/CustomModuleName.csproj" />
+    <Project Path="test/assets/GeneratedInterfacesSut/GeneratedInterfacesSut.csproj" />
   </Folder>
 </Solution>

src/AttributedDI.SourceGenerator/AGENTS.md

@@ -0,0 +1,140 @@
+# Source Generator Instructions
+
+Best practices for developing incremental source generators, based on official Roslyn documentation.
+
+References:
+- Incremental Generators Design: https://github.com/dotnet/roslyn/blob/main/docs/features/incremental-generators.md
+- Incremental Generators Cookbook: https://github.com/dotnet/roslyn/blob/main/docs/features/incremental-generators.cookbook.md
+
+## Core Principles
+
+### Pipeline Model Design
+
+Source generators must build value-equatable pipelines to enable incremental compilation caching.
+
+- Use `record` types for data models (value equality is generated automatically)
+- Never put `ISymbol` instances in pipeline models
+- Never put `SyntaxNode` instances in models
+- Never put `Location` instances in models
+- Extract information from symbols/syntax as early as possible in the pipeline
+- Use `ImmutableArray<T>` instead of `List<T>` or `T[]` in models
+
+Example anti-pattern to avoid:
+```csharp
+// DON'T do this - ISymbol prevents garbage collection
+private record ServiceInfo(INamedTypeSymbol Symbol, string Name);
+```
+
+Correct pattern:
+```csharp
+// DO this - extract what you need as strings
+private record ServiceInfo(string Namespace, string Name, string FullyQualifiedName);
+```
+
+### Use `ForAttributeWithMetadataName`
+
+This is much more efficient than `CreateSyntaxProvider`.
+
+- Always use `SyntaxProvider.ForAttributeWithMetadataName` when targeting attributes
+- Fully-qualified metadata names format: `Namespace.ClassName` (with backticks for generic parameters, e.g., `My.Namespace.MyAttribute`1`)
+- The built-in heuristic can eliminate most syntax nodes before any user code runs
+- Provides two lambdas:
+  - `predicate`: Runs only on files that might contain the attribute (syntactic check)
+  - `transform`: Runs on all matching nodes to capture semantic information
+
+Example:
+```csharp
+var pipeline = context.SyntaxProvider.ForAttributeWithMetadataName(
+    fullyQualifiedMetadataName: "AttributedDI.RegisterAsAttribute",
+    predicate: static (node, _) => node is ClassDeclarationSyntax,
+    transform: static (ctx, ct) =>
+    {
+        // Extract information from symbols here, not in the predicate
+        var symbol = (INamedTypeSymbol)ctx.TargetSymbol;
+        return new ServiceModel(symbol.Name, symbol.ContainingNamespace?.ToDisplayString());
+    });
+```
+
+## Performance Best Practices
+
+### Combine Order Matters
+
+Extract information from expensive sources (like `CompilationProvider`) before combining.
+
+Inefficient:
+```csharp
+var combined = texts.Combine(context.CompilationProvider);
+```
+
+Efficient:
+```csharp
+var assemblyName = context.CompilationProvider
+    .Select(static (c, _) => c.AssemblyName);
+var combined = texts.Combine(assemblyName);
+```
+
+### Minimize Collection Types in Models
+
+- Wrap `ImmutableArray<T>` in your models with custom equality if needed
+- Built-in collection types (`List<T>`, `T[]`) use reference equality
+- Consider creating wrapper types for better caching
+
+### Custom Comparers
+
+Use `WithComparer()` when default equality isn't sufficient:
+
+```csharp
+var pipeline = context.AdditionalTextsProvider
+    .Select(static (text, _) => text.Path)
+    .WithComparer(StringComparer.OrdinalIgnoreCase);
+```
+
+## Incremental Caching Strategy
+
+### Design for Caching
+
+Break operations into small transformation steps to maximize cache hit opportunities.
+
+- Each transformation is a checkpoint
+- If a checkpoint produces the same value as before, everything downstream is skipped
+- More transformations = more opportunities to cache
+
+Example:
+```csharp
+var names = items.Select(static i => i.Name);
+var prefixed = names.Select(static n => "prefix_" + n);
+var collected = prefixed.Collect();
+```
+
+### Determinism is Required
+
+- All transformations must be deterministic
+- Same input must always produce identical output
+- Avoid `Guid.NewGuid()`, `DateTime.Now`, `Random`, etc.
+- Be careful with `Dictionary` iteration order (consider `ImmutableSortedDictionary`)
+
+## Cancellation Handling
+
+- Always forward `CancellationToken` to Roslyn APIs that accept it
+- For expensive operations, call `cancellationToken.ThrowIfCancellationRequested()` at regular intervals
+- Never save partially generated results to work around cancellation
+
+```csharp
+var expensive = txtFilesArray.Select(static (files, cancellationToken) =>
+{
+    foreach (var file in files)
+    {
+        cancellationToken.ThrowIfCancellationRequested();
+        // expensive operation...
+    }
+});
+```
+
+## Patterns to Avoid
+
+- Scanning for indirectly implemented interfaces
+- Scanning for indirectly inherited types
+- Scanning for marker attributes on base types
+- Non-sealed marker attributes that expect inheritance
+
+These cause massive performance degradation in IDEs.

src/AttributedDI.SourceGenerator/AttributedDI.SourceGenerator.csproj

@@ -10,7 +10,7 @@
   </PropertyGroup>
 
   <ItemGroup>
-    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" PrivateAssets="all"/>
+    <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="5.0.0" PrivateAssets="all" />
     <PackageReference Include="Microsoft.CodeAnalysis.Analyzers" Version="3.11.0" PrivateAssets="all" />
     <PackageReference Include="PolySharp" Version="1.15.0" PrivateAssets="all" />
   </ItemGroup>

src/AttributedDI.SourceGenerator/GlobalUsings.cs

@@ -0,0 +1 @@
+global using static AttributedDI.SourceGenerator.Utils.IncrementalValuesProviderHelper;

src/AttributedDI.SourceGenerator/InterfacesGeneration/GeneratedInterfaceInfo.cs

@@ -0,0 +1,25 @@
+using System.Collections.Immutable;
+
+namespace AttributedDI.SourceGenerator.InterfacesGeneration;
+
+/// <summary>
+/// Value object describing an interface to be generated.
+/// </summary>
+/// <param name="InterfaceName">The interface name without namespace.</param>
+/// <param name="InterfaceNamespace">The namespace for the generated interface.</param>
+/// <param name="Accessibility">The accessibility keyword (public/internal) to apply.</param>
+/// <param name="MemberSignatures">Members to emit into the generated interface.</param>
+/// <param name="ClassName">The implementing class name without namespace.</param>
+/// <param name="ClassNamespace">The namespace for the implementing class.</param>
+/// <param name="ClassTypeParameters">Type parameters of the implementing class (e.g., "&lt;T, U&gt;" or empty string).</param>
+/// <param name="TypeParameterConstraints">Constraint clauses for the type parameters (e.g., "where T : class").</param>
+internal sealed record GeneratedInterfaceInfo(
+    string InterfaceName,
+    string InterfaceNamespace,
+    string Accessibility,
+    ImmutableArray<string> MemberSignatures,
+    string ClassName,
+    string ClassNamespace,
+    string ClassTypeParameters,
+    int TypeParameterCount,
+    string TypeParameterConstraints);

src/AttributedDI.SourceGenerator/InterfacesGeneration/GeneratedInterfaceNamingResolver.cs

@@ -0,0 +1,98 @@
+using Microsoft.CodeAnalysis;
+using System;
+
+namespace AttributedDI.SourceGenerator.InterfacesGeneration;
+
+internal static class GeneratedInterfaceNamingResolver
+{
+    internal static bool TryResolve(
+        INamedTypeSymbol typeSymbol,
+        AttributeData attribute,
+        out GeneratedInterfaceNaming? naming)
+    {
+        var interfaceNameArgument = GetOptionalStringArgument(attribute, position: 0, name: "InterfaceName");
+        var interfaceNamespaceArgument = GetOptionalStringArgument(attribute, position: 1, name: "InterfaceNamespace");
+
+        var defaultInterfaceName = $"I{typeSymbol.Name}";
+        var defaultNamespace = typeSymbol.ContainingNamespace?.ToDisplayString() ?? string.Empty;
+
+        if (!string.IsNullOrWhiteSpace(interfaceNameArgument))
+        {
+            var parsed = ParseInterfaceName(interfaceNameArgument!);
+            if (!string.IsNullOrEmpty(interfaceNamespaceArgument) && !string.IsNullOrEmpty(parsed.Namespace))
+            {
+                // TODO: emit diagnostic for conflicting interface name and namespace inputs.
+                naming = null;
+                return false;
+            }
+
+            naming = new GeneratedInterfaceNaming(
+                parsed.Name,
+                string.IsNullOrEmpty(parsed.Namespace) ? interfaceNamespaceArgument ?? defaultNamespace : parsed.Namespace);
+            return true;
+        }
+
+        if (!string.IsNullOrWhiteSpace(interfaceNamespaceArgument))
+        {
+            naming = new GeneratedInterfaceNaming(defaultInterfaceName, interfaceNamespaceArgument!);
+            return true;
+        }
+
+        naming = new GeneratedInterfaceNaming(defaultInterfaceName, defaultNamespace);
+        return true;
+    }
+
+    private static string? GetOptionalStringArgument(AttributeData attribute, int position, string name)
+    {
+        if (attribute.ConstructorArguments.Length > position)
+        {
+            var ctorArg = attribute.ConstructorArguments[position];
+            if (ctorArg.Value is string fromCtor && !string.IsNullOrWhiteSpace(fromCtor))
+            {
+                return fromCtor;
+            }
+        }
+
+        foreach (var namedArgument in attribute.NamedArguments)
+        {
+            var key = namedArgument.Key;
+            var typedConstant = namedArgument.Value;
+
+            if (!string.Equals(key, name, StringComparison.Ordinal))
+            {
+                continue;
+            }
+
+            if (typedConstant.Value is string fromNamed && !string.IsNullOrWhiteSpace(fromNamed))
+            {
+                return fromNamed;
+            }
+        }
+
+        return null;
+    }
+
+    private static (string Name, string Namespace) ParseInterfaceName(string rawName)
+    {
+        var nameToParse = rawName.StartsWith("global::", StringComparison.Ordinal)
+            ? rawName.Substring("global::".Length)
+            : rawName;
+
+        var lastDot = nameToParse.LastIndexOf('.');
+        if (lastDot < 0)
+        {
+            return (nameToParse, string.Empty);
+        }
+
+        var parsedNamespace = nameToParse[..lastDot];
+        var parsedName = nameToParse[(lastDot + 1)..];
+        return (parsedName, parsedNamespace);
+    }
+}
+
+internal sealed record GeneratedInterfaceNaming(string InterfaceName, string InterfaceNamespace)
+{
+    internal string FullyQualifiedName => string.IsNullOrWhiteSpace(InterfaceNamespace)
+        ? InterfaceName
+        : $"{InterfaceNamespace}.{InterfaceName}";
+}