Introduce ExtensionsCollection and #[AutowiredExtensions], replace extension providers (by Claude Opus 5)

[ondrejmirtes]

Built by Claude Opus 5. This is an alternative implementation of the same feature as #6098 (built by Claude Fable 5) — see Differences from #6098 at the bottom before picking one.

Since #6091 every extension interface declares its own service tag via #[ExtensionInterface(tag: ...)], so the complete interface => tag map is derivable. That makes a whole family of classes redundant: whenever a service needed "all extensions of type X" it either took a Container and called getServicesByTag(SomeExtension::EXTENSION_TAG) (~25 call sites), or went through a hand-written *ExtensionProvider whose only jobs were deferring the lookup so the container doesn't hit a circular reference, and offering a Direct* twin for tests.

The mechanism

Container::getExtensions() looks extensions up by interface:

/**
 * @template T of object
 * @param class-string<T> $interfaceName
 * @return list<T>
 */
public function getExtensions(string $interfaceName): array;

The #[ExtensionInterface] map is baked into the compiled container through a small ExtensionInterfaceTags service, so vendor/attributes.php is not needed at runtime. MemoizingContainer memoizes per interface.

Services declare what they need on the constructor parameter:

/**
 * @param ExtensionsCollection<ReadWritePropertiesExtension> $extensions
 */
public function __construct(
	#[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)]
	private ExtensionsCollection $extensions,
) {}

AutowiredAttributeServicesExtension::beforeCompile() wires those parameters. It has to be beforeCompile() and not loadConfiguration(): Nette registers NEON services: after every other extension's loadConfiguration(), so NEON-registered consumers (RichParser in conf/parsers.neon) are not in the builder yet at that point. ContainerBuilder::resolve() runs before beforeCompile() and argument autowiring runs after, so setting arguments there is safe.

No extra service definitions are registered. The argument becomes an inline Statement, which Nette renders at the use site:

public function createService0258(): PHPStan\Analyser\FileAnalyser
{
	return new PHPStan\Analyser\FileAnalyser(
		...
		new PHPStan\DependencyInjection\LazyExtensionsCollection(
			$this->getService('0434'),
			'PHPStan\Analyser\IgnoreErrorExtension'
		),
		...
	);
}

LazyExtensionsCollection resolves on the first getAll() — so the deferral the Lazy* providers existed for is preserved — and then nulls its Container reference, the trick LazyClassReflectionExtensionRegistryProvider does by hand today. Long-lived holders like ClassPropertiesNode therefore don't become transitive handles on the whole DI container, which means "holds the container" is no longer an argument against replacing a provider with a collection.

DirectExtensionsCollection is the test seam that Direct*ExtensionProvider used to be. RuleTestCase::getReadWritePropertiesExtensions() keeps its array signature; only the wrapping changed.

Passing an interface without #[ExtensionInterface] throws NotAnExtensionInterfaceException during container compilation.

Deleted

All eight extension-list providers with their Direct/Lazy twins:

ReadWritePropertiesExtensionProvider, AlwaysUsedClassConstantsExtensionProvider, AlwaysUsedMethodExtensionProvider, IgnoreErrorExtensionProvider, ParameterClosureThisExtensionProvider, ParameterClosureTypeExtensionProvider, ParameterOutTypeExtensionProvider, DynamicThrowTypeExtensionProvider

…and four registry providers, whose registries became #[AutowiredService]s holding collections:

ExpressionTypeResolverExtensionRegistryProvider, OperatorTypeSpecifyingExtensionRegistryProvider, UnaryOperatorTypeSpecifyingExtensionRegistryProvider, DynamicReturnTypeExtensionRegistryProvider

26 files gone, 6 added. The service tag constants they carried moved onto the extension interfaces themselves, next to the #[ExtensionInterface] attribute that references them.

The ~25 inline getServicesByTag() call sites are migrated too — the 10 RestrictedUsage rules, ClassNameCheck, ClassForbiddenNameCheck, InstantiationRule, ConstructorsHelper, DeprecationProvider (7 collections), DefaultStubFilesProvider, LazyRegistry, Collectors\RegistryFactory, ResultCacheManager, RichParser all drop their Container and their memo fields. Where the Container is still needed for other reasons (TypeSpecifierFactory, PromoteParameterRule, ExprHandlerRegistry's static dispatch, the diagnose commands) the tag lookup becomes the typed Container::getExtensions().

ForbiddenClassNameExtension, AdditionalConstructorsExtension and ConstantDeprecationExtension were missing #[ExtensionInterface] and get it here.

Kept, on purpose

TypeNodeResolverExtensionRegistryProvider and ClassReflectionExtensionRegistryProvider both break a real cycle — their registries need TypeNodeResolver and PhpClassReflectionExtension, which reach back to the registry through ReflectionProvider/ClassReflection. Only their tag pulls are typed now.

The single remaining getServicesByTag() caller is StubValidator: phpstan.stubValidator.rule is a second tag on Rule, which a 1:1 interface→tag map cannot express.

Notable trap

#[AutowiredExtensions] arguments are only set on definitions that instantiate the class themselves. src/Testing/TestCase.neon has

currentPhpVersionSimpleParser!:
	factory: @currentPhpVersionRichParser

whose resolved type is RichParser, so a naive type match sets the argument on the alias too and Nette generates $this->createServiceCurrentPhpVersionRichParser(visitors: ...) — "Unknown named parameter $visitors" at runtime, in every test. The guard is that the creator entity has to be the class itself.

Differences from #6098

Both branches were built independently from a7dfaa7a50 and reached the same scope, the same alias trap, the same three missing #[ExtensionInterface] attributes and the same two kept providers. Where they differ:

• This PR registers no per-interface services. Wiring lives in AutowiredAttributeServicesExtension::beforeCompile() and emits an inline Statement. Introduce ExtensionsCollection and #[AutowiredExtensions], replace extension providers (by Claude Fable 5) #6098 adds a dedicated AutowiredExtensionsExtension that registers one non-autowired phpstan.extensionsCollection.<FQCN> service per extension interface.
• Attribute argument is interface:, not of:.
• Container gains only getExtensions(); Introduce ExtensionsCollection and #[AutowiredExtensions], replace extension providers (by Claude Fable 5) #6098 also adds getExtensionsCollection().
• LazyExtensionsCollection releases its Container after the first getAll().

Verification

make phpstan, make cs, make tests (17678 tests) and make tests-integration are green. New tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php covers getExtensions() against the equivalent getServicesByTag() result, the unknown-interface error, the container release, and that a real #[AutowiredExtensions] consumer resolves from the container.

🤖 Generated with Claude Code

https://claude.ai/code/session_01XLPJxFJDzLPsieqEwJKpkn