From 3a1b5596c1ec43c64605150531d139b4845749c2 Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 21:47:13 +0100 Subject: [PATCH 1/4] Introduce ExtensionsCollection and #[AutowiredExtensions] Container::getExtensions() looks up extensions by their interface instead of by a service tag. The #[ExtensionInterface] mapping is baked into the compiled container through the new ExtensionInterfaceTags service, so vendor/attributes.php is not needed at runtime. Services ask for extensions with #[AutowiredExtensions] above a constructor parameter typed as ExtensionsCollection. AutowiredAttributeServicesExtension wires those parameters in beforeCompile() - services from NEON files are only in the builder at that point - with an inline LazyExtensionsCollection, which keeps the resolution deferred the way the Lazy*ExtensionProvider classes did. LazyExtensionsCollection releases its Container reference once the extensions are resolved so that long-lived holders don't retain the whole container. IgnoreErrorExtensionProvider is the first one replaced by this. ForbiddenClassNameExtension, AdditionalConstructorsExtension and ConstantDeprecationExtension were missing #[ExtensionInterface] and get it here. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01XLPJxFJDzLPsieqEwJKpkn --- src/Analyser/AnalyserResultFinalizer.php | 10 ++- src/Analyser/FileAnalyser.php | 10 ++- src/Analyser/IgnoreErrorExtensionProvider.php | 24 ------ src/Classes/ForbiddenClassNameExtension.php | 3 + .../AutowiredAttributeServicesExtension.php | 66 ++++++++++++++ .../AutowiredExtensions.php | 29 +++++++ src/DependencyInjection/Container.php | 12 +++ .../DirectExtensionsCollection.php | 25 ++++++ .../ExtensionInterfaceTags.php | 41 +++++++++ .../ExtensionsCollection.php | 26 ++++++ .../LazyExtensionsCollection.php | 43 ++++++++++ .../MemoizingContainer.php | 14 +++ .../Nette/NetteContainer.php | 13 +++ .../NotAnExtensionInterfaceException.php | 22 +++++ .../AdditionalConstructorsExtension.php | 3 + .../ConstantDeprecationExtension.php | 2 + src/Testing/RuleTestCase.php | 7 +- tests/PHPStan/Analyser/AnalyserTest.php | 7 +- .../ExtensionsCollectionTest.php | 86 +++++++++++++++++++ 19 files changed, 408 insertions(+), 35 deletions(-) delete mode 100644 src/Analyser/IgnoreErrorExtensionProvider.php create mode 100644 src/DependencyInjection/AutowiredExtensions.php create mode 100644 src/DependencyInjection/DirectExtensionsCollection.php create mode 100644 src/DependencyInjection/ExtensionInterfaceTags.php create mode 100644 src/DependencyInjection/ExtensionsCollection.php create mode 100644 src/DependencyInjection/LazyExtensionsCollection.php create mode 100644 src/DependencyInjection/NotAnExtensionInterfaceException.php create mode 100644 tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php diff --git a/src/Analyser/AnalyserResultFinalizer.php b/src/Analyser/AnalyserResultFinalizer.php index cc06cb3eee3..27ab917f08f 100644 --- a/src/Analyser/AnalyserResultFinalizer.php +++ b/src/Analyser/AnalyserResultFinalizer.php @@ -6,8 +6,10 @@ use PHPStan\BetterReflection\NodeCompiler\Exception\UnableToCompileNode; use PHPStan\BetterReflection\Reflection\Exception\CircularReference; use PHPStan\BetterReflection\Reflector\Exception\IdentifierNotFound; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\CollectedDataNode; use PHPStan\Rules\Registry as RuleRegistry; use Throwable; @@ -20,9 +22,13 @@ final class AnalyserResultFinalizer { + /** + * @param ExtensionsCollection $ignoreErrorExtensions + */ public function __construct( private RuleRegistry $ruleRegistry, - private IgnoreErrorExtensionProvider $ignoreErrorExtensionProvider, + #[AutowiredExtensions(interface: IgnoreErrorExtension::class)] + private ExtensionsCollection $ignoreErrorExtensions, private RuleErrorTransformer $ruleErrorTransformer, private ScopeFactory $scopeFactory, private LocalIgnoresProcessor $localIgnoresProcessor, @@ -96,7 +102,7 @@ public function finalize(AnalyserResult $analyserResult, bool $onlyFiles, bool $ $error = $this->ruleErrorTransformer->transform($ruleError, $scope, [], $node); if ($error->canBeIgnored()) { - foreach ($this->ignoreErrorExtensionProvider->getExtensions() as $ignoreErrorExtension) { + foreach ($this->ignoreErrorExtensions->getAll() as $ignoreErrorExtension) { if ($ignoreErrorExtension->shouldIgnore($error, $node, $scope)) { continue 2; } diff --git a/src/Analyser/FileAnalyser.php b/src/Analyser/FileAnalyser.php index 1870b581a69..3a53dcd6037 100644 --- a/src/Analyser/FileAnalyser.php +++ b/src/Analyser/FileAnalyser.php @@ -11,8 +11,10 @@ use PHPStan\Collectors\Registry as CollectorRegistry; use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\PackageDependencyResolver; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\FileNode; use PHPStan\Parser\Parser; use PHPStan\Parser\ParserErrorsException; @@ -51,6 +53,9 @@ final class FileAnalyser /** @var array */ private array $filteredPhpErrors = []; + /** + * @param ExtensionsCollection $ignoreErrorExtensions + */ public function __construct( private ScopeFactory $scopeFactory, #[AutowiredParameter(ref: '@' . NodeScopeResolver::class)] @@ -59,7 +64,8 @@ public function __construct( private Parser $parser, private DependencyResolver $dependencyResolver, private PackageDependencyResolver $packageDependencyResolver, - private IgnoreErrorExtensionProvider $ignoreErrorExtensionProvider, + #[AutowiredExtensions(interface: IgnoreErrorExtension::class)] + private ExtensionsCollection $ignoreErrorExtensions, private RuleErrorTransformer $ruleErrorTransformer, private LocalIgnoresProcessor $localIgnoresProcessor, #[AutowiredParameter] @@ -111,7 +117,7 @@ public function analyseFile( $collectorRegistry, $outerNodeCallback, $parserNodes, - $this->ignoreErrorExtensionProvider->getExtensions(), + $this->ignoreErrorExtensions->getAll(), $this->parser, $this->dependencyResolver, $this->packageDependencyResolver, diff --git a/src/Analyser/IgnoreErrorExtensionProvider.php b/src/Analyser/IgnoreErrorExtensionProvider.php deleted file mode 100644 index ff5af371693..00000000000 --- a/src/Analyser/IgnoreErrorExtensionProvider.php +++ /dev/null @@ -1,24 +0,0 @@ -container->getServicesByTag(IgnoreErrorExtension::EXTENSION_TAG); - } - -} diff --git a/src/Classes/ForbiddenClassNameExtension.php b/src/Classes/ForbiddenClassNameExtension.php index 7d545d83d42..73528f9c510 100644 --- a/src/Classes/ForbiddenClassNameExtension.php +++ b/src/Classes/ForbiddenClassNameExtension.php @@ -2,6 +2,8 @@ namespace PHPStan\Classes; +use PHPStan\DependencyInjection\ExtensionInterface; + /** * This is the extension interface to implement if you want to dynamically * add forbidden class prefixes to the ClassForbiddenNameCheck rule. @@ -21,6 +23,7 @@ * * @api */ +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface ForbiddenClassNameExtension { diff --git a/src/DependencyInjection/AutowiredAttributeServicesExtension.php b/src/DependencyInjection/AutowiredAttributeServicesExtension.php index 5a42201007e..49f5d1e1e7d 100644 --- a/src/DependencyInjection/AutowiredAttributeServicesExtension.php +++ b/src/DependencyInjection/AutowiredAttributeServicesExtension.php @@ -4,6 +4,7 @@ use Nette\DI\CompilerExtension; use Nette\DI\ContainerBuilder; +use Nette\DI\Definitions\FactoryDefinition; use Nette\DI\Definitions\Reference; use Nette\DI\Definitions\ServiceDefinition; use Nette\DI\Definitions\Statement; @@ -18,6 +19,8 @@ use PHPStan\Rules\LazyRegistry; use ReflectionClass; use stdClass; +use function array_key_exists; +use function count; use function explode; use function strcasecmp; use function strtolower; @@ -40,6 +43,12 @@ public function loadConfiguration(): void require_once __DIR__ . '/../../vendor/attributes.php'; $builder = $this->getContainerBuilder(); + // Bakes the #[ExtensionInterface] mapping into the compiled container + // so that Container::getExtensions() does not need vendor/attributes.php at runtime. + $builder->addDefinition($this->prefix('extensionInterfaceTags')) + ->setType(ExtensionInterfaceTags::class) + ->setArguments([ValidateServiceTagsExtension::getInterfaceTagMapping()]); + $autowiredParameters = Attributes::findTargetMethodParameters(AutowiredParameter::class); $constructorParameters = []; foreach ($autowiredParameters as $parameter) { @@ -142,6 +151,63 @@ public function loadConfiguration(): void } } + /** + * Wires #[AutowiredExtensions] constructor parameters. + * + * It has to happen in beforeCompile() and not in loadConfiguration(): services from the NEON + * files are registered by Nette's own ServicesExtension after every other extension's + * loadConfiguration(), so they are not in the builder yet at that point. + * + * @throws NotAnExtensionInterfaceException + */ + #[Override] + public function beforeCompile(): void + { + require_once __DIR__ . '/../../vendor/attributes.php'; + + /** @var array>> $constructorParameters */ + $constructorParameters = []; + foreach (Attributes::findTargetMethodParameters(AutowiredExtensions::class) as $parameter) { + if (strcasecmp($parameter->method, '__construct') !== 0) { + continue; + } + $constructorParameters[strtolower($parameter->class)][] = $parameter; + } + + if (count($constructorParameters) === 0) { + return; + } + + $mapping = ValidateServiceTagsExtension::getInterfaceTagMapping(); + $builder = $this->getContainerBuilder(); + + foreach ($builder->getDefinitions() as $definition) { + if ($definition instanceof FactoryDefinition) { + $definition = $definition->getResultDefinition(); + } + if (!$definition instanceof ServiceDefinition) { + continue; + } + + $className = $definition->getType(); + if ($className === null) { + continue; + } + + foreach ($constructorParameters[strtolower($className)] ?? [] as $parameter) { + $interface = $parameter->attribute->interface; + if (!array_key_exists($interface, $mapping)) { + throw new NotAnExtensionInterfaceException($className, $parameter->name, $interface); + } + + $definition->setArgument($parameter->name, new Statement(LazyExtensionsCollection::class, [ + new Reference(Container::class), + $interface, + ])); + } + } + } + /** * @param class-string $className * @param array>> $constructorParameters diff --git a/src/DependencyInjection/AutowiredExtensions.php b/src/DependencyInjection/AutowiredExtensions.php new file mode 100644 index 00000000000..940655384d7 --- /dev/null +++ b/src/DependencyInjection/AutowiredExtensions.php @@ -0,0 +1,29 @@ + $interfaceName + * @return list + * @throws MissingServiceException + */ + public function getExtensions(string $interfaceName): array; + /** * @return mixed[] */ diff --git a/src/DependencyInjection/DirectExtensionsCollection.php b/src/DependencyInjection/DirectExtensionsCollection.php new file mode 100644 index 00000000000..d9a2f75e512 --- /dev/null +++ b/src/DependencyInjection/DirectExtensionsCollection.php @@ -0,0 +1,25 @@ + + */ +final class DirectExtensionsCollection implements ExtensionsCollection +{ + + /** + * @param list $extensions + */ + public function __construct(private array $extensions) + { + } + + public function getAll(): array + { + return $this->extensions; + } + +} diff --git a/src/DependencyInjection/ExtensionInterfaceTags.php b/src/DependencyInjection/ExtensionInterfaceTags.php new file mode 100644 index 00000000000..b68028d38c3 --- /dev/null +++ b/src/DependencyInjection/ExtensionInterfaceTags.php @@ -0,0 +1,41 @@ + $tags + */ + public function __construct(private array $tags) + { + } + + /** + * @param class-string $interfaceName + * @throws MissingServiceException + */ + public function getTag(string $interfaceName): string + { + if (!array_key_exists($interfaceName, $this->tags)) { + throw new MissingServiceException(sprintf( + 'Interface %s is not an extension interface. Mark it with the #[%s] attribute.', + $interfaceName, + ExtensionInterface::class, + )); + } + + return $this->tags[$interfaceName]; + } + +} diff --git a/src/DependencyInjection/ExtensionsCollection.php b/src/DependencyInjection/ExtensionsCollection.php new file mode 100644 index 00000000000..c914cd058ed --- /dev/null +++ b/src/DependencyInjection/ExtensionsCollection.php @@ -0,0 +1,26 @@ + + */ + public function getAll(): array; + +} diff --git a/src/DependencyInjection/LazyExtensionsCollection.php b/src/DependencyInjection/LazyExtensionsCollection.php new file mode 100644 index 00000000000..a98b905aa65 --- /dev/null +++ b/src/DependencyInjection/LazyExtensionsCollection.php @@ -0,0 +1,43 @@ + + */ +final class LazyExtensionsCollection implements ExtensionsCollection +{ + + /** @var list|null */ + private ?array $extensions = null; + + /** + * @param class-string $interfaceName + */ + public function __construct(private ?Container $container, private string $interfaceName) + { + } + + public function getAll(): array + { + if ($this->extensions === null) { + if ($this->container === null) { + throw new ShouldNotHappenException(); + } + + $this->extensions = $this->container->getExtensions($this->interfaceName); + + // Collections are held by long-lived objects like ClassPropertiesNode. Keeping the + // container reference here would make each of them a transitive handle on the entire + // DI container. After the extensions are resolved the container is no longer needed. + $this->container = null; + } + + return $this->extensions; + } + +} diff --git a/src/DependencyInjection/MemoizingContainer.php b/src/DependencyInjection/MemoizingContainer.php index b4730deadf0..a4afc23e549 100644 --- a/src/DependencyInjection/MemoizingContainer.php +++ b/src/DependencyInjection/MemoizingContainer.php @@ -15,6 +15,9 @@ final class MemoizingContainer implements Container /** @var array */ private array $servicesByTag = []; + /** @var array> */ + private array $extensionsByInterface = []; + public function __construct( #[AutowiredParameter(ref: '@PHPStan\DependencyInjection\Nette\NetteContainer')] private Container $originalContainer, @@ -47,6 +50,17 @@ public function getServicesByTag(string $tagName): array return $this->servicesByTag[$tagName] ??= $this->originalContainer->getServicesByTag($tagName); } + /** + * @template T of object + * @param class-string $interfaceName + * @return list + */ + public function getExtensions(string $interfaceName): array + { + /** @var list */ + return $this->extensionsByInterface[$interfaceName] ??= $this->originalContainer->getExtensions($interfaceName); + } + public function getParameters(): array { return $this->originalContainer->getParameters(); diff --git a/src/DependencyInjection/Nette/NetteContainer.php b/src/DependencyInjection/Nette/NetteContainer.php index f5ae4164d65..dfda2c168d2 100644 --- a/src/DependencyInjection/Nette/NetteContainer.php +++ b/src/DependencyInjection/Nette/NetteContainer.php @@ -4,6 +4,7 @@ use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionInterfaceTags; use PHPStan\DependencyInjection\MissingServiceException; use PHPStan\DependencyInjection\ParameterNotFoundException; use function array_key_exists; @@ -22,6 +23,7 @@ final class NetteContainer implements Container public function __construct( private readonly \Nette\DI\Container $container, + private readonly ExtensionInterfaceTags $extensionInterfaceTags, ) { } @@ -74,6 +76,17 @@ public function getServicesByTag(string $tagName): array return $this->tagsToServices($this->container->findByTag($tagName)); } + /** + * @template T of object + * @param class-string $interfaceName + * @return list + */ + public function getExtensions(string $interfaceName): array + { + /** @var list */ + return $this->tagsToServices($this->container->findByTag($this->extensionInterfaceTags->getTag($interfaceName))); + } + /** * @return mixed[] */ diff --git a/src/DependencyInjection/NotAnExtensionInterfaceException.php b/src/DependencyInjection/NotAnExtensionInterfaceException.php new file mode 100644 index 00000000000..2d0a2af2d7d --- /dev/null +++ b/src/DependencyInjection/NotAnExtensionInterfaceException.php @@ -0,0 +1,22 @@ +getParser(), self::getContainer()->getByType(DependencyResolver::class), self::getContainer()->getByType(PackageDependencyResolver::class), - new IgnoreErrorExtensionProvider(self::getContainer()), + new LazyExtensionsCollection(self::getContainer(), IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), new LocalIgnoresProcessor(), false, @@ -324,7 +325,7 @@ private function gatherAnalyserErrorsWithDelayedErrors(array $files): array $finalizer = new AnalyserResultFinalizer( $ruleRegistry, - new IgnoreErrorExtensionProvider(self::getContainer()), + new LazyExtensionsCollection(self::getContainer(), IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), self::createScopeFactory($reflectionProvider, self::getContainer()->getService('typeSpecifier')), new LocalIgnoresProcessor(), diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 6f781f28a25..5faba6271b7 100644 --- a/tests/PHPStan/Analyser/AnalyserTest.php +++ b/tests/PHPStan/Analyser/AnalyserTest.php @@ -2,7 +2,6 @@ namespace PHPStan\Analyser; -use Nette\DI\Container; use PhpParser\Lexer; use PhpParser\NodeVisitor\NameResolver; use PhpParser\Parser\Php7; @@ -13,7 +12,7 @@ use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\ExportedNodeResolver; use PHPStan\Dependency\PackageDependencyResolver; -use PHPStan\DependencyInjection\Nette\NetteContainer; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; @@ -771,7 +770,7 @@ private function runAnalyser( $finalizer = new AnalyserResultFinalizer( new DirectRuleRegistry([]), - new IgnoreErrorExtensionProvider(new NetteContainer(new Container([]))), + new DirectExtensionsCollection([]), self::getContainer()->getByType(RuleErrorTransformer::class), $this->createScopeFactory( self::createReflectionProvider(), @@ -848,7 +847,7 @@ private function createAnalyser(): Analyser ), new DependencyResolver($fileHelper, $reflectionProvider, new ExportedNodeResolver($reflectionProvider, $fileTypeMapper, new ExprPrinter(new Printer())), $fileTypeMapper), new PackageDependencyResolver([], $fileHelper), - new IgnoreErrorExtensionProvider(new NetteContainer(new Container([]))), + new DirectExtensionsCollection([]), $container->getByType(RuleErrorTransformer::class), new LocalIgnoresProcessor(), false, diff --git a/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php b/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php new file mode 100644 index 00000000000..9aa21b58295 --- /dev/null +++ b/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php @@ -0,0 +1,86 @@ + + */ + public static function dataGetExtensions(): iterable + { + return [ + [DynamicMethodReturnTypeExtension::class, 'phpstan.broker.dynamicMethodReturnTypeExtension'], + [ReadWritePropertiesExtension::class, 'phpstan.properties.readWriteExtension'], + [IgnoreErrorExtension::class, 'phpstan.ignoreErrorExtension'], + ]; + } + + /** + * @param class-string $interfaceName + */ + #[DataProvider('dataGetExtensions')] + public function testGetExtensions(string $interfaceName, string $tag): void + { + $container = self::getContainer(); + $extensions = $container->getExtensions($interfaceName); + + $this->assertSame($container->getServicesByTag($tag), $extensions); + foreach ($extensions as $extension) { + $this->assertInstanceOf($interfaceName, $extension); + } + } + + public function testGetExtensionsOfNonExtensionInterface(): void + { + $this->expectException(MissingServiceException::class); + $this->expectExceptionMessage('Interface stdClass is not an extension interface. Mark it with the #[PHPStan\DependencyInjection\ExtensionInterface] attribute.'); + self::getContainer()->getExtensions(stdClass::class); + } + + public function testAutowiredExtensionsParameterIsWired(): void + { + // AnalyserResultFinalizer asks for #[AutowiredExtensions(IgnoreErrorExtension::class)]. + // ExtensionsCollection is not a registered service, so without the wiring in + // AutowiredAttributeServicesExtension::beforeCompile() the container could not build it. + $finalizer = self::getContainer()->getByType(AnalyserResultFinalizer::class); + + $property = new ReflectionProperty($finalizer, 'ignoreErrorExtensions'); + $collection = $property->getValue($finalizer); + + $this->assertInstanceOf(LazyExtensionsCollection::class, $collection); + $this->assertSame(self::getContainer()->getExtensions(IgnoreErrorExtension::class), $collection->getAll()); + } + + public function testLazyExtensionsCollectionReleasesTheContainer(): void + { + $collection = new LazyExtensionsCollection(self::getContainer(), DynamicMethodReturnTypeExtension::class); + + $containerProperty = new ReflectionProperty(LazyExtensionsCollection::class, 'container'); + $this->assertNotNull($containerProperty->getValue($collection)); + + $extensions = $collection->getAll(); + + $this->assertNull($containerProperty->getValue($collection)); + $this->assertSame($extensions, $collection->getAll()); + } + + public function testDirectExtensionsCollection(): void + { + $extension = self::getContainer()->getExtensions(IgnoreErrorExtension::class); + $collection = new DirectExtensionsCollection($extension); + + $this->assertSame($extension, $collection->getAll()); + } + +} From d6c29ea26c120d74eaec69b50d08daa7a183c084 Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 21:59:55 +0100 Subject: [PATCH 2/4] Replace extension-list providers with ExtensionsCollection The Direct*/Lazy* provider pairs existed only to defer getServicesByTag() past container construction and to let tests hand extensions in directly - both of which ExtensionsCollection now does. Deleted: - ReadWritePropertiesExtensionProvider - AlwaysUsedClassConstantsExtensionProvider - AlwaysUsedMethodExtensionProvider - ParameterClosureThisExtensionProvider - ParameterClosureTypeExtensionProvider - ParameterOutTypeExtensionProvider - DynamicThrowTypeExtensionProvider The service tag constants they carried move onto the extension interfaces themselves, next to the #[ExtensionInterface] attribute that references them. Providers with several getters (three per parameter/throw-type family) become one ExtensionsCollection parameter each, so consumers no longer go through a lookup method to reach a single list. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01XLPJxFJDzLPsieqEwJKpkn --- src/Analyser/ExprHandler/FuncCallHandler.php | 12 +++- .../Helper/MethodThrowPointHelper.php | 18 +++-- src/Analyser/ExprHandler/NewHandler.php | 12 +++- src/Analyser/NodeScopeResolver.php | 72 ++++++++++++++----- .../DirectExtensionsCollection.php | 10 ++- .../DynamicThrowTypeExtensionProvider.php | 21 ------ .../LazyDynamicThrowTypeExtensionProvider.php | 35 --------- ...yParameterClosureThisExtensionProvider.php | 47 ------------ ...yParameterClosureTypeExtensionProvider.php | 35 --------- .../LazyParameterOutTypeExtensionProvider.php | 35 --------- .../ParameterClosureThisExtensionProvider.php | 27 ------- .../ParameterClosureTypeExtensionProvider.php | 21 ------ .../ParameterOutTypeExtensionProvider.php | 21 ------ src/Node/ClassPropertiesNode.php | 8 ++- .../AlwaysUsedClassConstantsExtension.php | 4 +- ...aysUsedClassConstantsExtensionProvider.php | 15 ---- ...aysUsedClassConstantsExtensionProvider.php | 24 ------- .../DeadCode/UnusedPrivateConstantRule.php | 14 +++- .../DeadCode/UnusedPrivateMethodRule.php | 14 +++- .../DeadCode/UnusedPrivatePropertyRule.php | 10 ++- .../Methods/AlwaysUsedMethodExtension.php | 4 +- .../AlwaysUsedMethodExtensionProvider.php | 15 ---- ...irectAlwaysUsedMethodExtensionProvider.php | 20 ------ .../LazyAlwaysUsedMethodExtensionProvider.php | 24 ------- ...ctReadWritePropertiesExtensionProvider.php | 23 ------ ...zyReadWritePropertiesExtensionProvider.php | 24 ------- .../ReadWritePropertiesExtension.php | 4 +- .../ReadWritePropertiesExtensionProvider.php | 15 ---- .../TooWidePropertyTypeRule.php | 12 +++- src/Testing/RuleTestCase.php | 29 +++++--- src/Testing/TypeInferenceTestCase.php | 29 +++++--- .../DynamicFunctionThrowTypeExtension.php | 5 +- src/Type/DynamicMethodThrowTypeExtension.php | 5 +- .../DynamicStaticMethodThrowTypeExtension.php | 5 +- .../FunctionParameterClosureThisExtension.php | 5 +- .../FunctionParameterClosureTypeExtension.php | 5 +- .../FunctionParameterOutTypeExtension.php | 5 +- .../MethodParameterClosureThisExtension.php | 5 +- .../MethodParameterClosureTypeExtension.php | 5 +- src/Type/MethodParameterOutTypeExtension.php | 5 +- ...ticMethodParameterClosureThisExtension.php | 5 +- ...ticMethodParameterClosureTypeExtension.php | 5 +- .../StaticMethodParameterOutTypeExtension.php | 5 +- tests/PHPStan/Analyser/AnalyserTest.php | 29 +++++--- .../Fiber/FiberNodeScopeResolverRuleTest.php | 31 +++++--- .../Fiber/FiberNodeScopeResolverTest.php | 29 +++++--- .../Rules/Api/ApiClassImplementsRuleTest.php | 12 ++-- .../Rules/Api/ApiInterfaceExtendsRuleTest.php | 2 +- .../Api/data/class-implements-in-phpstan.php | 19 ++--- .../data/class-implements-out-of-phpstan.php | 18 ++--- .../Api/data/interface-extends-in-phpstan.php | 4 +- .../data/interface-extends-out-of-phpstan.php | 4 +- ...aysUsedClassConstantsExtensionProvider.php | 23 ------ .../UnusedPrivateConstantRuleTest.php | 4 +- .../DeadCode/UnusedPrivateMethodRuleTest.php | 4 +- .../UnusedPrivatePropertyRuleTest.php | 4 +- .../TooWidePropertyTypeRuleTest.php | 4 +- 57 files changed, 314 insertions(+), 587 deletions(-) delete mode 100644 src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/LazyParameterClosureThisExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/ParameterClosureThisExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/ParameterClosureTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/ParameterOutTypeExtensionProvider.php delete mode 100644 src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php delete mode 100644 src/Rules/Constants/LazyAlwaysUsedClassConstantsExtensionProvider.php delete mode 100644 src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php delete mode 100644 src/Rules/Methods/DirectAlwaysUsedMethodExtensionProvider.php delete mode 100644 src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php delete mode 100644 src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php delete mode 100644 src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php delete mode 100644 src/Rules/Properties/ReadWritePropertiesExtensionProvider.php delete mode 100644 tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php diff --git a/src/Analyser/ExprHandler/FuncCallHandler.php b/src/Analyser/ExprHandler/FuncCallHandler.php index 47efb2af7fe..693061ce1f6 100644 --- a/src/Analyser/ExprHandler/FuncCallHandler.php +++ b/src/Analyser/ExprHandler/FuncCallHandler.php @@ -29,10 +29,11 @@ use PHPStan\Analyser\SpecifiedTypes; use PHPStan\Analyser\TypeSpecifier; use PHPStan\Analyser\TypeSpecifierContext; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; use PHPStan\Node\ClosureReturnStatementsNode; use PHPStan\Node\Expr\NativeTypeExpr; use PHPStan\Node\Expr\PossiblyImpureCallExpr; @@ -53,6 +54,7 @@ use PHPStan\Type\ClosureType; use PHPStan\Type\Constant\ConstantArrayType; use PHPStan\Type\Constant\ConstantArrayTypeBuilder; +use PHPStan\Type\DynamicFunctionThrowTypeExtension; use PHPStan\Type\ErrorType; use PHPStan\Type\GeneralizePrecision; use PHPStan\Type\Generic\TemplateTypeHelper; @@ -88,9 +90,13 @@ final class FuncCallHandler implements ExprHandler { + /** + * @param ExtensionsCollection $functionThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, + #[AutowiredExtensions(interface: DynamicFunctionThrowTypeExtension::class)] + private ExtensionsCollection $functionThrowTypeExtensions, private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, @@ -604,7 +610,7 @@ private function getFunctionThrowPoint( ExpressionContext $context, ): ?InternalThrowPoint { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicFunctionThrowTypeExtensions() as $extension) { + foreach ($this->functionThrowTypeExtensions->getAll() as $extension) { if (!$extension->isFunctionSupported($functionReflection)) { continue; } diff --git a/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php b/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php index 08ff8735587..001c048cfc0 100644 --- a/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php +++ b/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php @@ -7,11 +7,14 @@ use PHPStan\Analyser\ExpressionContext; use PHPStan\Analyser\InternalThrowPoint; use PHPStan\Analyser\MutatingScope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParametersAcceptor; +use PHPStan\Type\DynamicMethodThrowTypeExtension; +use PHPStan\Type\DynamicStaticMethodThrowTypeExtension; use PHPStan\Type\NeverType; use PHPStan\Type\ObjectType; use ReflectionFunction; @@ -23,8 +26,15 @@ final class MethodThrowPointHelper { + /** + * @param ExtensionsCollection $methodThrowTypeExtensions + * @param ExtensionsCollection $staticMethodThrowTypeExtensions + */ public function __construct( - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, + #[AutowiredExtensions(interface: DynamicMethodThrowTypeExtension::class)] + private ExtensionsCollection $methodThrowTypeExtensions, + #[AutowiredExtensions(interface: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $staticMethodThrowTypeExtensions, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, ) @@ -40,7 +50,7 @@ public function getThrowPoint( ): ?InternalThrowPoint { if ($normalizedMethodCall instanceof MethodCall) { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicMethodThrowTypeExtensions() as $extension) { + foreach ($this->methodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isMethodSupported($methodReflection)) { continue; } @@ -53,7 +63,7 @@ public function getThrowPoint( return InternalThrowPoint::createExplicit($scope, $throwType, $normalizedMethodCall, false); } } else { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicStaticMethodThrowTypeExtensions() as $extension) { + foreach ($this->staticMethodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isStaticMethodSupported($methodReflection)) { continue; } diff --git a/src/Analyser/ExprHandler/NewHandler.php b/src/Analyser/ExprHandler/NewHandler.php index 111fe38a682..6eb944b7b64 100644 --- a/src/Analyser/ExprHandler/NewHandler.php +++ b/src/Analyser/ExprHandler/NewHandler.php @@ -26,10 +26,11 @@ use PHPStan\Analyser\Traverser\GenericTypeTemplateTraverser; use PHPStan\Analyser\TypeSpecifier; use PHPStan\Analyser\TypeSpecifierContext; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; use PHPStan\Node\MethodReturnStatementsNode; use PHPStan\Parser\NewAssignedToPropertyVisitor; use PHPStan\Reflection\Callables\SimpleImpurePoint; @@ -42,6 +43,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\ShouldNotHappenException; +use PHPStan\Type\DynamicStaticMethodThrowTypeExtension; use PHPStan\Type\ErrorType; use PHPStan\Type\Generic\GenericObjectType; use PHPStan\Type\Generic\GenericStaticType; @@ -71,9 +73,13 @@ final class NewHandler implements ExprHandler { + /** + * @param ExtensionsCollection $staticMethodThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, + #[AutowiredExtensions(interface: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $staticMethodThrowTypeExtensions, private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, private PropertyReflectionFinder $propertyReflectionFinder, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] @@ -303,7 +309,7 @@ private function getConstructorThrowPoint(MethodReflection $constructorReflectio $methodCall = new StaticCall($className, $constructorReflection->getName(), $args); $normalizedMethodCall = ArgumentsNormalizer::reorderStaticCallArguments($parametersAcceptor, $methodCall); if ($normalizedMethodCall !== null) { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicStaticMethodThrowTypeExtensions() as $extension) { + foreach ($this->staticMethodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isStaticMethodSupported($constructorReflection)) { continue; } diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php index 72f087b400d..9ba903e4480 100644 --- a/src/Analyser/NodeScopeResolver.php +++ b/src/Analyser/NodeScopeResolver.php @@ -57,12 +57,11 @@ use PHPStan\BetterReflection\Reflector\Reflector; use PHPStan\BetterReflection\SourceLocator\Ast\Strategy\NodeToReflection; use PHPStan\BetterReflection\SourceLocator\Located\LocatedSource; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\FileReader; use PHPStan\Node\BreaklessWhileLoopNode; @@ -139,15 +138,21 @@ use PHPStan\Reflection\Php\PhpMethodReflection; use PHPStan\Reflection\Php\PhpPropertyReflection; use PHPStan\Reflection\ReflectionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ClosureType; use PHPStan\Type\Constant\ConstantIntegerType; use PHPStan\Type\Constant\ConstantStringType; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; use PHPStan\Type\Generic\TemplateTypeHelper; use PHPStan\Type\Generic\TemplateTypeMap; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; use PHPStan\Type\MixedType; use PHPStan\Type\NeverType; use PHPStan\Type\NullType; @@ -155,6 +160,9 @@ use PHPStan\Type\ObjectWithoutClassType; use PHPStan\Type\ParserNodeTypeToPHPStanType; use PHPStan\Type\ResourceType; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\StaticType; use PHPStan\Type\StaticTypeFactory; use PHPStan\Type\ThisType; @@ -209,6 +217,16 @@ class NodeScopeResolver /** * @param string[][] $earlyTerminatingMethodCalls className(string) => methods(string[]) * @param array $earlyTerminatingFunctionCalls + * @param ExtensionsCollection $functionParameterOutTypeExtensions + * @param ExtensionsCollection $methodParameterOutTypeExtensions + * @param ExtensionsCollection $staticMethodParameterOutTypeExtensions + * @param ExtensionsCollection $readWritePropertiesExtensions + * @param ExtensionsCollection $functionParameterClosureThisExtensions + * @param ExtensionsCollection $methodParameterClosureThisExtensions + * @param ExtensionsCollection $staticMethodParameterClosureThisExtensions + * @param ExtensionsCollection $functionParameterClosureTypeExtensions + * @param ExtensionsCollection $methodParameterClosureTypeExtensions + * @param ExtensionsCollection $staticMethodParameterClosureTypeExtensions */ public function __construct( private readonly Container $container, @@ -216,16 +234,32 @@ public function __construct( private readonly InitializerExprTypeResolver $initializerExprTypeResolver, private readonly Reflector $reflector, private readonly ClassReflectionFactory $classReflectionFactory, - private readonly ParameterOutTypeExtensionProvider $parameterOutTypeExtensionProvider, + #[AutowiredExtensions(interface: FunctionParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterOutTypeExtensions, + #[AutowiredExtensions(interface: MethodParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterOutTypeExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterOutTypeExtensions, #[AutowiredParameter(ref: '@defaultAnalysisParser')] private readonly Parser $parser, private readonly FileTypeMapper $fileTypeMapper, private readonly PhpDocInheritanceResolver $phpDocInheritanceResolver, private readonly FileHelper $fileHelper, private readonly TypeSpecifier $typeSpecifier, - private readonly ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider, - private readonly ParameterClosureThisExtensionProvider $parameterClosureThisExtensionProvider, - private readonly ParameterClosureTypeExtensionProvider $parameterClosureTypeExtensionProvider, + #[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)] + private readonly ExtensionsCollection $readWritePropertiesExtensions, + #[AutowiredExtensions(interface: FunctionParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureThisExtensions, + #[AutowiredExtensions(interface: MethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureThisExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterClosureThisExtensions, + #[AutowiredExtensions(interface: FunctionParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureTypeExtensions, + #[AutowiredExtensions(interface: MethodParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureTypeExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterClosureTypeExtensions, private readonly ScopeFactory $scopeFactory, private readonly DeepNodeCloner $deepNodeCloner, #[AutowiredParameter] @@ -1241,7 +1275,7 @@ public function processStmtNode( }); $this->processStmtNodesInternal($stmt, $classLikeStatements, $classScope, $storage, $classStatementsGatherer, $context); - $this->callNodeCallback($nodeCallback, new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope, $storage); + $this->callNodeCallback($nodeCallback, new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensions, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope, $storage); $this->callNodeCallback($nodeCallback, new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection), $classScope, $storage); $this->callNodeCallback($nodeCallback, new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches(), $classReflection), $classScope, $storage); $classReflection->evictPrivateSymbols(); @@ -3479,7 +3513,7 @@ private function resolveClosureThisType( ): ?Type { if ($call instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getFunctionParameterClosureThisExtensions() as $extension) { + foreach ($this->functionParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isFunctionSupported($calleeReflection, $parameter)) { continue; } @@ -3489,7 +3523,7 @@ private function resolveClosureThisType( } } } elseif ($call instanceof StaticCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getStaticMethodParameterClosureThisExtensions() as $extension) { + foreach ($this->staticMethodParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isStaticMethodSupported($calleeReflection, $parameter)) { continue; } @@ -3499,7 +3533,7 @@ private function resolveClosureThisType( } } } elseif ($call instanceof MethodCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getMethodParameterClosureThisExtensions() as $extension) { + foreach ($this->methodParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isMethodSupported($calleeReflection, $parameter)) { continue; } @@ -3937,14 +3971,14 @@ private function shouldInvalidateCallbackExpressions(?ParameterReflection $param private function getParameterTypeFromParameterClosureTypeExtension(CallLike $callLike, $calleeReflection, ParameterReflection $parameter, MutatingScope $scope): ?Type { if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterClosureTypeExtensionProvider->getFunctionParameterClosureTypeExtensions() as $functionParameterClosureTypeExtension) { + foreach ($this->functionParameterClosureTypeExtensions->getAll() as $functionParameterClosureTypeExtension) { if ($functionParameterClosureTypeExtension->isFunctionSupported($calleeReflection, $parameter)) { return $functionParameterClosureTypeExtension->getTypeFromFunctionCall($calleeReflection, $callLike, $parameter, $scope); } } } elseif ($calleeReflection instanceof MethodReflection) { if ($callLike instanceof StaticCall) { - foreach ($this->parameterClosureTypeExtensionProvider->getStaticMethodParameterClosureTypeExtensions() as $staticMethodParameterClosureTypeExtension) { + foreach ($this->staticMethodParameterClosureTypeExtensions->getAll() as $staticMethodParameterClosureTypeExtension) { if ($staticMethodParameterClosureTypeExtension->isStaticMethodSupported($calleeReflection, $parameter)) { return $staticMethodParameterClosureTypeExtension->getTypeFromStaticMethodCall($calleeReflection, $callLike, $parameter, $scope); } @@ -3955,13 +3989,13 @@ private function getParameterTypeFromParameterClosureTypeExtension(CallLike $cal new Identifier('__construct'), $callLike->getArgs(), ); - foreach ($this->parameterClosureTypeExtensionProvider->getStaticMethodParameterClosureTypeExtensions() as $staticMethodParameterClosureTypeExtension) { + foreach ($this->staticMethodParameterClosureTypeExtensions->getAll() as $staticMethodParameterClosureTypeExtension) { if ($staticMethodParameterClosureTypeExtension->isStaticMethodSupported($calleeReflection, $parameter)) { return $staticMethodParameterClosureTypeExtension->getTypeFromStaticMethodCall($calleeReflection, $staticCall, $parameter, $scope); } } } elseif ($callLike instanceof MethodCall) { - foreach ($this->parameterClosureTypeExtensionProvider->getMethodParameterClosureTypeExtensions() as $methodParameterClosureTypeExtension) { + foreach ($this->methodParameterClosureTypeExtensions->getAll() as $methodParameterClosureTypeExtension) { if ($methodParameterClosureTypeExtension->isMethodSupported($calleeReflection, $parameter)) { return $methodParameterClosureTypeExtension->getTypeFromMethodCall($calleeReflection, $callLike, $parameter, $scope); } @@ -3979,7 +4013,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec { $paramOutTypes = []; if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getFunctionParameterOutTypeExtensions() as $functionParameterOutTypeExtension) { + foreach ($this->functionParameterOutTypeExtensions->getAll() as $functionParameterOutTypeExtension) { if (!$functionParameterOutTypeExtension->isFunctionSupported($calleeReflection, $currentParameter)) { continue; } @@ -3991,7 +4025,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec $paramOutTypes[] = $resolvedType; } } elseif ($callLike instanceof MethodCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getMethodParameterOutTypeExtensions() as $methodParameterOutTypeExtension) { + foreach ($this->methodParameterOutTypeExtensions->getAll() as $methodParameterOutTypeExtension) { if (!$methodParameterOutTypeExtension->isMethodSupported($calleeReflection, $currentParameter)) { continue; } @@ -4003,7 +4037,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec $paramOutTypes[] = $resolvedType; } } elseif ($callLike instanceof StaticCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getStaticMethodParameterOutTypeExtensions() as $staticMethodParameterOutTypeExtension) { + foreach ($this->staticMethodParameterOutTypeExtensions->getAll() as $staticMethodParameterOutTypeExtension) { if (!$staticMethodParameterOutTypeExtension->isStaticMethodSupported($calleeReflection, $currentParameter)) { continue; } diff --git a/src/DependencyInjection/DirectExtensionsCollection.php b/src/DependencyInjection/DirectExtensionsCollection.php index d9a2f75e512..0420fc4000f 100644 --- a/src/DependencyInjection/DirectExtensionsCollection.php +++ b/src/DependencyInjection/DirectExtensionsCollection.php @@ -2,6 +2,8 @@ namespace PHPStan\DependencyInjection; +use function array_values; + /** * @api * @template-covariant T of object @@ -10,11 +12,15 @@ final class DirectExtensionsCollection implements ExtensionsCollection { + /** @var list */ + private array $extensions; + /** - * @param list $extensions + * @param array $extensions */ - public function __construct(private array $extensions) + public function __construct(array $extensions) { + $this->extensions = array_values($extensions); } public function getAll(): array diff --git a/src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php b/src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php deleted file mode 100644 index 9f67221cf1f..00000000000 --- a/src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php +++ /dev/null @@ -1,21 +0,0 @@ -container->getServicesByTag(self::FUNCTION_TAG); - } - - public function getDynamicMethodThrowTypeExtensions(): array - { - return $this->container->getServicesByTag(self::METHOD_TAG); - } - - public function getDynamicStaticMethodThrowTypeExtensions(): array - { - return $this->container->getServicesByTag(self::STATIC_METHOD_TAG); - } - -} diff --git a/src/DependencyInjection/Type/LazyParameterClosureThisExtensionProvider.php b/src/DependencyInjection/Type/LazyParameterClosureThisExtensionProvider.php deleted file mode 100644 index 915fd3d621a..00000000000 --- a/src/DependencyInjection/Type/LazyParameterClosureThisExtensionProvider.php +++ /dev/null @@ -1,47 +0,0 @@ -functionExtensions ??= $this->container->getServicesByTag(self::FUNCTION_TAG); - } - - public function getMethodParameterClosureThisExtensions(): array - { - return $this->methodExtensions ??= $this->container->getServicesByTag(self::METHOD_TAG); - } - - public function getStaticMethodParameterClosureThisExtensions(): array - { - return $this->staticMethodExtensions ??= $this->container->getServicesByTag(self::STATIC_METHOD_TAG); - } - -} diff --git a/src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php b/src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php deleted file mode 100644 index ecc30869f50..00000000000 --- a/src/DependencyInjection/Type/LazyParameterClosureTypeExtensionProvider.php +++ /dev/null @@ -1,35 +0,0 @@ -container->getServicesByTag(self::FUNCTION_TAG); - } - - public function getMethodParameterClosureTypeExtensions(): array - { - return $this->container->getServicesByTag(self::METHOD_TAG); - } - - public function getStaticMethodParameterClosureTypeExtensions(): array - { - return $this->container->getServicesByTag(self::STATIC_METHOD_TAG); - } - -} diff --git a/src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php b/src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php deleted file mode 100644 index 113eea7b295..00000000000 --- a/src/DependencyInjection/Type/LazyParameterOutTypeExtensionProvider.php +++ /dev/null @@ -1,35 +0,0 @@ -container->getServicesByTag(self::FUNCTION_TAG); - } - - public function getMethodParameterOutTypeExtensions(): array - { - return $this->container->getServicesByTag(self::METHOD_TAG); - } - - public function getStaticMethodParameterOutTypeExtensions(): array - { - return $this->container->getServicesByTag(self::STATIC_METHOD_TAG); - } - -} diff --git a/src/DependencyInjection/Type/ParameterClosureThisExtensionProvider.php b/src/DependencyInjection/Type/ParameterClosureThisExtensionProvider.php deleted file mode 100644 index 9528a0a764e..00000000000 --- a/src/DependencyInjection/Type/ParameterClosureThisExtensionProvider.php +++ /dev/null @@ -1,27 +0,0 @@ - $methodCalls * @param array $returnStatementNodes * @param list $propertyAssigns + * @param ExtensionsCollection $readWritePropertiesExtensions */ public function __construct( private ClassLike $class, - private ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider, + private ExtensionsCollection $readWritePropertiesExtensions, private array $properties, private array $propertyUsages, private array $methodCalls, @@ -115,7 +117,7 @@ public function getUninitializedProperties( $originalProperties = []; $initialInitializedProperties = []; $initializedProperties = []; - $extensions = $this->readWritePropertiesExtensionProvider->getExtensions(); + $extensions = $this->readWritePropertiesExtensions->getAll(); $initializedViaExtension = []; foreach ($this->getProperties() as $property) { if ($property->isStatic()) { diff --git a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php index 63a66a1e97f..b80d61ac01a 100644 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php +++ b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php @@ -23,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface AlwaysUsedClassConstantsExtension { + public const EXTENSION_TAG = 'phpstan.constants.alwaysUsedClassConstantsExtension'; + public function isAlwaysUsed(ClassConstantReflection $constant): bool; } diff --git a/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php deleted file mode 100644 index b0c0cbfd89b..00000000000 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ -extensions ??= $this->container->getServicesByTag(AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG); - } - -} diff --git a/src/Rules/DeadCode/UnusedPrivateConstantRule.php b/src/Rules/DeadCode/UnusedPrivateConstantRule.php index 7d3e2e1e997..5eb5ab46908 100644 --- a/src/Rules/DeadCode/UnusedPrivateConstantRule.php +++ b/src/Rules/DeadCode/UnusedPrivateConstantRule.php @@ -4,9 +4,11 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassConstantsNode; -use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider; +use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\ObjectType; @@ -19,7 +21,13 @@ final class UnusedPrivateConstantRule implements Rule { - public function __construct(private AlwaysUsedClassConstantsExtensionProvider $extensionProvider) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: AlwaysUsedClassConstantsExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -47,7 +55,7 @@ public function processNode(Node $node, Scope $scope): array $constantName = $const->name->toString(); $constantReflection = $classReflection->getConstant($constantName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysUsed($constantReflection)) { continue 2; } diff --git a/src/Rules/DeadCode/UnusedPrivateMethodRule.php b/src/Rules/DeadCode/UnusedPrivateMethodRule.php index 823e2d5bc5f..2499e3dff63 100644 --- a/src/Rules/DeadCode/UnusedPrivateMethodRule.php +++ b/src/Rules/DeadCode/UnusedPrivateMethodRule.php @@ -5,10 +5,12 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassMethodsNode; use PHPStan\Reflection\MethodReflection; -use PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider; +use PHPStan\Rules\Methods\AlwaysUsedMethodExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\Constant\ConstantStringType; @@ -25,7 +27,13 @@ final class UnusedPrivateMethodRule implements Rule { - public function __construct(private AlwaysUsedMethodExtensionProvider $extensionProvider) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: AlwaysUsedMethodExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -63,7 +71,7 @@ public function processNode(Node $node, Scope $scope): array } $methodReflection = $classReflection->getNativeMethod($methodName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysUsed($methodReflection)) { continue 2; } diff --git a/src/Rules/DeadCode/UnusedPrivatePropertyRule.php b/src/Rules/DeadCode/UnusedPrivatePropertyRule.php index 9eab53b7759..fdb9973134e 100644 --- a/src/Rules/DeadCode/UnusedPrivatePropertyRule.php +++ b/src/Rules/DeadCode/UnusedPrivatePropertyRule.php @@ -4,14 +4,16 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassPropertiesNode; use PHPStan\Node\ClassPropertyNode; use PHPStan\Node\Property\PropertyRead; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\Constant\ConstantStringType; @@ -34,9 +36,11 @@ final class UnusedPrivatePropertyRule implements Rule /** * @param string[] $alwaysWrittenTags * @param string[] $alwaysReadTags + * @param ExtensionsCollection $extensions */ public function __construct( - private ReadWritePropertiesExtensionProvider $extensionProvider, + #[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)] + private ExtensionsCollection $extensions, #[AutowiredParameter(ref: '%propertyAlwaysWrittenTags%')] private array $alwaysWrittenTags, #[AutowiredParameter(ref: '%propertyAlwaysReadTags%')] @@ -99,7 +103,7 @@ public function processNode(Node $node, Scope $scope): array $propertyReflection = $classReflection->getNativeProperty($propertyName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($alwaysRead && $alwaysWritten) { break; } diff --git a/src/Rules/Methods/AlwaysUsedMethodExtension.php b/src/Rules/Methods/AlwaysUsedMethodExtension.php index 048600fd8f8..aa61d933873 100644 --- a/src/Rules/Methods/AlwaysUsedMethodExtension.php +++ b/src/Rules/Methods/AlwaysUsedMethodExtension.php @@ -20,10 +20,12 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedMethodExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface AlwaysUsedMethodExtension { + public const EXTENSION_TAG = 'phpstan.methods.alwaysUsedMethodExtension'; + public function isAlwaysUsed(ExtendedMethodReflection $methodReflection): bool; } diff --git a/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php b/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php deleted file mode 100644 index 7452a738719..00000000000 --- a/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ -extensions; - } - -} diff --git a/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php b/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php deleted file mode 100644 index 1a2b49ee389..00000000000 --- a/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php +++ /dev/null @@ -1,24 +0,0 @@ -extensions ??= $this->container->getServicesByTag(static::EXTENSION_TAG); - } - -} diff --git a/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 0130c2f6336..00000000000 --- a/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,23 +0,0 @@ -extensions; - } - -} diff --git a/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 603c685105b..00000000000 --- a/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,24 +0,0 @@ -extensions ??= $this->container->getServicesByTag(ReadWritePropertiesExtensionProvider::EXTENSION_TAG); - } - -} diff --git a/src/Rules/Properties/ReadWritePropertiesExtension.php b/src/Rules/Properties/ReadWritePropertiesExtension.php index 71fe3e89ee0..b7ef5e47b79 100644 --- a/src/Rules/Properties/ReadWritePropertiesExtension.php +++ b/src/Rules/Properties/ReadWritePropertiesExtension.php @@ -23,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: ReadWritePropertiesExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface ReadWritePropertiesExtension { + public const EXTENSION_TAG = 'phpstan.properties.readWriteExtension'; + public function isAlwaysRead(ExtendedPropertyReflection $property, string $propertyName): bool; public function isAlwaysWritten(ExtendedPropertyReflection $property, string $propertyName): bool; diff --git a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 8b519aacd32..00000000000 --- a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ - $extensions + */ public function __construct( - private ReadWritePropertiesExtensionProvider $extensionProvider, + #[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)] + private ExtensionsCollection $extensions, private TooWideTypeCheck $check, ) { @@ -52,7 +58,7 @@ public function processNode(Node $node, Scope $scope): array $propertyReflection = $classReflection->getNativeProperty($propertyName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysRead($propertyReflection, $propertyName)) { continue 2; } diff --git a/src/Testing/RuleTestCase.php b/src/Testing/RuleTestCase.php index bf2157793e3..da80ac0aeb7 100644 --- a/src/Testing/RuleTestCase.php +++ b/src/Testing/RuleTestCase.php @@ -19,10 +19,8 @@ use PHPStan\Collectors\Registry as CollectorRegistry; use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\PackageDependencyResolver; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\DependencyInjection\LazyExtensionsCollection; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; use PHPStan\File\FileHelper; use PHPStan\File\FileReader; use PHPStan\Fixable\Patcher; @@ -32,11 +30,18 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\DirectRegistry as DirectRuleRegistry; use PHPStan\Rules\IdentifierRuleError; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; use PHPStan\Rules\Properties\ReadWritePropertiesExtension; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; use PHPStan\Rules\Rule; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use function array_map; use function array_merge; use function count; @@ -101,15 +106,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterOutTypeExtension::class), $this->getParser(), self::getContainer()->getByType(FileTypeMapper::class), self::getContainer()->getByType(PhpDocInheritanceResolver::class), self::getContainer()->getByType(FileHelper::class), $typeSpecifier, - $readWritePropertiesExtensions !== [] ? new DirectReadWritePropertiesExtensionProvider($readWritePropertiesExtensions) : self::getContainer()->getByType(ReadWritePropertiesExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureThisExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureTypeExtensionProvider::class), + $readWritePropertiesExtensions !== [] ? new DirectExtensionsCollection($readWritePropertiesExtensions) : new LazyExtensionsCollection(self::getContainer(), ReadWritePropertiesExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $this->shouldPolluteScopeWithLoopInitialAssignments(), diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 7723560fd06..2d538c0c646 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -12,9 +12,7 @@ use PHPStan\Analyser\NodeScopeResolver; use PHPStan\Analyser\Scope; use PHPStan\Analyser\ScopeContext; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\SystemAgnosticSimpleRelativePathHelper; use PHPStan\Node\DeepNodeCloner; @@ -24,11 +22,20 @@ use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Reflection\ReflectionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ConstantScalarType; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\Type; use PHPStan\Type\VerbosityLevel; use Symfony\Component\Finder\Finder; @@ -74,15 +81,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), self::getParser(), $container->getByType(FileTypeMapper::class), $container->getByType(PhpDocInheritanceResolver::class), $container->getByType(FileHelper::class), $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $container->getParameter('polluteScopeWithLoopInitialAssignments'), diff --git a/src/Type/DynamicFunctionThrowTypeExtension.php b/src/Type/DynamicFunctionThrowTypeExtension.php index def41a9a4b6..f980c44e039 100644 --- a/src/Type/DynamicFunctionThrowTypeExtension.php +++ b/src/Type/DynamicFunctionThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicFunctionThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicFunctionThrowTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection): bool; public function getThrowTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, Scope $scope): ?Type; diff --git a/src/Type/DynamicMethodThrowTypeExtension.php b/src/Type/DynamicMethodThrowTypeExtension.php index 5d9fce22b61..7dd2d60b473 100644 --- a/src/Type/DynamicMethodThrowTypeExtension.php +++ b/src/Type/DynamicMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicMethodThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicMethodThrowTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection): bool; public function getThrowTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type; diff --git a/src/Type/DynamicStaticMethodThrowTypeExtension.php b/src/Type/DynamicStaticMethodThrowTypeExtension.php index 1dc3c5334fb..57e0a16d3e3 100644 --- a/src/Type/DynamicStaticMethodThrowTypeExtension.php +++ b/src/Type/DynamicStaticMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicStaticMethodThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicStaticMethodThrowTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection): bool; public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): ?Type; diff --git a/src/Type/FunctionParameterClosureThisExtension.php b/src/Type/FunctionParameterClosureThisExtension.php index 7b56a8d30fb..14f8b4a75c2 100644 --- a/src/Type/FunctionParameterClosureThisExtension.php +++ b/src/Type/FunctionParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterClosureThisExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/FunctionParameterClosureTypeExtension.php b/src/Type/FunctionParameterClosureTypeExtension.php index bffc1a191a4..71941efb498 100644 --- a/src/Type/FunctionParameterClosureTypeExtension.php +++ b/src/Type/FunctionParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterClosureTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/FunctionParameterOutTypeExtension.php b/src/Type/FunctionParameterOutTypeExtension.php index 9f7de7e0312..3284050bbfc 100644 --- a/src/Type/FunctionParameterOutTypeExtension.php +++ b/src/Type/FunctionParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterOutTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterClosureThisExtension.php b/src/Type/MethodParameterClosureThisExtension.php index ebab7d31f30..35d7474a4c5 100644 --- a/src/Type/MethodParameterClosureThisExtension.php +++ b/src/Type/MethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterClosureThisExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterClosureTypeExtension.php b/src/Type/MethodParameterClosureTypeExtension.php index 0f372bfa449..6b9da26a340 100644 --- a/src/Type/MethodParameterClosureTypeExtension.php +++ b/src/Type/MethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterClosureTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterOutTypeExtension.php b/src/Type/MethodParameterOutTypeExtension.php index e11c4b33ea5..2b138323cd5 100644 --- a/src/Type/MethodParameterOutTypeExtension.php +++ b/src/Type/MethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterOutTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/StaticMethodParameterClosureThisExtension.php b/src/Type/StaticMethodParameterClosureThisExtension.php index 78946073ac4..906ff672a5f 100644 --- a/src/Type/StaticMethodParameterClosureThisExtension.php +++ b/src/Type/StaticMethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterClosureThisExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/StaticMethodParameterClosureTypeExtension.php b/src/Type/StaticMethodParameterClosureTypeExtension.php index 341f1805d5e..0f1f012bbf7 100644 --- a/src/Type/StaticMethodParameterClosureTypeExtension.php +++ b/src/Type/StaticMethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterClosureTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/StaticMethodParameterOutTypeExtension.php b/src/Type/StaticMethodParameterOutTypeExtension.php index 73572de9bf6..2f1c7e1a91b 100644 --- a/src/Type/StaticMethodParameterOutTypeExtension.php +++ b/src/Type/StaticMethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterOutTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 5faba6271b7..1908b4f10d2 100644 --- a/tests/PHPStan/Analyser/AnalyserTest.php +++ b/tests/PHPStan/Analyser/AnalyserTest.php @@ -13,9 +13,7 @@ use PHPStan\Dependency\ExportedNodeResolver; use PHPStan\Dependency\PackageDependencyResolver; use PHPStan\DependencyInjection\DirectExtensionsCollection; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Node\DeepNodeCloner; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Node\Printer\Printer; @@ -25,9 +23,18 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\AlwaysFailRule; use PHPStan\Rules\DirectRegistry as DirectRuleRegistry; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Testing\PHPStanTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPUnit\Framework\Attributes\DataProvider; use function array_map; use function array_merge; @@ -815,15 +822,21 @@ private function createAnalyser(): Analyser $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), $this->getParser(), $fileTypeMapper, $phpDocInheritanceResolver, $fileHelper, $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), false, diff --git a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php index 0a1804341a6..f2bfd46e44b 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php @@ -6,21 +6,28 @@ use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; use PHPStan\Analyser\NodeScopeResolver; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\DirectExtensionsCollection; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Node\DeepNodeCloner; use PHPStan\PhpDoc\PhpDocInheritanceResolver; use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\IdentifierRuleError; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\VerbosityLevel; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -119,15 +126,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterOutTypeExtension::class), $this->getParser(), self::getContainer()->getByType(FileTypeMapper::class), self::getContainer()->getByType(PhpDocInheritanceResolver::class), self::getContainer()->getByType(FileHelper::class), $typeSpecifier, - $readWritePropertiesExtensions !== [] ? new DirectReadWritePropertiesExtensionProvider($readWritePropertiesExtensions) : self::getContainer()->getByType(ReadWritePropertiesExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureThisExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureTypeExtensionProvider::class), + $readWritePropertiesExtensions !== [] ? new DirectExtensionsCollection($readWritePropertiesExtensions) : new LazyExtensionsCollection(self::getContainer(), ReadWritePropertiesExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $this->shouldPolluteScopeWithLoopInitialAssignments(), diff --git a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php index ae9aa1ec4c1..3118a78df71 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php @@ -4,17 +4,24 @@ use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; use PHPStan\Analyser\NodeScopeResolver; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Node\DeepNodeCloner; use PHPStan\PhpDoc\PhpDocInheritanceResolver; use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Testing\TypeInferenceTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -52,15 +59,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), self::getParser(), $container->getByType(FileTypeMapper::class), $container->getByType(PhpDocInheritanceResolver::class), $container->getByType(FileHelper::class), $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), $container->getParameter('polluteScopeWithLoopInitialAssignments'), diff --git a/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php index 7d3246d0146..c052ad7baa3 100644 --- a/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php @@ -31,33 +31,33 @@ public function testRuleOutOfPhpStan(): void $this->analyse([__DIR__ . '/data/class-implements-out-of-phpstan.php'], [ [ - 'Implementing PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', + 'Implementing PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', 20, $tip, ], [ 'Implementing PHPStan\Type\Type is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 54, + 44, $tip, ], [ 'Implementing PHPStan\Reflection\ReflectionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 363, + 353, $tip, ], [ 'Implementing PHPStan\Analyser\Scope is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 368, + 358, $tip, ], [ 'Implementing PHPStan\Reflection\FunctionReflection is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 373, + 363, $tip, ], [ 'Implementing PHPStan\Reflection\ExtendedMethodReflection is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 377, + 367, $tip, ], ]); diff --git a/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php index ee499665b80..9f2d7bed52d 100644 --- a/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php @@ -31,7 +31,7 @@ public function testRuleOutOfPhpStan(): void $this->analyse([__DIR__ . '/data/interface-extends-out-of-phpstan.php'], [ [ - 'Extending PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', + 'Extending PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', 10, $tip, ], diff --git a/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php b/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php index a2a94181962..6e7fda63605 100644 --- a/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php @@ -4,25 +4,16 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Reflection\FunctionReflection; +use PHPStan\Reflection\ReflectionProvider; use PHPStan\Type\DynamicFunctionThrowTypeExtension; -class Foo implements DynamicThrowTypeExtensionProvider +class Foo implements ReflectionProviderProvider { - public function getDynamicFunctionThrowTypeExtensions(): array + public function getReflectionProvider(): ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. - } - - public function getDynamicMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicMethodThrowTypeExtensions() method. - } - - public function getDynamicStaticMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicStaticMethodThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } } diff --git a/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php b/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php index 44204e0f2c2..dd10070da4f 100644 --- a/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php @@ -4,7 +4,7 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Php\PhpVersion; use PHPStan\Reflection\ClassMemberAccessAnswerer; use PHPStan\Reflection\ExtendedMethodReflection; @@ -17,21 +17,11 @@ use PHPStan\Type\Type; use PHPStan\Type\VerbosityLevel; -class Foo implements DynamicThrowTypeExtensionProvider +class Foo implements ReflectionProviderProvider { - public function getDynamicFunctionThrowTypeExtensions(): array + public function getReflectionProvider(): ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. - } - - public function getDynamicMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicMethodThrowTypeExtensions() method. - } - - public function getDynamicStaticMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicStaticMethodThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } } diff --git a/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php b/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php index 1df7e6b0b36..b48b8eb83c5 100644 --- a/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php @@ -2,10 +2,10 @@ namespace PHPStan\InterfaceExtends; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Type\DynamicFunctionThrowTypeExtension; -interface Foo extends DynamicThrowTypeExtensionProvider +interface Foo extends ReflectionProviderProvider { } diff --git a/tests/PHPStan/Rules/Api/data/interface-extends-out-of-phpstan.php b/tests/PHPStan/Rules/Api/data/interface-extends-out-of-phpstan.php index c3d4b48e096..b174df315a8 100644 --- a/tests/PHPStan/Rules/Api/data/interface-extends-out-of-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/interface-extends-out-of-phpstan.php @@ -2,12 +2,12 @@ namespace App\InterfaceExtends; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Reflection\ExtendedMethodReflection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Type\DynamicFunctionThrowTypeExtension; -interface Foo extends DynamicThrowTypeExtensionProvider +interface Foo extends ReflectionProviderProvider { } diff --git a/tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php b/tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php deleted file mode 100644 index 861c72d7ab5..00000000000 --- a/tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php +++ /dev/null @@ -1,23 +0,0 @@ -extensions; - } - -} diff --git a/tests/PHPStan/Rules/DeadCode/UnusedPrivateConstantRuleTest.php b/tests/PHPStan/Rules/DeadCode/UnusedPrivateConstantRuleTest.php index 889298c3ecc..46d72f8c78a 100644 --- a/tests/PHPStan/Rules/DeadCode/UnusedPrivateConstantRuleTest.php +++ b/tests/PHPStan/Rules/DeadCode/UnusedPrivateConstantRuleTest.php @@ -2,9 +2,9 @@ namespace PHPStan\Rules\DeadCode; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Reflection\ClassConstantReflection; use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtension; -use PHPStan\Rules\Constants\DirectAlwaysUsedClassConstantsExtensionProvider; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -19,7 +19,7 @@ class UnusedPrivateConstantRuleTest extends RuleTestCase protected function getRule(): Rule { return new UnusedPrivateConstantRule( - new DirectAlwaysUsedClassConstantsExtensionProvider([ + new DirectExtensionsCollection([ new class() implements AlwaysUsedClassConstantsExtension { public function isAlwaysUsed(ClassConstantReflection $constant): bool diff --git a/tests/PHPStan/Rules/DeadCode/UnusedPrivateMethodRuleTest.php b/tests/PHPStan/Rules/DeadCode/UnusedPrivateMethodRuleTest.php index 9a2cf7c2074..f57d00b9e5f 100644 --- a/tests/PHPStan/Rules/DeadCode/UnusedPrivateMethodRuleTest.php +++ b/tests/PHPStan/Rules/DeadCode/UnusedPrivateMethodRuleTest.php @@ -2,9 +2,9 @@ namespace PHPStan\Rules\DeadCode; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Reflection\MethodReflection; use PHPStan\Rules\Methods\AlwaysUsedMethodExtension; -use PHPStan\Rules\Methods\DirectAlwaysUsedMethodExtensionProvider; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -18,7 +18,7 @@ class UnusedPrivateMethodRuleTest extends RuleTestCase protected function getRule(): Rule { return new UnusedPrivateMethodRule( - new DirectAlwaysUsedMethodExtensionProvider([ + new DirectExtensionsCollection([ new class() implements AlwaysUsedMethodExtension { public function isAlwaysUsed(MethodReflection $methodReflection): bool diff --git a/tests/PHPStan/Rules/DeadCode/UnusedPrivatePropertyRuleTest.php b/tests/PHPStan/Rules/DeadCode/UnusedPrivatePropertyRuleTest.php index e749b4939a9..d724318377a 100644 --- a/tests/PHPStan/Rules/DeadCode/UnusedPrivatePropertyRuleTest.php +++ b/tests/PHPStan/Rules/DeadCode/UnusedPrivatePropertyRuleTest.php @@ -2,8 +2,8 @@ namespace PHPStan\Rules\DeadCode; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Reflection\PropertyReflection; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -27,7 +27,7 @@ class UnusedPrivatePropertyRuleTest extends RuleTestCase protected function getRule(): Rule { return new UnusedPrivatePropertyRule( - new DirectReadWritePropertiesExtensionProvider([ + new DirectExtensionsCollection([ new class() implements ReadWritePropertiesExtension { public function isAlwaysRead(PropertyReflection $property, string $propertyName): bool diff --git a/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php b/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php index 4e95d632c3a..ee62bdef57c 100644 --- a/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php +++ b/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php @@ -2,7 +2,7 @@ namespace PHPStan\Rules\TooWideTypehints; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -21,7 +21,7 @@ class TooWidePropertyTypeRuleTest extends RuleTestCase protected function getRule(): Rule { return new TooWidePropertyTypeRule( - new DirectReadWritePropertiesExtensionProvider([]), + new DirectExtensionsCollection([]), new TooWideTypeCheck(new PropertyReflectionFinder(), $this->reportTooWideBool, $this->reportNestedTooWideType), ); } From c1f6ee5767e5aae2680fac0aa10184ac4af81567 Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 22:12:12 +0100 Subject: [PATCH 3/4] Take extensions through ExtensionsCollection instead of the container Rules, checks and factories that held a Container only to call getServicesByTag() now declare what they need with #[AutowiredExtensions], which also drops their per-class memo fields and the tag constants from their bodies. 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(). #[AutowiredExtensions] arguments are only set on definitions that instantiate the class themselves - an alias like TestCase.neon's currentPhpVersionSimpleParser delegates to another service's creator, where the extra argument would become an unknown named parameter. Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01XLPJxFJDzLPsieqEwJKpkn --- phpstan-baseline.neon | 4 +- src/Analyser/ExprHandlerRegistry.php | 3 +- .../ResultCache/ResultCacheManager.php | 10 ++- src/Analyser/TypeSpecifierFactory.php | 25 +++--- src/Collectors/RegistryFactory.php | 14 +++- src/Command/AnalyseCommand.php | 2 +- src/Command/DiagnoseCommand.php | 2 +- .../AutowiredAttributeServicesExtension.php | 9 +++ src/Parser/RichParser.php | 12 ++- src/PhpDoc/DefaultStubFilesProvider.php | 10 ++- src/Reflection/ConstructorsHelper.php | 11 +-- .../Deprecation/DeprecationProvider.php | 76 ++++++++----------- src/Rules/ClassForbiddenNameCheck.php | 13 +++- src/Rules/ClassNameCheck.php | 15 ++-- src/Rules/Classes/InstantiationRule.php | 15 ++-- src/Rules/LazyRegistry.php | 31 +++++--- src/Rules/Playground/PromoteParameterRule.php | 3 +- .../RestrictedClassConstantUsageRule.php | 15 ++-- .../RestrictedFunctionCallableUsageRule.php | 15 ++-- .../RestrictedFunctionUsageRule.php | 15 ++-- .../RestrictedMethodCallableUsageRule.php | 15 ++-- .../RestrictedMethodUsageRule.php | 15 ++-- .../RestrictedPropertyUsageRule.php | 15 ++-- ...estrictedStaticMethodCallableUsageRule.php | 15 ++-- .../RestrictedStaticMethodUsageRule.php | 15 ++-- .../RestrictedStaticPropertyUsageRule.php | 15 ++-- ...trictedUsageOfDeprecatedStringCastRule.php | 15 ++-- tests/PHPStan/Analyser/AnalyserTest.php | 3 +- .../PhpDoc/DefaultStubFilesProviderTest.php | 3 +- .../Rules/Classes/ClassAttributesRuleTest.php | 7 +- .../ClassConstantAttributesRuleTest.php | 7 +- .../Rules/Classes/ClassConstantRuleTest.php | 7 +- .../ExistingClassInClassExtendsRuleTest.php | 7 +- .../ExistingClassInInstanceOfRuleTest.php | 7 +- .../ExistingClassInTraitUseRuleTest.php | 7 +- ...istingClassesInClassImplementsRuleTest.php | 7 +- ...xistingClassesInEnumImplementsRuleTest.php | 7 +- ...stingClassesInInterfaceExtendsRuleTest.php | 7 +- .../ForbiddenNameCheckExtensionRuleTest.php | 10 ++- .../Rules/Classes/InstantiationRuleTest.php | 10 ++- .../Classes/LocalTypeAliasesRuleTest.php | 7 +- .../Classes/LocalTypeTraitAliasesRuleTest.php | 7 +- .../LocalTypeTraitUseAliasesRuleTest.php | 7 +- .../Rules/Classes/MethodTagRuleTest.php | 7 +- .../Rules/Classes/MethodTagTraitRuleTest.php | 7 +- .../Classes/MethodTagTraitUseRuleTest.php | 7 +- tests/PHPStan/Rules/Classes/MixinRuleTest.php | 7 +- .../Rules/Classes/MixinTraitRuleTest.php | 7 +- .../Rules/Classes/MixinTraitUseRuleTest.php | 7 +- .../Rules/Classes/PropertyTagRuleTest.php | 7 +- .../Classes/PropertyTagTraitRuleTest.php | 7 +- .../Classes/PropertyTagTraitUseRuleTest.php | 7 +- .../Constants/ConstantAttributesRuleTest.php | 7 +- .../EnumCases/EnumCaseAttributesRuleTest.php | 7 +- .../CaughtExceptionExistenceRuleTest.php | 7 +- .../ArrowFunctionAttributesRuleTest.php | 7 +- .../Functions/ClosureAttributesRuleTest.php | 7 +- ...lassesInArrowFunctionTypehintsRuleTest.php | 7 +- ...stingClassesInClosureTypehintsRuleTest.php | 7 +- .../ExistingClassesInTypehintsRuleTest.php | 7 +- .../Functions/FunctionAttributesRuleTest.php | 7 +- .../Functions/ParamAttributesRuleTest.php | 7 +- .../Generics/ClassTemplateTypeRuleTest.php | 7 +- .../Generics/FunctionTemplateTypeRuleTest.php | 7 +- .../InterfaceTemplateTypeRuleTest.php | 7 +- .../MethodTagTemplateTypeRuleTest.php | 7 +- .../MethodTagTemplateTypeTraitRuleTest.php | 7 +- .../Generics/MethodTemplateTypeRuleTest.php | 7 +- .../Generics/TraitTemplateTypeRuleTest.php | 7 +- .../Methods/CallStaticMethodsRuleTest.php | 7 +- .../ExistingClassesInTypehintsRuleTest.php | 7 +- .../Methods/MethodAttributesRuleTest.php | 7 +- .../Methods/StaticMethodCallableRuleTest.php | 7 +- .../ExistingNamesInGroupUseRuleTest.php | 7 +- .../Namespaces/ExistingNamesInUseRuleTest.php | 7 +- .../Rules/PhpDoc/FunctionAssertRuleTest.php | 7 +- .../PhpDoc/IncompatiblePhpDocTypeRuleTest.php | 7 +- ...mpatiblePropertyHookPhpDocTypeRuleTest.php | 7 +- ...IncompatiblePropertyPhpDocTypeRuleTest.php | 7 +- .../InvalidPhpDocVarTagTypeRuleTest.php | 7 +- .../Rules/PhpDoc/MethodAssertRuleTest.php | 7 +- .../RequireExtendsDefinitionClassRuleTest.php | 7 +- .../RequireExtendsDefinitionTraitRuleTest.php | 7 +- ...quireImplementsDefinitionTraitRuleTest.php | 7 +- .../PhpDoc/SealedDefinitionClassRuleTest.php | 7 +- .../Playground/PromoteParameterRuleTest.php | 4 +- ...AccessStaticPropertiesInAssignRuleTest.php | 7 +- .../AccessStaticPropertiesRuleTest.php | 7 +- .../ExistingClassesInPropertiesRuleTest.php | 7 +- ...ClassesInPropertyHookTypehintsRuleTest.php | 7 +- ...ReadOnlyByPhpDocPropertyAssignRuleTest.php | 4 +- .../MissingReadOnlyPropertyAssignRuleTest.php | 4 +- .../Properties/PropertyAttributesRuleTest.php | 7 +- .../PropertyHookAttributesRuleTest.php | 7 +- ...ReadOnlyByPhpDocPropertyAssignRuleTest.php | 4 +- .../ReadOnlyPropertyAssignRuleTest.php | 4 +- .../UninitializedPropertyRuleTest.php | 4 +- .../RestrictedClassConstantUsageRuleTest.php | 3 +- ...estrictedFunctionCallableUsageRuleTest.php | 3 +- .../RestrictedFunctionUsageRuleTest.php | 3 +- .../RestrictedMethodCallableUsageRuleTest.php | 3 +- .../RestrictedMethodUsageRuleTest.php | 3 +- .../RestrictedPropertyUsageRuleTest.php | 3 +- ...ictedStaticMethodCallableUsageRuleTest.php | 3 +- .../RestrictedStaticMethodUsageRuleTest.php | 3 +- .../RestrictedStaticPropertyUsageRuleTest.php | 3 +- ...tedUsageOfDeprecatedStringCastRuleTest.php | 3 +- .../Rules/Traits/TraitAttributesRuleTest.php | 7 +- 108 files changed, 587 insertions(+), 325 deletions(-) diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon index 246d46dee0d..32412e894e7 100644 --- a/phpstan-baseline.neon +++ b/phpstan-baseline.neon @@ -688,7 +688,7 @@ parameters: path: src/Rules/LazyRegistry.php - - rawMessage: 'Method PHPStan\Rules\LazyRegistry::getRulesFromContainer() return type with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' + rawMessage: 'Method PHPStan\Rules\LazyRegistry::getRulesByNodeType() return type with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' identifier: missingType.generics count: 1 path: src/Rules/LazyRegistry.php @@ -700,7 +700,7 @@ parameters: path: src/Rules/LazyRegistry.php - - rawMessage: 'Property PHPStan\Rules\LazyRegistry::$rules with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' + rawMessage: 'Property PHPStan\Rules\LazyRegistry::$rulesByNodeType with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' identifier: missingType.generics count: 1 path: src/Rules/LazyRegistry.php diff --git a/src/Analyser/ExprHandlerRegistry.php b/src/Analyser/ExprHandlerRegistry.php index 95d74897719..a0a53afcb9b 100644 --- a/src/Analyser/ExprHandlerRegistry.php +++ b/src/Analyser/ExprHandlerRegistry.php @@ -41,8 +41,7 @@ public static function resolve(Expr $expr, Container $container): ?ExprHandler } $matchedHandler = null; - /** @var ExprHandler $exprHandler */ - foreach ($container->getServicesByTag(ExprHandler::EXTENSION_TAG) as $exprHandler) { + foreach ($container->getExtensions(ExprHandler::class) as $exprHandler) { if (!$exprHandler->supports($expr)) { continue; } diff --git a/src/Analyser/ResultCache/ResultCacheManager.php b/src/Analyser/ResultCache/ResultCacheManager.php index b603780145a..b2509e7cc7c 100644 --- a/src/Analyser/ResultCache/ResultCacheManager.php +++ b/src/Analyser/ResultCache/ResultCacheManager.php @@ -12,8 +12,9 @@ use PHPStan\Dependency\ExportedNodeFetcher; use PHPStan\Dependency\PackageDependencyResolver; use PHPStan\Dependency\RootExportedNode; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\GenerateFactory; use PHPStan\DependencyInjection\ProjectConfigHelper; use PHPStan\File\CouldNotReadFileException; @@ -84,9 +85,11 @@ final class ResultCacheManager * @param string[] $scanDirectories * @param list> $parametersNotInvalidatingCache * @param array $fileReplacements + * @param ExtensionsCollection $resultCacheMetaExtensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: ResultCacheMetaExtension::class)] + private ExtensionsCollection $resultCacheMetaExtensions, private ExportedNodeFetcher $exportedNodeFetcher, #[AutowiredParameter(ref: '@fileFinderScan')] private FileFinder $scanFileFinder, @@ -1539,8 +1542,7 @@ private function getMetaFromPhpStanExtensions(): array { $meta = []; - /** @var ResultCacheMetaExtension $extension */ - foreach ($this->container->getServicesByTag(ResultCacheMetaExtension::EXTENSION_TAG) as $extension) { + foreach ($this->resultCacheMetaExtensions->getAll() as $extension) { if (array_key_exists($extension->getKey(), $meta)) { throw new ShouldNotHappenException(sprintf( 'Duplicate ResultCacheMetaExtension with key "%s" found.', diff --git a/src/Analyser/TypeSpecifierFactory.php b/src/Analyser/TypeSpecifierFactory.php index 64d1a652afb..61cb065a736 100644 --- a/src/Analyser/TypeSpecifierFactory.php +++ b/src/Analyser/TypeSpecifierFactory.php @@ -2,11 +2,18 @@ namespace PHPStan\Analyser; -use PHPStan\Broker\BrokerFactory; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; use PHPStan\Node\Printer\ExprPrinter; +use PHPStan\Reflection\MethodsClassReflectionExtension; +use PHPStan\Reflection\PropertiesClassReflectionExtension; use PHPStan\Reflection\ReflectionProvider; +use PHPStan\Type\DynamicFunctionReturnTypeExtension; +use PHPStan\Type\DynamicMethodReturnTypeExtension; +use PHPStan\Type\DynamicStaticMethodReturnTypeExtension; +use PHPStan\Type\FunctionTypeSpecifyingExtension; +use PHPStan\Type\MethodTypeSpecifyingExtension; +use PHPStan\Type\StaticMethodTypeSpecifyingExtension; use function array_merge; #[AutowiredService(name: 'typeSpecifierFactory')] @@ -23,9 +30,9 @@ public function __construct(private Container $container) public function create(): TypeSpecifier { - $functionTypeSpecifying = $this->container->getServicesByTag(self::FUNCTION_TYPE_SPECIFYING_EXTENSION_TAG); - $methodTypeSpecifying = $this->container->getServicesByTag(self::METHOD_TYPE_SPECIFYING_EXTENSION_TAG); - $staticMethodTypeSpecifying = $this->container->getServicesByTag(self::STATIC_METHOD_TYPE_SPECIFYING_EXTENSION_TAG); + $functionTypeSpecifying = $this->container->getExtensions(FunctionTypeSpecifyingExtension::class); + $methodTypeSpecifying = $this->container->getExtensions(MethodTypeSpecifyingExtension::class); + $staticMethodTypeSpecifying = $this->container->getExtensions(StaticMethodTypeSpecifyingExtension::class); $typeSpecifier = new TypeSpecifier( $this->container->getByType(ExprPrinter::class), @@ -38,11 +45,11 @@ public function create(): TypeSpecifier ); foreach (array_merge( - $this->container->getServicesByTag(BrokerFactory::PROPERTIES_CLASS_REFLECTION_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::METHODS_CLASS_REFLECTION_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_STATIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_FUNCTION_RETURN_TYPE_EXTENSION_TAG), + $this->container->getExtensions(PropertiesClassReflectionExtension::class), + $this->container->getExtensions(MethodsClassReflectionExtension::class), + $this->container->getExtensions(DynamicMethodReturnTypeExtension::class), + $this->container->getExtensions(DynamicStaticMethodReturnTypeExtension::class), + $this->container->getExtensions(DynamicFunctionReturnTypeExtension::class), $functionTypeSpecifying, $methodTypeSpecifying, $staticMethodTypeSpecifying, diff --git a/src/Collectors/RegistryFactory.php b/src/Collectors/RegistryFactory.php index a95dbe2a51d..8db4740c48a 100644 --- a/src/Collectors/RegistryFactory.php +++ b/src/Collectors/RegistryFactory.php @@ -2,8 +2,10 @@ namespace PHPStan\Collectors; +use PhpParser\Node; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; #[AutowiredService] final class RegistryFactory @@ -11,14 +13,20 @@ final class RegistryFactory public const COLLECTOR_TAG = 'phpstan.collector'; - public function __construct(private Container $container) + /** + * @param ExtensionsCollection> $collectors + */ + public function __construct( + #[AutowiredExtensions(interface: Collector::class)] + private ExtensionsCollection $collectors, + ) { } public function create(): Registry { return new Registry( - $this->container->getServicesByTag(self::COLLECTOR_TAG), + $this->collectors->getAll(), ); } diff --git a/src/Command/AnalyseCommand.php b/src/Command/AnalyseCommand.php index 5b3be09c6b5..7eb0890a438 100644 --- a/src/Command/AnalyseCommand.php +++ b/src/Command/AnalyseCommand.php @@ -880,7 +880,7 @@ private function runDiagnoseExtensions(Container $container, Output $errorOutput $phpstanDiagnoseExtension->print($errorOutput, $processedFiles); /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($errorOutput); } } diff --git a/src/Command/DiagnoseCommand.php b/src/Command/DiagnoseCommand.php index 371bfcfa1aa..4d1950b57ea 100644 --- a/src/Command/DiagnoseCommand.php +++ b/src/Command/DiagnoseCommand.php @@ -102,7 +102,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int $phpstanDiagnoseExtension->print($output, []); /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($output); } diff --git a/src/DependencyInjection/AutowiredAttributeServicesExtension.php b/src/DependencyInjection/AutowiredAttributeServicesExtension.php index 49f5d1e1e7d..15da3a3876f 100644 --- a/src/DependencyInjection/AutowiredAttributeServicesExtension.php +++ b/src/DependencyInjection/AutowiredAttributeServicesExtension.php @@ -22,6 +22,7 @@ use function array_key_exists; use function count; use function explode; +use function is_string; use function strcasecmp; use function strtolower; use function substr; @@ -194,6 +195,14 @@ public function beforeCompile(): void continue; } + // Only definitions that instantiate the class themselves take its constructor + // arguments. Aliases (factory: @otherService) and static factories delegate + // elsewhere and would turn the argument into an unknown named parameter. + $entity = $definition->getCreator()->getEntity(); + if (!is_string($entity) || strcasecmp($entity, $className) !== 0) { + continue; + } + foreach ($constructorParameters[strtolower($className)] ?? [] as $parameter) { $interface = $parameter->attribute->interface; if (!array_key_exists($interface, $mapping)) { diff --git a/src/Parser/RichParser.php b/src/Parser/RichParser.php index d23ecb227aa..0e4c33717f8 100644 --- a/src/Parser/RichParser.php +++ b/src/Parser/RichParser.php @@ -5,12 +5,14 @@ use PhpParser\ErrorHandler\Collecting; use PhpParser\Node; use PhpParser\NodeTraverser; +use PhpParser\NodeVisitor; use PhpParser\NodeVisitor\NameResolver; use PhpParser\Token; use PHPStan\Analyser\FileAnalyserResult; use PHPStan\Analyser\Ignore\IgnoreLexer; use PHPStan\Analyser\Ignore\IgnoreParseException; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileReader; use PHPStan\ShouldNotHappenException; use function array_filter; @@ -44,10 +46,14 @@ final class RichParser implements Parser private const PHPDOC_DOCTRINE_TAG_REGEX = '(@[a-z_\\\\][a-z0-9_\:\\\\]*[a-z_][a-z0-9_]*)'; + /** + * @param ExtensionsCollection $visitors + */ public function __construct( private \PhpParser\Parser $parser, private NameResolver $nameResolver, - private Container $container, + #[AutowiredExtensions(interface: NodeVisitor::class)] + private ExtensionsCollection $visitors, private IgnoreLexer $ignoreLexer, ) { @@ -92,7 +98,7 @@ public function parseString(string $sourceCode): array $traitCollectingVisitor = new TraitCollectingVisitor(); $nodeTraverser->addVisitor($traitCollectingVisitor); - foreach ($this->container->getServicesByTag(self::VISITOR_SERVICE_TAG) as $visitor) { + foreach ($this->visitors->getAll() as $visitor) { $nodeTraverser->addVisitor($visitor); } diff --git a/src/PhpDoc/DefaultStubFilesProvider.php b/src/PhpDoc/DefaultStubFilesProvider.php index 6b9edcdadbb..7e6bda8b4b9 100644 --- a/src/PhpDoc/DefaultStubFilesProvider.php +++ b/src/PhpDoc/DefaultStubFilesProvider.php @@ -2,9 +2,10 @@ namespace PHPStan\PhpDoc; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Internal\ComposerHelper; use function array_filter; @@ -27,9 +28,11 @@ final class DefaultStubFilesProvider implements StubFilesProvider /** * @param string[] $stubFiles * @param string[] $composerAutoloaderProjectPaths + * @param ExtensionsCollection $extensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: StubFilesExtension::class)] + private ExtensionsCollection $extensions, private FileHelper $fileHelper, #[AutowiredParameter] private array $stubFiles, @@ -46,8 +49,7 @@ public function getStubFiles(): array } $files = array_map(fn ($path) => $this->fileHelper->normalizePath($path), $this->stubFiles); - $extensions = $this->container->getServicesByTag(StubFilesExtension::EXTENSION_TAG); - foreach ($extensions as $extension) { + foreach ($this->extensions->getAll() as $extension) { foreach ($extension->getFiles() as $extensionFile) { $files[] = $this->fileHelper->normalizePath($extensionFile); } diff --git a/src/Reflection/ConstructorsHelper.php b/src/Reflection/ConstructorsHelper.php index fc38d722982..0a946d2656c 100644 --- a/src/Reflection/ConstructorsHelper.php +++ b/src/Reflection/ConstructorsHelper.php @@ -2,9 +2,10 @@ namespace PHPStan\Reflection; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use ReflectionException; use function array_key_exists; use function explode; @@ -18,9 +19,11 @@ final class ConstructorsHelper /** * @param list $additionalConstructors + * @param ExtensionsCollection $extensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: AdditionalConstructorsExtension::class)] + private ExtensionsCollection $extensions, #[AutowiredParameter] private array $additionalConstructors, ) @@ -40,9 +43,7 @@ public function getConstructors(ClassReflection $classReflection): array $constructors[] = $classReflection->getConstructor()->getName(); } - /** @var AdditionalConstructorsExtension[] $extensions */ - $extensions = $this->container->getServicesByTag(AdditionalConstructorsExtension::EXTENSION_TAG); - foreach ($extensions as $extension) { + foreach ($this->extensions->getAll() as $extension) { $extensionConstructors = $extension->getAdditionalConstructors($classReflection); foreach ($extensionConstructors as $extensionConstructor) { $constructors[] = $extensionConstructor; diff --git a/src/Reflection/Deprecation/DeprecationProvider.php b/src/Reflection/Deprecation/DeprecationProvider.php index ebd25cde0db..5f2f1d16d9b 100644 --- a/src/Reflection/Deprecation/DeprecationProvider.php +++ b/src/Reflection/Deprecation/DeprecationProvider.php @@ -11,45 +11,45 @@ use PHPStan\BetterReflection\Reflection\Adapter\ReflectionMethod; use PHPStan\BetterReflection\Reflection\Adapter\ReflectionProperty; use PHPStan\BetterReflection\Reflection\ReflectionConstant; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; #[AutowiredService] final class DeprecationProvider { - /** @var ?array $propertyDeprecationExtensions */ - private ?array $propertyDeprecationExtensions = null; - - /** @var ?array $methodDeprecationExtensions */ - private ?array $methodDeprecationExtensions = null; - - /** @var ?array $classConstantDeprecationExtensions */ - private ?array $classConstantDeprecationExtensions = null; - - /** @var ?array $classDeprecationExtensions */ - private ?array $classDeprecationExtensions = null; - - /** @var ?array $functionDeprecationExtensions */ - private ?array $functionDeprecationExtensions = null; - - /** @var ?array $constantDeprecationExtensions */ - private ?array $constantDeprecationExtensions = null; - - /** @var ?array $enumCaseDeprecationExtensions */ - private ?array $enumCaseDeprecationExtensions = null; - + /** + * @param ExtensionsCollection $propertyDeprecationExtensions + * @param ExtensionsCollection $methodDeprecationExtensions + * @param ExtensionsCollection $classConstantDeprecationExtensions + * @param ExtensionsCollection $classDeprecationExtensions + * @param ExtensionsCollection $functionDeprecationExtensions + * @param ExtensionsCollection $constantDeprecationExtensions + * @param ExtensionsCollection $enumCaseDeprecationExtensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: PropertyDeprecationExtension::class)] + private ExtensionsCollection $propertyDeprecationExtensions, + #[AutowiredExtensions(interface: MethodDeprecationExtension::class)] + private ExtensionsCollection $methodDeprecationExtensions, + #[AutowiredExtensions(interface: ClassConstantDeprecationExtension::class)] + private ExtensionsCollection $classConstantDeprecationExtensions, + #[AutowiredExtensions(interface: ClassDeprecationExtension::class)] + private ExtensionsCollection $classDeprecationExtensions, + #[AutowiredExtensions(interface: FunctionDeprecationExtension::class)] + private ExtensionsCollection $functionDeprecationExtensions, + #[AutowiredExtensions(interface: ConstantDeprecationExtension::class)] + private ExtensionsCollection $constantDeprecationExtensions, + #[AutowiredExtensions(interface: EnumCaseDeprecationExtension::class)] + private ExtensionsCollection $enumCaseDeprecationExtensions, ) { } public function getPropertyDeprecation(ReflectionProperty $reflectionProperty): ?Deprecation { - $this->propertyDeprecationExtensions ??= $this->container->getServicesByTag(PropertyDeprecationExtension::PROPERTY_EXTENSION_TAG); - - foreach ($this->propertyDeprecationExtensions as $extension) { + foreach ($this->propertyDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getPropertyDeprecation($reflectionProperty); if ($deprecation !== null) { return $deprecation; @@ -61,9 +61,7 @@ public function getPropertyDeprecation(ReflectionProperty $reflectionProperty): public function getMethodDeprecation(ReflectionMethod $methodReflection): ?Deprecation { - $this->methodDeprecationExtensions ??= $this->container->getServicesByTag(MethodDeprecationExtension::METHOD_EXTENSION_TAG); - - foreach ($this->methodDeprecationExtensions as $extension) { + foreach ($this->methodDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getMethodDeprecation($methodReflection); if ($deprecation !== null) { return $deprecation; @@ -75,9 +73,7 @@ public function getMethodDeprecation(ReflectionMethod $methodReflection): ?Depre public function getClassConstantDeprecation(ReflectionClassConstant $reflectionConstant): ?Deprecation { - $this->classConstantDeprecationExtensions ??= $this->container->getServicesByTag(ClassConstantDeprecationExtension::CLASS_CONSTANT_EXTENSION_TAG); - - foreach ($this->classConstantDeprecationExtensions as $extension) { + foreach ($this->classConstantDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getClassConstantDeprecation($reflectionConstant); if ($deprecation !== null) { return $deprecation; @@ -89,9 +85,7 @@ public function getClassConstantDeprecation(ReflectionClassConstant $reflectionC public function getClassDeprecation(ReflectionClass|ReflectionEnum $reflection): ?Deprecation { - $this->classDeprecationExtensions ??= $this->container->getServicesByTag(ClassDeprecationExtension::CLASS_EXTENSION_TAG); - - foreach ($this->classDeprecationExtensions as $extension) { + foreach ($this->classDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getClassDeprecation($reflection); if ($deprecation !== null) { return $deprecation; @@ -103,9 +97,7 @@ public function getClassDeprecation(ReflectionClass|ReflectionEnum $reflection): public function getFunctionDeprecation(ReflectionFunction $reflectionFunction): ?Deprecation { - $this->functionDeprecationExtensions ??= $this->container->getServicesByTag(FunctionDeprecationExtension::FUNCTION_EXTENSION_TAG); - - foreach ($this->functionDeprecationExtensions as $extension) { + foreach ($this->functionDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getFunctionDeprecation($reflectionFunction); if ($deprecation !== null) { return $deprecation; @@ -117,9 +109,7 @@ public function getFunctionDeprecation(ReflectionFunction $reflectionFunction): public function getConstantDeprecation(ReflectionConstant $constantReflection): ?Deprecation { - $this->constantDeprecationExtensions ??= $this->container->getServicesByTag(ConstantDeprecationExtension::CONSTANT_EXTENSION_TAG); - - foreach ($this->constantDeprecationExtensions as $extension) { + foreach ($this->constantDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getConstantDeprecation($constantReflection); if ($deprecation !== null) { return $deprecation; @@ -131,9 +121,7 @@ public function getConstantDeprecation(ReflectionConstant $constantReflection): public function getEnumCaseDeprecation(ReflectionEnumUnitCase|ReflectionEnumBackedCase $enumCaseReflection): ?Deprecation { - $this->enumCaseDeprecationExtensions ??= $this->container->getServicesByTag(EnumCaseDeprecationExtension::ENUM_CASE_EXTENSION_TAG); - - foreach ($this->enumCaseDeprecationExtensions as $extension) { + foreach ($this->enumCaseDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getEnumCaseDeprecation($enumCaseReflection); if ($deprecation !== null) { return $deprecation; diff --git a/src/Rules/ClassForbiddenNameCheck.php b/src/Rules/ClassForbiddenNameCheck.php index 70249cc6660..cf3d900a23e 100644 --- a/src/Rules/ClassForbiddenNameCheck.php +++ b/src/Rules/ClassForbiddenNameCheck.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_map; use function array_merge; use function sprintf; @@ -25,7 +26,13 @@ final class ClassForbiddenNameCheck 'Box' => '_HumbugBox', ]; - public function __construct(private Container $container) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: ForbiddenClassNameExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -35,7 +42,7 @@ public function __construct(private Container $container) */ public function checkClassNames(array $pairs): array { - $extensions = $this->container->getServicesByTag(ForbiddenClassNameExtension::EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $classPrefixes = array_merge( self::INTERNAL_CLASS_PREFIXES, diff --git a/src/Rules/ClassNameCheck.php b/src/Rules/ClassNameCheck.php index 025996acd99..9c05c805d4c 100644 --- a/src/Rules/ClassNameCheck.php +++ b/src/Rules/ClassNameCheck.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; @@ -12,14 +13,15 @@ final class ClassNameCheck { - /** @var RestrictedClassNameUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( private ClassCaseSensitivityCheck $classCaseSensitivityCheck, private ClassForbiddenNameCheck $classForbiddenNameCheck, private ReflectionProvider $reflectionProvider, - private Container $container, + #[AutowiredExtensions(interface: RestrictedClassNameUsageExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -50,8 +52,7 @@ public function checkClassNames( return $errors; } - /** @var RestrictedClassNameUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedClassNameUsageExtension::CLASS_NAME_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return $errors; } diff --git a/src/Rules/Classes/InstantiationRule.php b/src/Rules/Classes/InstantiationRule.php index 3719adb7282..dcb831ff3c0 100644 --- a/src/Rules/Classes/InstantiationRule.php +++ b/src/Rules/Classes/InstantiationRule.php @@ -7,8 +7,9 @@ use PHPStan\Analyser\CollectedDataEmitter; use PHPStan\Analyser\NodeCallbackInvoker; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Internal\SprintfHelper; use PHPStan\Reflection\ClassReflection; @@ -47,11 +48,12 @@ final class InstantiationRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private FunctionCallParametersCheck $check, private ClassNameCheck $classCheck, @@ -268,8 +270,7 @@ private function checkClassName(string $class, bool $isName, Node $node, Scope&N ->build(); } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); foreach ($extensions as $extension) { $restrictedUsage = $extension->isRestrictedMethodUsage($constructorReflection, $scope); diff --git a/src/Rules/LazyRegistry.php b/src/Rules/LazyRegistry.php index 4a55509947b..1c1fc26e8c1 100644 --- a/src/Rules/LazyRegistry.php +++ b/src/Rules/LazyRegistry.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PhpParser\Node; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use function class_implements; use function class_parents; @@ -15,12 +16,18 @@ final class LazyRegistry implements Registry public const RULE_TAG = 'phpstan.rules.rule'; /** @var Rule[][]|null */ - private ?array $rules = null; + private ?array $rulesByNodeType = null; /** @var Rule[][] */ private array $cache = []; - public function __construct(private Container $container) + /** + * @param ExtensionsCollection> $rules + */ + public function __construct( + #[AutowiredExtensions(interface: Rule::class)] + private ExtensionsCollection $rules, + ) { } @@ -35,9 +42,9 @@ public function getRules(string $nodeType): array $parentNodeTypes = [$nodeType] + class_parents($nodeType) + class_implements($nodeType); $rules = []; - $rulesFromContainer = $this->getRulesFromContainer(); + $rulesByNodeType = $this->getRulesByNodeType(); foreach ($parentNodeTypes as $parentNodeType) { - foreach ($rulesFromContainer[$parentNodeType] ?? [] as $rule) { + foreach ($rulesByNodeType[$parentNodeType] ?? [] as $rule) { $rules[] = $rule; } } @@ -56,18 +63,18 @@ public function getRules(string $nodeType): array /** * @return Rule[][] */ - private function getRulesFromContainer(): array + private function getRulesByNodeType(): array { - if ($this->rules !== null) { - return $this->rules; + if ($this->rulesByNodeType !== null) { + return $this->rulesByNodeType; } - $rules = []; - foreach ($this->container->getServicesByTag(self::RULE_TAG) as $rule) { - $rules[$rule->getNodeType()][] = $rule; + $rulesByNodeType = []; + foreach ($this->rules->getAll() as $rule) { + $rulesByNodeType[$rule->getNodeType()][] = $rule; } - return $this->rules = $rules; + return $this->rulesByNodeType = $rulesByNodeType; } } diff --git a/src/Rules/Playground/PromoteParameterRule.php b/src/Rules/Playground/PromoteParameterRule.php index d01b77c530e..bd9a97e862d 100644 --- a/src/Rules/Playground/PromoteParameterRule.php +++ b/src/Rules/Playground/PromoteParameterRule.php @@ -9,7 +9,6 @@ use PHPStan\DependencyInjection\Container; use PHPStan\DependencyInjection\MissingServiceException; use PHPStan\Rules\FixableNodeRuleError; -use PHPStan\Rules\LazyRegistry; use PHPStan\Rules\LineRuleError; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -63,7 +62,7 @@ private function getOriginalRule(): ?Rule try { /** @var Rule $originalRule */ $originalRule = $this->container->getByType(get_class($this->rule)); - $taggedRules = $this->container->getServicesByTag(LazyRegistry::RULE_TAG); + $taggedRules = $this->container->getExtensions(Rule::class); $found = false; foreach ($taggedRules as $rule) { if ($originalRule !== $rule) { diff --git a/src/Rules/RestrictedUsage/RestrictedClassConstantUsageRule.php b/src/Rules/RestrictedUsage/RestrictedClassConstantUsageRule.php index e3271dde86b..2669910aca6 100644 --- a/src/Rules/RestrictedUsage/RestrictedClassConstantUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedClassConstantUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -22,11 +23,12 @@ final class RestrictedClassConstantUsageRule implements Rule { - /** @var RestrictedClassConstantUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedClassConstantUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedClassConstantUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedClassConstantUsageExtension::CLASS_CONSTANT_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php index 944f7f2a3d2..74010863703 100644 --- a/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\FunctionCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -19,11 +20,12 @@ final class RestrictedFunctionCallableUsageRule implements Rule { - /** @var RestrictedFunctionUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedFunctionUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -49,8 +51,7 @@ public function processNode(Node $node, Scope $scope): array $functionReflection = $this->reflectionProvider->getFunction($node->getName(), $scope); - /** @var RestrictedFunctionUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedFunctionUsageExtension::FUNCTION_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $errors = []; foreach ($extensions as $extension) { diff --git a/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php b/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php index b94843abc6c..cdda1d5a83b 100644 --- a/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedFunctionUsageRule implements Rule { - /** @var RestrictedFunctionUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedFunctionUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -48,8 +50,7 @@ public function processNode(Node $node, Scope $scope): array $functionReflection = $this->reflectionProvider->getFunction($node->name, $scope); - /** @var RestrictedFunctionUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedFunctionUsageExtension::FUNCTION_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $errors = []; foreach ($extensions as $extension) { diff --git a/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php index 7d2829baa92..a199d906777 100644 --- a/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\MethodCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -19,11 +20,12 @@ final class RestrictedMethodCallableUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -43,8 +45,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php b/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php index 8c17430751d..7d04c6a980e 100644 --- a/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -19,11 +20,12 @@ final class RestrictedMethodUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -43,8 +45,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php b/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php index 74d225f571d..222ecf98553 100644 --- a/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedPropertyUsageRule implements Rule { - /** @var RestrictedPropertyUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedPropertyUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -42,8 +44,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedPropertyUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedPropertyUsageExtension::PROPERTY_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php index 0fad6925066..2d13fbbef1b 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\StaticMethodCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -23,11 +24,12 @@ final class RestrictedStaticMethodCallableUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -48,8 +50,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php index 6abda13e158..32b116334a4 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -22,11 +23,12 @@ final class RestrictedStaticMethodUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php index 338fa71b736..15a9c7c2ff5 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -22,11 +23,12 @@ final class RestrictedStaticPropertyUsageRule implements Rule { - /** @var RestrictedPropertyUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedPropertyUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedPropertyUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedPropertyUsageExtension::PROPERTY_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php b/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php index 26e9bf74e07..e5126cc08fb 100644 --- a/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php +++ b/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Expr\Cast; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedUsageOfDeprecatedStringCastRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -35,8 +37,7 @@ public function getNodeType(): string public function processNode(Node $node, Scope $scope): array { - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 1908b4f10d2..e175fdf2613 100644 --- a/tests/PHPStan/Analyser/AnalyserTest.php +++ b/tests/PHPStan/Analyser/AnalyserTest.php @@ -3,6 +3,7 @@ namespace PHPStan\Analyser; use PhpParser\Lexer; +use PhpParser\NodeVisitor; use PhpParser\NodeVisitor\NameResolver; use PhpParser\Parser\Php7; use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; @@ -855,7 +856,7 @@ private function createAnalyser(): Analyser new RichParser( new Php7($lexer), new NameResolver(), - $container, + new LazyExtensionsCollection($container, NodeVisitor::class), new IgnoreLexer(), ), new DependencyResolver($fileHelper, $reflectionProvider, new ExportedNodeResolver($reflectionProvider, $fileTypeMapper, new ExprPrinter(new Printer())), $fileTypeMapper), diff --git a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php index eef6033cfdd..d382220f866 100644 --- a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php +++ b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php @@ -3,6 +3,7 @@ namespace PHPStan\PhpDoc; use Override; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Testing\PHPStanTestCase; use function dirname; @@ -64,7 +65,7 @@ public function testGetProjectStubFilesWhenPathContainsWindowsSeparator(): void */ private function createDefaultStubFilesProvider(array $stubFiles): DefaultStubFilesProvider { - return new DefaultStubFilesProvider($this->getContainer(), new FileHelper(__DIR__), $stubFiles, [$this->currentWorkingDirectory]); + return new DefaultStubFilesProvider(new LazyExtensionsCollection($this->getContainer(), StubFilesExtension::class), new FileHelper(__DIR__), $stubFiles, [$this->currentWorkingDirectory]); } } diff --git a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php index d9869111676..ee5c1b21118 100644 --- a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -54,9 +57,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php index 82d35191085..c78801ab7f3 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php index 7e2e6d8b86e..38ef2c9b530 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -39,9 +42,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new PhpVersion($this->phpVersion), checkNonStringableDynamicAccess: true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php index f7b9da55c9c..33ab2f0216d 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassInClassExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php index 30512a74c3c..ce3438c1c95 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -23,9 +26,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php index 55c86b9fb02..3f8cfd01bcf 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassInTraitUseRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php index cef3fee647d..a2815e293e5 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassesInClassImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php index 8a9f99cebf4..026d8f7efb9 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -23,9 +26,9 @@ protected function getRule(): Rule return new ExistingClassesInEnumImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php index 3a97ab00196..fc21958c9b1 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassesInInterfaceExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php index a075fb6bb42..f4833853be7 100644 --- a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,8 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; +use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -35,7 +39,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + new LazyExtensionsCollection($container, RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -50,9 +54,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php index 105257b4993..d6f8c0223ea 100644 --- a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php +++ b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,8 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; +use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -37,7 +41,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + new LazyExtensionsCollection($container, RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -52,9 +56,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php index 8b1e6ebd23e..f6c9b84c78b 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -32,9 +35,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php index e2c0836fe7f..ccd59e6bb0a 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -31,9 +34,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php index dd998ea14cf..c90123b0a93 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -31,9 +34,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php index 21cf1a62b9d..a5fdaba18d7 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php index a75edf63c1b..412940631f5 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php index ed0a4039f38..b689ddb5295 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinRuleTest.php b/tests/PHPStan/Rules/Classes/MixinRuleTest.php index 54a2594c0ce..ed07bc1f304 100644 --- a/tests/PHPStan/Rules/Classes/MixinRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php b/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php index 1d10c554b75..5454609eb13 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php index 673783bb6ab..5bfea4e5b6c 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php index e2e6f0dda63..75a2cc99c6d 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php index dd6631d0c60..98fdeee6275 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php index 244b79acaaf..e179c979d80 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php index 7d3e86139e9..5a4aa89cd34 100644 --- a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Constants; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -11,6 +13,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -58,9 +61,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php index 2e4dc4462ea..e169d5e5f9a 100644 --- a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php +++ b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\EnumCases; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -50,9 +53,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php index 312ef01b058..6a9e6eee57a 100644 --- a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php +++ b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Exceptions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php index 48384cb74da..b63682cd798 100644 --- a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php index 661cf08dc5e..92ee01b94fd 100644 --- a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php index 5026167c935..ed28b53703c 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php index c640852429b..bdb9c487299 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php index a075b099be9..80fbcb79e4a 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php index 0025c2d6658..4c51270dcfb 100644 --- a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php index d7a77b3d814..c585e01831e 100644 --- a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php index 2632e3334df..74a1ad200d2 100644 --- a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -26,9 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php index 2ecba0fc61d..8222eb69072 100644 --- a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php index 34115b037a3..94e3b94ae6f 100644 --- a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php index d8b2582bc19..e1ce2e8c6af 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php index a47ea46988c..007e866e405 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php index 872d525b002..a980c2764db 100644 --- a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php index 9336e1d8734..56af62657d2 100644 --- a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php index cc31101ece2..28cdcbbbfd7 100644 --- a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -52,9 +55,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php index 4193804ed4d..21b1ae494d7 100644 --- a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php index 517bed39133..f0dd93d6390 100644 --- a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -52,9 +55,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php index d5186cf16f0..7bc83d1e7bc 100644 --- a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php +++ b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -44,9 +47,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php index 89ccc73cb8b..5e07fe2d837 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php index ab27893aed6..08a05305033 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php b/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php index 247ce2a0075..e2968dc12cc 100644 --- a/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new MissingTypehintCheck(true, [], true), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php index 046f92d5d14..78cbfcf4081 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -34,9 +37,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php index b40c3f21559..693bcc8e0a3 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -34,9 +37,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php index 34e8c292802..4527463d287 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php index 4153877cea7..e45ccb2af7c 100644 --- a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php b/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php index e23fa3eb55f..54d9265e74b 100644 --- a/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new MissingTypehintCheck(true, [], true), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php index 7f80bf1577c..ffc3cb1ee74 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -25,9 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php index 97707a262b9..6d0001a82ae 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -26,9 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php index c1703565d4a..f11e7db805b 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -24,9 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php index dfd91efc498..34ce25d6dd6 100644 --- a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -24,9 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php index fc4942719b7..454697fea16 100644 --- a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php +++ b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php @@ -2,7 +2,9 @@ namespace PHPStan\Rules\Playground; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Node\ClassPropertiesNode; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Properties\UninitializedPropertyRule; use PHPStan\Rules\Rule; @@ -19,7 +21,7 @@ protected function getRule(): Rule $container = self::getContainer(); return new PromoteParameterRule( new UninitializedPropertyRule(new ConstructorsHelper( - $container, + new LazyExtensionsCollection($container, AdditionalConstructorsExtension::class), [], )), $container, diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php index f8ddba0d610..af320eb665e 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -36,9 +39,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(new LazyExtensionsCollection(self::getContainer(), ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassNameUsageExtension::class), ), new PhpVersion(PHP_VERSION_ID), discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php index a6e80a4dff5..248fb8139a8 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -35,9 +38,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(new LazyExtensionsCollection(self::getContainer(), ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassNameUsageExtension::class), ), new PhpVersion(PHP_VERSION_ID), discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php index 2e9b97364cf..cc91adbc0ee 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersion), diff --git a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php index 42d1aba91a0..cd95fc3394f 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion(PHP_VERSION_ID), diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php index 868e3d77e04..3a268016f81 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -19,7 +21,7 @@ protected function getRule(): Rule { return new MissingReadOnlyByPhpDocPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'MissingReadOnlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php index 1f6332b72dd..3f3fd0f6299 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +22,7 @@ protected function getRule(): Rule { return new MissingReadOnlyPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'MissingReadOnlyPropertyAssign\\TestCase::setUp', 'Bug10523\\Controller::init', diff --git a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php index 78de39db51d..f91453d7f98 100644 --- a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\FunctionCallParametersCheck; use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -51,9 +54,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php index d007f02c39e..38b8c0de937 100644 --- a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\FunctionCallParametersCheck; use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php index c52d60b8f75..054998a835d 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -18,7 +20,7 @@ protected function getRule(): Rule return new ReadOnlyByPhpDocPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php index d062d09af14..d1b8c4e22de 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php @@ -2,7 +2,9 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -21,7 +23,7 @@ protected function getRule(): Rule return new ReadOnlyPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssign\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php index d1b137e35cd..935b9abb47a 100644 --- a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php +++ b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +22,7 @@ protected function getRule(): Rule { return new UninitializedPropertyRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'UninitializedProperty\\TestCase::setUp', 'Bug9619\\AdminPresenter::startup', diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php index 344f48a91e6..6679ca6220a 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -16,7 +17,7 @@ protected function getRule(): Rule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedClassConstantUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassConstantUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php index 52656ce167f..1090723d0ed 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -15,7 +16,7 @@ class RestrictedFunctionCallableUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php index d96412eab90..6413998e4bd 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedFunctionUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php index c690bb46249..034ea6044f7 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -15,7 +16,7 @@ class RestrictedMethodCallableUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php index dd7aac599a4..91794fa9eb1 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedMethodUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php index 2fd50f13ad9..f21e3e956f2 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedPropertyUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedPropertyUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedPropertyUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php index d3bfce59003..bf0957c8529 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -17,7 +18,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php index 7684f1f70e1..a0eb85c2d16 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -17,7 +18,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php index 9f1e9f8fb9d..9752f6917c2 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -16,7 +17,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticPropertyUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedPropertyUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php index 660acdad201..7d02611af43 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedUsageOfDeprecatedStringCastRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedUsageOfDeprecatedStringCastRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php index 68caade88a1..19cd5fe1b86 100644 --- a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Traits; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -11,6 +13,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -56,9 +59,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), From 85c904c8263e08595f1f71152238cc9429df369c Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 22:19:04 +0100 Subject: [PATCH 4/4] Make extension registries services, delete their providers ExpressionTypeResolverExtensionRegistry, OperatorTypeSpecifyingExtensionRegistry, UnaryOperatorTypeSpecifyingExtensionRegistry and DynamicReturnTypeExtensionRegistry take ExtensionsCollection instead of plain arrays, which makes them cheap enough to be #[AutowiredService]s that consumers depend on directly. Their *RegistryProvider interfaces and Lazy* implementations are gone. Two providers stay: TypeNodeResolverExtensionRegistryProvider and ClassReflectionExtensionRegistryProvider both break a real cycle - their registries need TypeNodeResolver and PhpClassReflectionExtension, which reach back to the registry through ReflectionProvider/ClassReflection. Their tag lookups still switch to Container::getExtensions(). Co-Authored-By: Claude Opus 5 (1M context) Claude-Session: https://claude.ai/code/session_01XLPJxFJDzLPsieqEwJKpkn --- src/Analyser/DirectInternalScopeFactory.php | 10 +++--- .../DirectInternalScopeFactoryFactory.php | 6 ++-- src/Analyser/ExprHandler/FuncCallHandler.php | 6 ++-- .../Helper/MethodCallReturnTypeHelper.php | 8 ++--- src/Analyser/ExprHandler/NewHandler.php | 6 ++-- src/Analyser/LazyInternalScopeFactory.php | 3 +- ...assReflectionExtensionRegistryProvider.php | 10 +++--- ...micReturnTypeExtensionRegistryProvider.php | 12 ------- ...nTypeResolverExtensionRegistryProvider.php | 12 ------- ...micReturnTypeExtensionRegistryProvider.php | 31 ------------------- ...nTypeResolverExtensionRegistryProvider.php | 27 ---------------- ...ypeSpecifyingExtensionRegistryProvider.php | 27 ---------------- ...ypeSpecifyingExtensionRegistryProvider.php | 27 ---------------- ...ypeSpecifyingExtensionRegistryProvider.php | 12 ------- ...ypeSpecifyingExtensionRegistryProvider.php | 12 ------- .../ValidateIgnoredErrorsExtension.php | 26 ++++++---------- ...eNodeResolverExtensionRegistryProvider.php | 2 +- .../InitializerExprTypeResolver.php | 30 +++++++++--------- .../InvalidComparisonOperationRule.php | 6 ++-- src/Testing/PHPStanTestCase.php | 12 +++---- .../DynamicReturnTypeExtensionRegistry.php | 25 +++++++++------ ...xpressionTypeResolverExtensionRegistry.php | 14 ++++++--- ...peratorTypeSpecifyingExtensionRegistry.php | 11 +++++-- ...peratorTypeSpecifyingExtensionRegistry.php | 11 +++++-- .../InvalidComparisonOperationRuleTest.php | 4 +-- 25 files changed, 103 insertions(+), 247 deletions(-) delete mode 100644 src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/ExpressionTypeResolverExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyDynamicReturnTypeExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyUnaryOperatorTypeSpecifyingExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/UnaryOperatorTypeSpecifyingExtensionRegistryProvider.php diff --git a/src/Analyser/DirectInternalScopeFactory.php b/src/Analyser/DirectInternalScopeFactory.php index 533d37c5f92..cf93e9d167f 100644 --- a/src/Analyser/DirectInternalScopeFactory.php +++ b/src/Analyser/DirectInternalScopeFactory.php @@ -5,7 +5,6 @@ use PhpParser\Node; use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -15,6 +14,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\ClosureType; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; final class DirectInternalScopeFactory implements InternalScopeFactory { @@ -27,7 +27,7 @@ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -71,7 +71,7 @@ public function create( $this, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider->getRegistry(), + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -106,7 +106,7 @@ public function toFiberFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -126,7 +126,7 @@ public function toMutatingFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/DirectInternalScopeFactoryFactory.php b/src/Analyser/DirectInternalScopeFactoryFactory.php index 84b96d27a35..4f7042f7e3b 100644 --- a/src/Analyser/DirectInternalScopeFactoryFactory.php +++ b/src/Analyser/DirectInternalScopeFactoryFactory.php @@ -4,7 +4,6 @@ use PhpParser\Node; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -12,6 +11,7 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; final class DirectInternalScopeFactoryFactory implements InternalScopeFactoryFactory { @@ -23,7 +23,7 @@ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -45,7 +45,7 @@ public function create(?callable $nodeCallback): DirectInternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/ExprHandler/FuncCallHandler.php b/src/Analyser/ExprHandler/FuncCallHandler.php index 693061ce1f6..4c50db1b0dd 100644 --- a/src/Analyser/ExprHandler/FuncCallHandler.php +++ b/src/Analyser/ExprHandler/FuncCallHandler.php @@ -33,7 +33,6 @@ use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\ExtensionsCollection; -use PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider; use PHPStan\Node\ClosureReturnStatementsNode; use PHPStan\Node\Expr\NativeTypeExpr; use PHPStan\Node\Expr\PossiblyImpureCallExpr; @@ -55,6 +54,7 @@ use PHPStan\Type\Constant\ConstantArrayType; use PHPStan\Type\Constant\ConstantArrayTypeBuilder; use PHPStan\Type\DynamicFunctionThrowTypeExtension; +use PHPStan\Type\DynamicReturnTypeExtensionRegistry; use PHPStan\Type\ErrorType; use PHPStan\Type\GeneralizePrecision; use PHPStan\Type\Generic\TemplateTypeHelper; @@ -97,7 +97,7 @@ public function __construct( private ReflectionProvider $reflectionProvider, #[AutowiredExtensions(interface: DynamicFunctionThrowTypeExtension::class)] private ExtensionsCollection $functionThrowTypeExtensions, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, #[AutowiredParameter] @@ -1008,7 +1008,7 @@ private function specifyTypesFromCallableCall(TypeSpecifier $typeSpecifier, Type private function getDynamicFunctionReturnType(MutatingScope $scope, FuncCall $normalizedNode, FunctionReflection $functionReflection): ?Type { - foreach ($this->dynamicReturnTypeExtensionRegistryProvider->getRegistry()->getDynamicFunctionReturnTypeExtensions($functionReflection) as $dynamicFunctionReturnTypeExtension) { + foreach ($this->dynamicReturnTypeExtensionRegistry->getDynamicFunctionReturnTypeExtensions($functionReflection) as $dynamicFunctionReturnTypeExtension) { $resolvedType = $dynamicFunctionReturnTypeExtension->getTypeFromFunctionCall( $functionReflection, $normalizedNode, diff --git a/src/Analyser/ExprHandler/Helper/MethodCallReturnTypeHelper.php b/src/Analyser/ExprHandler/Helper/MethodCallReturnTypeHelper.php index da565b78d8d..df89e968336 100644 --- a/src/Analyser/ExprHandler/Helper/MethodCallReturnTypeHelper.php +++ b/src/Analyser/ExprHandler/Helper/MethodCallReturnTypeHelper.php @@ -7,8 +7,8 @@ use PHPStan\Analyser\ArgumentsNormalizer; use PHPStan\Analyser\MutatingScope; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider; use PHPStan\Reflection\ParametersAcceptorSelector; +use PHPStan\Type\DynamicReturnTypeExtensionRegistry; use PHPStan\Type\ObjectType; use PHPStan\Type\Type; use PHPStan\Type\TypeCombinator; @@ -19,7 +19,7 @@ final class MethodCallReturnTypeHelper { public function __construct( - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry, ) { } @@ -57,7 +57,7 @@ public function methodCallReturnType( $handledClassNames = []; foreach ($allClassNames as $className) { if ($normalizedMethodCall instanceof MethodCall) { - foreach ($this->dynamicReturnTypeExtensionRegistryProvider->getRegistry()->getDynamicMethodReturnTypeExtensionsForClass($className) as $dynamicMethodReturnTypeExtension) { + foreach ($this->dynamicReturnTypeExtensionRegistry->getDynamicMethodReturnTypeExtensionsForClass($className) as $dynamicMethodReturnTypeExtension) { if (!$dynamicMethodReturnTypeExtension->isMethodSupported($methodReflection)) { continue; } @@ -71,7 +71,7 @@ public function methodCallReturnType( $handledClassNames[] = $className; } } else { - foreach ($this->dynamicReturnTypeExtensionRegistryProvider->getRegistry()->getDynamicStaticMethodReturnTypeExtensionsForClass($className) as $dynamicStaticMethodReturnTypeExtension) { + foreach ($this->dynamicReturnTypeExtensionRegistry->getDynamicStaticMethodReturnTypeExtensionsForClass($className) as $dynamicStaticMethodReturnTypeExtension) { if (!$dynamicStaticMethodReturnTypeExtension->isStaticMethodSupported($methodReflection)) { continue; } diff --git a/src/Analyser/ExprHandler/NewHandler.php b/src/Analyser/ExprHandler/NewHandler.php index 6eb944b7b64..5ec08de9c0b 100644 --- a/src/Analyser/ExprHandler/NewHandler.php +++ b/src/Analyser/ExprHandler/NewHandler.php @@ -30,7 +30,6 @@ use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\ExtensionsCollection; -use PHPStan\DependencyInjection\Type\DynamicReturnTypeExtensionRegistryProvider; use PHPStan\Node\MethodReturnStatementsNode; use PHPStan\Parser\NewAssignedToPropertyVisitor; use PHPStan\Reflection\Callables\SimpleImpurePoint; @@ -43,6 +42,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\ShouldNotHappenException; +use PHPStan\Type\DynamicReturnTypeExtensionRegistry; use PHPStan\Type\DynamicStaticMethodThrowTypeExtension; use PHPStan\Type\ErrorType; use PHPStan\Type\Generic\GenericObjectType; @@ -80,7 +80,7 @@ public function __construct( private ReflectionProvider $reflectionProvider, #[AutowiredExtensions(interface: DynamicStaticMethodThrowTypeExtension::class)] private ExtensionsCollection $staticMethodThrowTypeExtensions, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry, private PropertyReflectionFinder $propertyReflectionFinder, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, @@ -407,7 +407,7 @@ private function exactInstantiation(MutatingScope $scope, New_ $node, Name $clas $normalizedMethodCall = ArgumentsNormalizer::reorderStaticCallArguments($parametersAcceptor, $methodCall); if ($normalizedMethodCall !== null) { - foreach ($this->dynamicReturnTypeExtensionRegistryProvider->getRegistry()->getDynamicStaticMethodReturnTypeExtensionsForClass($classReflection->getName()) as $dynamicStaticMethodReturnTypeExtension) { + foreach ($this->dynamicReturnTypeExtensionRegistry->getDynamicStaticMethodReturnTypeExtensionsForClass($classReflection->getName()) as $dynamicStaticMethodReturnTypeExtension) { if (!$dynamicStaticMethodReturnTypeExtension->isStaticMethodSupported($constructorMethod)) { continue; } diff --git a/src/Analyser/LazyInternalScopeFactory.php b/src/Analyser/LazyInternalScopeFactory.php index 30bad59a9a4..5609fb750ca 100644 --- a/src/Analyser/LazyInternalScopeFactory.php +++ b/src/Analyser/LazyInternalScopeFactory.php @@ -6,7 +6,6 @@ use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; use PHPStan\DependencyInjection\GenerateFactory; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -84,7 +83,7 @@ public function create( $this->reflectionProvider ??= $this->container->getByType(ReflectionProvider::class); $this->initializerExprTypeResolver ??= $this->container->getByType(InitializerExprTypeResolver::class); - $this->expressionTypeResolverExtensionRegistry ??= $this->container->getByType(ExpressionTypeResolverExtensionRegistryProvider::class)->getRegistry(); + $this->expressionTypeResolverExtensionRegistry ??= $this->container->getByType(ExpressionTypeResolverExtensionRegistry::class); $this->exprPrinter ??= $this->container->getByType(ExprPrinter::class); $this->typeSpecifier ??= $this->container->getByType(TypeSpecifier::class); $this->propertyReflectionFinder ??= $this->container->getByType(PropertyReflectionFinder::class); diff --git a/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php b/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php index a4722245e3d..7bc1cc2b36d 100644 --- a/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php +++ b/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php @@ -2,17 +2,19 @@ namespace PHPStan\DependencyInjection\Reflection; -use PHPStan\Broker\BrokerFactory; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; +use PHPStan\Reflection\AllowedSubTypesClassReflectionExtension; use PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension; use PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension; use PHPStan\Reflection\ClassReflectionExtensionRegistry; +use PHPStan\Reflection\MethodsClassReflectionExtension; use PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension; use PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension; use PHPStan\Reflection\Php\PhpClassReflectionExtension; use PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension; use PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension; +use PHPStan\Reflection\PropertiesClassReflectionExtension; use PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension; use PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension; use PHPStan\ShouldNotHappenException; @@ -45,9 +47,9 @@ public function getRegistry(): ClassReflectionExtensionRegistry $universalObjectCratesClassReflectionExtension = $container->getByType(UniversalObjectCratesClassReflectionExtension::class); $this->registry = new ClassReflectionExtensionRegistry( - array_merge($container->getServicesByTag(BrokerFactory::PROPERTIES_CLASS_REFLECTION_EXTENSION_TAG), [$annotationsPropertiesClassReflectionExtension, $mixinPropertiesClassReflectionExtension, $universalObjectCratesClassReflectionExtension]), - array_merge($container->getServicesByTag(BrokerFactory::METHODS_CLASS_REFLECTION_EXTENSION_TAG), [$annotationsMethodsClassReflectionExtension, $mixinMethodsClassReflectionExtension, $soapClientMethodsClassReflectionExtension]), - $container->getServicesByTag(BrokerFactory::ALLOWED_SUB_TYPES_CLASS_REFLECTION_EXTENSION_TAG), + array_merge($container->getExtensions(PropertiesClassReflectionExtension::class), [$annotationsPropertiesClassReflectionExtension, $mixinPropertiesClassReflectionExtension, $universalObjectCratesClassReflectionExtension]), + array_merge($container->getExtensions(MethodsClassReflectionExtension::class), [$annotationsMethodsClassReflectionExtension, $mixinMethodsClassReflectionExtension, $soapClientMethodsClassReflectionExtension]), + $container->getExtensions(AllowedSubTypesClassReflectionExtension::class), $container->getByType(RequireExtendsPropertiesClassReflectionExtension::class), $container->getByType(RequireExtendsMethodsClassReflectionExtension::class), $container->getByType(PhpClassReflectionExtension::class), diff --git a/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php b/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php deleted file mode 100644 index 14fb3eccefd..00000000000 --- a/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php +++ /dev/null @@ -1,12 +0,0 @@ -registry ??= new DynamicReturnTypeExtensionRegistry( - $this->container->getByType(ReflectionProvider::class), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_STATIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_FUNCTION_RETURN_TYPE_EXTENSION_TAG), - ); - } - -} diff --git a/src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php b/src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php deleted file mode 100644 index 6efc5fcb80a..00000000000 --- a/src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php +++ /dev/null @@ -1,27 +0,0 @@ -registry ??= new ExpressionTypeResolverExtensionRegistry( - $this->container->getServicesByTag(BrokerFactory::EXPRESSION_TYPE_RESOLVER_EXTENSION_TAG), - ); - } - -} diff --git a/src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php b/src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php deleted file mode 100644 index ead76923a3e..00000000000 --- a/src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.php +++ /dev/null @@ -1,27 +0,0 @@ -registry ??= new OperatorTypeSpecifyingExtensionRegistry( - $this->container->getServicesByTag(BrokerFactory::OPERATOR_TYPE_SPECIFYING_EXTENSION_TAG), - ); - } - -} diff --git a/src/DependencyInjection/Type/LazyUnaryOperatorTypeSpecifyingExtensionRegistryProvider.php b/src/DependencyInjection/Type/LazyUnaryOperatorTypeSpecifyingExtensionRegistryProvider.php deleted file mode 100644 index 631ad4f3b54..00000000000 --- a/src/DependencyInjection/Type/LazyUnaryOperatorTypeSpecifyingExtensionRegistryProvider.php +++ /dev/null @@ -1,27 +0,0 @@ -registry ??= new UnaryOperatorTypeSpecifyingExtensionRegistry( - $this->container->getServicesByTag(BrokerFactory::UNARY_OPERATOR_TYPE_SPECIFYING_EXTENSION_TAG), - ); - } - -} diff --git a/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php b/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php deleted file mode 100644 index 2a1de7beae6..00000000000 --- a/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php +++ /dev/null @@ -1,12 +0,0 @@ -registry ??= new TypeNodeResolverExtensionAwareRegistry( $this->container->getByType(TypeNodeResolver::class), - $this->container->getServicesByTag(TypeNodeResolverExtension::EXTENSION_TAG), + $this->container->getExtensions(TypeNodeResolverExtension::class), ); } diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php index 8b54b83b213..ac40ef08960 100644 --- a/src/Reflection/InitializerExprTypeResolver.php +++ b/src/Reflection/InitializerExprTypeResolver.php @@ -32,8 +32,6 @@ use PHPStan\Analyser\OutOfClassScope; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\UnaryOperatorTypeSpecifyingExtensionRegistryProvider; use PHPStan\Node\Expr\TypeExpr; use PHPStan\Php\PhpVersion; use PHPStan\PhpDoc\Tag\TemplateTag; @@ -86,6 +84,7 @@ use PHPStan\Type\ObjectShapeType; use PHPStan\Type\ObjectType; use PHPStan\Type\ObjectWithoutClassType; +use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\ParserNodeTypeToPHPStanType; use PHPStan\Type\StaticType; use PHPStan\Type\StringType; @@ -96,6 +95,7 @@ use PHPStan\Type\TypeResult; use PHPStan\Type\TypeUtils; use PHPStan\Type\TypeWithClassName; +use PHPStan\Type\UnaryOperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\UnionType; use stdClass; use Throwable; @@ -139,8 +139,8 @@ public function __construct( private ConstantResolver $constantResolver, private ReflectionProviderProvider $reflectionProviderProvider, private PhpVersion $phpVersion, - private OperatorTypeSpecifyingExtensionRegistryProvider $operatorTypeSpecifyingExtensionRegistryProvider, - private UnaryOperatorTypeSpecifyingExtensionRegistryProvider $unaryOperatorTypeSpecifyingExtensionRegistryProvider, + private OperatorTypeSpecifyingExtensionRegistry $operatorTypeSpecifyingExtensionRegistry, + private UnaryOperatorTypeSpecifyingExtensionRegistry $unaryOperatorTypeSpecifyingExtensionRegistry, private OversizedArrayBuilder $oversizedArrayBuilder, #[AutowiredParameter] private bool $usePathConstantsAsConstantString, @@ -1006,7 +1006,7 @@ public function getBitwiseAndType(Expr $left, Expr $right, callable $getTypeCall $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseAnd($left, $right), $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -1065,7 +1065,7 @@ public function getBitwiseOrType(Expr $left, Expr $right, callable $getTypeCallb $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseOr($left, $right), $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -1114,7 +1114,7 @@ public function getBitwiseXorType(Expr $left, Expr $right, callable $getTypeCall $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\BitwiseXor($left, $right), $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -1326,7 +1326,7 @@ public function getModType(Expr $left, Expr $right, callable $getTypeCallback): return $this->getNeverType($leftType, $rightType); } - $extensionSpecified = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $extensionSpecified = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\Mod($left, $right), $leftType, $rightType); if ($extensionSpecified !== null) { return $extensionSpecified; @@ -1770,7 +1770,7 @@ public function getPowType(Expr $left, Expr $right, callable $getTypeCallback): $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $extensionSpecified = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $extensionSpecified = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\Pow($left, $right), $leftType, $rightType); if ($extensionSpecified !== null) { return $extensionSpecified; @@ -1792,7 +1792,7 @@ public function getShiftLeftType(Expr $left, Expr $right, callable $getTypeCallb $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\ShiftLeft($left, $right), $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -1857,7 +1857,7 @@ public function getShiftRightType(Expr $left, Expr $right, callable $getTypeCall $leftType = $getTypeCallback($left); $rightType = $getTypeCallback($right); - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions(new BinaryOp\ShiftRight($left, $right), $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -2072,7 +2072,7 @@ private function resolveConstantArrayTypeComparison(ConstantArrayType $leftType, */ private function resolveCommonMath(Expr\BinaryOp $expr, Type $leftType, Type $rightType): Type { - $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->operatorTypeSpecifyingExtensionRegistry ->callOperatorTypeSpecifyingExtensions($expr, $leftType, $rightType); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -2581,7 +2581,7 @@ public function getUnaryPlusType(Expr $expr, callable $getTypeCallback): Type { $type = $getTypeCallback($expr); - $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistry ->callUnaryOperatorTypeSpecifyingExtensions('+', $type); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -2597,7 +2597,7 @@ public function getUnaryMinusType(Expr $expr, callable $getTypeCallback): Type { $type = $getTypeCallback($expr); - $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistry ->callUnaryOperatorTypeSpecifyingExtensions('-', $type); if ($specifiedTypes !== null) { return $specifiedTypes; @@ -2646,7 +2646,7 @@ public function getBitwiseNotType(Expr $expr, callable $getTypeCallback): Type { $exprType = $getTypeCallback($expr); - $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistryProvider->getRegistry() + $specifiedTypes = $this->unaryOperatorTypeSpecifyingExtensionRegistry ->callUnaryOperatorTypeSpecifyingExtensions('~', $exprType); if ($specifiedTypes !== null) { return $specifiedTypes; diff --git a/src/Rules/Operators/InvalidComparisonOperationRule.php b/src/Rules/Operators/InvalidComparisonOperationRule.php index b410ae0fb9a..0030d4798a0 100644 --- a/src/Rules/Operators/InvalidComparisonOperationRule.php +++ b/src/Rules/Operators/InvalidComparisonOperationRule.php @@ -6,7 +6,6 @@ use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\RegisteredRule; -use PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider; use PHPStan\Rules\IdentifierRuleError; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -19,6 +18,7 @@ use PHPStan\Type\MixedType; use PHPStan\Type\NullType; use PHPStan\Type\ObjectWithoutClassType; +use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\Type; use PHPStan\Type\UnionType; use PHPStan\Type\VerbosityLevel; @@ -34,7 +34,7 @@ final class InvalidComparisonOperationRule implements Rule public function __construct( private RuleLevelHelper $ruleLevelHelper, - private OperatorTypeSpecifyingExtensionRegistryProvider $operatorTypeSpecifyingExtensionRegistryProvider, + private OperatorTypeSpecifyingExtensionRegistry $operatorTypeSpecifyingExtensionRegistry, #[AutowiredParameter(ref: '%featureToggles.checkExtensionsForComparisonOperators%')] private bool $checkExtensionsForComparisonOperators, ) @@ -66,7 +66,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - $result = $this->operatorTypeSpecifyingExtensionRegistryProvider->getRegistry()->callOperatorTypeSpecifyingExtensions( + $result = $this->operatorTypeSpecifyingExtensionRegistry->callOperatorTypeSpecifyingExtensions( $node, $scope->getType($node->left), $scope->getType($node->right), diff --git a/src/Testing/PHPStanTestCase.php b/src/Testing/PHPStanTestCase.php index 2845f997681..c0f717eae1b 100644 --- a/src/Testing/PHPStanTestCase.php +++ b/src/Testing/PHPStanTestCase.php @@ -10,9 +10,6 @@ use PHPStan\Analyser\TypeSpecifier; use PHPStan\BetterReflection\Reflector\Reflector; use PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\UnaryOperatorTypeSpecifyingExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\ComposerPhpVersionFactory; @@ -26,7 +23,10 @@ use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\Constant\OversizedArrayBuilder; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; +use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\TypeAliasResolver; +use PHPStan\Type\UnaryOperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\UsefulTypeAliasResolver; use PHPUnit\Framework\ExpectationFailedException; use PHPUnit\Framework\TestCase; @@ -102,8 +102,8 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider $constantResolver, $reflectionProviderProvider, $container->getByType(PhpVersion::class), - $container->getByType(OperatorTypeSpecifyingExtensionRegistryProvider::class), - $container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistryProvider::class), + $container->getByType(OperatorTypeSpecifyingExtensionRegistry::class), + $container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistry::class), new OversizedArrayBuilder(), $container->getParameter('usePathConstantsAsConstantString'), ); @@ -113,7 +113,7 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider $container, $reflectionProvider, $initializerExprTypeResolver, - $container->getByType(ExpressionTypeResolverExtensionRegistryProvider::class), + $container->getByType(ExpressionTypeResolverExtensionRegistry::class), $container->getByType(ExprPrinter::class), $typeSpecifier, new PropertyReflectionFinder(), diff --git a/src/Type/DynamicReturnTypeExtensionRegistry.php b/src/Type/DynamicReturnTypeExtensionRegistry.php index bceef62997e..7fe688623e3 100644 --- a/src/Type/DynamicReturnTypeExtensionRegistry.php +++ b/src/Type/DynamicReturnTypeExtensionRegistry.php @@ -2,11 +2,15 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ReflectionProvider; use function array_merge; use function strtolower; +#[AutowiredService] final class DynamicReturnTypeExtensionRegistry { @@ -20,15 +24,18 @@ final class DynamicReturnTypeExtensionRegistry private array $dynamicReturnTypeExtensionsByFunction = []; /** - * @param DynamicMethodReturnTypeExtension[] $dynamicMethodReturnTypeExtensions - * @param DynamicStaticMethodReturnTypeExtension[] $dynamicStaticMethodReturnTypeExtensions - * @param DynamicFunctionReturnTypeExtension[] $dynamicFunctionReturnTypeExtensions + * @param ExtensionsCollection $dynamicMethodReturnTypeExtensions + * @param ExtensionsCollection $dynamicStaticMethodReturnTypeExtensions + * @param ExtensionsCollection $dynamicFunctionReturnTypeExtensions */ public function __construct( private ReflectionProvider $reflectionProvider, - private array $dynamicMethodReturnTypeExtensions, - private array $dynamicStaticMethodReturnTypeExtensions, - private array $dynamicFunctionReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicMethodReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicStaticMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicStaticMethodReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicFunctionReturnTypeExtension::class)] + private ExtensionsCollection $dynamicFunctionReturnTypeExtensions, ) { } @@ -40,7 +47,7 @@ public function getDynamicMethodReturnTypeExtensionsForClass(string $className): { if ($this->dynamicMethodReturnTypeExtensionsByClass === null) { $byClass = []; - foreach ($this->dynamicMethodReturnTypeExtensions as $extension) { + foreach ($this->dynamicMethodReturnTypeExtensions->getAll() as $extension) { $byClass[strtolower($extension->getClass())][] = $extension; } @@ -56,7 +63,7 @@ public function getDynamicStaticMethodReturnTypeExtensionsForClass(string $class { if ($this->dynamicStaticMethodReturnTypeExtensionsByClass === null) { $byClass = []; - foreach ($this->dynamicStaticMethodReturnTypeExtensions as $extension) { + foreach ($this->dynamicStaticMethodReturnTypeExtensions->getAll() as $extension) { $byClass[strtolower($extension->getClass())][] = $extension; } @@ -100,7 +107,7 @@ public function getDynamicFunctionReturnTypeExtensions(FunctionReflection $funct } $supportedFunctions = []; - foreach ($this->dynamicFunctionReturnTypeExtensions as $dynamicFunctionReturnTypeExtension) { + foreach ($this->dynamicFunctionReturnTypeExtensions->getAll() as $dynamicFunctionReturnTypeExtension) { if (!$dynamicFunctionReturnTypeExtension->isFunctionSupported($functionReflection)) { continue; } diff --git a/src/Type/ExpressionTypeResolverExtensionRegistry.php b/src/Type/ExpressionTypeResolverExtensionRegistry.php index 1d9dc436c07..cb4f89da404 100644 --- a/src/Type/ExpressionTypeResolverExtensionRegistry.php +++ b/src/Type/ExpressionTypeResolverExtensionRegistry.php @@ -2,24 +2,30 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; + +#[AutowiredService] final class ExpressionTypeResolverExtensionRegistry { /** - * @param array $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: ExpressionTypeResolverExtension::class)] + private ExtensionsCollection $extensions, ) { } /** - * @return array + * @return list */ public function getExtensions(): array { - return $this->extensions; + return $this->extensions->getAll(); } } diff --git a/src/Type/OperatorTypeSpecifyingExtensionRegistry.php b/src/Type/OperatorTypeSpecifyingExtensionRegistry.php index bb830a69449..f8ada91842d 100644 --- a/src/Type/OperatorTypeSpecifyingExtensionRegistry.php +++ b/src/Type/OperatorTypeSpecifyingExtensionRegistry.php @@ -3,18 +3,23 @@ namespace PHPStan\Type; use PhpParser\Node\Expr; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_filter; use function array_values; use function count; +#[AutowiredService] final class OperatorTypeSpecifyingExtensionRegistry { /** - * @param OperatorTypeSpecifyingExtension[] $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: OperatorTypeSpecifyingExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -24,7 +29,7 @@ public function __construct( */ private function getOperatorTypeSpecifyingExtensions(string $operator, Type $leftType, Type $rightType): array { - return array_values(array_filter($this->extensions, static fn (OperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $leftType, $rightType))); + return array_values(array_filter($this->extensions->getAll(), static fn (OperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $leftType, $rightType))); } public function callOperatorTypeSpecifyingExtensions(Expr\BinaryOp $expr, Type $leftType, Type $rightType): ?Type diff --git a/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php b/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php index 0e643195988..9e5104a2140 100644 --- a/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php +++ b/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php @@ -2,18 +2,23 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_filter; use function array_values; use function count; +#[AutowiredService] final class UnaryOperatorTypeSpecifyingExtensionRegistry { /** - * @param UnaryOperatorTypeSpecifyingExtension[] $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: UnaryOperatorTypeSpecifyingExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -23,7 +28,7 @@ public function __construct( */ private function getOperatorTypeSpecifyingExtensions(string $operator, Type $operandType): array { - return array_values(array_filter($this->extensions, static fn (UnaryOperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $operandType))); + return array_values(array_filter($this->extensions->getAll(), static fn (UnaryOperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $operandType))); } public function callUnaryOperatorTypeSpecifyingExtensions(string $operatorSigil, Type $operandType): ?Type diff --git a/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php index 7d8d929890b..5e6b864cdb4 100644 --- a/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php +++ b/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php @@ -2,10 +2,10 @@ namespace PHPStan\Rules\Operators; -use PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; +use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry; use PHPUnit\Framework\Attributes\RequiresPhp; /** @@ -29,7 +29,7 @@ protected function getRule(): Rule checkBenevolentUnionTypes: false, discoveringSymbolsTip: true, ), - $this->getContainer()->getByType(OperatorTypeSpecifyingExtensionRegistryProvider::class), + $this->getContainer()->getByType(OperatorTypeSpecifyingExtensionRegistry::class), checkExtensionsForComparisonOperators: true, ); }