Convention selection and shape gaps

[ipjohnson]

The whole Scrutor parity plan from docs/design/convention-registration-and-decorators.md — steps 1 through 8 — plus two performance fixes and one defect the work exposed.

Silent or wrong behaviours, fixed

A partial class was two candidates. The provider runs per declaration and reads the base list in front of it, so partial class Foo : IFoo in one part and partial class Foo : FooBase in another each saw half the picture — and the ambiguity check refused both with matched by more than one convention — as 'IFoo' and as 'IFoo'. One convention, named twice.

A handler covering two messages registered one. Silently — green build, no diagnostic, an event that never fires. FirstMatchingInterface is now AllMatchingInterfaces.

A nested type's constructor was the outer type's. GetConstructorInfo walked DescendantNodes, which reaches into nested declarations. Only visible with GenerateFactories on, which is why the test that pins it sets the property and fails against the old walk.

AsSelfWithInterfaces cross-wired BCL interfaces. Anything whose base implements IDisposable became resolvable as IDisposable; a FluentValidation validator became resolvable as IEnumerable<IValidationRule>. Now skips System.* — one rule rather than the growing blocklist Autofac and Scrutor each maintain half of.

DM0004 now means what it says

Keyed on (implementation, service type) rather than the implementation alone. A type filling two roles is the ordinary shape of a MediatR handler and registers twice; one service type claimed by two conventions still fails, because one lifetime has to win and the source does not say which.

The API

conventions.RegisterAll<IFoo>().AsSelf().AsSingleton();
conventions.RegisterAll<IFoo>().AsSelfWithInterfaces().AsSingleton();
conventions.RegisterAll<IMarker>().AsMatchingInterface().AsSingleton();
conventions.RegisterAll<IFoo>().As<IMarker>().AsSingleton();

conventions.RegisterAll().InNamespaceOf<OrderMarker>().AsSelf().AsScoped();
conventions.RegisterAll().WithName("*Repository").AsSelf().AsScoped();
conventions.RegisterAll<IFoo>().WithAttribute<HandlerAttribute>().AsSingleton();
conventions.RegisterAll<IFoo>().WithoutAttribute<LegacyAttribute>().AsSingleton();
conventions.RegisterAll<IFoo>().NotInNamespaces("MyApp.Internal").AsSingleton();

conventions.RegisterAll<IFoo>().AsSingleton().Using(RegistrationType.Try);
conventions.RegisterAll<IFoo>().AsSingleton().WithKey("primary");

conventions.RegisterAll(typeof(IHandler<,>)).InAssemblyOf<SomePackageType>().AsScoped();

Multi-interface registration is N instances, matching Scrutor and MediatR; one shared instance is AsSelfWithInterfaces(), opt-in. Attributes and service types are resolved, not matched on how they were written — name-matching is how a namespace-qualified usage came to be silently ignored here once already.

Referenced assemblies, and why it is AOT-safe

InAssemblyOf<T>() reads types as Roslyn symbols at compile time and emits a literal typeof() per match — a static reference the trimmer roots, which also lets the DynamicallyAccessedMembers annotation on ServiceDescriptor flow to a known type so the constructor survives. Nothing is loaded at run time. That is the difference from Scrutor, whose scan is reflection and finds nothing once the trimmer has run.

The assembly is always named, by a type rather than a string, so an unreferenced assembly cannot be asked for. There is no scan-everything: walking every reference visits thousands of types per keystroke where one named assembly visits its own.

Performance

Admitting concrete types with no interface meant the predicate could no longer reject declarations with no base list, and providers cannot see each other, so the cost is unconditional. Measured, 2,000 ordinary classes, second generator run after editing one file:

	after one edit
before this branch	9 ms
naive widening	73 ms
constructors from members	40 ms
syntax-only path for types with no base list	12 ms

The constructor fix applies to the convention path that already shipped — 29 ms to 17 ms on the same workload. The metadata provider adds nothing when no convention names an assembly.

The benchmark is kept, in the solution so it cannot rot and out of the coverage gate. Four things in it are load-bearing and each produced a believable but wrong number first: time only RunGeneratorsAndUpdateCompilation, one syntax tree per class, real class bodies, and measure the run after an edit rather than the cold one.

Verification

• dotnet build -c Release --no-incremental — 0 warnings
• ./scripts/coverage.sh 85 — 590 tests pass, 87.8% coverage
• ./scripts/verify-packages.sh — clean

Behaviour is asserted by compiling and executing generated assemblies. Every defect here was reproduced before being fixed.

Not in this PR

AlsoAsSelf — item 1 of docs/design/convention-self-registration.md, the shape between Interfaces and SelfAndInterfaces that FluentValidation wants. Item 2 of that doc is done.

The lambda-taking Scrutor overloads have no compile-time equivalent; IServiceCollectionConfiguration.ConfigureServices is the escape hatch. FromApplicationDependencies and friends load assemblies by name at run time and are deliberately out.

🤖 Generated with Claude Code

https://claude.ai/code/session_01C56x6Vv6HJ6ArfqwKsuSb9