From 3f5bbd89a0b450dc1601453c2de487eaf66e270c Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 21:52:29 +0100 Subject: [PATCH 1/2] Introduce ExtensionsCollection, #[AutowiredExtensions] and Container::getExtensionsCollection(), replace extension providers Every interface marked with #[ExtensionInterface] now gets a compiled LazyExtensionsCollection service registered by AutowiredExtensionsExtension. Extensions can be looked up by interface name via Container::getExtensionsCollection(), and injected into constructors with #[AutowiredExtensions(of: SomeExtension::class)] above an ExtensionsCollection parameter. Tests substitute extensions with DirectExtensionsCollection. This replaces the hand-written provider layer whose only job was lazily pulling tagged services out of the container: - ParameterClosureThisExtensionProvider + Lazy - ParameterClosureTypeExtensionProvider + Lazy - ParameterOutTypeExtensionProvider + Lazy - DynamicThrowTypeExtensionProvider + Lazy - ReadWritePropertiesExtensionProvider + Lazy + Direct - AlwaysUsedClassConstantsExtensionProvider + Lazy + Direct - AlwaysUsedMethodExtensionProvider + Lazy + Direct - IgnoreErrorExtensionProvider - DynamicReturnTypeExtensionRegistryProvider + Lazy - ExpressionTypeResolverExtensionRegistryProvider + Lazy - OperatorTypeSpecifyingExtensionRegistryProvider + Lazy - UnaryOperatorTypeSpecifyingExtensionRegistryProvider + Lazy The four *Registry classes stay but are now autowired services holding lazy collections, so they are injected directly. Tag constants moved from the deleted providers onto the extension interfaces themselves. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01NPozex9wKR84GgzFQ6Vx5o --- conf/config.neon | 1 + src/Analyser/AnalyserResultFinalizer.php | 10 +- src/Analyser/DirectInternalScopeFactory.php | 12 ++- .../DirectInternalScopeFactoryFactory.php | 8 +- src/Analyser/ExprHandler/FuncCallHandler.php | 18 ++-- .../Helper/MethodCallReturnTypeHelper.php | 8 +- .../Helper/MethodThrowPointHelper.php | 18 +++- src/Analyser/ExprHandler/NewHandler.php | 18 ++-- src/Analyser/FileAnalyser.php | 10 +- src/Analyser/IgnoreErrorExtensionProvider.php | 24 ----- src/Analyser/LazyInternalScopeFactory.php | 11 ++- src/Analyser/MutatingScope.php | 8 +- src/Analyser/NodeScopeResolver.php | 72 ++++++++++---- .../AutowiredExtensions.php | 27 +++++ .../AutowiredExtensionsExtension.php | 98 +++++++++++++++++++ src/DependencyInjection/Container.php | 12 +++ .../DirectExtensionsCollection.php | 32 ++++++ .../ExtensionsCollection.php | 28 ++++++ .../LazyExtensionsCollection.php | 32 ++++++ .../MemoizingContainer.php | 14 +++ .../Nette/NetteContainer.php | 19 ++++ ...micReturnTypeExtensionRegistryProvider.php | 12 --- .../DynamicThrowTypeExtensionProvider.php | 21 ---- ...nTypeResolverExtensionRegistryProvider.php | 12 --- ...micReturnTypeExtensionRegistryProvider.php | 31 ------ .../LazyDynamicThrowTypeExtensionProvider.php | 35 ------- ...nTypeResolverExtensionRegistryProvider.php | 27 ----- ...ypeSpecifyingExtensionRegistryProvider.php | 27 ----- ...yParameterClosureThisExtensionProvider.php | 47 --------- ...yParameterClosureTypeExtensionProvider.php | 35 ------- .../LazyParameterOutTypeExtensionProvider.php | 35 ------- ...ypeSpecifyingExtensionRegistryProvider.php | 27 ----- ...ypeSpecifyingExtensionRegistryProvider.php | 12 --- .../ParameterClosureThisExtensionProvider.php | 27 ----- .../ParameterClosureTypeExtensionProvider.php | 21 ---- .../ParameterOutTypeExtensionProvider.php | 21 ---- ...ypeSpecifyingExtensionRegistryProvider.php | 12 --- .../ValidateIgnoredErrorsExtension.php | 18 +--- src/Node/ClassPropertiesNode.php | 8 +- .../InitializerExprTypeResolver.php | 30 +++--- .../AlwaysUsedClassConstantsExtension.php | 2 +- ...aysUsedClassConstantsExtensionProvider.php | 15 --- ...aysUsedClassConstantsExtensionProvider.php | 24 ----- .../DeadCode/UnusedPrivateConstantRule.php | 14 ++- .../DeadCode/UnusedPrivateMethodRule.php | 14 ++- .../DeadCode/UnusedPrivatePropertyRule.php | 10 +- .../Methods/AlwaysUsedMethodExtension.php | 2 +- .../AlwaysUsedMethodExtensionProvider.php | 15 --- ...irectAlwaysUsedMethodExtensionProvider.php | 20 ---- .../LazyAlwaysUsedMethodExtensionProvider.php | 24 ----- .../InvalidComparisonOperationRule.php | 6 +- ...ctReadWritePropertiesExtensionProvider.php | 23 ----- ...zyReadWritePropertiesExtensionProvider.php | 24 ----- .../ReadWritePropertiesExtension.php | 2 +- .../ReadWritePropertiesExtensionProvider.php | 15 --- .../TooWidePropertyTypeRule.php | 12 ++- src/Testing/PHPStanTestCase.php | 12 +-- src/Testing/RuleTestCase.php | 35 ++++--- src/Testing/TypeInferenceTestCase.php | 28 ++++-- .../DynamicFunctionThrowTypeExtension.php | 3 +- src/Type/DynamicMethodThrowTypeExtension.php | 3 +- .../DynamicReturnTypeExtensionRegistry.php | 25 +++-- .../DynamicStaticMethodThrowTypeExtension.php | 3 +- ...xpressionTypeResolverExtensionRegistry.php | 25 ----- .../FunctionParameterClosureThisExtension.php | 3 +- .../FunctionParameterClosureTypeExtension.php | 3 +- .../FunctionParameterOutTypeExtension.php | 3 +- .../MethodParameterClosureThisExtension.php | 3 +- .../MethodParameterClosureTypeExtension.php | 3 +- src/Type/MethodParameterOutTypeExtension.php | 3 +- ...peratorTypeSpecifyingExtensionRegistry.php | 11 ++- ...ticMethodParameterClosureThisExtension.php | 3 +- ...ticMethodParameterClosureTypeExtension.php | 3 +- .../StaticMethodParameterOutTypeExtension.php | 3 +- ...peratorTypeSpecifyingExtensionRegistry.php | 11 ++- tests/PHPStan/Analyser/AnalyserTest.php | 35 ++++--- .../Fiber/FiberNodeScopeResolverRuleTest.php | 30 ++++-- .../Fiber/FiberNodeScopeResolverTest.php | 28 ++++-- .../AutowiredExtensionsExtensionTest.php | 66 +++++++++++++ .../TestedReadWritePropertiesExtension.php | 26 +++++ .../autowiredExtensions.neon | 5 + .../Rules/Api/ApiClassImplementsRuleTest.php | 2 +- .../Rules/Api/ApiInterfaceExtendsRuleTest.php | 2 +- .../Api/data/class-implements-in-phpstan.php | 8 +- .../data/class-implements-out-of-phpstan.php | 8 +- .../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 +- .../InvalidComparisonOperationRuleTest.php | 4 +- .../TooWidePropertyTypeRuleTest.php | 4 +- 93 files changed, 740 insertions(+), 864 deletions(-) delete mode 100644 src/Analyser/IgnoreErrorExtensionProvider.php create mode 100644 src/DependencyInjection/AutowiredExtensions.php create mode 100644 src/DependencyInjection/AutowiredExtensionsExtension.php create mode 100644 src/DependencyInjection/DirectExtensionsCollection.php create mode 100644 src/DependencyInjection/ExtensionsCollection.php create mode 100644 src/DependencyInjection/LazyExtensionsCollection.php delete mode 100644 src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/DynamicThrowTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/ExpressionTypeResolverExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyDynamicReturnTypeExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php delete mode 100644 src/DependencyInjection/Type/LazyExpressionTypeResolverExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/LazyOperatorTypeSpecifyingExtensionRegistryProvider.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/LazyUnaryOperatorTypeSpecifyingExtensionRegistryProvider.php delete mode 100644 src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.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/DependencyInjection/Type/UnaryOperatorTypeSpecifyingExtensionRegistryProvider.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 src/Type/ExpressionTypeResolverExtensionRegistry.php create mode 100644 tests/PHPStan/DependencyInjection/AutowiredExtensionsExtensionTest.php create mode 100644 tests/PHPStan/DependencyInjection/TestedReadWritePropertiesExtension.php create mode 100644 tests/PHPStan/DependencyInjection/autowiredExtensions.neon delete mode 100644 tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php diff --git a/conf/config.neon b/conf/config.neon index 3012ca68af2..f64d5491829 100644 --- a/conf/config.neon +++ b/conf/config.neon @@ -258,6 +258,7 @@ extensions: validateIgnoredErrors: PHPStan\DependencyInjection\ValidateIgnoredErrorsExtension validateExcludePaths: PHPStan\DependencyInjection\ValidateExcludePathsExtension autowiredAttributeServices: PHPStan\DependencyInjection\AutowiredAttributeServicesExtension + autowiredExtensions: PHPStan\DependencyInjection\AutowiredExtensionsExtension validateServiceTags: PHPStan\DependencyInjection\ValidateServiceTagsExtension fnsr: PHPStan\DependencyInjection\FnsrExtension diff --git a/src/Analyser/AnalyserResultFinalizer.php b/src/Analyser/AnalyserResultFinalizer.php index cc06cb3eee3..1688b4fd2f3 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(of: 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/DirectInternalScopeFactory.php b/src/Analyser/DirectInternalScopeFactory.php index 533d37c5f92..9cb78a28e8b 100644 --- a/src/Analyser/DirectInternalScopeFactory.php +++ b/src/Analyser/DirectInternalScopeFactory.php @@ -5,7 +5,7 @@ use PhpParser\Node; use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -15,6 +15,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\ClosureType; +use PHPStan\Type\ExpressionTypeResolverExtension; final class DirectInternalScopeFactory implements InternalScopeFactory { @@ -22,12 +23,13 @@ final class DirectInternalScopeFactory implements InternalScopeFactory /** * @param int|array{min: int, max: int}|null $configPhpVersion * @param callable(Node $node, Scope $scope): void|null $nodeCallback + * @param ExtensionsCollection $expressionTypeResolverExtensions */ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExtensionsCollection $expressionTypeResolverExtensions, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -71,7 +73,7 @@ public function create( $this, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider->getRegistry(), + $this->expressionTypeResolverExtensions, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -106,7 +108,7 @@ public function toFiberFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensions, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -126,7 +128,7 @@ public function toMutatingFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensions, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/DirectInternalScopeFactoryFactory.php b/src/Analyser/DirectInternalScopeFactoryFactory.php index 84b96d27a35..a9e4310a20c 100644 --- a/src/Analyser/DirectInternalScopeFactoryFactory.php +++ b/src/Analyser/DirectInternalScopeFactoryFactory.php @@ -4,7 +4,7 @@ use PhpParser\Node; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -12,18 +12,20 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Type\ExpressionTypeResolverExtension; final class DirectInternalScopeFactoryFactory implements InternalScopeFactoryFactory { /** * @param int|array{min: int, max: int}|null $configPhpVersion + * @param ExtensionsCollection $expressionTypeResolverExtensions */ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExtensionsCollection $expressionTypeResolverExtensions, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -45,7 +47,7 @@ public function create(?callable $nodeCallback): DirectInternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensions, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/ExprHandler/FuncCallHandler.php b/src/Analyser/ExprHandler/FuncCallHandler.php index 47efb2af7fe..958fda6500c 100644 --- a/src/Analyser/ExprHandler/FuncCallHandler.php +++ b/src/Analyser/ExprHandler/FuncCallHandler.php @@ -29,10 +29,10 @@ 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\Type\DynamicReturnTypeExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\ClosureReturnStatementsNode; use PHPStan\Node\Expr\NativeTypeExpr; use PHPStan\Node\Expr\PossiblyImpureCallExpr; @@ -53,6 +53,8 @@ use PHPStan\Type\ClosureType; 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; @@ -88,10 +90,14 @@ final class FuncCallHandler implements ExprHandler { + /** + * @param ExtensionsCollection $dynamicFunctionThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + #[AutowiredExtensions(of: DynamicFunctionThrowTypeExtension::class)] + private ExtensionsCollection $dynamicFunctionThrowTypeExtensions, + private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, #[AutowiredParameter] @@ -604,7 +610,7 @@ private function getFunctionThrowPoint( ExpressionContext $context, ): ?InternalThrowPoint { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicFunctionThrowTypeExtensions() as $extension) { + foreach ($this->dynamicFunctionThrowTypeExtensions->getAll() as $extension) { if (!$extension->isFunctionSupported($functionReflection)) { continue; } @@ -1002,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/Helper/MethodThrowPointHelper.php b/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php index 08ff8735587..2658beb2ce0 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 $dynamicMethodThrowTypeExtensions + * @param ExtensionsCollection $dynamicStaticMethodThrowTypeExtensions + */ public function __construct( - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, + #[AutowiredExtensions(of: DynamicMethodThrowTypeExtension::class)] + private ExtensionsCollection $dynamicMethodThrowTypeExtensions, + #[AutowiredExtensions(of: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $dynamicStaticMethodThrowTypeExtensions, #[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->dynamicMethodThrowTypeExtensions->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->dynamicStaticMethodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isStaticMethodSupported($methodReflection)) { continue; } diff --git a/src/Analyser/ExprHandler/NewHandler.php b/src/Analyser/ExprHandler/NewHandler.php index 111fe38a682..75c9a3cef97 100644 --- a/src/Analyser/ExprHandler/NewHandler.php +++ b/src/Analyser/ExprHandler/NewHandler.php @@ -26,10 +26,10 @@ 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\Type\DynamicReturnTypeExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\MethodReturnStatementsNode; use PHPStan\Parser\NewAssignedToPropertyVisitor; use PHPStan\Reflection\Callables\SimpleImpurePoint; @@ -42,6 +42,8 @@ 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; use PHPStan\Type\Generic\GenericStaticType; @@ -71,10 +73,14 @@ final class NewHandler implements ExprHandler { + /** + * @param ExtensionsCollection $dynamicStaticMethodThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + #[AutowiredExtensions(of: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $dynamicStaticMethodThrowTypeExtensions, + private DynamicReturnTypeExtensionRegistry $dynamicReturnTypeExtensionRegistry, private PropertyReflectionFinder $propertyReflectionFinder, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $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->dynamicStaticMethodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isStaticMethodSupported($constructorReflection)) { continue; } @@ -401,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/FileAnalyser.php b/src/Analyser/FileAnalyser.php index 1870b581a69..99b1460c3b1 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(of: 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/Analyser/LazyInternalScopeFactory.php b/src/Analyser/LazyInternalScopeFactory.php index 30bad59a9a4..7b583633875 100644 --- a/src/Analyser/LazyInternalScopeFactory.php +++ b/src/Analyser/LazyInternalScopeFactory.php @@ -5,8 +5,8 @@ use PhpParser\Node; use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\GenerateFactory; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -16,7 +16,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\ClosureType; -use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; +use PHPStan\Type\ExpressionTypeResolverExtension; #[GenerateFactory(interface: InternalScopeFactoryFactory::class, resultType: LazyInternalScopeFactory::class)] final class LazyInternalScopeFactory implements InternalScopeFactory @@ -31,7 +31,8 @@ final class LazyInternalScopeFactory implements InternalScopeFactory private ?InitializerExprTypeResolver $initializerExprTypeResolver = null; - private ?ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry = null; + /** @var ExtensionsCollection|null */ + private ?ExtensionsCollection $expressionTypeResolverExtensions = null; private ?ExprPrinter $exprPrinter = null; @@ -84,7 +85,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->expressionTypeResolverExtensions ??= $this->container->getExtensionsCollection(ExpressionTypeResolverExtension::class); $this->exprPrinter ??= $this->container->getByType(ExprPrinter::class); $this->typeSpecifier ??= $this->container->getByType(TypeSpecifier::class); $this->propertyReflectionFinder ??= $this->container->getByType(PropertyReflectionFinder::class); @@ -99,7 +100,7 @@ public function create( $this, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistry, + $this->expressionTypeResolverExtensions, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php index 8a2e5c78f88..58c962b05a0 100644 --- a/src/Analyser/MutatingScope.php +++ b/src/Analyser/MutatingScope.php @@ -24,6 +24,7 @@ use PHPStan\Analyser\Traverser\TransformStaticTypeTraverser; use PHPStan\Collectors\Collector; use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\EmitCollectedDataNode; use PHPStan\Node\Expr\AlwaysRememberedExpr; use PHPStan\Node\Expr\CloneReinitializationExpr; @@ -78,7 +79,7 @@ use PHPStan\Type\Constant\ConstantStringType; use PHPStan\Type\ConstantTypeHelper; use PHPStan\Type\ErrorType; -use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; +use PHPStan\Type\ExpressionTypeResolverExtension; use PHPStan\Type\GeneralizePrecision; use PHPStan\Type\Generic\TemplateTypeHelper; use PHPStan\Type\Generic\TemplateTypeMap; @@ -169,13 +170,14 @@ class MutatingScope implements Scope, NodeCallbackInvoker, CollectedDataEmitter * @param array $currentlyAllowedUndefinedExpressions * @param array $nativeExpressionTypes * @param list $inFunctionCallsStack + * @param ExtensionsCollection $expressionTypeResolverExtensions */ public function __construct( private Container $container, protected InternalScopeFactory $scopeFactory, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry, + private ExtensionsCollection $expressionTypeResolverExtensions, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -1057,7 +1059,7 @@ public function getClosureScopeCacheKey(): string private function resolveType(string $exprString, Expr $node): Type { - foreach ($this->expressionTypeResolverExtensionRegistry->getExtensions() as $extension) { + foreach ($this->expressionTypeResolverExtensions->getAll() as $extension) { $type = $extension->getType($node, $this); if ($type !== null) { return $type; diff --git a/src/Analyser/NodeScopeResolver.php b/src/Analyser/NodeScopeResolver.php index 72f087b400d..7cb8aa28052 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(of: FunctionParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterOutTypeExtensions, + #[AutowiredExtensions(of: MethodParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterOutTypeExtensions, + #[AutowiredExtensions(of: 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(of: ReadWritePropertiesExtension::class)] + private readonly ExtensionsCollection $readWritePropertiesExtensions, + #[AutowiredExtensions(of: FunctionParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureThisExtensions, + #[AutowiredExtensions(of: MethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureThisExtensions, + #[AutowiredExtensions(of: StaticMethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterClosureThisExtensions, + #[AutowiredExtensions(of: FunctionParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureTypeExtensions, + #[AutowiredExtensions(of: MethodParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureTypeExtensions, + #[AutowiredExtensions(of: 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/AutowiredExtensions.php b/src/DependencyInjection/AutowiredExtensions.php new file mode 100644 index 00000000000..19f98785ffd --- /dev/null +++ b/src/DependencyInjection/AutowiredExtensions.php @@ -0,0 +1,27 @@ +getContainerBuilder(); + foreach (ValidateServiceTagsExtension::getInterfaceTagMapping() as $interface => $tag) { + $builder->addDefinition(self::getCollectionServiceName($interface)) + ->setType(LazyExtensionsCollection::class) + ->setArgument('tagName', $tag) + ->setAutowired(false); + } + } + + #[Override] + public function beforeCompile(): void + { + require_once __DIR__ . '/../../vendor/attributes.php'; + $builder = $this->getContainerBuilder(); + $mapping = ValidateServiceTagsExtension::getInterfaceTagMapping(); + + $parametersByClass = []; + foreach (Attributes::findTargetMethodParameters(AutowiredExtensions::class) as $parameter) { + if (strcasecmp($parameter->method, '__construct') !== 0) { + throw new ShouldNotHappenException(sprintf('Attribute #[AutowiredExtensions] is only supported on constructor parameters, found on %s::%s() $%s.', $parameter->class, $parameter->method, $parameter->name)); + } + if (!array_key_exists($parameter->attribute->of, $mapping)) { + throw new ShouldNotHappenException(sprintf('Interface %s referenced by #[AutowiredExtensions] on %s::__construct() $%s is not marked with the #[ExtensionInterface] attribute.', $parameter->attribute->of, $parameter->class, $parameter->name)); + } + + $nativeType = null; + foreach ((new ReflectionMethod($parameter->class, '__construct'))->getParameters() as $constructorParameter) { + if ($constructorParameter->getName() !== $parameter->name) { + continue; + } + + $nativeType = $constructorParameter->getType(); + break; + } + if (!$nativeType instanceof ReflectionNamedType || $nativeType->getName() !== ExtensionsCollection::class) { + throw new ShouldNotHappenException(sprintf('Parameter $%s of %s::__construct() with #[AutowiredExtensions] must have the native type %s.', $parameter->name, $parameter->class, ExtensionsCollection::class)); + } + + $parametersByClass[strtolower($parameter->class)][] = $parameter; + } + + 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 ($parametersByClass[strtolower($className)] ?? [] as $parameter) { + $definition->setArgument($parameter->name, new Reference(self::getCollectionServiceName($parameter->attribute->of))); + } + } + } + +} diff --git a/src/DependencyInjection/Container.php b/src/DependencyInjection/Container.php index c14892ca232..8df43be4f72 100644 --- a/src/DependencyInjection/Container.php +++ b/src/DependencyInjection/Container.php @@ -31,6 +31,18 @@ public function getByType(string $className); */ public function findServiceNamesByType(string $className): array; + /** + * Returns a lazy collection of all registered extensions implementing the given extension interface. + * + * The interface must be marked with the #[ExtensionInterface] attribute. + * + * @template T of object + * @param class-string $extensionInterfaceName + * @return ExtensionsCollection + * @throws MissingServiceException + */ + public function getExtensionsCollection(string $extensionInterfaceName): ExtensionsCollection; + /** * @return mixed[] */ diff --git a/src/DependencyInjection/DirectExtensionsCollection.php b/src/DependencyInjection/DirectExtensionsCollection.php new file mode 100644 index 00000000000..7dedefbe83e --- /dev/null +++ b/src/DependencyInjection/DirectExtensionsCollection.php @@ -0,0 +1,32 @@ + + */ +final class DirectExtensionsCollection implements ExtensionsCollection +{ + + /** @var list */ + private array $extensions; + + /** + * @param array $extensions + */ + public function __construct(array $extensions) + { + $this->extensions = array_values($extensions); + } + + public function getAll(): array + { + return $this->extensions; + } + +} diff --git a/src/DependencyInjection/ExtensionsCollection.php b/src/DependencyInjection/ExtensionsCollection.php new file mode 100644 index 00000000000..6b89074ff09 --- /dev/null +++ b/src/DependencyInjection/ExtensionsCollection.php @@ -0,0 +1,28 @@ + + */ + public function getAll(): array; + +} diff --git a/src/DependencyInjection/LazyExtensionsCollection.php b/src/DependencyInjection/LazyExtensionsCollection.php new file mode 100644 index 00000000000..60f5c2d60c9 --- /dev/null +++ b/src/DependencyInjection/LazyExtensionsCollection.php @@ -0,0 +1,32 @@ + + */ +final class LazyExtensionsCollection implements ExtensionsCollection +{ + + /** @var list|null */ + private ?array $extensions = null; + + public function __construct( + private Container $container, + private string $tagName, + ) + { + } + + public function getAll(): array + { + return $this->extensions ??= array_values($this->container->getServicesByTag($this->tagName)); + } + +} diff --git a/src/DependencyInjection/MemoizingContainer.php b/src/DependencyInjection/MemoizingContainer.php index b4730deadf0..643f4b3687c 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 $extensionsCollections = []; + 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 $extensionInterfaceName + * @return ExtensionsCollection + */ + public function getExtensionsCollection(string $extensionInterfaceName): ExtensionsCollection + { + /** @var ExtensionsCollection */ + return $this->extensionsCollections[$extensionInterfaceName] ??= $this->originalContainer->getExtensionsCollection($extensionInterfaceName); + } + public function getParameters(): array { return $this->originalContainer->getParameters(); diff --git a/src/DependencyInjection/Nette/NetteContainer.php b/src/DependencyInjection/Nette/NetteContainer.php index f5ae4164d65..c0f48b8a689 100644 --- a/src/DependencyInjection/Nette/NetteContainer.php +++ b/src/DependencyInjection/Nette/NetteContainer.php @@ -2,13 +2,16 @@ namespace PHPStan\DependencyInjection\Nette; +use PHPStan\DependencyInjection\AutowiredExtensionsExtension; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\MissingServiceException; use PHPStan\DependencyInjection\ParameterNotFoundException; use function array_key_exists; use function array_keys; use function array_map; +use function sprintf; /** * @internal @@ -66,6 +69,22 @@ public function findServiceNamesByType(string $className): array return $this->container->findByType($className); } + /** + * @template T of object + * @param class-string $extensionInterfaceName + * @return ExtensionsCollection + */ + public function getExtensionsCollection(string $extensionInterfaceName): ExtensionsCollection + { + $serviceName = AutowiredExtensionsExtension::getCollectionServiceName($extensionInterfaceName); + if (!$this->container->hasService($serviceName)) { + throw new MissingServiceException(sprintf('%s is not an extension interface marked with the #[ExtensionInterface] attribute.', $extensionInterfaceName)); + } + + /** @var ExtensionsCollection */ + return $this->getService($serviceName); + } + /** * @return mixed[] */ 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/LazyDynamicThrowTypeExtensionProvider.php b/src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php deleted file mode 100644 index 1a56f432684..00000000000 --- a/src/DependencyInjection/Type/LazyDynamicThrowTypeExtensionProvider.php +++ /dev/null @@ -1,35 +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/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/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/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 @@ - $readWritePropertiesExtensions * @param ClassPropertyNode[] $properties * @param array $propertyUsages * @param array $methodCalls @@ -44,7 +46,7 @@ final class ClassPropertiesNode extends NodeAbstract implements VirtualNode */ 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/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/Constants/AlwaysUsedClassConstantsExtension.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php index 63a66a1e97f..8dc8e821e6d 100644 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php +++ b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php @@ -23,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.constants.alwaysUsedClassConstantsExtension')] interface AlwaysUsedClassConstantsExtension { 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..5a0f01f3acb 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(of: 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..4a442bf489d 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(of: 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..b96c6f58bee 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; @@ -32,11 +34,13 @@ final class UnusedPrivatePropertyRule implements Rule { /** + * @param ExtensionsCollection $extensions * @param string[] $alwaysWrittenTags * @param string[] $alwaysReadTags */ public function __construct( - private ReadWritePropertiesExtensionProvider $extensionProvider, + #[AutowiredExtensions(of: 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..4a4123c4048 100644 --- a/src/Rules/Methods/AlwaysUsedMethodExtension.php +++ b/src/Rules/Methods/AlwaysUsedMethodExtension.php @@ -20,7 +20,7 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedMethodExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.methods.alwaysUsedMethodExtension')] interface AlwaysUsedMethodExtension { 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/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/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..66fda5c1433 100644 --- a/src/Rules/Properties/ReadWritePropertiesExtension.php +++ b/src/Rules/Properties/ReadWritePropertiesExtension.php @@ -23,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: ReadWritePropertiesExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.properties.readWriteExtension')] interface ReadWritePropertiesExtension { 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(of: 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/PHPStanTestCase.php b/src/Testing/PHPStanTestCase.php index 2845f997681..d06c9e3b41a 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\ExpressionTypeResolverExtension; +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->getExtensionsCollection(ExpressionTypeResolverExtension::class), $container->getByType(ExprPrinter::class), $typeSpecifier, new PropertyReflectionFinder(), diff --git a/src/Testing/RuleTestCase.php b/src/Testing/RuleTestCase.php index 7f137660159..7f70e1f0317 100644 --- a/src/Testing/RuleTestCase.php +++ b/src/Testing/RuleTestCase.php @@ -9,7 +9,7 @@ use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; use PHPStan\Analyser\Fiber\FiberNodeScopeResolver; use PHPStan\Analyser\FileAnalyser; -use PHPStan\Analyser\IgnoreErrorExtensionProvider; +use PHPStan\Analyser\IgnoreErrorExtension; use PHPStan\Analyser\InternalError; use PHPStan\Analyser\LocalIgnoresProcessor; use PHPStan\Analyser\NodeScopeResolver; @@ -19,9 +19,7 @@ use PHPStan\Collectors\Registry as CollectorRegistry; use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\PackageDependencyResolver; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\FileReader; use PHPStan\Fixable\Patcher; @@ -31,11 +29,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; @@ -100,15 +105,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + self::getContainer()->getExtensionsCollection(FunctionParameterOutTypeExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterOutTypeExtension::class), + self::getContainer()->getExtensionsCollection(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) : self::getContainer()->getExtensionsCollection(ReadWritePropertiesExtension::class), + self::getContainer()->getExtensionsCollection(FunctionParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterClosureTypeExtension::class), + self::getContainer()->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $this->shouldPolluteScopeWithLoopInitialAssignments(), @@ -138,7 +149,7 @@ private function getAnalyser(DirectRuleRegistry $ruleRegistry): Analyser $this->getParser(), self::getContainer()->getByType(DependencyResolver::class), self::getContainer()->getByType(PackageDependencyResolver::class), - new IgnoreErrorExtensionProvider(self::getContainer()), + self::getContainer()->getExtensionsCollection(IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), new LocalIgnoresProcessor(), false, @@ -324,7 +335,7 @@ private function gatherAnalyserErrorsWithDelayedErrors(array $files): array $finalizer = new AnalyserResultFinalizer( $ruleRegistry, - new IgnoreErrorExtensionProvider(self::getContainer()), + self::getContainer()->getExtensionsCollection(IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), self::createScopeFactory($reflectionProvider, self::getContainer()->getService('typeSpecifier')), new LocalIgnoresProcessor(), diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 7723560fd06..6dbcfd5f4c9 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -12,9 +12,6 @@ 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\File\FileHelper; use PHPStan\File\SystemAgnosticSimpleRelativePathHelper; use PHPStan\Node\DeepNodeCloner; @@ -24,11 +21,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 +80,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + $container->getExtensionsCollection(FunctionParameterOutTypeExtension::class), + $container->getExtensionsCollection(MethodParameterOutTypeExtension::class), + $container->getExtensionsCollection(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), + $container->getExtensionsCollection(ReadWritePropertiesExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureThisExtension::class), + $container->getExtensionsCollection(MethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), + $container->getExtensionsCollection(MethodParameterClosureTypeExtension::class), + $container->getExtensionsCollection(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..95ece186e6b 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicFunctionThrowTypeExtension')] interface DynamicFunctionThrowTypeExtension { diff --git a/src/Type/DynamicMethodThrowTypeExtension.php b/src/Type/DynamicMethodThrowTypeExtension.php index 5d9fce22b61..4a51da06e9a 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicMethodThrowTypeExtension')] interface DynamicMethodThrowTypeExtension { diff --git a/src/Type/DynamicReturnTypeExtensionRegistry.php b/src/Type/DynamicReturnTypeExtensionRegistry.php index bceef62997e..5002627ec5f 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(of: DynamicMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicMethodReturnTypeExtensions, + #[AutowiredExtensions(of: DynamicStaticMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicStaticMethodReturnTypeExtensions, + #[AutowiredExtensions(of: 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/DynamicStaticMethodThrowTypeExtension.php b/src/Type/DynamicStaticMethodThrowTypeExtension.php index 1dc3c5334fb..034a10cac0c 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicStaticMethodThrowTypeExtension')] interface DynamicStaticMethodThrowTypeExtension { diff --git a/src/Type/ExpressionTypeResolverExtensionRegistry.php b/src/Type/ExpressionTypeResolverExtensionRegistry.php deleted file mode 100644 index 1d9dc436c07..00000000000 --- a/src/Type/ExpressionTypeResolverExtensionRegistry.php +++ /dev/null @@ -1,25 +0,0 @@ - $extensions - */ - public function __construct( - private array $extensions, - ) - { - } - - /** - * @return array - */ - public function getExtensions(): array - { - return $this->extensions; - } - -} diff --git a/src/Type/FunctionParameterClosureThisExtension.php b/src/Type/FunctionParameterClosureThisExtension.php index 7b56a8d30fb..dbd24b934e0 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterClosureThisExtension')] interface FunctionParameterClosureThisExtension { diff --git a/src/Type/FunctionParameterClosureTypeExtension.php b/src/Type/FunctionParameterClosureTypeExtension.php index bffc1a191a4..1a4e62813bd 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterClosureTypeExtension')] interface FunctionParameterClosureTypeExtension { diff --git a/src/Type/FunctionParameterOutTypeExtension.php b/src/Type/FunctionParameterOutTypeExtension.php index 9f7de7e0312..6522028dced 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterOutTypeExtension')] interface FunctionParameterOutTypeExtension { diff --git a/src/Type/MethodParameterClosureThisExtension.php b/src/Type/MethodParameterClosureThisExtension.php index ebab7d31f30..f2f00a90245 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterClosureThisExtension')] interface MethodParameterClosureThisExtension { diff --git a/src/Type/MethodParameterClosureTypeExtension.php b/src/Type/MethodParameterClosureTypeExtension.php index 0f372bfa449..1931970dd7a 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterClosureTypeExtension')] interface MethodParameterClosureTypeExtension { diff --git a/src/Type/MethodParameterOutTypeExtension.php b/src/Type/MethodParameterOutTypeExtension.php index e11c4b33ea5..c28bb7f9e25 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterOutTypeExtension')] interface MethodParameterOutTypeExtension { diff --git a/src/Type/OperatorTypeSpecifyingExtensionRegistry.php b/src/Type/OperatorTypeSpecifyingExtensionRegistry.php index bb830a69449..ae042d55290 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(of: 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/StaticMethodParameterClosureThisExtension.php b/src/Type/StaticMethodParameterClosureThisExtension.php index 78946073ac4..53dce95c119 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,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterClosureThisExtension')] interface StaticMethodParameterClosureThisExtension { diff --git a/src/Type/StaticMethodParameterClosureTypeExtension.php b/src/Type/StaticMethodParameterClosureTypeExtension.php index 341f1805d5e..1e74985cf37 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterClosureTypeExtension')] interface StaticMethodParameterClosureTypeExtension { diff --git a/src/Type/StaticMethodParameterOutTypeExtension.php b/src/Type/StaticMethodParameterOutTypeExtension.php index 73572de9bf6..7eed9c50690 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,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterOutTypeExtension')] interface StaticMethodParameterOutTypeExtension { diff --git a/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php b/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php index 0e643195988..db77628bd5c 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(of: 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/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 6f781f28a25..f0ef5957003 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,10 +12,7 @@ use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\ExportedNodeResolver; use PHPStan\Dependency\PackageDependencyResolver; -use PHPStan\DependencyInjection\Nette\NetteContainer; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Node\DeepNodeCloner; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Node\Printer\Printer; @@ -26,9 +22,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; @@ -771,7 +776,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(), @@ -816,15 +821,21 @@ private function createAnalyser(): Analyser $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + $container->getExtensionsCollection(FunctionParameterOutTypeExtension::class), + $container->getExtensionsCollection(MethodParameterOutTypeExtension::class), + $container->getExtensionsCollection(StaticMethodParameterOutTypeExtension::class), $this->getParser(), $fileTypeMapper, $phpDocInheritanceResolver, $fileHelper, $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + $container->getExtensionsCollection(ReadWritePropertiesExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureThisExtension::class), + $container->getExtensionsCollection(MethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), + $container->getExtensionsCollection(MethodParameterClosureTypeExtension::class), + $container->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), false, @@ -848,7 +859,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/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php index 0a1804341a6..fa04faa0d0d 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php @@ -6,21 +6,27 @@ 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\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 +125,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + self::getContainer()->getExtensionsCollection(FunctionParameterOutTypeExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterOutTypeExtension::class), + self::getContainer()->getExtensionsCollection(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) : self::getContainer()->getExtensionsCollection(ReadWritePropertiesExtension::class), + self::getContainer()->getExtensionsCollection(FunctionParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + self::getContainer()->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), + self::getContainer()->getExtensionsCollection(MethodParameterClosureTypeExtension::class), + self::getContainer()->getExtensionsCollection(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..5ede52160a9 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php @@ -4,17 +4,23 @@ 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\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 +58,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + $container->getExtensionsCollection(FunctionParameterOutTypeExtension::class), + $container->getExtensionsCollection(MethodParameterOutTypeExtension::class), + $container->getExtensionsCollection(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), + $container->getExtensionsCollection(ReadWritePropertiesExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureThisExtension::class), + $container->getExtensionsCollection(MethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(StaticMethodParameterClosureThisExtension::class), + $container->getExtensionsCollection(FunctionParameterClosureTypeExtension::class), + $container->getExtensionsCollection(MethodParameterClosureTypeExtension::class), + $container->getExtensionsCollection(StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), $container->getParameter('polluteScopeWithLoopInitialAssignments'), diff --git a/tests/PHPStan/DependencyInjection/AutowiredExtensionsExtensionTest.php b/tests/PHPStan/DependencyInjection/AutowiredExtensionsExtensionTest.php new file mode 100644 index 00000000000..797b08482ac --- /dev/null +++ b/tests/PHPStan/DependencyInjection/AutowiredExtensionsExtensionTest.php @@ -0,0 +1,66 @@ +create($tmpDir, [__DIR__ . '/autowiredExtensions.neon'], []); + } + + public function testGetExtensions(): void + { + $container = self::createContainer(); + $extensions = $container->getExtensionsCollection(ReadWritePropertiesExtension::class)->getAll(); + $this->assertCount(1, $extensions); + $this->assertInstanceOf(TestedReadWritePropertiesExtension::class, $extensions[0]); + } + + public function testGetExtensionsCollectionIsLazyAndMemoized(): void + { + $container = self::createContainer(); + $collection = $container->getExtensionsCollection(ReadWritePropertiesExtension::class); + $this->assertInstanceOf(LazyExtensionsCollection::class, $collection); + $this->assertSame($collection->getAll(), $collection->getAll()); + $this->assertSame($collection, $container->getExtensionsCollection(ReadWritePropertiesExtension::class)); + } + + public function testGetExtensionsForUnknownInterface(): void + { + $container = self::createContainer(); + $this->expectException(MissingServiceException::class); + $this->expectExceptionMessage('Countable is not an extension interface marked with the #[ExtensionInterface] attribute.'); + $container->getExtensionsCollection(Countable::class); + } + + public function testAliasOfServiceWithAutowiredExtensionsParameterIsLeftAlone(): void + { + $container = self::createContainer(); + $this->assertSame( + $container->getService('currentPhpVersionRichParser'), + $container->getService('testAliasedRichParser'), + ); + } + +} diff --git a/tests/PHPStan/DependencyInjection/TestedReadWritePropertiesExtension.php b/tests/PHPStan/DependencyInjection/TestedReadWritePropertiesExtension.php new file mode 100644 index 00000000000..08df037265d --- /dev/null +++ b/tests/PHPStan/DependencyInjection/TestedReadWritePropertiesExtension.php @@ -0,0 +1,26 @@ +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, ], 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..f21d8056738 100644 --- a/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php @@ -4,15 +4,15 @@ 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\Type\DynamicFunctionThrowTypeExtension; -class Foo implements DynamicThrowTypeExtensionProvider +class Foo implements ReflectionProviderProvider { - public function getDynamicFunctionThrowTypeExtensions(): array + public function getReflectionProvider(): \PHPStan\Reflection\ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } public function getDynamicMethodThrowTypeExtensions(): array 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..69735317357 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,11 +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(): \PHPStan\Reflection\ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } public function getDynamicMethodThrowTypeExtensions(): array 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/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, ); } 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 f0276bd169e27baf018dad0b40d812327928c8a5 Mon Sep 17 00:00:00 2001 From: Ondrej Mirtes Date: Fri, 24 Jul 2026 22:24:03 +0100 Subject: [PATCH 2/2] Convert DeprecationProvider and all inline getServicesByTag() callers to extension collections Services whose Container dependency existed only to pull a tagged extension list now inject an ExtensionsCollection via #[AutowiredExtensions]: DeprecationProvider (seven deprecation extension collections), the ten RestrictedUsage rules, InstantiationRule, ClassNameCheck, ClassForbiddenNameCheck, ConstructorsHelper, DefaultStubFilesProvider, LazyRegistry, Collectors\RegistryFactory, ResultCacheManager and RichParser. Callers that keep the Container for other reasons (TypeSpecifierFactory, PromoteParameterRule, ExprHandlerRegistry, AnalyseCommand, DiagnoseCommand, and the kept ClassReflection/TypeNodeResolver registry providers) switch from getServicesByTag() to the typed Container::getExtensions(). AdditionalConstructorsExtension, ConstantDeprecationExtension and ForbiddenClassNameExtension now carry #[ExtensionInterface] - they declared service tags but were missing from the interface-tag mapping, so their tagged services were never validated. AutowiredExtensionsExtension now skips definitions whose creator is not the class itself - a service aliasing another (factory: @otherService), like TestCase.neon's currentPhpVersionSimpleParser, resolves getType() to the aliased class and must not receive constructor arguments. The only remaining getServicesByTag() caller is StubValidator, whose stub-validation rule tag is a second tag on Rule services and cannot appear in the one-to-one interface-tag mapping. Co-Authored-By: Claude Fable 5 Claude-Session: https://claude.ai/code/session_01NPozex9wKR84GgzFQ6Vx5o --- phpstan-baseline.neon | 4 +- src/Analyser/ExprHandlerRegistry.php | 2 +- .../ResultCache/ResultCacheManager.php | 9 ++- src/Analyser/TypeSpecifierFactory.php | 25 +++--- src/Classes/ForbiddenClassNameExtension.php | 3 + src/Collectors/RegistryFactory.php | 14 +++- src/Command/AnalyseCommand.php | 3 +- src/Command/DiagnoseCommand.php | 3 +- .../AutowiredExtensionsExtension.php | 9 +++ ...assReflectionExtensionRegistryProvider.php | 10 ++- src/Parser/RichParser.php | 12 ++- src/PhpDoc/DefaultStubFilesProvider.php | 9 ++- ...eNodeResolverExtensionRegistryProvider.php | 2 +- .../AdditionalConstructorsExtension.php | 3 + src/Reflection/ConstructorsHelper.php | 10 ++- .../ConstantDeprecationExtension.php | 2 + .../Deprecation/DeprecationProvider.php | 76 ++++++++----------- src/Rules/ClassForbiddenNameCheck.php | 13 +++- src/Rules/ClassNameCheck.php | 15 ++-- src/Rules/Classes/InstantiationRule.php | 15 ++-- src/Rules/LazyRegistry.php | 25 +++--- 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 +- .../autowiredExtensions.neon | 6 ++ .../PhpDoc/DefaultStubFilesProviderTest.php | 2 +- .../Rules/Classes/ClassAttributesRuleTest.php | 6 +- .../ClassConstantAttributesRuleTest.php | 6 +- .../Rules/Classes/ClassConstantRuleTest.php | 6 +- .../ExistingClassInClassExtendsRuleTest.php | 6 +- .../ExistingClassInInstanceOfRuleTest.php | 6 +- .../ExistingClassInTraitUseRuleTest.php | 6 +- ...istingClassesInClassImplementsRuleTest.php | 6 +- ...xistingClassesInEnumImplementsRuleTest.php | 6 +- ...stingClassesInInterfaceExtendsRuleTest.php | 6 +- .../ForbiddenNameCheckExtensionRuleTest.php | 9 ++- .../Rules/Classes/InstantiationRuleTest.php | 9 ++- .../Classes/LocalTypeAliasesRuleTest.php | 6 +- .../Classes/LocalTypeTraitAliasesRuleTest.php | 6 +- .../LocalTypeTraitUseAliasesRuleTest.php | 6 +- .../Rules/Classes/MethodTagRuleTest.php | 6 +- .../Rules/Classes/MethodTagTraitRuleTest.php | 6 +- .../Classes/MethodTagTraitUseRuleTest.php | 6 +- tests/PHPStan/Rules/Classes/MixinRuleTest.php | 6 +- .../Rules/Classes/MixinTraitRuleTest.php | 6 +- .../Rules/Classes/MixinTraitUseRuleTest.php | 6 +- .../Rules/Classes/PropertyTagRuleTest.php | 6 +- .../Classes/PropertyTagTraitRuleTest.php | 6 +- .../Classes/PropertyTagTraitUseRuleTest.php | 6 +- .../Constants/ConstantAttributesRuleTest.php | 6 +- .../EnumCases/EnumCaseAttributesRuleTest.php | 6 +- .../CaughtExceptionExistenceRuleTest.php | 6 +- .../ArrowFunctionAttributesRuleTest.php | 6 +- .../Functions/ClosureAttributesRuleTest.php | 6 +- ...lassesInArrowFunctionTypehintsRuleTest.php | 6 +- ...stingClassesInClosureTypehintsRuleTest.php | 6 +- .../ExistingClassesInTypehintsRuleTest.php | 6 +- .../Functions/FunctionAttributesRuleTest.php | 6 +- .../Functions/ParamAttributesRuleTest.php | 6 +- .../Generics/ClassTemplateTypeRuleTest.php | 6 +- .../Generics/FunctionTemplateTypeRuleTest.php | 6 +- .../InterfaceTemplateTypeRuleTest.php | 6 +- .../MethodTagTemplateTypeRuleTest.php | 6 +- .../MethodTagTemplateTypeTraitRuleTest.php | 6 +- .../Generics/MethodTemplateTypeRuleTest.php | 6 +- .../Generics/TraitTemplateTypeRuleTest.php | 6 +- .../Methods/CallStaticMethodsRuleTest.php | 6 +- .../ExistingClassesInTypehintsRuleTest.php | 6 +- .../Methods/MethodAttributesRuleTest.php | 6 +- .../Methods/StaticMethodCallableRuleTest.php | 6 +- .../ExistingNamesInGroupUseRuleTest.php | 6 +- .../Namespaces/ExistingNamesInUseRuleTest.php | 6 +- .../Rules/PhpDoc/FunctionAssertRuleTest.php | 6 +- .../PhpDoc/IncompatiblePhpDocTypeRuleTest.php | 6 +- ...mpatiblePropertyHookPhpDocTypeRuleTest.php | 6 +- ...IncompatiblePropertyPhpDocTypeRuleTest.php | 6 +- .../InvalidPhpDocVarTagTypeRuleTest.php | 6 +- .../Rules/PhpDoc/MethodAssertRuleTest.php | 6 +- .../RequireExtendsDefinitionClassRuleTest.php | 6 +- .../RequireExtendsDefinitionTraitRuleTest.php | 6 +- ...quireImplementsDefinitionTraitRuleTest.php | 6 +- .../PhpDoc/SealedDefinitionClassRuleTest.php | 6 +- .../Playground/PromoteParameterRuleTest.php | 3 +- ...AccessStaticPropertiesInAssignRuleTest.php | 6 +- .../AccessStaticPropertiesRuleTest.php | 6 +- .../ExistingClassesInPropertiesRuleTest.php | 6 +- ...ClassesInPropertyHookTypehintsRuleTest.php | 6 +- ...ReadOnlyByPhpDocPropertyAssignRuleTest.php | 3 +- .../MissingReadOnlyPropertyAssignRuleTest.php | 3 +- .../Properties/PropertyAttributesRuleTest.php | 6 +- .../PropertyHookAttributesRuleTest.php | 6 +- ...ReadOnlyByPhpDocPropertyAssignRuleTest.php | 3 +- .../ReadOnlyPropertyAssignRuleTest.php | 3 +- .../UninitializedPropertyRuleTest.php | 3 +- .../RestrictedClassConstantUsageRuleTest.php | 2 +- ...estrictedFunctionCallableUsageRuleTest.php | 2 +- .../RestrictedFunctionUsageRuleTest.php | 2 +- .../RestrictedMethodCallableUsageRuleTest.php | 2 +- .../RestrictedMethodUsageRuleTest.php | 2 +- .../RestrictedPropertyUsageRuleTest.php | 2 +- ...ictedStaticMethodCallableUsageRuleTest.php | 2 +- .../RestrictedStaticMethodUsageRuleTest.php | 2 +- .../RestrictedStaticPropertyUsageRuleTest.php | 2 +- ...tedUsageOfDeprecatedStringCastRuleTest.php | 2 +- .../Rules/Traits/TraitAttributesRuleTest.php | 6 +- 114 files changed, 525 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..e389207d13e 100644 --- a/src/Analyser/ExprHandlerRegistry.php +++ b/src/Analyser/ExprHandlerRegistry.php @@ -42,7 +42,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->getExtensionsCollection(ExprHandler::class)->getAll() as $exprHandler) { if (!$exprHandler->supports($expr)) { continue; } diff --git a/src/Analyser/ResultCache/ResultCacheManager.php b/src/Analyser/ResultCache/ResultCacheManager.php index b603780145a..1e974237236 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(of: ResultCacheMetaExtension::class)] + private ExtensionsCollection $resultCacheMetaExtensions, private ExportedNodeFetcher $exportedNodeFetcher, #[AutowiredParameter(ref: '@fileFinderScan')] private FileFinder $scanFileFinder, @@ -1540,7 +1543,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..fc4abda69c6 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->getExtensionsCollection(FunctionTypeSpecifyingExtension::class)->getAll(); + $methodTypeSpecifying = $this->container->getExtensionsCollection(MethodTypeSpecifyingExtension::class)->getAll(); + $staticMethodTypeSpecifying = $this->container->getExtensionsCollection(StaticMethodTypeSpecifyingExtension::class)->getAll(); $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->getExtensionsCollection(PropertiesClassReflectionExtension::class)->getAll(), + $this->container->getExtensionsCollection(MethodsClassReflectionExtension::class)->getAll(), + $this->container->getExtensionsCollection(DynamicMethodReturnTypeExtension::class)->getAll(), + $this->container->getExtensionsCollection(DynamicStaticMethodReturnTypeExtension::class)->getAll(), + $this->container->getExtensionsCollection(DynamicFunctionReturnTypeExtension::class)->getAll(), $functionTypeSpecifying, $methodTypeSpecifying, $staticMethodTypeSpecifying, 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/Collectors/RegistryFactory.php b/src/Collectors/RegistryFactory.php index a95dbe2a51d..8ae688dc04e 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(of: 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..b874dff3183 100644 --- a/src/Command/AnalyseCommand.php +++ b/src/Command/AnalyseCommand.php @@ -879,8 +879,7 @@ private function runDiagnoseExtensions(Container $container, Output $errorOutput // not using tag for this extension to make sure it's always first $phpstanDiagnoseExtension->print($errorOutput, $processedFiles); - /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensionsCollection(DiagnoseExtension::class)->getAll() as $extension) { $extension->print($errorOutput); } } diff --git a/src/Command/DiagnoseCommand.php b/src/Command/DiagnoseCommand.php index 371bfcfa1aa..b489269e01c 100644 --- a/src/Command/DiagnoseCommand.php +++ b/src/Command/DiagnoseCommand.php @@ -101,8 +101,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int // not using tag for this extension to make sure it's always first $phpstanDiagnoseExtension->print($output, []); - /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensionsCollection(DiagnoseExtension::class)->getAll() as $extension) { $extension->print($output); } diff --git a/src/DependencyInjection/AutowiredExtensionsExtension.php b/src/DependencyInjection/AutowiredExtensionsExtension.php index de85ad26f4d..16f7a10db03 100644 --- a/src/DependencyInjection/AutowiredExtensionsExtension.php +++ b/src/DependencyInjection/AutowiredExtensionsExtension.php @@ -12,6 +12,7 @@ use ReflectionMethod; use ReflectionNamedType; use function array_key_exists; +use function is_string; use function sprintf; use function str_replace; use function strcasecmp; @@ -89,6 +90,14 @@ public function beforeCompile(): void if ($className === null) { continue; } + + // only wire arguments into definitions that actually invoke the constructor, + // not aliases of other services (factory: @otherService) or method factories + $creatorEntity = $definition->getCreator()->getEntity(); + if ($creatorEntity !== null && (!is_string($creatorEntity) || strcasecmp($creatorEntity, $className) !== 0)) { + continue; + } + foreach ($parametersByClass[strtolower($className)] ?? [] as $parameter) { $definition->setArgument($parameter->name, new Reference(self::getCollectionServiceName($parameter->attribute->of))); } diff --git a/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php b/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php index a4722245e3d..680376ba533 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->getExtensionsCollection(PropertiesClassReflectionExtension::class)->getAll(), [$annotationsPropertiesClassReflectionExtension, $mixinPropertiesClassReflectionExtension, $universalObjectCratesClassReflectionExtension]), + array_merge($container->getExtensionsCollection(MethodsClassReflectionExtension::class)->getAll(), [$annotationsMethodsClassReflectionExtension, $mixinMethodsClassReflectionExtension, $soapClientMethodsClassReflectionExtension]), + $container->getExtensionsCollection(AllowedSubTypesClassReflectionExtension::class)->getAll(), $container->getByType(RequireExtendsPropertiesClassReflectionExtension::class), $container->getByType(RequireExtendsMethodsClassReflectionExtension::class), $container->getByType(PhpClassReflectionExtension::class), diff --git a/src/Parser/RichParser.php b/src/Parser/RichParser.php index d23ecb227aa..75adc400405 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 $nodeVisitors + */ public function __construct( private \PhpParser\Parser $parser, private NameResolver $nameResolver, - private Container $container, + #[AutowiredExtensions(of: NodeVisitor::class)] + private ExtensionsCollection $nodeVisitors, 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->nodeVisitors->getAll() as $visitor) { $nodeTraverser->addVisitor($visitor); } diff --git a/src/PhpDoc/DefaultStubFilesProvider.php b/src/PhpDoc/DefaultStubFilesProvider.php index 6b9edcdadbb..0409304b261 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; @@ -25,11 +26,13 @@ final class DefaultStubFilesProvider implements StubFilesProvider private ?array $cachedProjectFiles = null; /** + * @param ExtensionsCollection $stubFilesExtensions * @param string[] $stubFiles * @param string[] $composerAutoloaderProjectPaths */ public function __construct( - private Container $container, + #[AutowiredExtensions(of: StubFilesExtension::class)] + private ExtensionsCollection $stubFilesExtensions, private FileHelper $fileHelper, #[AutowiredParameter] private array $stubFiles, @@ -46,7 +49,7 @@ public function getStubFiles(): array } $files = array_map(fn ($path) => $this->fileHelper->normalizePath($path), $this->stubFiles); - $extensions = $this->container->getServicesByTag(StubFilesExtension::EXTENSION_TAG); + $extensions = $this->stubFilesExtensions->getAll(); foreach ($extensions as $extension) { foreach ($extension->getFiles() as $extensionFile) { $files[] = $this->fileHelper->normalizePath($extensionFile); diff --git a/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php b/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php index eb0a48b337d..5b017fe0b0c 100644 --- a/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php +++ b/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php @@ -19,7 +19,7 @@ public function getRegistry(): TypeNodeResolverExtensionRegistry { return $this->registry ??= new TypeNodeResolverExtensionAwareRegistry( $this->container->getByType(TypeNodeResolver::class), - $this->container->getServicesByTag(TypeNodeResolverExtension::EXTENSION_TAG), + $this->container->getExtensionsCollection(TypeNodeResolverExtension::class)->getAll(), ); } diff --git a/src/Reflection/AdditionalConstructorsExtension.php b/src/Reflection/AdditionalConstructorsExtension.php index ad9995b64c5..9f20fe8b5bb 100644 --- a/src/Reflection/AdditionalConstructorsExtension.php +++ b/src/Reflection/AdditionalConstructorsExtension.php @@ -2,6 +2,8 @@ namespace PHPStan\Reflection; +use PHPStan\DependencyInjection\ExtensionInterface; + /** * This is the extension interface to implement if you want to dynamically * mark methods as constructor. As opposed to simply list them in the configuration file. @@ -18,6 +20,7 @@ * * @api */ +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface AdditionalConstructorsExtension { diff --git a/src/Reflection/ConstructorsHelper.php b/src/Reflection/ConstructorsHelper.php index fc38d722982..464e3d626c4 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; @@ -17,10 +18,12 @@ final class ConstructorsHelper private array $additionalConstructorsCache = []; /** + * @param ExtensionsCollection $additionalConstructorsExtensions * @param list $additionalConstructors */ public function __construct( - private Container $container, + #[AutowiredExtensions(of: AdditionalConstructorsExtension::class)] + private ExtensionsCollection $additionalConstructorsExtensions, #[AutowiredParameter] private array $additionalConstructors, ) @@ -40,8 +43,7 @@ public function getConstructors(ClassReflection $classReflection): array $constructors[] = $classReflection->getConstructor()->getName(); } - /** @var AdditionalConstructorsExtension[] $extensions */ - $extensions = $this->container->getServicesByTag(AdditionalConstructorsExtension::EXTENSION_TAG); + $extensions = $this->additionalConstructorsExtensions->getAll(); foreach ($extensions as $extension) { $extensionConstructors = $extension->getAdditionalConstructors($classReflection); foreach ($extensionConstructors as $extensionConstructor) { diff --git a/src/Reflection/Deprecation/ConstantDeprecationExtension.php b/src/Reflection/Deprecation/ConstantDeprecationExtension.php index 20dbf09016a..fd1b90b447c 100644 --- a/src/Reflection/Deprecation/ConstantDeprecationExtension.php +++ b/src/Reflection/Deprecation/ConstantDeprecationExtension.php @@ -3,6 +3,7 @@ namespace PHPStan\Reflection\Deprecation; use PHPStan\BetterReflection\Reflection\ReflectionConstant; +use PHPStan\DependencyInjection\ExtensionInterface; /** * This interface allows you to provide custom deprecation information @@ -19,6 +20,7 @@ * * @api */ +#[ExtensionInterface(tag: self::CONSTANT_EXTENSION_TAG)] interface ConstantDeprecationExtension { diff --git a/src/Reflection/Deprecation/DeprecationProvider.php b/src/Reflection/Deprecation/DeprecationProvider.php index ebd25cde0db..8abf0320448 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 $classDeprecationExtensions + * @param ExtensionsCollection $classConstantDeprecationExtensions + * @param ExtensionsCollection $constantDeprecationExtensions + * @param ExtensionsCollection $enumCaseDeprecationExtensions + * @param ExtensionsCollection $functionDeprecationExtensions + * @param ExtensionsCollection $methodDeprecationExtensions + * @param ExtensionsCollection $propertyDeprecationExtensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(of: ClassDeprecationExtension::class)] + private ExtensionsCollection $classDeprecationExtensions, + #[AutowiredExtensions(of: ClassConstantDeprecationExtension::class)] + private ExtensionsCollection $classConstantDeprecationExtensions, + #[AutowiredExtensions(of: ConstantDeprecationExtension::class)] + private ExtensionsCollection $constantDeprecationExtensions, + #[AutowiredExtensions(of: EnumCaseDeprecationExtension::class)] + private ExtensionsCollection $enumCaseDeprecationExtensions, + #[AutowiredExtensions(of: FunctionDeprecationExtension::class)] + private ExtensionsCollection $functionDeprecationExtensions, + #[AutowiredExtensions(of: MethodDeprecationExtension::class)] + private ExtensionsCollection $methodDeprecationExtensions, + #[AutowiredExtensions(of: PropertyDeprecationExtension::class)] + private ExtensionsCollection $propertyDeprecationExtensions, ) { } 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..6caed8c5954 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(of: 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..6764eee7761 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(of: 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..f0b4f4bf424 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(of: 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..feb0593424e 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(of: Rule::class)] + private ExtensionsCollection $rules, + ) { } @@ -35,7 +42,7 @@ public function getRules(string $nodeType): array $parentNodeTypes = [$nodeType] + class_parents($nodeType) + class_implements($nodeType); $rules = []; - $rulesFromContainer = $this->getRulesFromContainer(); + $rulesFromContainer = $this->getRulesByNodeType(); foreach ($parentNodeTypes as $parentNodeType) { foreach ($rulesFromContainer[$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) { + foreach ($this->rules->getAll() as $rule) { $rules[$rule->getNodeType()][] = $rule; } - return $this->rules = $rules; + return $this->rulesByNodeType = $rules; } } diff --git a/src/Rules/Playground/PromoteParameterRule.php b/src/Rules/Playground/PromoteParameterRule.php index d01b77c530e..22a1c6aeedc 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->getExtensionsCollection(Rule::class)->getAll(); $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..43505b34532 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(of: 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..8f570c8e640 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(of: 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..5c27299f6fd 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(of: 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..f983f281f4c 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(of: 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..7a869fddef4 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(of: 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..1d3dc8a126a 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(of: 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..cc5b2b46f28 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(of: 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..7028d8e68c5 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(of: 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..da220231c7c 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(of: 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..4641a2f19d6 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(of: 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 f0ef5957003..fbdcabe9546 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; @@ -854,7 +855,7 @@ private function createAnalyser(): Analyser new RichParser( new Php7($lexer), new NameResolver(), - $container, + $container->getExtensionsCollection(NodeVisitor::class), new IgnoreLexer(), ), new DependencyResolver($fileHelper, $reflectionProvider, new ExportedNodeResolver($reflectionProvider, $fileTypeMapper, new ExprPrinter(new Printer())), $fileTypeMapper), diff --git a/tests/PHPStan/DependencyInjection/autowiredExtensions.neon b/tests/PHPStan/DependencyInjection/autowiredExtensions.neon index 34808a4eada..ab6db03dfd9 100644 --- a/tests/PHPStan/DependencyInjection/autowiredExtensions.neon +++ b/tests/PHPStan/DependencyInjection/autowiredExtensions.neon @@ -3,3 +3,9 @@ services: class: PHPStan\DependencyInjection\TestedReadWritePropertiesExtension tags: - phpstan.properties.readWriteExtension + + # alias of a service whose class has #[AutowiredExtensions] parameters - + # the compiler pass must not wire constructor arguments into the alias + testAliasedRichParser: + factory: @currentPhpVersionRichParser + autowired: false diff --git a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php index eef6033cfdd..3603e5c0989 100644 --- a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php +++ b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php @@ -64,7 +64,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($this->getContainer()->getExtensionsCollection(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..a9e75314f24 100644 --- a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -54,9 +56,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php index 82d35191085..5e1e49d1c54 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -49,9 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php index 7e2e6d8b86e..a6109480c32 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php @@ -2,10 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +41,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..5901eac6ad8 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule return new ExistingClassInClassExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php index 30512a74c3c..8447534ec9c 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php index 55c86b9fb02..20764ec57a7 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule return new ExistingClassInTraitUseRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php index cef3fee647d..c2e53f1bf89 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule return new ExistingClassesInClassImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php index 8a9f99cebf4..89eb29cbb35 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +25,9 @@ protected function getRule(): Rule return new ExistingClassesInEnumImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php index 3a97ab00196..c0e1c3bb9a8 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule return new ExistingClassesInInterfaceExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php index a075fb6bb42..0c5c640b794 100644 --- a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +10,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 +38,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + $container->getExtensionsCollection(RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -50,9 +53,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php index 105257b4993..f4cc96575bf 100644 --- a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php +++ b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +10,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 +40,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + $container->getExtensionsCollection(RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -52,9 +55,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php index 8b1e6ebd23e..965595f31e1 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +10,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 +34,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php index e2c0836fe7f..fc2ab495270 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +10,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 +33,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php index dd998ea14cf..1fe15dc1f13 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +10,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 +33,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php index 21cf1a62b9d..11744b0e0ca 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..39e19c1f75e 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..7a44a8678ca 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..3917a32459b 100644 --- a/tests/PHPStan/Rules/Classes/MixinRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..d5b81db9812 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..ff62fca13a3 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..78a9c6dfc52 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..7bd77d248e8 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..d83dd814962 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..a9d853a3907 100644 --- a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Constants; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -11,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; @@ -58,9 +60,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php index 2e4dc4462ea..d2d76782cc0 100644 --- a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php +++ b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\EnumCases; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -50,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php index 312ef01b058..2f4df6b049a 100644 --- a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php +++ b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Exceptions; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php index 48384cb74da..80c987474cd 100644 --- a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -49,9 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php index 661cf08dc5e..ec1d69de635 100644 --- a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -49,9 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php index 5026167c935..d1d9f60c591 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +33,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..85105d76474 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +33,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..7d9f3510747 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +33,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..0ad877c2c30 100644 --- a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -49,9 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php index d7a77b3d814..32747cba13e 100644 --- a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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; @@ -49,9 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php index 2632e3334df..53efb228d7f 100644 --- a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php index 2ecba0fc61d..8a069c297c7 100644 --- a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php index 34115b037a3..e677a32397f 100644 --- a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php index d8b2582bc19..f2ca7568a4d 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php index a47ea46988c..9ddd6e983af 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php index 872d525b002..7db505c2de3 100644 --- a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php index 9336e1d8734..e99d6add8b1 100644 --- a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php index cc31101ece2..1f7e6a8a0e1 100644 --- a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +10,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 +54,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php index 4193804ed4d..b0d2d53bff3 100644 --- a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +33,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..d9f2516fdb2 100644 --- a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,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 +54,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php index d5186cf16f0..68cc6f11545 100644 --- a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php +++ b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php @@ -2,10 +2,12 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +46,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php index 89ccc73cb8b..5e87a88814e 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php index ab27893aed6..192dd386388 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +24,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php b/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php index 247ce2a0075..8a2b0319043 100644 --- a/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +27,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..7c224a027c3 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +36,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php index b40c3f21559..ef942fccdf4 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +36,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php index 34e8c292802..ac5fd037f04 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +33,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php index 4153877cea7..aa3146393b4 100644 --- a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..b1685af8529 100644 --- a/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +27,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..18862d28d8d 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php index 97707a262b9..6f4b957c845 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php index c1703565d4a..aec90d4ffae 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +26,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php index dfd91efc498..fae52e4c7b8 100644 --- a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php @@ -2,9 +2,11 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +26,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php index fc4942719b7..c4f8b0f4cb7 100644 --- a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php +++ b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php @@ -3,6 +3,7 @@ namespace PHPStan\Rules\Playground; use PHPStan\Node\ClassPropertiesNode; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Properties\UninitializedPropertyRule; use PHPStan\Rules\Rule; @@ -19,7 +20,7 @@ protected function getRule(): Rule $container = self::getContainer(); return new PromoteParameterRule( new UninitializedPropertyRule(new ConstructorsHelper( - $container, + $container->getExtensionsCollection(AdditionalConstructorsExtension::class), [], )), $container, diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php index f8ddba0d610..2fc183a83e6 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php @@ -2,10 +2,12 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +38,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(self::getContainer()->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + self::getContainer()->getExtensionsCollection(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..fbef5055d71 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php @@ -2,10 +2,12 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +37,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(self::getContainer()->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + self::getContainer()->getExtensionsCollection(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..369e071b7ec 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php @@ -2,11 +2,13 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..59d38242a56 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php @@ -2,12 +2,14 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; 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 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(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..7d296db1152 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -19,7 +20,7 @@ protected function getRule(): Rule { return new MissingReadOnlyByPhpDocPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + self::getContainer()->getExtensionsCollection(AdditionalConstructorsExtension::class), [ 'MissingReadOnlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php index 1f6332b72dd..6e9a1b98c9a 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +21,7 @@ protected function getRule(): Rule { return new MissingReadOnlyPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + self::getContainer()->getExtensionsCollection(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..a35a951753e 100644 --- a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -10,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; @@ -51,9 +53,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php index d007f02c39e..385ff733bf3 100644 --- a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +10,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 +51,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php index c52d60b8f75..59c6b998966 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -18,7 +19,7 @@ protected function getRule(): Rule return new ReadOnlyByPhpDocPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + self::getContainer()->getExtensionsCollection(AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php index d062d09af14..b351211ea98 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php @@ -3,6 +3,7 @@ namespace PHPStan\Rules\Properties; use PHPStan\Php\PhpVersion; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -21,7 +22,7 @@ protected function getRule(): Rule return new ReadOnlyPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + self::getContainer()->getExtensionsCollection(AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssign\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php index d1b137e35cd..b89b1e75959 100644 --- a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php +++ b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +21,7 @@ protected function getRule(): Rule { return new UninitializedPropertyRule( new ConstructorsHelper( - self::getContainer(), + self::getContainer()->getExtensionsCollection(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..460af0a1fd8 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php @@ -16,7 +16,7 @@ protected function getRule(): Rule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedClassConstantUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedClassConstantUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php index 52656ce167f..6d1eea1db8a 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php @@ -15,7 +15,7 @@ class RestrictedFunctionCallableUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionCallableUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php index d96412eab90..10b5f9fce00 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php @@ -14,7 +14,7 @@ class RestrictedFunctionUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php index c690bb46249..331116731e8 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php @@ -15,7 +15,7 @@ class RestrictedMethodCallableUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodCallableUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php index dd7aac599a4..d3c6fa093cd 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php @@ -14,7 +14,7 @@ class RestrictedMethodUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php index 2fd50f13ad9..f011b645f9c 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php @@ -14,7 +14,7 @@ class RestrictedPropertyUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedPropertyUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedPropertyUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php index d3bfce59003..a643faf3034 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php @@ -17,7 +17,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodCallableUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php index 7684f1f70e1..11c4d674504 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php @@ -17,7 +17,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php index 9f1e9f8fb9d..9d8fa01f6d7 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php @@ -16,7 +16,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticPropertyUsageRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedPropertyUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php index 660acdad201..d6ed16a496b 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php @@ -14,7 +14,7 @@ class RestrictedUsageOfDeprecatedStringCastRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedUsageOfDeprecatedStringCastRule( - self::getContainer(), + self::getContainer()->getExtensionsCollection(RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php index 68caade88a1..68fea35dcde 100644 --- a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php @@ -3,6 +3,8 @@ namespace PHPStan\Rules\Traits; use PHPStan\Php\PhpVersion; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; +use PHPStan\Classes\ForbiddenClassNameExtension; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -56,9 +58,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck($container->getExtensionsCollection(ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + $container->getExtensionsCollection(RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ),