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/phpstan-baseline.neon b/phpstan-baseline.neon index 246d46dee0d..eb07cf1b571 100644 --- a/phpstan-baseline.neon +++ b/phpstan-baseline.neon @@ -688,7 +688,13 @@ 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::__construct() has parameter $rules with generic interface PHPStan\Rules\Rule but does not specify its types: TNodeType' + identifier: missingType.generics + count: 1 + path: src/Rules/LazyRegistry.php + + - + 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 +706,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/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..cf93e9d167f 100644 --- a/src/Analyser/DirectInternalScopeFactory.php +++ b/src/Analyser/DirectInternalScopeFactory.php @@ -5,7 +5,6 @@ use PhpParser\Node; use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -15,6 +14,7 @@ use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\ClosureType; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; final class DirectInternalScopeFactory implements InternalScopeFactory { @@ -27,7 +27,7 @@ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -71,7 +71,7 @@ public function create( $this, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider->getRegistry(), + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -106,7 +106,7 @@ public function toFiberFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, @@ -126,7 +126,7 @@ public function toMutatingFactory(): InternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/DirectInternalScopeFactoryFactory.php b/src/Analyser/DirectInternalScopeFactoryFactory.php index 84b96d27a35..4f7042f7e3b 100644 --- a/src/Analyser/DirectInternalScopeFactoryFactory.php +++ b/src/Analyser/DirectInternalScopeFactoryFactory.php @@ -4,7 +4,6 @@ use PhpParser\Node; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -12,6 +11,7 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; final class DirectInternalScopeFactoryFactory implements InternalScopeFactoryFactory { @@ -23,7 +23,7 @@ public function __construct( private Container $container, private ReflectionProvider $reflectionProvider, private InitializerExprTypeResolver $initializerExprTypeResolver, - private ExpressionTypeResolverExtensionRegistryProvider $expressionTypeResolverExtensionRegistryProvider, + private ExpressionTypeResolverExtensionRegistry $expressionTypeResolverExtensionRegistry, private ExprPrinter $exprPrinter, private TypeSpecifier $typeSpecifier, private PropertyReflectionFinder $propertyReflectionFinder, @@ -45,7 +45,7 @@ public function create(?callable $nodeCallback): DirectInternalScopeFactory $this->container, $this->reflectionProvider, $this->initializerExprTypeResolver, - $this->expressionTypeResolverExtensionRegistryProvider, + $this->expressionTypeResolverExtensionRegistry, $this->exprPrinter, $this->typeSpecifier, $this->propertyReflectionFinder, diff --git a/src/Analyser/ExprHandler/FuncCallHandler.php b/src/Analyser/ExprHandler/FuncCallHandler.php index 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/ExprHandlerRegistry.php b/src/Analyser/ExprHandlerRegistry.php index 95d74897719..baa34185ae7 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->getExtensions(ExprHandler::class) as $exprHandler) { if (!$exprHandler->supports($expr)) { 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..5609fb750ca 100644 --- a/src/Analyser/LazyInternalScopeFactory.php +++ b/src/Analyser/LazyInternalScopeFactory.php @@ -6,7 +6,6 @@ use PHPStan\Analyser\Fiber\FiberScope; use PHPStan\DependencyInjection\Container; use PHPStan\DependencyInjection\GenerateFactory; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\PhpVersion; @@ -84,7 +83,7 @@ public function create( $this->reflectionProvider ??= $this->container->getByType(ReflectionProvider::class); $this->initializerExprTypeResolver ??= $this->container->getByType(InitializerExprTypeResolver::class); - $this->expressionTypeResolverExtensionRegistry ??= $this->container->getByType(ExpressionTypeResolverExtensionRegistryProvider::class)->getRegistry(); + $this->expressionTypeResolverExtensionRegistry ??= $this->container->getByType(ExpressionTypeResolverExtensionRegistry::class); $this->exprPrinter ??= $this->container->getByType(ExprPrinter::class); $this->typeSpecifier ??= $this->container->getByType(TypeSpecifier::class); $this->propertyReflectionFinder ??= $this->container->getByType(PropertyReflectionFinder::class); diff --git a/src/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/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..61cb065a736 100644 --- a/src/Analyser/TypeSpecifierFactory.php +++ b/src/Analyser/TypeSpecifierFactory.php @@ -2,11 +2,18 @@ namespace PHPStan\Analyser; -use PHPStan\Broker\BrokerFactory; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; use PHPStan\Node\Printer\ExprPrinter; +use PHPStan\Reflection\MethodsClassReflectionExtension; +use PHPStan\Reflection\PropertiesClassReflectionExtension; use PHPStan\Reflection\ReflectionProvider; +use PHPStan\Type\DynamicFunctionReturnTypeExtension; +use PHPStan\Type\DynamicMethodReturnTypeExtension; +use PHPStan\Type\DynamicStaticMethodReturnTypeExtension; +use PHPStan\Type\FunctionTypeSpecifyingExtension; +use PHPStan\Type\MethodTypeSpecifyingExtension; +use PHPStan\Type\StaticMethodTypeSpecifyingExtension; use function array_merge; #[AutowiredService(name: 'typeSpecifierFactory')] @@ -23,9 +30,9 @@ public function __construct(private Container $container) public function create(): TypeSpecifier { - $functionTypeSpecifying = $this->container->getServicesByTag(self::FUNCTION_TYPE_SPECIFYING_EXTENSION_TAG); - $methodTypeSpecifying = $this->container->getServicesByTag(self::METHOD_TYPE_SPECIFYING_EXTENSION_TAG); - $staticMethodTypeSpecifying = $this->container->getServicesByTag(self::STATIC_METHOD_TYPE_SPECIFYING_EXTENSION_TAG); + $functionTypeSpecifying = $this->container->getExtensions(FunctionTypeSpecifyingExtension::class); + $methodTypeSpecifying = $this->container->getExtensions(MethodTypeSpecifyingExtension::class); + $staticMethodTypeSpecifying = $this->container->getExtensions(StaticMethodTypeSpecifyingExtension::class); $typeSpecifier = new TypeSpecifier( $this->container->getByType(ExprPrinter::class), @@ -38,11 +45,11 @@ public function create(): TypeSpecifier ); foreach (array_merge( - $this->container->getServicesByTag(BrokerFactory::PROPERTIES_CLASS_REFLECTION_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::METHODS_CLASS_REFLECTION_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_STATIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_FUNCTION_RETURN_TYPE_EXTENSION_TAG), + $this->container->getExtensions(PropertiesClassReflectionExtension::class), + $this->container->getExtensions(MethodsClassReflectionExtension::class), + $this->container->getExtensions(DynamicMethodReturnTypeExtension::class), + $this->container->getExtensions(DynamicStaticMethodReturnTypeExtension::class), + $this->container->getExtensions(DynamicFunctionReturnTypeExtension::class), $functionTypeSpecifying, $methodTypeSpecifying, $staticMethodTypeSpecifying, diff --git a/src/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..cf4ad72e7dc 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->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($errorOutput); } } diff --git a/src/Command/DiagnoseCommand.php b/src/Command/DiagnoseCommand.php index 371bfcfa1aa..970e9de5804 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->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($output); } 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 = (new ReflectionParameter([$parameter->class, '__construct'], $parameter->name))->getType(); + 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; + } + + // 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/Container.php b/src/DependencyInjection/Container.php index c14892ca232..033273ac13d 100644 --- a/src/DependencyInjection/Container.php +++ b/src/DependencyInjection/Container.php @@ -31,6 +31,30 @@ public function getByType(string $className); */ public function findServiceNamesByType(string $className): array; + /** + * Returns 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 list + * @throws MissingServiceException + */ + public function getExtensions(string $extensionInterfaceName): 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..7c8110a4b72 100644 --- a/src/DependencyInjection/MemoizingContainer.php +++ b/src/DependencyInjection/MemoizingContainer.php @@ -15,6 +15,12 @@ final class MemoizingContainer implements Container /** @var array */ private array $servicesByTag = []; + /** @var array> */ + private array $extensionsCollections = []; + + /** @var array> */ + private array $extensions = []; + public function __construct( #[AutowiredParameter(ref: '@PHPStan\DependencyInjection\Nette\NetteContainer')] private Container $originalContainer, @@ -47,6 +53,28 @@ public function getServicesByTag(string $tagName): array return $this->servicesByTag[$tagName] ??= $this->originalContainer->getServicesByTag($tagName); } + /** + * @template T of object + * @param class-string $extensionInterfaceName + * @return list + */ + public function getExtensions(string $extensionInterfaceName): array + { + /** @var list */ + return $this->extensions[$extensionInterfaceName] ??= $this->getExtensionsCollection($extensionInterfaceName)->getAll(); + } + + /** + * @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..6d52729b343 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,32 @@ public function findServiceNamesByType(string $className): array return $this->container->findByType($className); } + /** + * @template T of object + * @param class-string $extensionInterfaceName + * @return list + */ + public function getExtensions(string $extensionInterfaceName): array + { + return $this->getExtensionsCollection($extensionInterfaceName)->getAll(); + } + + /** + * @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/Reflection/LazyClassReflectionExtensionRegistryProvider.php b/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php index a4722245e3d..7bc1cc2b36d 100644 --- a/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php +++ b/src/DependencyInjection/Reflection/LazyClassReflectionExtensionRegistryProvider.php @@ -2,17 +2,19 @@ namespace PHPStan\DependencyInjection\Reflection; -use PHPStan\Broker\BrokerFactory; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; +use PHPStan\Reflection\AllowedSubTypesClassReflectionExtension; use PHPStan\Reflection\Annotations\AnnotationsMethodsClassReflectionExtension; use PHPStan\Reflection\Annotations\AnnotationsPropertiesClassReflectionExtension; use PHPStan\Reflection\ClassReflectionExtensionRegistry; +use PHPStan\Reflection\MethodsClassReflectionExtension; use PHPStan\Reflection\Mixin\MixinMethodsClassReflectionExtension; use PHPStan\Reflection\Mixin\MixinPropertiesClassReflectionExtension; use PHPStan\Reflection\Php\PhpClassReflectionExtension; use PHPStan\Reflection\Php\Soap\SoapClientMethodsClassReflectionExtension; use PHPStan\Reflection\Php\UniversalObjectCratesClassReflectionExtension; +use PHPStan\Reflection\PropertiesClassReflectionExtension; use PHPStan\Reflection\RequireExtension\RequireExtendsMethodsClassReflectionExtension; use PHPStan\Reflection\RequireExtension\RequireExtendsPropertiesClassReflectionExtension; use PHPStan\ShouldNotHappenException; @@ -45,9 +47,9 @@ public function getRegistry(): ClassReflectionExtensionRegistry $universalObjectCratesClassReflectionExtension = $container->getByType(UniversalObjectCratesClassReflectionExtension::class); $this->registry = new ClassReflectionExtensionRegistry( - array_merge($container->getServicesByTag(BrokerFactory::PROPERTIES_CLASS_REFLECTION_EXTENSION_TAG), [$annotationsPropertiesClassReflectionExtension, $mixinPropertiesClassReflectionExtension, $universalObjectCratesClassReflectionExtension]), - array_merge($container->getServicesByTag(BrokerFactory::METHODS_CLASS_REFLECTION_EXTENSION_TAG), [$annotationsMethodsClassReflectionExtension, $mixinMethodsClassReflectionExtension, $soapClientMethodsClassReflectionExtension]), - $container->getServicesByTag(BrokerFactory::ALLOWED_SUB_TYPES_CLASS_REFLECTION_EXTENSION_TAG), + array_merge($container->getExtensions(PropertiesClassReflectionExtension::class), [$annotationsPropertiesClassReflectionExtension, $mixinPropertiesClassReflectionExtension, $universalObjectCratesClassReflectionExtension]), + array_merge($container->getExtensions(MethodsClassReflectionExtension::class), [$annotationsMethodsClassReflectionExtension, $mixinMethodsClassReflectionExtension, $soapClientMethodsClassReflectionExtension]), + $container->getExtensions(AllowedSubTypesClassReflectionExtension::class), $container->getByType(RequireExtendsPropertiesClassReflectionExtension::class), $container->getByType(RequireExtendsMethodsClassReflectionExtension::class), $container->getByType(PhpClassReflectionExtension::class), diff --git a/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php b/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php deleted file mode 100644 index 14fb3eccefd..00000000000 --- a/src/DependencyInjection/Type/DynamicReturnTypeExtensionRegistryProvider.php +++ /dev/null @@ -1,12 +0,0 @@ -registry ??= new DynamicReturnTypeExtensionRegistry( - $this->container->getByType(ReflectionProvider::class), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_STATIC_METHOD_RETURN_TYPE_EXTENSION_TAG), - $this->container->getServicesByTag(BrokerFactory::DYNAMIC_FUNCTION_RETURN_TYPE_EXTENSION_TAG), - ); - } - -} diff --git a/src/DependencyInjection/Type/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/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..65959df75ee 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->getExtensions(TypeNodeResolverExtension::class), ); } 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/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/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/Constants/AlwaysUsedClassConstantsExtension.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php index 63a66a1e97f..b80d61ac01a 100644 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php +++ b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php @@ -23,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface AlwaysUsedClassConstantsExtension { + public const EXTENSION_TAG = 'phpstan.constants.alwaysUsedClassConstantsExtension'; + public function isAlwaysUsed(ClassConstantReflection $constant): bool; } diff --git a/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php deleted file mode 100644 index b0c0cbfd89b..00000000000 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ -extensions ??= $this->container->getServicesByTag(AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG); - } - -} diff --git a/src/Rules/DeadCode/UnusedPrivateConstantRule.php b/src/Rules/DeadCode/UnusedPrivateConstantRule.php index 7d3e2e1e997..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/LazyRegistry.php b/src/Rules/LazyRegistry.php index 4a55509947b..c23308bdf0e 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/Methods/AlwaysUsedMethodExtension.php b/src/Rules/Methods/AlwaysUsedMethodExtension.php index 048600fd8f8..aa61d933873 100644 --- a/src/Rules/Methods/AlwaysUsedMethodExtension.php +++ b/src/Rules/Methods/AlwaysUsedMethodExtension.php @@ -20,10 +20,12 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedMethodExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface AlwaysUsedMethodExtension { + public const EXTENSION_TAG = 'phpstan.methods.alwaysUsedMethodExtension'; + public function isAlwaysUsed(ExtendedMethodReflection $methodReflection): bool; } diff --git a/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php b/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php deleted file mode 100644 index 7452a738719..00000000000 --- a/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ -extensions; - } - -} diff --git a/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php b/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php deleted file mode 100644 index 1a2b49ee389..00000000000 --- a/src/Rules/Methods/LazyAlwaysUsedMethodExtensionProvider.php +++ /dev/null @@ -1,24 +0,0 @@ -extensions ??= $this->container->getServicesByTag(static::EXTENSION_TAG); - } - -} diff --git a/src/Rules/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/Playground/PromoteParameterRule.php b/src/Rules/Playground/PromoteParameterRule.php index d01b77c530e..bd9a97e862d 100644 --- a/src/Rules/Playground/PromoteParameterRule.php +++ b/src/Rules/Playground/PromoteParameterRule.php @@ -9,7 +9,6 @@ use PHPStan\DependencyInjection\Container; use PHPStan\DependencyInjection\MissingServiceException; use PHPStan\Rules\FixableNodeRuleError; -use PHPStan\Rules\LazyRegistry; use PHPStan\Rules\LineRuleError; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -63,7 +62,7 @@ private function getOriginalRule(): ?Rule try { /** @var Rule $originalRule */ $originalRule = $this->container->getByType(get_class($this->rule)); - $taggedRules = $this->container->getServicesByTag(LazyRegistry::RULE_TAG); + $taggedRules = $this->container->getExtensions(Rule::class); $found = false; foreach ($taggedRules as $rule) { if ($originalRule !== $rule) { diff --git a/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 0130c2f6336..00000000000 --- a/src/Rules/Properties/DirectReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,23 +0,0 @@ -extensions; - } - -} diff --git a/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 603c685105b..00000000000 --- a/src/Rules/Properties/LazyReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,24 +0,0 @@ -extensions ??= $this->container->getServicesByTag(ReadWritePropertiesExtensionProvider::EXTENSION_TAG); - } - -} diff --git a/src/Rules/Properties/ReadWritePropertiesExtension.php b/src/Rules/Properties/ReadWritePropertiesExtension.php index 71fe3e89ee0..b7ef5e47b79 100644 --- a/src/Rules/Properties/ReadWritePropertiesExtension.php +++ b/src/Rules/Properties/ReadWritePropertiesExtension.php @@ -23,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: ReadWritePropertiesExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface ReadWritePropertiesExtension { + public const EXTENSION_TAG = 'phpstan.properties.readWriteExtension'; + public function isAlwaysRead(ExtendedPropertyReflection $property, string $propertyName): bool; public function isAlwaysWritten(ExtendedPropertyReflection $property, string $propertyName): bool; diff --git a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 8b519aacd32..00000000000 --- a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ - $extensions + */ public function __construct( - private 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/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php b/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php index 387fbfbdcdb..4abaac8e9f6 100644 --- a/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php +++ b/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php @@ -4,10 +4,12 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassPropertiesNode; use PHPStan\Reflection\PropertyReflection; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use function sprintf; @@ -18,8 +20,12 @@ final class TooWidePropertyTypeRule implements Rule { + /** + * @param ExtensionsCollection $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..c0f717eae1b 100644 --- a/src/Testing/PHPStanTestCase.php +++ b/src/Testing/PHPStanTestCase.php @@ -10,9 +10,6 @@ use PHPStan\Analyser\TypeSpecifier; use PHPStan\BetterReflection\Reflector\Reflector; use PHPStan\DependencyInjection\Reflection\ClassReflectionExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\ExpressionTypeResolverExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\OperatorTypeSpecifyingExtensionRegistryProvider; -use PHPStan\DependencyInjection\Type\UnaryOperatorTypeSpecifyingExtensionRegistryProvider; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Parser\Parser; use PHPStan\Php\ComposerPhpVersionFactory; @@ -26,7 +23,10 @@ use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider; use PHPStan\Rules\Properties\PropertyReflectionFinder; use PHPStan\Type\Constant\OversizedArrayBuilder; +use PHPStan\Type\ExpressionTypeResolverExtensionRegistry; +use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\TypeAliasResolver; +use PHPStan\Type\UnaryOperatorTypeSpecifyingExtensionRegistry; use PHPStan\Type\UsefulTypeAliasResolver; use PHPUnit\Framework\ExpectationFailedException; use PHPUnit\Framework\TestCase; @@ -102,8 +102,8 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider $constantResolver, $reflectionProviderProvider, $container->getByType(PhpVersion::class), - $container->getByType(OperatorTypeSpecifyingExtensionRegistryProvider::class), - $container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistryProvider::class), + $container->getByType(OperatorTypeSpecifyingExtensionRegistry::class), + $container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistry::class), new OversizedArrayBuilder(), $container->getParameter('usePathConstantsAsConstantString'), ); @@ -113,7 +113,7 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider $container, $reflectionProvider, $initializerExprTypeResolver, - $container->getByType(ExpressionTypeResolverExtensionRegistryProvider::class), + $container->getByType(ExpressionTypeResolverExtensionRegistry::class), $container->getByType(ExprPrinter::class), $typeSpecifier, new PropertyReflectionFinder(), diff --git a/src/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..f980c44e039 100644 --- a/src/Type/DynamicFunctionThrowTypeExtension.php +++ b/src/Type/DynamicFunctionThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicFunctionThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicFunctionThrowTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection): bool; public function getThrowTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, Scope $scope): ?Type; diff --git a/src/Type/DynamicMethodThrowTypeExtension.php b/src/Type/DynamicMethodThrowTypeExtension.php index 5d9fce22b61..7dd2d60b473 100644 --- a/src/Type/DynamicMethodThrowTypeExtension.php +++ b/src/Type/DynamicMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicMethodThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicMethodThrowTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection): bool; public function getThrowTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, Scope $scope): ?Type; diff --git a/src/Type/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..57e0a16d3e3 100644 --- a/src/Type/DynamicStaticMethodThrowTypeExtension.php +++ b/src/Type/DynamicStaticMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface DynamicStaticMethodThrowTypeExtension { + public const EXTENSION_TAG = 'phpstan.dynamicStaticMethodThrowTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection): bool; public function getThrowTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, Scope $scope): ?Type; diff --git a/src/Type/ExpressionTypeResolverExtensionRegistry.php b/src/Type/ExpressionTypeResolverExtensionRegistry.php index 1d9dc436c07..a4257eda71d 100644 --- a/src/Type/ExpressionTypeResolverExtensionRegistry.php +++ b/src/Type/ExpressionTypeResolverExtensionRegistry.php @@ -2,14 +2,20 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; + +#[AutowiredService] final class ExpressionTypeResolverExtensionRegistry { /** - * @param array $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(of: ExpressionTypeResolverExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -19,7 +25,7 @@ public function __construct( */ public function getExtensions(): array { - return $this->extensions; + return $this->extensions->getAll(); } } diff --git a/src/Type/FunctionParameterClosureThisExtension.php b/src/Type/FunctionParameterClosureThisExtension.php index 7b56a8d30fb..14f8b4a75c2 100644 --- a/src/Type/FunctionParameterClosureThisExtension.php +++ b/src/Type/FunctionParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterClosureThisExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/FunctionParameterClosureTypeExtension.php b/src/Type/FunctionParameterClosureTypeExtension.php index bffc1a191a4..71941efb498 100644 --- a/src/Type/FunctionParameterClosureTypeExtension.php +++ b/src/Type/FunctionParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterClosureTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $functionCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/FunctionParameterOutTypeExtension.php b/src/Type/FunctionParameterOutTypeExtension.php index 9f7de7e0312..3284050bbfc 100644 --- a/src/Type/FunctionParameterOutTypeExtension.php +++ b/src/Type/FunctionParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface FunctionParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.functionParameterOutTypeExtension'; + public function isFunctionSupported(FunctionReflection $functionReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromFunctionCall(FunctionReflection $functionReflection, FuncCall $funcCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterClosureThisExtension.php b/src/Type/MethodParameterClosureThisExtension.php index ebab7d31f30..35d7474a4c5 100644 --- a/src/Type/MethodParameterClosureThisExtension.php +++ b/src/Type/MethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterClosureThisExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterClosureTypeExtension.php b/src/Type/MethodParameterClosureTypeExtension.php index 0f372bfa449..6b9da26a340 100644 --- a/src/Type/MethodParameterClosureTypeExtension.php +++ b/src/Type/MethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterClosureTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/MethodParameterOutTypeExtension.php b/src/Type/MethodParameterOutTypeExtension.php index e11c4b33ea5..2b138323cd5 100644 --- a/src/Type/MethodParameterOutTypeExtension.php +++ b/src/Type/MethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface MethodParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.methodParameterOutTypeExtension'; + public function isMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromMethodCall(MethodReflection $methodReflection, MethodCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/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..906ff672a5f 100644 --- a/src/Type/StaticMethodParameterClosureThisExtension.php +++ b/src/Type/StaticMethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,10 +24,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterClosureThisExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterClosureThisExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getClosureThisTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/StaticMethodParameterClosureTypeExtension.php b/src/Type/StaticMethodParameterClosureTypeExtension.php index 341f1805d5e..0f1f012bbf7 100644 --- a/src/Type/StaticMethodParameterClosureTypeExtension.php +++ b/src/Type/StaticMethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterClosureTypeExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterClosureTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/src/Type/StaticMethodParameterOutTypeExtension.php b/src/Type/StaticMethodParameterOutTypeExtension.php index 73572de9bf6..2f1c7e1a91b 100644 --- a/src/Type/StaticMethodParameterOutTypeExtension.php +++ b/src/Type/StaticMethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,10 +23,12 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: self::EXTENSION_TAG)] interface StaticMethodParameterOutTypeExtension { + public const EXTENSION_TAG = 'phpstan.staticMethodParameterOutTypeExtension'; + public function isStaticMethodSupported(MethodReflection $methodReflection, ParameterReflection $parameter): bool; public function getParameterOutTypeFromStaticMethodCall(MethodReflection $methodReflection, StaticCall $methodCall, ParameterReflection $parameter, Scope $scope): ?Type; diff --git a/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..fbdcabe9546 100644 --- a/tests/PHPStan/Analyser/AnalyserTest.php +++ b/tests/PHPStan/Analyser/AnalyserTest.php @@ -2,8 +2,8 @@ namespace PHPStan\Analyser; -use Nette\DI\Container; use PhpParser\Lexer; +use PhpParser\NodeVisitor; use PhpParser\NodeVisitor\NameResolver; use PhpParser\Parser\Php7; use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; @@ -13,10 +13,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 +23,18 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\AlwaysFailRule; use PHPStan\Rules\DirectRegistry as DirectRuleRegistry; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Testing\PHPStanTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPUnit\Framework\Attributes\DataProvider; use function array_map; use function array_merge; @@ -771,7 +777,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 +822,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, @@ -843,12 +855,12 @@ 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), 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..7df99554c85 --- /dev/null +++ b/tests/PHPStan/DependencyInjection/AutowiredExtensionsExtensionTest.php @@ -0,0 +1,84 @@ +create($tmpDir, [__DIR__ . '/autowiredExtensions.neon'], []); + } + + public function testGetExtensions(): void + { + $container = self::createContainer(); + $extensions = $container->getExtensions(ReadWritePropertiesExtension::class); + $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)); + $this->assertSame($container->getExtensions(ReadWritePropertiesExtension::class), $collection->getAll()); + } + + 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->getExtensions(Countable::class); + } + + public function testAliasOfServiceWithAutowiredExtensionsParameterIsLeftAlone(): void + { + $container = self::createContainer(); + $this->assertSame( + $container->getService('currentPhpVersionRichParser'), + $container->getService('testAliasedRichParser'), + ); + } + + public function testAutowiredExtensionsAttributeWiresConstructorParameters(): void + { + $container = self::createContainer(); + $nodeScopeResolver = $container->getByType(NodeScopeResolver::class); + + $property = new ReflectionProperty(NodeScopeResolver::class, 'readWritePropertiesExtensions'); + /** @var ExtensionsCollection $collection */ + $collection = $property->getValue($nodeScopeResolver); + + $this->assertInstanceOf(LazyExtensionsCollection::class, $collection); + $extensions = $collection->getAll(); + $this->assertCount(1, $extensions); + $this->assertInstanceOf(TestedReadWritePropertiesExtension::class, $extensions[0]); + } + +} 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 @@ +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/Api/ApiClassImplementsRuleTest.php b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php index 7d3246d0146..088b9b87de9 100644 --- a/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php @@ -31,7 +31,7 @@ public function testRuleOutOfPhpStan(): void $this->analyse([__DIR__ . '/data/class-implements-out-of-phpstan.php'], [ [ - 'Implementing PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', + 'Implementing PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', 20, $tip, ], 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/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/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/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/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/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/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), ); } 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, ),