diff --git a/phpstan-baseline.neon b/phpstan-baseline.neon index 246d46dee0..ed4a989bc7 100644 --- a/phpstan-baseline.neon +++ b/phpstan-baseline.neon @@ -133,7 +133,7 @@ parameters: path: src/Collectors/Collector.php - - rawMessage: 'Method PHPStan\Collectors\Registry::__construct() has parameter $collectors with generic interface PHPStan\Collectors\Collector but does not specify its types: TNodeType, TValue' + rawMessage: 'Method PHPStan\Collectors\Registry::getCollectorsByNodeType() return type with generic interface PHPStan\Collectors\Collector does not specify its types: TNodeType, TValue' identifier: missingType.generics count: 1 path: src/Collectors/Registry.php @@ -145,7 +145,7 @@ parameters: path: src/Collectors/Registry.php - - rawMessage: 'Property PHPStan\Collectors\Registry::$collectors with generic interface PHPStan\Collectors\Collector does not specify its types: TNodeType, TValue' + rawMessage: 'Property PHPStan\Collectors\Registry::$collectorsByNodeType with generic interface PHPStan\Collectors\Collector does not specify its types: TNodeType, TValue' identifier: missingType.generics count: 1 path: src/Collectors/Registry.php @@ -688,7 +688,7 @@ parameters: path: src/Rules/LazyRegistry.php - - rawMessage: 'Method PHPStan\Rules\LazyRegistry::getRulesFromContainer() return type with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' + rawMessage: 'Method PHPStan\Rules\LazyRegistry::getRulesByNodeType() return type with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' identifier: missingType.generics count: 1 path: src/Rules/LazyRegistry.php @@ -700,7 +700,7 @@ parameters: path: src/Rules/LazyRegistry.php - - rawMessage: 'Property PHPStan\Rules\LazyRegistry::$rules with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' + rawMessage: 'Property PHPStan\Rules\LazyRegistry::$rulesByNodeType with generic interface PHPStan\Rules\Rule does not specify its types: TNodeType' identifier: missingType.generics count: 1 path: src/Rules/LazyRegistry.php diff --git a/src/Analyser/AnalyserResultFinalizer.php b/src/Analyser/AnalyserResultFinalizer.php index cc06cb3eee..27ab917f08 100644 --- a/src/Analyser/AnalyserResultFinalizer.php +++ b/src/Analyser/AnalyserResultFinalizer.php @@ -6,8 +6,10 @@ use PHPStan\BetterReflection\NodeCompiler\Exception\UnableToCompileNode; use PHPStan\BetterReflection\Reflection\Exception\CircularReference; use PHPStan\BetterReflection\Reflector\Exception\IdentifierNotFound; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\CollectedDataNode; use PHPStan\Rules\Registry as RuleRegistry; use Throwable; @@ -20,9 +22,13 @@ final class AnalyserResultFinalizer { + /** + * @param ExtensionsCollection $ignoreErrorExtensions + */ public function __construct( private RuleRegistry $ruleRegistry, - private IgnoreErrorExtensionProvider $ignoreErrorExtensionProvider, + #[AutowiredExtensions(interface: IgnoreErrorExtension::class)] + private ExtensionsCollection $ignoreErrorExtensions, private RuleErrorTransformer $ruleErrorTransformer, private ScopeFactory $scopeFactory, private LocalIgnoresProcessor $localIgnoresProcessor, @@ -96,7 +102,7 @@ public function finalize(AnalyserResult $analyserResult, bool $onlyFiles, bool $ $error = $this->ruleErrorTransformer->transform($ruleError, $scope, [], $node); if ($error->canBeIgnored()) { - foreach ($this->ignoreErrorExtensionProvider->getExtensions() as $ignoreErrorExtension) { + foreach ($this->ignoreErrorExtensions->getAll() as $ignoreErrorExtension) { if ($ignoreErrorExtension->shouldIgnore($error, $node, $scope)) { continue 2; } diff --git a/src/Analyser/DirectInternalScopeFactory.php b/src/Analyser/DirectInternalScopeFactory.php index 533d37c5f9..cf93e9d167 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 84b96d27a3..4f7042f7e3 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 47efb2af7f..4c50db1b0d 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 $functionThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + #[AutowiredExtensions(interface: DynamicFunctionThrowTypeExtension::class)] + private ExtensionsCollection $functionThrowTypeExtensions, + 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->functionThrowTypeExtensions->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 da565b78d8..df89e96833 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 08ff873558..001c048cfc 100644 --- a/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php +++ b/src/Analyser/ExprHandler/Helper/MethodThrowPointHelper.php @@ -7,11 +7,14 @@ use PHPStan\Analyser\ExpressionContext; use PHPStan\Analyser\InternalThrowPoint; use PHPStan\Analyser\MutatingScope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParametersAcceptor; +use PHPStan\Type\DynamicMethodThrowTypeExtension; +use PHPStan\Type\DynamicStaticMethodThrowTypeExtension; use PHPStan\Type\NeverType; use PHPStan\Type\ObjectType; use ReflectionFunction; @@ -23,8 +26,15 @@ final class MethodThrowPointHelper { + /** + * @param ExtensionsCollection $methodThrowTypeExtensions + * @param ExtensionsCollection $staticMethodThrowTypeExtensions + */ public function __construct( - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, + #[AutowiredExtensions(interface: DynamicMethodThrowTypeExtension::class)] + private ExtensionsCollection $methodThrowTypeExtensions, + #[AutowiredExtensions(interface: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $staticMethodThrowTypeExtensions, #[AutowiredParameter(ref: '%exceptions.implicitThrows%')] private bool $implicitThrows, ) @@ -40,7 +50,7 @@ public function getThrowPoint( ): ?InternalThrowPoint { if ($normalizedMethodCall instanceof MethodCall) { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicMethodThrowTypeExtensions() as $extension) { + foreach ($this->methodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isMethodSupported($methodReflection)) { continue; } @@ -53,7 +63,7 @@ public function getThrowPoint( return InternalThrowPoint::createExplicit($scope, $throwType, $normalizedMethodCall, false); } } else { - foreach ($this->dynamicThrowTypeExtensionProvider->getDynamicStaticMethodThrowTypeExtensions() as $extension) { + foreach ($this->staticMethodThrowTypeExtensions->getAll() as $extension) { if (!$extension->isStaticMethodSupported($methodReflection)) { continue; } diff --git a/src/Analyser/ExprHandler/NewHandler.php b/src/Analyser/ExprHandler/NewHandler.php index 111fe38a68..5ec08de9c0 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 $staticMethodThrowTypeExtensions + */ public function __construct( private ReflectionProvider $reflectionProvider, - private DynamicThrowTypeExtensionProvider $dynamicThrowTypeExtensionProvider, - private DynamicReturnTypeExtensionRegistryProvider $dynamicReturnTypeExtensionRegistryProvider, + #[AutowiredExtensions(interface: DynamicStaticMethodThrowTypeExtension::class)] + private ExtensionsCollection $staticMethodThrowTypeExtensions, + 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->staticMethodThrowTypeExtensions->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 95d7489771..a0a53afcb9 100644 --- a/src/Analyser/ExprHandlerRegistry.php +++ b/src/Analyser/ExprHandlerRegistry.php @@ -41,8 +41,7 @@ public static function resolve(Expr $expr, Container $container): ?ExprHandler } $matchedHandler = null; - /** @var ExprHandler $exprHandler */ - foreach ($container->getServicesByTag(ExprHandler::EXTENSION_TAG) as $exprHandler) { + foreach ($container->getExtensions(ExprHandler::class) as $exprHandler) { if (!$exprHandler->supports($expr)) { continue; } diff --git a/src/Analyser/FileAnalyser.php b/src/Analyser/FileAnalyser.php index 1870b581a6..3a53dcd603 100644 --- a/src/Analyser/FileAnalyser.php +++ b/src/Analyser/FileAnalyser.php @@ -11,8 +11,10 @@ use PHPStan\Collectors\Registry as CollectorRegistry; use PHPStan\Dependency\DependencyResolver; use PHPStan\Dependency\PackageDependencyResolver; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\FileNode; use PHPStan\Parser\Parser; use PHPStan\Parser\ParserErrorsException; @@ -51,6 +53,9 @@ final class FileAnalyser /** @var array */ private array $filteredPhpErrors = []; + /** + * @param ExtensionsCollection $ignoreErrorExtensions + */ public function __construct( private ScopeFactory $scopeFactory, #[AutowiredParameter(ref: '@' . NodeScopeResolver::class)] @@ -59,7 +64,8 @@ public function __construct( private Parser $parser, private DependencyResolver $dependencyResolver, private PackageDependencyResolver $packageDependencyResolver, - private IgnoreErrorExtensionProvider $ignoreErrorExtensionProvider, + #[AutowiredExtensions(interface: IgnoreErrorExtension::class)] + private ExtensionsCollection $ignoreErrorExtensions, private RuleErrorTransformer $ruleErrorTransformer, private LocalIgnoresProcessor $localIgnoresProcessor, #[AutowiredParameter] @@ -111,7 +117,7 @@ public function analyseFile( $collectorRegistry, $outerNodeCallback, $parserNodes, - $this->ignoreErrorExtensionProvider->getExtensions(), + $this->ignoreErrorExtensions->getAll(), $this->parser, $this->dependencyResolver, $this->packageDependencyResolver, diff --git a/src/Analyser/IgnoreErrorExtensionProvider.php b/src/Analyser/IgnoreErrorExtensionProvider.php deleted file mode 100644 index ff5af37169..0000000000 --- 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 30bad59a9a..5609fb750c 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 72f087b400..9ba903e448 100644 --- a/src/Analyser/NodeScopeResolver.php +++ b/src/Analyser/NodeScopeResolver.php @@ -57,12 +57,11 @@ use PHPStan\BetterReflection\Reflector\Reflector; use PHPStan\BetterReflection\SourceLocator\Ast\Strategy\NodeToReflection; use PHPStan\BetterReflection\SourceLocator\Located\LocatedSource; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\FileReader; use PHPStan\Node\BreaklessWhileLoopNode; @@ -139,15 +138,21 @@ use PHPStan\Reflection\Php\PhpMethodReflection; use PHPStan\Reflection\Php\PhpPropertyReflection; use PHPStan\Reflection\ReflectionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ClosureType; use PHPStan\Type\Constant\ConstantIntegerType; use PHPStan\Type\Constant\ConstantStringType; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; use PHPStan\Type\Generic\TemplateTypeHelper; use PHPStan\Type\Generic\TemplateTypeMap; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; use PHPStan\Type\MixedType; use PHPStan\Type\NeverType; use PHPStan\Type\NullType; @@ -155,6 +160,9 @@ use PHPStan\Type\ObjectWithoutClassType; use PHPStan\Type\ParserNodeTypeToPHPStanType; use PHPStan\Type\ResourceType; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\StaticType; use PHPStan\Type\StaticTypeFactory; use PHPStan\Type\ThisType; @@ -209,6 +217,16 @@ class NodeScopeResolver /** * @param string[][] $earlyTerminatingMethodCalls className(string) => methods(string[]) * @param array $earlyTerminatingFunctionCalls + * @param ExtensionsCollection $functionParameterOutTypeExtensions + * @param ExtensionsCollection $methodParameterOutTypeExtensions + * @param ExtensionsCollection $staticMethodParameterOutTypeExtensions + * @param ExtensionsCollection $readWritePropertiesExtensions + * @param ExtensionsCollection $functionParameterClosureThisExtensions + * @param ExtensionsCollection $methodParameterClosureThisExtensions + * @param ExtensionsCollection $staticMethodParameterClosureThisExtensions + * @param ExtensionsCollection $functionParameterClosureTypeExtensions + * @param ExtensionsCollection $methodParameterClosureTypeExtensions + * @param ExtensionsCollection $staticMethodParameterClosureTypeExtensions */ public function __construct( private readonly Container $container, @@ -216,16 +234,32 @@ public function __construct( private readonly InitializerExprTypeResolver $initializerExprTypeResolver, private readonly Reflector $reflector, private readonly ClassReflectionFactory $classReflectionFactory, - private readonly ParameterOutTypeExtensionProvider $parameterOutTypeExtensionProvider, + #[AutowiredExtensions(interface: FunctionParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterOutTypeExtensions, + #[AutowiredExtensions(interface: MethodParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterOutTypeExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterOutTypeExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterOutTypeExtensions, #[AutowiredParameter(ref: '@defaultAnalysisParser')] private readonly Parser $parser, private readonly FileTypeMapper $fileTypeMapper, private readonly PhpDocInheritanceResolver $phpDocInheritanceResolver, private readonly FileHelper $fileHelper, private readonly TypeSpecifier $typeSpecifier, - private readonly ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider, - private readonly ParameterClosureThisExtensionProvider $parameterClosureThisExtensionProvider, - private readonly ParameterClosureTypeExtensionProvider $parameterClosureTypeExtensionProvider, + #[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)] + private readonly ExtensionsCollection $readWritePropertiesExtensions, + #[AutowiredExtensions(interface: FunctionParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureThisExtensions, + #[AutowiredExtensions(interface: MethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureThisExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterClosureThisExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterClosureThisExtensions, + #[AutowiredExtensions(interface: FunctionParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $functionParameterClosureTypeExtensions, + #[AutowiredExtensions(interface: MethodParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $methodParameterClosureTypeExtensions, + #[AutowiredExtensions(interface: StaticMethodParameterClosureTypeExtension::class)] + private readonly ExtensionsCollection $staticMethodParameterClosureTypeExtensions, private readonly ScopeFactory $scopeFactory, private readonly DeepNodeCloner $deepNodeCloner, #[AutowiredParameter] @@ -1241,7 +1275,7 @@ public function processStmtNode( }); $this->processStmtNodesInternal($stmt, $classLikeStatements, $classScope, $storage, $classStatementsGatherer, $context); - $this->callNodeCallback($nodeCallback, new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensionProvider, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope, $storage); + $this->callNodeCallback($nodeCallback, new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensions, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope, $storage); $this->callNodeCallback($nodeCallback, new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection), $classScope, $storage); $this->callNodeCallback($nodeCallback, new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches(), $classReflection), $classScope, $storage); $classReflection->evictPrivateSymbols(); @@ -3479,7 +3513,7 @@ private function resolveClosureThisType( ): ?Type { if ($call instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getFunctionParameterClosureThisExtensions() as $extension) { + foreach ($this->functionParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isFunctionSupported($calleeReflection, $parameter)) { continue; } @@ -3489,7 +3523,7 @@ private function resolveClosureThisType( } } } elseif ($call instanceof StaticCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getStaticMethodParameterClosureThisExtensions() as $extension) { + foreach ($this->staticMethodParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isStaticMethodSupported($calleeReflection, $parameter)) { continue; } @@ -3499,7 +3533,7 @@ private function resolveClosureThisType( } } } elseif ($call instanceof MethodCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterClosureThisExtensionProvider->getMethodParameterClosureThisExtensions() as $extension) { + foreach ($this->methodParameterClosureThisExtensions->getAll() as $extension) { if (! $extension->isMethodSupported($calleeReflection, $parameter)) { continue; } @@ -3937,14 +3971,14 @@ private function shouldInvalidateCallbackExpressions(?ParameterReflection $param private function getParameterTypeFromParameterClosureTypeExtension(CallLike $callLike, $calleeReflection, ParameterReflection $parameter, MutatingScope $scope): ?Type { if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterClosureTypeExtensionProvider->getFunctionParameterClosureTypeExtensions() as $functionParameterClosureTypeExtension) { + foreach ($this->functionParameterClosureTypeExtensions->getAll() as $functionParameterClosureTypeExtension) { if ($functionParameterClosureTypeExtension->isFunctionSupported($calleeReflection, $parameter)) { return $functionParameterClosureTypeExtension->getTypeFromFunctionCall($calleeReflection, $callLike, $parameter, $scope); } } } elseif ($calleeReflection instanceof MethodReflection) { if ($callLike instanceof StaticCall) { - foreach ($this->parameterClosureTypeExtensionProvider->getStaticMethodParameterClosureTypeExtensions() as $staticMethodParameterClosureTypeExtension) { + foreach ($this->staticMethodParameterClosureTypeExtensions->getAll() as $staticMethodParameterClosureTypeExtension) { if ($staticMethodParameterClosureTypeExtension->isStaticMethodSupported($calleeReflection, $parameter)) { return $staticMethodParameterClosureTypeExtension->getTypeFromStaticMethodCall($calleeReflection, $callLike, $parameter, $scope); } @@ -3955,13 +3989,13 @@ private function getParameterTypeFromParameterClosureTypeExtension(CallLike $cal new Identifier('__construct'), $callLike->getArgs(), ); - foreach ($this->parameterClosureTypeExtensionProvider->getStaticMethodParameterClosureTypeExtensions() as $staticMethodParameterClosureTypeExtension) { + foreach ($this->staticMethodParameterClosureTypeExtensions->getAll() as $staticMethodParameterClosureTypeExtension) { if ($staticMethodParameterClosureTypeExtension->isStaticMethodSupported($calleeReflection, $parameter)) { return $staticMethodParameterClosureTypeExtension->getTypeFromStaticMethodCall($calleeReflection, $staticCall, $parameter, $scope); } } } elseif ($callLike instanceof MethodCall) { - foreach ($this->parameterClosureTypeExtensionProvider->getMethodParameterClosureTypeExtensions() as $methodParameterClosureTypeExtension) { + foreach ($this->methodParameterClosureTypeExtensions->getAll() as $methodParameterClosureTypeExtension) { if ($methodParameterClosureTypeExtension->isMethodSupported($calleeReflection, $parameter)) { return $methodParameterClosureTypeExtension->getTypeFromMethodCall($calleeReflection, $callLike, $parameter, $scope); } @@ -3979,7 +4013,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec { $paramOutTypes = []; if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getFunctionParameterOutTypeExtensions() as $functionParameterOutTypeExtension) { + foreach ($this->functionParameterOutTypeExtensions->getAll() as $functionParameterOutTypeExtension) { if (!$functionParameterOutTypeExtension->isFunctionSupported($calleeReflection, $currentParameter)) { continue; } @@ -3991,7 +4025,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec $paramOutTypes[] = $resolvedType; } } elseif ($callLike instanceof MethodCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getMethodParameterOutTypeExtensions() as $methodParameterOutTypeExtension) { + foreach ($this->methodParameterOutTypeExtensions->getAll() as $methodParameterOutTypeExtension) { if (!$methodParameterOutTypeExtension->isMethodSupported($calleeReflection, $currentParameter)) { continue; } @@ -4003,7 +4037,7 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec $paramOutTypes[] = $resolvedType; } } elseif ($callLike instanceof StaticCall && $calleeReflection instanceof MethodReflection) { - foreach ($this->parameterOutTypeExtensionProvider->getStaticMethodParameterOutTypeExtensions() as $staticMethodParameterOutTypeExtension) { + foreach ($this->staticMethodParameterOutTypeExtensions->getAll() as $staticMethodParameterOutTypeExtension) { if (!$staticMethodParameterOutTypeExtension->isStaticMethodSupported($calleeReflection, $currentParameter)) { continue; } diff --git a/src/Analyser/ResultCache/ResultCacheManager.php b/src/Analyser/ResultCache/ResultCacheManager.php index b603780145..b2509e7cc7 100644 --- a/src/Analyser/ResultCache/ResultCacheManager.php +++ b/src/Analyser/ResultCache/ResultCacheManager.php @@ -12,8 +12,9 @@ use PHPStan\Dependency\ExportedNodeFetcher; use PHPStan\Dependency\PackageDependencyResolver; use PHPStan\Dependency\RootExportedNode; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\GenerateFactory; use PHPStan\DependencyInjection\ProjectConfigHelper; use PHPStan\File\CouldNotReadFileException; @@ -84,9 +85,11 @@ final class ResultCacheManager * @param string[] $scanDirectories * @param list> $parametersNotInvalidatingCache * @param array $fileReplacements + * @param ExtensionsCollection $resultCacheMetaExtensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: ResultCacheMetaExtension::class)] + private ExtensionsCollection $resultCacheMetaExtensions, private ExportedNodeFetcher $exportedNodeFetcher, #[AutowiredParameter(ref: '@fileFinderScan')] private FileFinder $scanFileFinder, @@ -1539,8 +1542,7 @@ private function getMetaFromPhpStanExtensions(): array { $meta = []; - /** @var ResultCacheMetaExtension $extension */ - foreach ($this->container->getServicesByTag(ResultCacheMetaExtension::EXTENSION_TAG) as $extension) { + foreach ($this->resultCacheMetaExtensions->getAll() as $extension) { if (array_key_exists($extension->getKey(), $meta)) { throw new ShouldNotHappenException(sprintf( 'Duplicate ResultCacheMetaExtension with key "%s" found.', diff --git a/src/Analyser/TypeSpecifierFactory.php b/src/Analyser/TypeSpecifierFactory.php index 64d1a652af..61cb065a73 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 7d545d83d4..73528f9c51 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/Collector.php b/src/Collectors/Collector.php index 3e27b17c22..f950565431 100644 --- a/src/Collectors/Collector.php +++ b/src/Collectors/Collector.php @@ -24,7 +24,7 @@ * @template-covariant TNodeType of Node * @template-covariant TValue */ -#[ExtensionInterface(tag: RegistryFactory::COLLECTOR_TAG)] +#[ExtensionInterface(tag: Registry::COLLECTOR_TAG)] interface Collector { diff --git a/src/Collectors/Registry.php b/src/Collectors/Registry.php index c0ff3dd404..e9d77a3f9d 100644 --- a/src/Collectors/Registry.php +++ b/src/Collectors/Registry.php @@ -3,28 +3,32 @@ namespace PHPStan\Collectors; use PhpParser\Node; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use function class_implements; use function class_parents; -#[AutowiredService(factory: '@PHPStan\Collectors\RegistryFactory::create')] +#[AutowiredService] final class Registry { - /** @var Collector[][] */ - private array $collectors = []; + public const COLLECTOR_TAG = 'phpstan.collector'; + + /** @var Collector[][]|null */ + private ?array $collectorsByNodeType = null; /** @var Collector[][] */ private array $cache = []; /** - * @param Collector[] $collectors + * @param ExtensionsCollection> $collectors */ - public function __construct(array $collectors) + public function __construct( + #[AutowiredExtensions(interface: Collector::class)] + private ExtensionsCollection $collectors, + ) { - foreach ($collectors as $collector) { - $this->collectors[$collector->getNodeType()][] = $collector; - } } /** @@ -38,8 +42,9 @@ public function getCollectors(string $nodeType): array $parentNodeTypes = [$nodeType] + class_parents($nodeType) + class_implements($nodeType); $collectors = []; + $collectorsFromContainer = $this->getCollectorsByNodeType(); foreach ($parentNodeTypes as $parentNodeType) { - foreach ($this->collectors[$parentNodeType] ?? [] as $collector) { + foreach ($collectorsFromContainer[$parentNodeType] ?? [] as $collector) { $collectors[] = $collector; } } @@ -55,4 +60,21 @@ public function getCollectors(string $nodeType): array return $selectedCollectors; } + /** + * @return Collector[][] + */ + private function getCollectorsByNodeType(): array + { + if ($this->collectorsByNodeType !== null) { + return $this->collectorsByNodeType; + } + + $collectors = []; + foreach ($this->collectors->getAll() as $collector) { + $collectors[$collector->getNodeType()][] = $collector; + } + + return $this->collectorsByNodeType = $collectors; + } + } diff --git a/src/Collectors/RegistryFactory.php b/src/Collectors/RegistryFactory.php deleted file mode 100644 index a95dbe2a51..0000000000 --- a/src/Collectors/RegistryFactory.php +++ /dev/null @@ -1,25 +0,0 @@ -container->getServicesByTag(self::COLLECTOR_TAG), - ); - } - -} diff --git a/src/Command/AnalyseCommand.php b/src/Command/AnalyseCommand.php index 5b3be09c6b..7eb0890a43 100644 --- a/src/Command/AnalyseCommand.php +++ b/src/Command/AnalyseCommand.php @@ -880,7 +880,7 @@ private function runDiagnoseExtensions(Container $container, Output $errorOutput $phpstanDiagnoseExtension->print($errorOutput, $processedFiles); /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($errorOutput); } } diff --git a/src/Command/DiagnoseCommand.php b/src/Command/DiagnoseCommand.php index 371bfcfa1a..4d1950b57e 100644 --- a/src/Command/DiagnoseCommand.php +++ b/src/Command/DiagnoseCommand.php @@ -102,7 +102,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int $phpstanDiagnoseExtension->print($output, []); /** @var DiagnoseExtension $extension */ - foreach ($container->getServicesByTag(DiagnoseExtension::EXTENSION_TAG) as $extension) { + foreach ($container->getExtensions(DiagnoseExtension::class) as $extension) { $extension->print($output); } diff --git a/src/DependencyInjection/AutowiredAttributeServicesExtension.php b/src/DependencyInjection/AutowiredAttributeServicesExtension.php index 5a42201007..75cfbcbc75 100644 --- a/src/DependencyInjection/AutowiredAttributeServicesExtension.php +++ b/src/DependencyInjection/AutowiredAttributeServicesExtension.php @@ -4,6 +4,7 @@ use Nette\DI\CompilerExtension; use Nette\DI\ContainerBuilder; +use Nette\DI\Definitions\FactoryDefinition; use Nette\DI\Definitions\Reference; use Nette\DI\Definitions\ServiceDefinition; use Nette\DI\Definitions\Statement; @@ -14,11 +15,14 @@ use olvlvl\ComposerAttributeCollector\Attributes; use olvlvl\ComposerAttributeCollector\TargetMethodParameter; use Override; -use PHPStan\Collectors\RegistryFactory; +use PHPStan\Collectors\Registry as CollectorRegistry; use PHPStan\Rules\LazyRegistry; use ReflectionClass; use stdClass; +use function array_key_exists; +use function count; use function explode; +use function is_string; use function strcasecmp; use function strtolower; use function substr; @@ -40,6 +44,12 @@ public function loadConfiguration(): void require_once __DIR__ . '/../../vendor/attributes.php'; $builder = $this->getContainerBuilder(); + // Bakes the #[ExtensionInterface] mapping into the compiled container + // so that Container::getExtensions() does not need vendor/attributes.php at runtime. + $builder->addDefinition($this->prefix('extensionInterfaceTags')) + ->setType(ExtensionInterfaceTags::class) + ->setArguments([ValidateServiceTagsExtension::getInterfaceTagMapping()]); + $autowiredParameters = Attributes::findTargetMethodParameters(AutowiredParameter::class); $constructorParameters = []; foreach ($autowiredParameters as $parameter) { @@ -136,12 +146,77 @@ public function loadConfiguration(): void $definition = $builder->addDefinition(null) ->setFactory($class->name) ->setAutowired($class->name) - ->addTag(RegistryFactory::COLLECTOR_TAG); + ->addTag(CollectorRegistry::COLLECTOR_TAG); self::processConstructorParameters($builder, $class->name, $definition, $constructorParameters); } } + /** + * Wires #[AutowiredExtensions] constructor parameters. + * + * It has to happen in beforeCompile() and not in loadConfiguration(): services from the NEON + * files are registered by Nette's own ServicesExtension after every other extension's + * loadConfiguration(), so they are not in the builder yet at that point. + * + * @throws NotAnExtensionInterfaceException + */ + #[Override] + public function beforeCompile(): void + { + require_once __DIR__ . '/../../vendor/attributes.php'; + + /** @var array>> $constructorParameters */ + $constructorParameters = []; + foreach (Attributes::findTargetMethodParameters(AutowiredExtensions::class) as $parameter) { + if (strcasecmp($parameter->method, '__construct') !== 0) { + continue; + } + $constructorParameters[strtolower($parameter->class)][] = $parameter; + } + + if (count($constructorParameters) === 0) { + return; + } + + $mapping = ValidateServiceTagsExtension::getInterfaceTagMapping(); + $builder = $this->getContainerBuilder(); + + foreach ($builder->getDefinitions() as $definition) { + if ($definition instanceof FactoryDefinition) { + $definition = $definition->getResultDefinition(); + } + if (!$definition instanceof ServiceDefinition) { + continue; + } + + $className = $definition->getType(); + if ($className === null) { + continue; + } + + // Only definitions that instantiate the class themselves take its constructor + // arguments. Aliases (factory: @otherService) and static factories delegate + // elsewhere and would turn the argument into an unknown named parameter. + $entity = $definition->getCreator()->getEntity(); + if (!is_string($entity) || strcasecmp($entity, $className) !== 0) { + continue; + } + + foreach ($constructorParameters[strtolower($className)] ?? [] as $parameter) { + $interface = $parameter->attribute->interface; + if (!array_key_exists($interface, $mapping)) { + throw new NotAnExtensionInterfaceException($className, $parameter->name, $interface); + } + + $definition->setArgument($parameter->name, new Statement(LazyExtensionsCollection::class, [ + new Reference(Container::class), + $interface, + ])); + } + } + } + /** * @param class-string $className * @param array>> $constructorParameters diff --git a/src/DependencyInjection/AutowiredExtensions.php b/src/DependencyInjection/AutowiredExtensions.php new file mode 100644 index 0000000000..940655384d --- /dev/null +++ b/src/DependencyInjection/AutowiredExtensions.php @@ -0,0 +1,29 @@ + $interfaceName + * @return list + * @throws MissingServiceException + */ + public function getExtensions(string $interfaceName): array; + /** * @return mixed[] */ diff --git a/src/DependencyInjection/DirectExtensionsCollection.php b/src/DependencyInjection/DirectExtensionsCollection.php new file mode 100644 index 0000000000..0420fc4000 --- /dev/null +++ b/src/DependencyInjection/DirectExtensionsCollection.php @@ -0,0 +1,31 @@ + + */ +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/ExtensionInterfaceTags.php b/src/DependencyInjection/ExtensionInterfaceTags.php new file mode 100644 index 0000000000..b68028d38c --- /dev/null +++ b/src/DependencyInjection/ExtensionInterfaceTags.php @@ -0,0 +1,41 @@ + $tags + */ + public function __construct(private array $tags) + { + } + + /** + * @param class-string $interfaceName + * @throws MissingServiceException + */ + public function getTag(string $interfaceName): string + { + if (!array_key_exists($interfaceName, $this->tags)) { + throw new MissingServiceException(sprintf( + 'Interface %s is not an extension interface. Mark it with the #[%s] attribute.', + $interfaceName, + ExtensionInterface::class, + )); + } + + return $this->tags[$interfaceName]; + } + +} diff --git a/src/DependencyInjection/ExtensionsCollection.php b/src/DependencyInjection/ExtensionsCollection.php new file mode 100644 index 0000000000..c914cd058e --- /dev/null +++ b/src/DependencyInjection/ExtensionsCollection.php @@ -0,0 +1,26 @@ + + */ + public function getAll(): array; + +} diff --git a/src/DependencyInjection/LazyExtensionsCollection.php b/src/DependencyInjection/LazyExtensionsCollection.php new file mode 100644 index 0000000000..a98b905aa6 --- /dev/null +++ b/src/DependencyInjection/LazyExtensionsCollection.php @@ -0,0 +1,43 @@ + + */ +final class LazyExtensionsCollection implements ExtensionsCollection +{ + + /** @var list|null */ + private ?array $extensions = null; + + /** + * @param class-string $interfaceName + */ + public function __construct(private ?Container $container, private string $interfaceName) + { + } + + public function getAll(): array + { + if ($this->extensions === null) { + if ($this->container === null) { + throw new ShouldNotHappenException(); + } + + $this->extensions = $this->container->getExtensions($this->interfaceName); + + // Collections are held by long-lived objects like ClassPropertiesNode. Keeping the + // container reference here would make each of them a transitive handle on the entire + // DI container. After the extensions are resolved the container is no longer needed. + $this->container = null; + } + + return $this->extensions; + } + +} diff --git a/src/DependencyInjection/MemoizingContainer.php b/src/DependencyInjection/MemoizingContainer.php index b4730deadf..a4afc23e54 100644 --- a/src/DependencyInjection/MemoizingContainer.php +++ b/src/DependencyInjection/MemoizingContainer.php @@ -15,6 +15,9 @@ final class MemoizingContainer implements Container /** @var array */ private array $servicesByTag = []; + /** @var array> */ + private array $extensionsByInterface = []; + public function __construct( #[AutowiredParameter(ref: '@PHPStan\DependencyInjection\Nette\NetteContainer')] private Container $originalContainer, @@ -47,6 +50,17 @@ public function getServicesByTag(string $tagName): array return $this->servicesByTag[$tagName] ??= $this->originalContainer->getServicesByTag($tagName); } + /** + * @template T of object + * @param class-string $interfaceName + * @return list + */ + public function getExtensions(string $interfaceName): array + { + /** @var list */ + return $this->extensionsByInterface[$interfaceName] ??= $this->originalContainer->getExtensions($interfaceName); + } + public function getParameters(): array { return $this->originalContainer->getParameters(); diff --git a/src/DependencyInjection/Nette/NetteContainer.php b/src/DependencyInjection/Nette/NetteContainer.php index f5ae4164d6..dfda2c168d 100644 --- a/src/DependencyInjection/Nette/NetteContainer.php +++ b/src/DependencyInjection/Nette/NetteContainer.php @@ -4,6 +4,7 @@ use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionInterfaceTags; use PHPStan\DependencyInjection\MissingServiceException; use PHPStan\DependencyInjection\ParameterNotFoundException; use function array_key_exists; @@ -22,6 +23,7 @@ final class NetteContainer implements Container public function __construct( private readonly \Nette\DI\Container $container, + private readonly ExtensionInterfaceTags $extensionInterfaceTags, ) { } @@ -74,6 +76,17 @@ public function getServicesByTag(string $tagName): array return $this->tagsToServices($this->container->findByTag($tagName)); } + /** + * @template T of object + * @param class-string $interfaceName + * @return list + */ + public function getExtensions(string $interfaceName): array + { + /** @var list */ + return $this->tagsToServices($this->container->findByTag($this->extensionInterfaceTags->getTag($interfaceName))); + } + /** * @return mixed[] */ diff --git a/src/DependencyInjection/NotAnExtensionInterfaceException.php b/src/DependencyInjection/NotAnExtensionInterfaceException.php new file mode 100644 index 0000000000..2d0a2af2d7 --- /dev/null +++ b/src/DependencyInjection/NotAnExtensionInterfaceException.php @@ -0,0 +1,22 @@ +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 14fb3eccef..0000000000 --- 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 1a56f43268..0000000000 --- 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 6efc5fcb80..0000000000 --- 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 ead76923a3..0000000000 --- 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 915fd3d621..0000000000 --- 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 ecc30869f5..0000000000 --- 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 113eea7b29..0000000000 --- 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 631ad4f3b5..0000000000 --- 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 2a1de7beae..0000000000 --- a/src/DependencyInjection/Type/OperatorTypeSpecifyingExtensionRegistryProvider.php +++ /dev/null @@ -1,12 +0,0 @@ - $methodCalls * @param array $returnStatementNodes * @param list $propertyAssigns + * @param ExtensionsCollection $readWritePropertiesExtensions */ public function __construct( private ClassLike $class, - private ReadWritePropertiesExtensionProvider $readWritePropertiesExtensionProvider, + private ExtensionsCollection $readWritePropertiesExtensions, private array $properties, private array $propertyUsages, private array $methodCalls, @@ -115,7 +117,7 @@ public function getUninitializedProperties( $originalProperties = []; $initialInitializedProperties = []; $initializedProperties = []; - $extensions = $this->readWritePropertiesExtensionProvider->getExtensions(); + $extensions = $this->readWritePropertiesExtensions->getAll(); $initializedViaExtension = []; foreach ($this->getProperties() as $property) { if ($property->isStatic()) { diff --git a/src/Parser/RichParser.php b/src/Parser/RichParser.php index d23ecb227a..0e4c33717f 100644 --- a/src/Parser/RichParser.php +++ b/src/Parser/RichParser.php @@ -5,12 +5,14 @@ use PhpParser\ErrorHandler\Collecting; use PhpParser\Node; use PhpParser\NodeTraverser; +use PhpParser\NodeVisitor; use PhpParser\NodeVisitor\NameResolver; use PhpParser\Token; use PHPStan\Analyser\FileAnalyserResult; use PHPStan\Analyser\Ignore\IgnoreLexer; use PHPStan\Analyser\Ignore\IgnoreParseException; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileReader; use PHPStan\ShouldNotHappenException; use function array_filter; @@ -44,10 +46,14 @@ final class RichParser implements Parser private const PHPDOC_DOCTRINE_TAG_REGEX = '(@[a-z_\\\\][a-z0-9_\:\\\\]*[a-z_][a-z0-9_]*)'; + /** + * @param ExtensionsCollection $visitors + */ public function __construct( private \PhpParser\Parser $parser, private NameResolver $nameResolver, - private Container $container, + #[AutowiredExtensions(interface: NodeVisitor::class)] + private ExtensionsCollection $visitors, private IgnoreLexer $ignoreLexer, ) { @@ -92,7 +98,7 @@ public function parseString(string $sourceCode): array $traitCollectingVisitor = new TraitCollectingVisitor(); $nodeTraverser->addVisitor($traitCollectingVisitor); - foreach ($this->container->getServicesByTag(self::VISITOR_SERVICE_TAG) as $visitor) { + foreach ($this->visitors->getAll() as $visitor) { $nodeTraverser->addVisitor($visitor); } diff --git a/src/PhpDoc/DefaultStubFilesProvider.php b/src/PhpDoc/DefaultStubFilesProvider.php index 6b9edcdadb..7e6bda8b4b 100644 --- a/src/PhpDoc/DefaultStubFilesProvider.php +++ b/src/PhpDoc/DefaultStubFilesProvider.php @@ -2,9 +2,10 @@ namespace PHPStan\PhpDoc; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Internal\ComposerHelper; use function array_filter; @@ -27,9 +28,11 @@ final class DefaultStubFilesProvider implements StubFilesProvider /** * @param string[] $stubFiles * @param string[] $composerAutoloaderProjectPaths + * @param ExtensionsCollection $extensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: StubFilesExtension::class)] + private ExtensionsCollection $extensions, private FileHelper $fileHelper, #[AutowiredParameter] private array $stubFiles, @@ -46,8 +49,7 @@ public function getStubFiles(): array } $files = array_map(fn ($path) => $this->fileHelper->normalizePath($path), $this->stubFiles); - $extensions = $this->container->getServicesByTag(StubFilesExtension::EXTENSION_TAG); - foreach ($extensions as $extension) { + foreach ($this->extensions->getAll() as $extension) { foreach ($extension->getFiles() as $extensionFile) { $files[] = $this->fileHelper->normalizePath($extensionFile); } diff --git a/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php b/src/PhpDoc/LazyTypeNodeResolverExtensionRegistryProvider.php index eb0a48b337..65959df75e 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/PhpDoc/StubValidator.php b/src/PhpDoc/StubValidator.php index d15b89bcdc..0b6c9cca85 100644 --- a/src/PhpDoc/StubValidator.php +++ b/src/PhpDoc/StubValidator.php @@ -7,6 +7,7 @@ use PHPStan\Analyser\InternalError; use PHPStan\Analyser\NodeScopeResolver; use PHPStan\Collectors\Registry as CollectorRegistry; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\DependencyInjection\AutowiredService; use PHPStan\DependencyInjection\Container; use PHPStan\DependencyInjection\ContainerFactory; @@ -59,7 +60,7 @@ public function validate(array $stubFiles, bool $debug): array $analysedFiles = array_fill_keys($stubFiles, true); $ruleRegistry = new DirectRuleRegistry($container->getServicesByTag(self::SERVICE_RULE_TAG)); - $collectorRegistry = new CollectorRegistry([]); + $collectorRegistry = new CollectorRegistry(new DirectExtensionsCollection([])); $errors = []; foreach ($stubFiles as $stubFile) { diff --git a/src/Reflection/AdditionalConstructorsExtension.php b/src/Reflection/AdditionalConstructorsExtension.php index ad9995b64c..9f20fe8b5b 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 fc38d72298..0a946d2656 100644 --- a/src/Reflection/ConstructorsHelper.php +++ b/src/Reflection/ConstructorsHelper.php @@ -2,9 +2,10 @@ namespace PHPStan\Reflection; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use ReflectionException; use function array_key_exists; use function explode; @@ -18,9 +19,11 @@ final class ConstructorsHelper /** * @param list $additionalConstructors + * @param ExtensionsCollection $extensions */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: AdditionalConstructorsExtension::class)] + private ExtensionsCollection $extensions, #[AutowiredParameter] private array $additionalConstructors, ) @@ -40,9 +43,7 @@ public function getConstructors(ClassReflection $classReflection): array $constructors[] = $classReflection->getConstructor()->getName(); } - /** @var AdditionalConstructorsExtension[] $extensions */ - $extensions = $this->container->getServicesByTag(AdditionalConstructorsExtension::EXTENSION_TAG); - foreach ($extensions as $extension) { + foreach ($this->extensions->getAll() as $extension) { $extensionConstructors = $extension->getAdditionalConstructors($classReflection); foreach ($extensionConstructors as $extensionConstructor) { $constructors[] = $extensionConstructor; diff --git a/src/Reflection/Deprecation/ConstantDeprecationExtension.php b/src/Reflection/Deprecation/ConstantDeprecationExtension.php index 20dbf09016..fd1b90b447 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 ebd25cde0d..5f2f1d16d9 100644 --- a/src/Reflection/Deprecation/DeprecationProvider.php +++ b/src/Reflection/Deprecation/DeprecationProvider.php @@ -11,45 +11,45 @@ use PHPStan\BetterReflection\Reflection\Adapter\ReflectionMethod; use PHPStan\BetterReflection\Reflection\Adapter\ReflectionProperty; use PHPStan\BetterReflection\Reflection\ReflectionConstant; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; #[AutowiredService] final class DeprecationProvider { - /** @var ?array $propertyDeprecationExtensions */ - private ?array $propertyDeprecationExtensions = null; - - /** @var ?array $methodDeprecationExtensions */ - private ?array $methodDeprecationExtensions = null; - - /** @var ?array $classConstantDeprecationExtensions */ - private ?array $classConstantDeprecationExtensions = null; - - /** @var ?array $classDeprecationExtensions */ - private ?array $classDeprecationExtensions = null; - - /** @var ?array $functionDeprecationExtensions */ - private ?array $functionDeprecationExtensions = null; - - /** @var ?array $constantDeprecationExtensions */ - private ?array $constantDeprecationExtensions = null; - - /** @var ?array $enumCaseDeprecationExtensions */ - private ?array $enumCaseDeprecationExtensions = null; - + /** + * @param ExtensionsCollection $propertyDeprecationExtensions + * @param ExtensionsCollection $methodDeprecationExtensions + * @param ExtensionsCollection $classConstantDeprecationExtensions + * @param ExtensionsCollection $classDeprecationExtensions + * @param ExtensionsCollection $functionDeprecationExtensions + * @param ExtensionsCollection $constantDeprecationExtensions + * @param ExtensionsCollection $enumCaseDeprecationExtensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: PropertyDeprecationExtension::class)] + private ExtensionsCollection $propertyDeprecationExtensions, + #[AutowiredExtensions(interface: MethodDeprecationExtension::class)] + private ExtensionsCollection $methodDeprecationExtensions, + #[AutowiredExtensions(interface: ClassConstantDeprecationExtension::class)] + private ExtensionsCollection $classConstantDeprecationExtensions, + #[AutowiredExtensions(interface: ClassDeprecationExtension::class)] + private ExtensionsCollection $classDeprecationExtensions, + #[AutowiredExtensions(interface: FunctionDeprecationExtension::class)] + private ExtensionsCollection $functionDeprecationExtensions, + #[AutowiredExtensions(interface: ConstantDeprecationExtension::class)] + private ExtensionsCollection $constantDeprecationExtensions, + #[AutowiredExtensions(interface: EnumCaseDeprecationExtension::class)] + private ExtensionsCollection $enumCaseDeprecationExtensions, ) { } public function getPropertyDeprecation(ReflectionProperty $reflectionProperty): ?Deprecation { - $this->propertyDeprecationExtensions ??= $this->container->getServicesByTag(PropertyDeprecationExtension::PROPERTY_EXTENSION_TAG); - - foreach ($this->propertyDeprecationExtensions as $extension) { + foreach ($this->propertyDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getPropertyDeprecation($reflectionProperty); if ($deprecation !== null) { return $deprecation; @@ -61,9 +61,7 @@ public function getPropertyDeprecation(ReflectionProperty $reflectionProperty): public function getMethodDeprecation(ReflectionMethod $methodReflection): ?Deprecation { - $this->methodDeprecationExtensions ??= $this->container->getServicesByTag(MethodDeprecationExtension::METHOD_EXTENSION_TAG); - - foreach ($this->methodDeprecationExtensions as $extension) { + foreach ($this->methodDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getMethodDeprecation($methodReflection); if ($deprecation !== null) { return $deprecation; @@ -75,9 +73,7 @@ public function getMethodDeprecation(ReflectionMethod $methodReflection): ?Depre public function getClassConstantDeprecation(ReflectionClassConstant $reflectionConstant): ?Deprecation { - $this->classConstantDeprecationExtensions ??= $this->container->getServicesByTag(ClassConstantDeprecationExtension::CLASS_CONSTANT_EXTENSION_TAG); - - foreach ($this->classConstantDeprecationExtensions as $extension) { + foreach ($this->classConstantDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getClassConstantDeprecation($reflectionConstant); if ($deprecation !== null) { return $deprecation; @@ -89,9 +85,7 @@ public function getClassConstantDeprecation(ReflectionClassConstant $reflectionC public function getClassDeprecation(ReflectionClass|ReflectionEnum $reflection): ?Deprecation { - $this->classDeprecationExtensions ??= $this->container->getServicesByTag(ClassDeprecationExtension::CLASS_EXTENSION_TAG); - - foreach ($this->classDeprecationExtensions as $extension) { + foreach ($this->classDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getClassDeprecation($reflection); if ($deprecation !== null) { return $deprecation; @@ -103,9 +97,7 @@ public function getClassDeprecation(ReflectionClass|ReflectionEnum $reflection): public function getFunctionDeprecation(ReflectionFunction $reflectionFunction): ?Deprecation { - $this->functionDeprecationExtensions ??= $this->container->getServicesByTag(FunctionDeprecationExtension::FUNCTION_EXTENSION_TAG); - - foreach ($this->functionDeprecationExtensions as $extension) { + foreach ($this->functionDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getFunctionDeprecation($reflectionFunction); if ($deprecation !== null) { return $deprecation; @@ -117,9 +109,7 @@ public function getFunctionDeprecation(ReflectionFunction $reflectionFunction): public function getConstantDeprecation(ReflectionConstant $constantReflection): ?Deprecation { - $this->constantDeprecationExtensions ??= $this->container->getServicesByTag(ConstantDeprecationExtension::CONSTANT_EXTENSION_TAG); - - foreach ($this->constantDeprecationExtensions as $extension) { + foreach ($this->constantDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getConstantDeprecation($constantReflection); if ($deprecation !== null) { return $deprecation; @@ -131,9 +121,7 @@ public function getConstantDeprecation(ReflectionConstant $constantReflection): public function getEnumCaseDeprecation(ReflectionEnumUnitCase|ReflectionEnumBackedCase $enumCaseReflection): ?Deprecation { - $this->enumCaseDeprecationExtensions ??= $this->container->getServicesByTag(EnumCaseDeprecationExtension::ENUM_CASE_EXTENSION_TAG); - - foreach ($this->enumCaseDeprecationExtensions as $extension) { + foreach ($this->enumCaseDeprecationExtensions->getAll() as $extension) { $deprecation = $extension->getEnumCaseDeprecation($enumCaseReflection); if ($deprecation !== null) { return $deprecation; diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php index 8b54b83b21..ac40ef0896 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 70249cc666..cf3d900a23 100644 --- a/src/Rules/ClassForbiddenNameCheck.php +++ b/src/Rules/ClassForbiddenNameCheck.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_map; use function array_merge; use function sprintf; @@ -25,7 +26,13 @@ final class ClassForbiddenNameCheck 'Box' => '_HumbugBox', ]; - public function __construct(private Container $container) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: ForbiddenClassNameExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -35,7 +42,7 @@ public function __construct(private Container $container) */ public function checkClassNames(array $pairs): array { - $extensions = $this->container->getServicesByTag(ForbiddenClassNameExtension::EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $classPrefixes = array_merge( self::INTERNAL_CLASS_PREFIXES, diff --git a/src/Rules/ClassNameCheck.php b/src/Rules/ClassNameCheck.php index 025996acd9..9c05c805d4 100644 --- a/src/Rules/ClassNameCheck.php +++ b/src/Rules/ClassNameCheck.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; @@ -12,14 +13,15 @@ final class ClassNameCheck { - /** @var RestrictedClassNameUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( private ClassCaseSensitivityCheck $classCaseSensitivityCheck, private ClassForbiddenNameCheck $classForbiddenNameCheck, private ReflectionProvider $reflectionProvider, - private Container $container, + #[AutowiredExtensions(interface: RestrictedClassNameUsageExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -50,8 +52,7 @@ public function checkClassNames( return $errors; } - /** @var RestrictedClassNameUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedClassNameUsageExtension::CLASS_NAME_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return $errors; } diff --git a/src/Rules/Classes/InstantiationRule.php b/src/Rules/Classes/InstantiationRule.php index 3719adb728..dcb831ff3c 100644 --- a/src/Rules/Classes/InstantiationRule.php +++ b/src/Rules/Classes/InstantiationRule.php @@ -7,8 +7,9 @@ use PHPStan\Analyser\CollectedDataEmitter; use PHPStan\Analyser\NodeCallbackInvoker; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Internal\SprintfHelper; use PHPStan\Reflection\ClassReflection; @@ -47,11 +48,12 @@ final class InstantiationRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private FunctionCallParametersCheck $check, private ClassNameCheck $classCheck, @@ -268,8 +270,7 @@ private function checkClassName(string $class, bool $isName, Node $node, Scope&N ->build(); } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); foreach ($extensions as $extension) { $restrictedUsage = $extension->isRestrictedMethodUsage($constructorReflection, $scope); diff --git a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php index 63a66a1e97..8dc8e821e6 100644 --- a/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php +++ b/src/Rules/Constants/AlwaysUsedClassConstantsExtension.php @@ -23,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedClassConstantsExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.constants.alwaysUsedClassConstantsExtension')] interface AlwaysUsedClassConstantsExtension { diff --git a/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php b/src/Rules/Constants/AlwaysUsedClassConstantsExtensionProvider.php deleted file mode 100644 index b0c0cbfd89..0000000000 --- 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 7d3e2e1e99..5eb5ab4690 100644 --- a/src/Rules/DeadCode/UnusedPrivateConstantRule.php +++ b/src/Rules/DeadCode/UnusedPrivateConstantRule.php @@ -4,9 +4,11 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassConstantsNode; -use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtensionProvider; +use PHPStan\Rules\Constants\AlwaysUsedClassConstantsExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\ObjectType; @@ -19,7 +21,13 @@ final class UnusedPrivateConstantRule implements Rule { - public function __construct(private AlwaysUsedClassConstantsExtensionProvider $extensionProvider) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: AlwaysUsedClassConstantsExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -47,7 +55,7 @@ public function processNode(Node $node, Scope $scope): array $constantName = $const->name->toString(); $constantReflection = $classReflection->getConstant($constantName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysUsed($constantReflection)) { continue 2; } diff --git a/src/Rules/DeadCode/UnusedPrivateMethodRule.php b/src/Rules/DeadCode/UnusedPrivateMethodRule.php index 823e2d5bc5..2499e3dff6 100644 --- a/src/Rules/DeadCode/UnusedPrivateMethodRule.php +++ b/src/Rules/DeadCode/UnusedPrivateMethodRule.php @@ -5,10 +5,12 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassMethodsNode; use PHPStan\Reflection\MethodReflection; -use PHPStan\Rules\Methods\AlwaysUsedMethodExtensionProvider; +use PHPStan\Rules\Methods\AlwaysUsedMethodExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\Constant\ConstantStringType; @@ -25,7 +27,13 @@ final class UnusedPrivateMethodRule implements Rule { - public function __construct(private AlwaysUsedMethodExtensionProvider $extensionProvider) + /** + * @param ExtensionsCollection $extensions + */ + public function __construct( + #[AutowiredExtensions(interface: AlwaysUsedMethodExtension::class)] + private ExtensionsCollection $extensions, + ) { } @@ -63,7 +71,7 @@ public function processNode(Node $node, Scope $scope): array } $methodReflection = $classReflection->getNativeMethod($methodName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysUsed($methodReflection)) { continue 2; } diff --git a/src/Rules/DeadCode/UnusedPrivatePropertyRule.php b/src/Rules/DeadCode/UnusedPrivatePropertyRule.php index 9eab53b775..fdb9973134 100644 --- a/src/Rules/DeadCode/UnusedPrivatePropertyRule.php +++ b/src/Rules/DeadCode/UnusedPrivatePropertyRule.php @@ -4,14 +4,16 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredParameter; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\DependencyInjection\RegisteredRule; use PHPStan\Node\ClassPropertiesNode; use PHPStan\Node\ClassPropertyNode; use PHPStan\Node\Property\PropertyRead; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\Php\PhpMethodFromParserNodeReflection; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Type\Constant\ConstantStringType; @@ -34,9 +36,11 @@ final class UnusedPrivatePropertyRule implements Rule /** * @param string[] $alwaysWrittenTags * @param string[] $alwaysReadTags + * @param ExtensionsCollection $extensions */ public function __construct( - private ReadWritePropertiesExtensionProvider $extensionProvider, + #[AutowiredExtensions(interface: ReadWritePropertiesExtension::class)] + private ExtensionsCollection $extensions, #[AutowiredParameter(ref: '%propertyAlwaysWrittenTags%')] private array $alwaysWrittenTags, #[AutowiredParameter(ref: '%propertyAlwaysReadTags%')] @@ -99,7 +103,7 @@ public function processNode(Node $node, Scope $scope): array $propertyReflection = $classReflection->getNativeProperty($propertyName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($alwaysRead && $alwaysWritten) { break; } diff --git a/src/Rules/LazyRegistry.php b/src/Rules/LazyRegistry.php index 4a55509947..1c1fc26e8c 100644 --- a/src/Rules/LazyRegistry.php +++ b/src/Rules/LazyRegistry.php @@ -3,8 +3,9 @@ namespace PHPStan\Rules; use PhpParser\Node; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use function class_implements; use function class_parents; @@ -15,12 +16,18 @@ final class LazyRegistry implements Registry public const RULE_TAG = 'phpstan.rules.rule'; /** @var Rule[][]|null */ - private ?array $rules = null; + private ?array $rulesByNodeType = null; /** @var Rule[][] */ private array $cache = []; - public function __construct(private Container $container) + /** + * @param ExtensionsCollection> $rules + */ + public function __construct( + #[AutowiredExtensions(interface: Rule::class)] + private ExtensionsCollection $rules, + ) { } @@ -35,9 +42,9 @@ public function getRules(string $nodeType): array $parentNodeTypes = [$nodeType] + class_parents($nodeType) + class_implements($nodeType); $rules = []; - $rulesFromContainer = $this->getRulesFromContainer(); + $rulesByNodeType = $this->getRulesByNodeType(); foreach ($parentNodeTypes as $parentNodeType) { - foreach ($rulesFromContainer[$parentNodeType] ?? [] as $rule) { + foreach ($rulesByNodeType[$parentNodeType] ?? [] as $rule) { $rules[] = $rule; } } @@ -56,18 +63,18 @@ public function getRules(string $nodeType): array /** * @return Rule[][] */ - private function getRulesFromContainer(): array + private function getRulesByNodeType(): array { - if ($this->rules !== null) { - return $this->rules; + if ($this->rulesByNodeType !== null) { + return $this->rulesByNodeType; } - $rules = []; - foreach ($this->container->getServicesByTag(self::RULE_TAG) as $rule) { - $rules[$rule->getNodeType()][] = $rule; + $rulesByNodeType = []; + foreach ($this->rules->getAll() as $rule) { + $rulesByNodeType[$rule->getNodeType()][] = $rule; } - return $this->rules = $rules; + return $this->rulesByNodeType = $rulesByNodeType; } } diff --git a/src/Rules/Methods/AlwaysUsedMethodExtension.php b/src/Rules/Methods/AlwaysUsedMethodExtension.php index 048600fd8f..4a4123c404 100644 --- a/src/Rules/Methods/AlwaysUsedMethodExtension.php +++ b/src/Rules/Methods/AlwaysUsedMethodExtension.php @@ -20,7 +20,7 @@ * * @api */ -#[ExtensionInterface(tag: AlwaysUsedMethodExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.methods.alwaysUsedMethodExtension')] interface AlwaysUsedMethodExtension { diff --git a/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php b/src/Rules/Methods/AlwaysUsedMethodExtensionProvider.php deleted file mode 100644 index 7452a73871..0000000000 --- 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 1a2b49ee38..0000000000 --- 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 b410ae0fb9..0030d4798a 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 d01b77c530..bd9a97e862 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 0130c2f633..0000000000 --- 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 603c685105..0000000000 --- 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 71fe3e89ee..66fda5c143 100644 --- a/src/Rules/Properties/ReadWritePropertiesExtension.php +++ b/src/Rules/Properties/ReadWritePropertiesExtension.php @@ -23,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: ReadWritePropertiesExtensionProvider::EXTENSION_TAG)] +#[ExtensionInterface(tag: 'phpstan.properties.readWriteExtension')] interface ReadWritePropertiesExtension { diff --git a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php b/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php deleted file mode 100644 index 8b519aacd3..0000000000 --- a/src/Rules/Properties/ReadWritePropertiesExtensionProvider.php +++ /dev/null @@ -1,15 +0,0 @@ - $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedClassConstantUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedClassConstantUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedClassConstantUsageExtension::CLASS_CONSTANT_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php index 944f7f2a3d..7401086370 100644 --- a/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\FunctionCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -19,11 +20,12 @@ final class RestrictedFunctionCallableUsageRule implements Rule { - /** @var RestrictedFunctionUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedFunctionUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -49,8 +51,7 @@ public function processNode(Node $node, Scope $scope): array $functionReflection = $this->reflectionProvider->getFunction($node->getName(), $scope); - /** @var RestrictedFunctionUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedFunctionUsageExtension::FUNCTION_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $errors = []; foreach ($extensions as $extension) { diff --git a/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php b/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php index b94843abc6..cdda1d5a83 100644 --- a/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedFunctionUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedFunctionUsageRule implements Rule { - /** @var RestrictedFunctionUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedFunctionUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -48,8 +50,7 @@ public function processNode(Node $node, Scope $scope): array $functionReflection = $this->reflectionProvider->getFunction($node->name, $scope); - /** @var RestrictedFunctionUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedFunctionUsageExtension::FUNCTION_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); $errors = []; foreach ($extensions as $extension) { diff --git a/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php index 7d2829baa9..a199d90677 100644 --- a/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedMethodCallableUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\MethodCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -19,11 +20,12 @@ final class RestrictedMethodCallableUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -43,8 +45,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php b/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php index 8c17430751..7d04c6a980 100644 --- a/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedMethodUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Expr\MethodCall; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -19,11 +20,12 @@ final class RestrictedMethodUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -43,8 +45,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php b/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php index 74d225f571..222ecf9855 100644 --- a/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedPropertyUsageRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Identifier; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedPropertyUsageRule implements Rule { - /** @var RestrictedPropertyUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedPropertyUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -42,8 +44,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedPropertyUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedPropertyUsageExtension::PROPERTY_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php index 0fad692506..2d13fbbef1 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Node\StaticMethodCallableNode; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; @@ -23,11 +24,12 @@ final class RestrictedStaticMethodCallableUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -48,8 +50,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php index 6abda13e15..32b116334a 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticMethodUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -22,11 +23,12 @@ final class RestrictedStaticMethodUsageRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php b/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php index 338fa71b73..15a9c7c2ff 100644 --- a/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php +++ b/src/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRule.php @@ -6,8 +6,9 @@ use PhpParser\Node\Identifier; use PhpParser\Node\Name; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -22,11 +23,12 @@ final class RestrictedStaticPropertyUsageRule implements Rule { - /** @var RestrictedPropertyUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedPropertyUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, private RuleLevelHelper $ruleLevelHelper, ) @@ -47,8 +49,7 @@ public function processNode(Node $node, Scope $scope): array return []; } - /** @var RestrictedPropertyUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedPropertyUsageExtension::PROPERTY_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php b/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php index 26e9bf74e0..e5126cc08f 100644 --- a/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php +++ b/src/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRule.php @@ -5,8 +5,9 @@ use PhpParser\Node; use PhpParser\Node\Expr\Cast; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\AutowiredExtensions; use PHPStan\DependencyInjection\AutowiredService; -use PHPStan\DependencyInjection\Container; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\ReflectionProvider; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; @@ -18,11 +19,12 @@ final class RestrictedUsageOfDeprecatedStringCastRule implements Rule { - /** @var RestrictedMethodUsageExtension[] $extensions */ - private ?array $extensions = null; - + /** + * @param ExtensionsCollection $extensions + */ public function __construct( - private Container $container, + #[AutowiredExtensions(interface: RestrictedMethodUsageExtension::class)] + private ExtensionsCollection $extensions, private ReflectionProvider $reflectionProvider, ) { @@ -35,8 +37,7 @@ public function getNodeType(): string public function processNode(Node $node, Scope $scope): array { - /** @var RestrictedMethodUsageExtension[] $extensions */ - $extensions = $this->extensions ??= $this->container->getServicesByTag(RestrictedMethodUsageExtension::METHOD_EXTENSION_TAG); + $extensions = $this->extensions->getAll(); if ($extensions === []) { return []; } diff --git a/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php b/src/Rules/TooWideTypehints/TooWidePropertyTypeRule.php index 387fbfbdcd..3b4dc43313 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(interface: ReadWritePropertiesExtension::class)] + private ExtensionsCollection $extensions, private TooWideTypeCheck $check, ) { @@ -52,7 +58,7 @@ public function processNode(Node $node, Scope $scope): array $propertyReflection = $classReflection->getNativeProperty($propertyName); - foreach ($this->extensionProvider->getExtensions() as $extension) { + foreach ($this->extensions->getAll() as $extension) { if ($extension->isAlwaysRead($propertyReflection, $propertyName)) { continue 2; } diff --git a/src/Testing/PHPStanTestCase.php b/src/Testing/PHPStanTestCase.php index 2845f99768..c0f717eae1 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 7f13766015..b9fcaf86b9 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,8 @@ 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\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\FileReader; use PHPStan\Fixable\Patcher; @@ -31,11 +30,18 @@ use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\DirectRegistry as DirectRuleRegistry; use PHPStan\Rules\IdentifierRuleError; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; use PHPStan\Rules\Properties\ReadWritePropertiesExtension; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; use PHPStan\Rules\Rule; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use function array_map; use function array_merge; use function count; @@ -100,15 +106,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterOutTypeExtension::class), $this->getParser(), self::getContainer()->getByType(FileTypeMapper::class), self::getContainer()->getByType(PhpDocInheritanceResolver::class), self::getContainer()->getByType(FileHelper::class), $typeSpecifier, - $readWritePropertiesExtensions !== [] ? new DirectReadWritePropertiesExtensionProvider($readWritePropertiesExtensions) : self::getContainer()->getByType(ReadWritePropertiesExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureThisExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureTypeExtensionProvider::class), + $readWritePropertiesExtensions !== [] ? new DirectExtensionsCollection($readWritePropertiesExtensions) : new LazyExtensionsCollection(self::getContainer(), ReadWritePropertiesExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $this->shouldPolluteScopeWithLoopInitialAssignments(), @@ -125,7 +137,7 @@ protected function createNodeScopeResolver(): NodeScopeResolver private function getAnalyser(DirectRuleRegistry $ruleRegistry): Analyser { if ($this->analyser === null) { - $collectorRegistry = new CollectorRegistry($this->getCollectors()); + $collectorRegistry = new CollectorRegistry(new DirectExtensionsCollection($this->getCollectors())); $nodeScopeResolver = $this->createNodeScopeResolver(); @@ -138,7 +150,7 @@ private function getAnalyser(DirectRuleRegistry $ruleRegistry): Analyser $this->getParser(), self::getContainer()->getByType(DependencyResolver::class), self::getContainer()->getByType(PackageDependencyResolver::class), - new IgnoreErrorExtensionProvider(self::getContainer()), + new LazyExtensionsCollection(self::getContainer(), IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), new LocalIgnoresProcessor(), false, @@ -324,7 +336,7 @@ private function gatherAnalyserErrorsWithDelayedErrors(array $files): array $finalizer = new AnalyserResultFinalizer( $ruleRegistry, - new IgnoreErrorExtensionProvider(self::getContainer()), + new LazyExtensionsCollection(self::getContainer(), IgnoreErrorExtension::class), self::getContainer()->getByType(RuleErrorTransformer::class), self::createScopeFactory($reflectionProvider, self::getContainer()->getService('typeSpecifier')), new LocalIgnoresProcessor(), diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 7723560fd0..2d538c0c64 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -12,9 +12,7 @@ use PHPStan\Analyser\NodeScopeResolver; use PHPStan\Analyser\Scope; use PHPStan\Analyser\ScopeContext; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\File\SystemAgnosticSimpleRelativePathHelper; use PHPStan\Node\DeepNodeCloner; @@ -24,11 +22,20 @@ use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Reflection\ReflectionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\ShouldNotHappenException; use PHPStan\TrinaryLogic; use PHPStan\Type\ConstantScalarType; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\Type; use PHPStan\Type\VerbosityLevel; use Symfony\Component\Finder\Finder; @@ -74,15 +81,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), self::getParser(), $container->getByType(FileTypeMapper::class), $container->getByType(PhpDocInheritanceResolver::class), $container->getByType(FileHelper::class), $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $container->getParameter('polluteScopeWithLoopInitialAssignments'), diff --git a/src/Type/DynamicFunctionThrowTypeExtension.php b/src/Type/DynamicFunctionThrowTypeExtension.php index def41a9a4b..95ece186e6 100644 --- a/src/Type/DynamicFunctionThrowTypeExtension.php +++ b/src/Type/DynamicFunctionThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; /** @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicFunctionThrowTypeExtension')] interface DynamicFunctionThrowTypeExtension { diff --git a/src/Type/DynamicMethodThrowTypeExtension.php b/src/Type/DynamicMethodThrowTypeExtension.php index 5d9fce22b6..4a51da06e9 100644 --- a/src/Type/DynamicMethodThrowTypeExtension.php +++ b/src/Type/DynamicMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicMethodThrowTypeExtension')] interface DynamicMethodThrowTypeExtension { diff --git a/src/Type/DynamicReturnTypeExtensionRegistry.php b/src/Type/DynamicReturnTypeExtensionRegistry.php index bceef62997..7fe688623e 100644 --- a/src/Type/DynamicReturnTypeExtensionRegistry.php +++ b/src/Type/DynamicReturnTypeExtensionRegistry.php @@ -2,11 +2,15 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ReflectionProvider; use function array_merge; use function strtolower; +#[AutowiredService] final class DynamicReturnTypeExtensionRegistry { @@ -20,15 +24,18 @@ final class DynamicReturnTypeExtensionRegistry private array $dynamicReturnTypeExtensionsByFunction = []; /** - * @param DynamicMethodReturnTypeExtension[] $dynamicMethodReturnTypeExtensions - * @param DynamicStaticMethodReturnTypeExtension[] $dynamicStaticMethodReturnTypeExtensions - * @param DynamicFunctionReturnTypeExtension[] $dynamicFunctionReturnTypeExtensions + * @param ExtensionsCollection $dynamicMethodReturnTypeExtensions + * @param ExtensionsCollection $dynamicStaticMethodReturnTypeExtensions + * @param ExtensionsCollection $dynamicFunctionReturnTypeExtensions */ public function __construct( private ReflectionProvider $reflectionProvider, - private array $dynamicMethodReturnTypeExtensions, - private array $dynamicStaticMethodReturnTypeExtensions, - private array $dynamicFunctionReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicMethodReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicStaticMethodReturnTypeExtension::class)] + private ExtensionsCollection $dynamicStaticMethodReturnTypeExtensions, + #[AutowiredExtensions(interface: DynamicFunctionReturnTypeExtension::class)] + private ExtensionsCollection $dynamicFunctionReturnTypeExtensions, ) { } @@ -40,7 +47,7 @@ public function getDynamicMethodReturnTypeExtensionsForClass(string $className): { if ($this->dynamicMethodReturnTypeExtensionsByClass === null) { $byClass = []; - foreach ($this->dynamicMethodReturnTypeExtensions as $extension) { + foreach ($this->dynamicMethodReturnTypeExtensions->getAll() as $extension) { $byClass[strtolower($extension->getClass())][] = $extension; } @@ -56,7 +63,7 @@ public function getDynamicStaticMethodReturnTypeExtensionsForClass(string $class { if ($this->dynamicStaticMethodReturnTypeExtensionsByClass === null) { $byClass = []; - foreach ($this->dynamicStaticMethodReturnTypeExtensions as $extension) { + foreach ($this->dynamicStaticMethodReturnTypeExtensions->getAll() as $extension) { $byClass[strtolower($extension->getClass())][] = $extension; } @@ -100,7 +107,7 @@ public function getDynamicFunctionReturnTypeExtensions(FunctionReflection $funct } $supportedFunctions = []; - foreach ($this->dynamicFunctionReturnTypeExtensions as $dynamicFunctionReturnTypeExtension) { + foreach ($this->dynamicFunctionReturnTypeExtensions->getAll() as $dynamicFunctionReturnTypeExtension) { if (!$dynamicFunctionReturnTypeExtension->isFunctionSupported($functionReflection)) { continue; } diff --git a/src/Type/DynamicStaticMethodThrowTypeExtension.php b/src/Type/DynamicStaticMethodThrowTypeExtension.php index 1dc3c5334f..034a10cac0 100644 --- a/src/Type/DynamicStaticMethodThrowTypeExtension.php +++ b/src/Type/DynamicStaticMethodThrowTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyDynamicThrowTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; /** @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyDynamicThrowTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.dynamicStaticMethodThrowTypeExtension')] interface DynamicStaticMethodThrowTypeExtension { diff --git a/src/Type/ExpressionTypeResolverExtensionRegistry.php b/src/Type/ExpressionTypeResolverExtensionRegistry.php index 1d9dc436c0..cb4f89da40 100644 --- a/src/Type/ExpressionTypeResolverExtensionRegistry.php +++ b/src/Type/ExpressionTypeResolverExtensionRegistry.php @@ -2,24 +2,30 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; + +#[AutowiredService] final class ExpressionTypeResolverExtensionRegistry { /** - * @param array $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: ExpressionTypeResolverExtension::class)] + private ExtensionsCollection $extensions, ) { } /** - * @return array + * @return list */ public function getExtensions(): array { - return $this->extensions; + return $this->extensions->getAll(); } } diff --git a/src/Type/FunctionParameterClosureThisExtension.php b/src/Type/FunctionParameterClosureThisExtension.php index 7b56a8d30f..dbd24b934e 100644 --- a/src/Type/FunctionParameterClosureThisExtension.php +++ b/src/Type/FunctionParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterClosureThisExtension')] interface FunctionParameterClosureThisExtension { diff --git a/src/Type/FunctionParameterClosureTypeExtension.php b/src/Type/FunctionParameterClosureTypeExtension.php index bffc1a191a..1a4e62813b 100644 --- a/src/Type/FunctionParameterClosureTypeExtension.php +++ b/src/Type/FunctionParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterClosureTypeExtension')] interface FunctionParameterClosureTypeExtension { diff --git a/src/Type/FunctionParameterOutTypeExtension.php b/src/Type/FunctionParameterOutTypeExtension.php index 9f7de7e031..6522028dce 100644 --- a/src/Type/FunctionParameterOutTypeExtension.php +++ b/src/Type/FunctionParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\FunctionReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::FUNCTION_TAG)] +#[ExtensionInterface(tag: 'phpstan.functionParameterOutTypeExtension')] interface FunctionParameterOutTypeExtension { diff --git a/src/Type/MethodParameterClosureThisExtension.php b/src/Type/MethodParameterClosureThisExtension.php index ebab7d31f3..f2f00a9024 100644 --- a/src/Type/MethodParameterClosureThisExtension.php +++ b/src/Type/MethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterClosureThisExtension')] interface MethodParameterClosureThisExtension { diff --git a/src/Type/MethodParameterClosureTypeExtension.php b/src/Type/MethodParameterClosureTypeExtension.php index 0f372bfa44..1931970dd7 100644 --- a/src/Type/MethodParameterClosureTypeExtension.php +++ b/src/Type/MethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterClosureTypeExtension')] interface MethodParameterClosureTypeExtension { diff --git a/src/Type/MethodParameterOutTypeExtension.php b/src/Type/MethodParameterOutTypeExtension.php index e11c4b33ea..c28bb7f9e2 100644 --- a/src/Type/MethodParameterOutTypeExtension.php +++ b/src/Type/MethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\MethodCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.methodParameterOutTypeExtension')] interface MethodParameterOutTypeExtension { diff --git a/src/Type/OperatorTypeSpecifyingExtensionRegistry.php b/src/Type/OperatorTypeSpecifyingExtensionRegistry.php index bb830a6944..f8ada91842 100644 --- a/src/Type/OperatorTypeSpecifyingExtensionRegistry.php +++ b/src/Type/OperatorTypeSpecifyingExtensionRegistry.php @@ -3,18 +3,23 @@ namespace PHPStan\Type; use PhpParser\Node\Expr; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_filter; use function array_values; use function count; +#[AutowiredService] final class OperatorTypeSpecifyingExtensionRegistry { /** - * @param OperatorTypeSpecifyingExtension[] $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: OperatorTypeSpecifyingExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -24,7 +29,7 @@ public function __construct( */ private function getOperatorTypeSpecifyingExtensions(string $operator, Type $leftType, Type $rightType): array { - return array_values(array_filter($this->extensions, static fn (OperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $leftType, $rightType))); + return array_values(array_filter($this->extensions->getAll(), static fn (OperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $leftType, $rightType))); } public function callOperatorTypeSpecifyingExtensions(Expr\BinaryOp $expr, Type $leftType, Type $rightType): ?Type diff --git a/src/Type/StaticMethodParameterClosureThisExtension.php b/src/Type/StaticMethodParameterClosureThisExtension.php index 78946073ac..53dce95c11 100644 --- a/src/Type/StaticMethodParameterClosureThisExtension.php +++ b/src/Type/StaticMethodParameterClosureThisExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureThisExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -25,7 +24,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureThisExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterClosureThisExtension')] interface StaticMethodParameterClosureThisExtension { diff --git a/src/Type/StaticMethodParameterClosureTypeExtension.php b/src/Type/StaticMethodParameterClosureTypeExtension.php index 341f1805d5..1e74985cf3 100644 --- a/src/Type/StaticMethodParameterClosureTypeExtension.php +++ b/src/Type/StaticMethodParameterClosureTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterClosureTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterClosureTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterClosureTypeExtension')] interface StaticMethodParameterClosureTypeExtension { diff --git a/src/Type/StaticMethodParameterOutTypeExtension.php b/src/Type/StaticMethodParameterOutTypeExtension.php index 73572de9bf..7eed9c5069 100644 --- a/src/Type/StaticMethodParameterOutTypeExtension.php +++ b/src/Type/StaticMethodParameterOutTypeExtension.php @@ -5,7 +5,6 @@ use PhpParser\Node\Expr\StaticCall; use PHPStan\Analyser\Scope; use PHPStan\DependencyInjection\ExtensionInterface; -use PHPStan\DependencyInjection\Type\LazyParameterOutTypeExtensionProvider; use PHPStan\Reflection\MethodReflection; use PHPStan\Reflection\ParameterReflection; @@ -24,7 +23,7 @@ * * @api */ -#[ExtensionInterface(tag: LazyParameterOutTypeExtensionProvider::STATIC_METHOD_TAG)] +#[ExtensionInterface(tag: 'phpstan.staticMethodParameterOutTypeExtension')] interface StaticMethodParameterOutTypeExtension { diff --git a/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php b/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php index 0e64319598..9e5104a214 100644 --- a/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php +++ b/src/Type/UnaryOperatorTypeSpecifyingExtensionRegistry.php @@ -2,18 +2,23 @@ namespace PHPStan\Type; +use PHPStan\DependencyInjection\AutowiredExtensions; +use PHPStan\DependencyInjection\AutowiredService; +use PHPStan\DependencyInjection\ExtensionsCollection; use function array_filter; use function array_values; use function count; +#[AutowiredService] final class UnaryOperatorTypeSpecifyingExtensionRegistry { /** - * @param UnaryOperatorTypeSpecifyingExtension[] $extensions + * @param ExtensionsCollection $extensions */ public function __construct( - private array $extensions, + #[AutowiredExtensions(interface: UnaryOperatorTypeSpecifyingExtension::class)] + private ExtensionsCollection $extensions, ) { } @@ -23,7 +28,7 @@ public function __construct( */ private function getOperatorTypeSpecifyingExtensions(string $operator, Type $operandType): array { - return array_values(array_filter($this->extensions, static fn (UnaryOperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $operandType))); + return array_values(array_filter($this->extensions->getAll(), static fn (UnaryOperatorTypeSpecifyingExtension $extension): bool => $extension->isOperatorSupported($operator, $operandType))); } public function callUnaryOperatorTypeSpecifyingExtensions(string $operatorSigil, Type $operandType): ?Type diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 6f781f28a2..dcff139568 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,8 @@ 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\DependencyInjection\LazyExtensionsCollection; use PHPStan\Node\DeepNodeCloner; use PHPStan\Node\Printer\ExprPrinter; use PHPStan\Node\Printer\Printer; @@ -26,9 +24,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 +778,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(), @@ -800,7 +807,7 @@ private function createAnalyser(): Analyser $ruleRegistry = new DirectRuleRegistry([ new AlwaysFailRule(), ]); - $collectorRegistry = new CollectorRegistry([]); + $collectorRegistry = new CollectorRegistry(new DirectExtensionsCollection([])); $reflectionProvider = self::createReflectionProvider(); $fileHelper = $this->getFileHelper(); @@ -816,15 +823,21 @@ private function createAnalyser(): Analyser $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), $this->getParser(), $fileTypeMapper, $phpDocInheritanceResolver, $fileHelper, $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), false, @@ -843,12 +856,12 @@ private function createAnalyser(): Analyser new RichParser( new Php7($lexer), new NameResolver(), - $container, + new LazyExtensionsCollection($container, NodeVisitor::class), new IgnoreLexer(), ), new DependencyResolver($fileHelper, $reflectionProvider, new ExportedNodeResolver($reflectionProvider, $fileTypeMapper, new ExprPrinter(new Printer())), $fileTypeMapper), 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 0a1804341a..f2bfd46e44 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverRuleTest.php @@ -6,21 +6,28 @@ use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; use PHPStan\Analyser\NodeScopeResolver; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\DirectExtensionsCollection; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Node\DeepNodeCloner; use PHPStan\PhpDoc\PhpDocInheritanceResolver; use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; use PHPStan\Rules\IdentifierRuleError; -use PHPStan\Rules\Properties\DirectReadWritePropertiesExtensionProvider; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleErrorBuilder; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPStan\Type\VerbosityLevel; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -119,15 +126,21 @@ protected function createNodeScopeResolver(): NodeScopeResolver self::getContainer()->getByType(InitializerExprTypeResolver::class), self::getReflector(), self::getContainer()->getByType(ClassReflectionFactory::class), - self::getContainer()->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterOutTypeExtension::class), $this->getParser(), self::getContainer()->getByType(FileTypeMapper::class), self::getContainer()->getByType(PhpDocInheritanceResolver::class), self::getContainer()->getByType(FileHelper::class), $typeSpecifier, - $readWritePropertiesExtensions !== [] ? new DirectReadWritePropertiesExtensionProvider($readWritePropertiesExtensions) : self::getContainer()->getByType(ReadWritePropertiesExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureThisExtensionProvider::class), - self::getContainer()->getByType(ParameterClosureTypeExtensionProvider::class), + $readWritePropertiesExtensions !== [] ? new DirectExtensionsCollection($readWritePropertiesExtensions) : new LazyExtensionsCollection(self::getContainer(), ReadWritePropertiesExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection(self::getContainer(), FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection(self::getContainer(), StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), self::getContainer()->getByType(DeepNodeCloner::class), $this->shouldPolluteScopeWithLoopInitialAssignments(), diff --git a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php index ae9aa1ec4c..3118a78df7 100644 --- a/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php +++ b/tests/PHPStan/Analyser/Fiber/FiberNodeScopeResolverTest.php @@ -4,17 +4,24 @@ use PHPStan\Analyser\ExprHandler\Helper\ImplicitToStringCallHelper; use PHPStan\Analyser\NodeScopeResolver; -use PHPStan\DependencyInjection\Type\ParameterClosureThisExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterClosureTypeExtensionProvider; -use PHPStan\DependencyInjection\Type\ParameterOutTypeExtensionProvider; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Node\DeepNodeCloner; use PHPStan\PhpDoc\PhpDocInheritanceResolver; use PHPStan\Reflection\ClassReflectionFactory; use PHPStan\Reflection\InitializerExprTypeResolver; -use PHPStan\Rules\Properties\ReadWritePropertiesExtensionProvider; +use PHPStan\Rules\Properties\ReadWritePropertiesExtension; use PHPStan\Testing\TypeInferenceTestCase; use PHPStan\Type\FileTypeMapper; +use PHPStan\Type\FunctionParameterClosureThisExtension; +use PHPStan\Type\FunctionParameterClosureTypeExtension; +use PHPStan\Type\FunctionParameterOutTypeExtension; +use PHPStan\Type\MethodParameterClosureThisExtension; +use PHPStan\Type\MethodParameterClosureTypeExtension; +use PHPStan\Type\MethodParameterOutTypeExtension; +use PHPStan\Type\StaticMethodParameterClosureThisExtension; +use PHPStan\Type\StaticMethodParameterClosureTypeExtension; +use PHPStan\Type\StaticMethodParameterOutTypeExtension; use PHPUnit\Framework\Attributes\DataProvider; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -52,15 +59,21 @@ protected static function createNodeScopeResolver(): NodeScopeResolver $container->getByType(InitializerExprTypeResolver::class), self::getReflector(), $container->getByType(ClassReflectionFactory::class), - $container->getByType(ParameterOutTypeExtensionProvider::class), + new LazyExtensionsCollection($container, FunctionParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterOutTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterOutTypeExtension::class), self::getParser(), $container->getByType(FileTypeMapper::class), $container->getByType(PhpDocInheritanceResolver::class), $container->getByType(FileHelper::class), $typeSpecifier, - $container->getByType(ReadWritePropertiesExtensionProvider::class), - $container->getByType(ParameterClosureThisExtensionProvider::class), - $container->getByType(ParameterClosureTypeExtensionProvider::class), + new LazyExtensionsCollection($container, ReadWritePropertiesExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureThisExtension::class), + new LazyExtensionsCollection($container, FunctionParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, MethodParameterClosureTypeExtension::class), + new LazyExtensionsCollection($container, StaticMethodParameterClosureTypeExtension::class), self::createScopeFactory($reflectionProvider, $typeSpecifier), $container->getByType(DeepNodeCloner::class), $container->getParameter('polluteScopeWithLoopInitialAssignments'), diff --git a/tests/PHPStan/Collectors/RegistryTest.php b/tests/PHPStan/Collectors/RegistryTest.php index ac7e0c2e9d..af5f1386e8 100644 --- a/tests/PHPStan/Collectors/RegistryTest.php +++ b/tests/PHPStan/Collectors/RegistryTest.php @@ -4,6 +4,7 @@ use PhpParser\Node; use PHPStan\Analyser\Scope; +use PHPStan\DependencyInjection\DirectExtensionsCollection; use PHPStan\Testing\PHPStanTestCase; class RegistryTest extends PHPStanTestCase @@ -13,9 +14,9 @@ public function testGetCollectors(): void { $collector = new DummyCollector(); - $registry = new Registry([ + $registry = new Registry(new DirectExtensionsCollection([ $collector, - ]); + ])); $collectors = $registry->getCollectors(Node\Expr\FuncCall::class); $this->assertCount(1, $collectors); @@ -29,10 +30,10 @@ public function testGetCollectorsWithTwoDifferentInstances(): void $fooCollector = new UniversalCollector(Node\Expr\FuncCall::class, static fn (Node\Expr\FuncCall $node, Scope $scope): array => ['Foo error']); $barCollector = new UniversalCollector(Node\Expr\FuncCall::class, static fn (Node\Expr\FuncCall $node, Scope $scope): array => ['Bar error']); - $registry = new Registry([ + $registry = new Registry(new DirectExtensionsCollection([ $fooCollector, $barCollector, - ]); + ])); $collectors = $registry->getCollectors(Node\Expr\FuncCall::class); $this->assertCount(2, $collectors); diff --git a/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php b/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php new file mode 100644 index 0000000000..8199043e64 --- /dev/null +++ b/tests/PHPStan/DependencyInjection/ExtensionsCollectionTest.php @@ -0,0 +1,71 @@ + + */ + public static function dataGetExtensions(): iterable + { + return [ + [DynamicMethodReturnTypeExtension::class, 'phpstan.broker.dynamicMethodReturnTypeExtension'], + [ReadWritePropertiesExtension::class, 'phpstan.properties.readWriteExtension'], + [IgnoreErrorExtension::class, 'phpstan.ignoreErrorExtension'], + ]; + } + + /** + * @param class-string $interfaceName + */ + #[DataProvider('dataGetExtensions')] + public function testGetExtensions(string $interfaceName, string $tag): void + { + $container = self::getContainer(); + $extensions = $container->getExtensions($interfaceName); + + $this->assertSame($container->getServicesByTag($tag), $extensions); + foreach ($extensions as $extension) { + $this->assertInstanceOf($interfaceName, $extension); + } + } + + public function testGetExtensionsOfNonExtensionInterface(): void + { + $this->expectException(MissingServiceException::class); + $this->expectExceptionMessage('Interface stdClass is not an extension interface. Mark it with the #[PHPStan\DependencyInjection\ExtensionInterface] attribute.'); + self::getContainer()->getExtensions(stdClass::class); + } + + public function testLazyExtensionsCollectionReleasesTheContainer(): void + { + $collection = new LazyExtensionsCollection(self::getContainer(), DynamicMethodReturnTypeExtension::class); + + $containerProperty = new ReflectionProperty(LazyExtensionsCollection::class, 'container'); + $this->assertNotNull($containerProperty->getValue($collection)); + + $extensions = $collection->getAll(); + + $this->assertNull($containerProperty->getValue($collection)); + $this->assertSame($extensions, $collection->getAll()); + } + + public function testDirectExtensionsCollection(): void + { + $extension = self::getContainer()->getExtensions(IgnoreErrorExtension::class); + $collection = new DirectExtensionsCollection($extension); + + $this->assertSame($extension, $collection->getAll()); + } + +} diff --git a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php index eef6033cfd..d382220f86 100644 --- a/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php +++ b/tests/PHPStan/PhpDoc/DefaultStubFilesProviderTest.php @@ -3,6 +3,7 @@ namespace PHPStan\PhpDoc; use Override; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\File\FileHelper; use PHPStan\Testing\PHPStanTestCase; use function dirname; @@ -64,7 +65,7 @@ public function testGetProjectStubFilesWhenPathContainsWindowsSeparator(): void */ private function createDefaultStubFilesProvider(array $stubFiles): DefaultStubFilesProvider { - return new DefaultStubFilesProvider($this->getContainer(), new FileHelper(__DIR__), $stubFiles, [$this->currentWorkingDirectory]); + return new DefaultStubFilesProvider(new LazyExtensionsCollection($this->getContainer(), StubFilesExtension::class), new FileHelper(__DIR__), $stubFiles, [$this->currentWorkingDirectory]); } } diff --git a/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php index 7d3246d014..c052ad7baa 100644 --- a/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Api/ApiClassImplementsRuleTest.php @@ -31,33 +31,33 @@ public function testRuleOutOfPhpStan(): void $this->analyse([__DIR__ . '/data/class-implements-out-of-phpstan.php'], [ [ - 'Implementing PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', + 'Implementing PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', 20, $tip, ], [ 'Implementing PHPStan\Type\Type is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 54, + 44, $tip, ], [ 'Implementing PHPStan\Reflection\ReflectionProvider is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 363, + 353, $tip, ], [ 'Implementing PHPStan\Analyser\Scope is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 368, + 358, $tip, ], [ 'Implementing PHPStan\Reflection\FunctionReflection is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 373, + 363, $tip, ], [ 'Implementing PHPStan\Reflection\ExtendedMethodReflection is not covered by backward compatibility promise. The interface might change in a minor PHPStan version.', - 377, + 367, $tip, ], ]); diff --git a/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Api/ApiInterfaceExtendsRuleTest.php index ee499665b8..9f2d7bed52 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 a2a9418196..6e7fda6360 100644 --- a/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/class-implements-in-phpstan.php @@ -4,25 +4,16 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Reflection\FunctionReflection; +use PHPStan\Reflection\ReflectionProvider; use PHPStan\Type\DynamicFunctionThrowTypeExtension; -class Foo implements DynamicThrowTypeExtensionProvider +class Foo implements ReflectionProviderProvider { - public function getDynamicFunctionThrowTypeExtensions(): array + public function getReflectionProvider(): ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. - } - - public function getDynamicMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicMethodThrowTypeExtensions() method. - } - - public function getDynamicStaticMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicStaticMethodThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } } diff --git a/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php b/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php index 44204e0f2c..dd10070da4 100644 --- a/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php +++ b/tests/PHPStan/Rules/Api/data/class-implements-out-of-phpstan.php @@ -4,7 +4,7 @@ use PhpParser\Node\Expr\FuncCall; use PHPStan\Analyser\Scope; -use PHPStan\DependencyInjection\Type\DynamicThrowTypeExtensionProvider; +use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider; use PHPStan\Php\PhpVersion; use PHPStan\Reflection\ClassMemberAccessAnswerer; use PHPStan\Reflection\ExtendedMethodReflection; @@ -17,21 +17,11 @@ use PHPStan\Type\Type; use PHPStan\Type\VerbosityLevel; -class Foo implements DynamicThrowTypeExtensionProvider +class Foo implements ReflectionProviderProvider { - public function getDynamicFunctionThrowTypeExtensions(): array + public function getReflectionProvider(): ReflectionProvider { - // TODO: Implement getDynamicFunctionThrowTypeExtensions() method. - } - - public function getDynamicMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicMethodThrowTypeExtensions() method. - } - - public function getDynamicStaticMethodThrowTypeExtensions(): array - { - // TODO: Implement getDynamicStaticMethodThrowTypeExtensions() method. + // TODO: Implement getReflectionProvider() method. } } diff --git a/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php b/tests/PHPStan/Rules/Api/data/interface-extends-in-phpstan.php index 1df7e6b0b3..b48b8eb83c 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 c3d4b48e09..b174df315a 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 d986911167..ee5c1b2111 100644 --- a/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -54,9 +57,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php index 82d3519108..c78801ab7f 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php index 7e2e6d8b86..38ef2c9b53 100644 --- a/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ClassConstantRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -39,9 +42,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new PhpVersion($this->phpVersion), checkNonStringableDynamicAccess: true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php index f7b9da55c9..33ab2f0216 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInClassExtendsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassInClassExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php index 30512a74c3..ce3438c1c9 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInInstanceOfRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -23,9 +26,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php index 55c86b9fb0..3f8cfd01bc 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassInTraitUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassInTraitUseRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php index cef3fee647..a2815e293e 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInClassImplementsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassesInClassImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php index 8a9f99cebf..026d8f7efb 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInEnumImplementsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -23,9 +26,9 @@ protected function getRule(): Rule return new ExistingClassesInEnumImplementsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php index 3a97ab0019..fc21958c9b 100644 --- a/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ExistingClassesInInterfaceExtendsRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -22,9 +25,9 @@ protected function getRule(): Rule return new ExistingClassesInInterfaceExtendsRule( new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $reflectionProvider, true, diff --git a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php index a075fb6bb4..f4833853be 100644 --- a/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php +++ b/tests/PHPStan/Rules/Classes/ForbiddenNameCheckExtensionRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,8 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; +use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -35,7 +39,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + new LazyExtensionsCollection($container, RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -50,9 +54,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php index 105257b499..d6f8c0223e 100644 --- a/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php +++ b/tests/PHPStan/Rules/Classes/InstantiationRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,8 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; +use PHPStan\Rules\RestrictedUsage\RestrictedMethodUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -37,7 +41,7 @@ protected function getRule(): Rule discoveringSymbolsTip: true, ); return new InstantiationRule( - $container, + new LazyExtensionsCollection($container, RestrictedMethodUsageExtension::class), $reflectionProvider, new FunctionCallParametersCheck( $ruleLevelHelper, @@ -52,9 +56,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), $ruleLevelHelper, new ConsistentConstructorHelper(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php index 8b1e6ebd23..f6c9b84c78 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -32,9 +35,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php index e2c0836fe7..ccd59e6bb0 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -31,9 +34,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php index dd998ea14c..c90123b0a9 100644 --- a/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php +++ b/tests/PHPStan/Rules/Classes/LocalTypeTraitUseAliasesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\PhpDoc\TypeNodeResolver; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -31,9 +34,9 @@ protected function getRule(): Rule new MissingTypehintCheck(true, [], true), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php index 21cf1a62b9..a5fdaba18d 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php index a75edf63c1..412940631f 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php index ed0a4039f3..b689ddb529 100644 --- a/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MethodTagTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinRuleTest.php b/tests/PHPStan/Rules/Classes/MixinRuleTest.php index 54a2594c0c..ed07bc1f30 100644 --- a/tests/PHPStan/Rules/Classes/MixinRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php b/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php index 1d10c554b7..5454609eb1 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php index 673783bb6a..5bfea4e5b6 100644 --- a/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/MixinTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php index e2e6f0dda6..75a2cc99c6 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php index dd6631d0c6..98fdeee627 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php b/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php index 244b79acaa..e179c979d8 100644 --- a/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php +++ b/tests/PHPStan/Rules/Classes/PropertyTagTraitUseRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Classes; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -27,9 +30,9 @@ protected function getRule(): TRule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php index 7d3e86139e..5a4aa89cd3 100644 --- a/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Constants/ConstantAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Constants; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -11,6 +13,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -58,9 +61,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php b/tests/PHPStan/Rules/Constants/DirectAlwaysUsedClassConstantsExtensionProvider.php deleted file mode 100644 index 861c72d7ab..0000000000 --- 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 889298c3ec..46d72f8c78 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 9a2cf7c207..f57d00b9e5 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 e749b4939a..d724318377 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 2e4dc4462e..e169d5e5f9 100644 --- a/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php +++ b/tests/PHPStan/Rules/EnumCases/EnumCaseAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\EnumCases; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -50,9 +53,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php index 312ef01b05..6a9e6eee57 100644 --- a/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php +++ b/tests/PHPStan/Rules/Exceptions/CaughtExceptionExistenceRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Exceptions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php index 48384cb74d..b63682cd79 100644 --- a/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ArrowFunctionAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php index 661cf08dc5..92ee01b94f 100644 --- a/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ClosureAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php index 5026167c93..ed28b53703 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInArrowFunctionTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php index c640852429..bdb9c48729 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInClosureTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php index a075b099be..80fbcb79e4 100644 --- a/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php index 0025c2d665..4c51270dcf 100644 --- a/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/FunctionAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php index d7a77b3d81..c585e01831 100644 --- a/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Functions/ParamAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Functions; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php index 2632e3334d..74a1ad200d 100644 --- a/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/ClassTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -26,9 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php index 2ecba0fc61..8222eb6907 100644 --- a/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/FunctionTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php index 34115b037a..94e3b94ae6 100644 --- a/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/InterfaceTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php index d8b2582bc1..e1ce2e8c6a 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php index a47ea46988..007e866e40 100644 --- a/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTagTemplateTypeTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php index 872d525b00..a980c2764d 100644 --- a/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/MethodTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php index 9336e1d873..56af62657d 100644 --- a/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php +++ b/tests/PHPStan/Rules/Generics/TraitTemplateTypeRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Generics; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php index cc31101ece..28cdcbbbfd 100644 --- a/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -52,9 +55,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php index 4193804ed4..21b1ae494d 100644 --- a/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Methods/ExistingClassesInTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersionId), diff --git a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php index 517bed3913..f0dd93d639 100644 --- a/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Methods/MethodAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -52,9 +55,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: false, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php index d5186cf16f..7bc83d1e7b 100644 --- a/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php +++ b/tests/PHPStan/Rules/Methods/StaticMethodCallableRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Methods; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -44,9 +47,9 @@ protected function getRule(): Rule $reflectionProvider, checkInternalClassCaseSensitivity: true, ), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), checkFunctionNameCase: true, discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php index 89ccc73cb8..5e07fe2d83 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInGroupUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php index ab27893aed..08a0530503 100644 --- a/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php +++ b/tests/PHPStan/Rules/Namespaces/ExistingNamesInUseRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\Namespaces; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -22,9 +25,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php b/tests/PHPStan/Rules/Operators/InvalidComparisonOperationRuleTest.php index 7d8d929890..5e6b864cdb 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 247ce2a007..e2968dc12c 100644 --- a/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/FunctionAssertRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new MissingTypehintCheck(true, [], true), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php index 046f92d5d1..78cbfcf408 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -34,9 +37,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php index b40c3f2155..693bcc8e0a 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyHookPhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -34,9 +37,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php index 34e8c29280..4527463d28 100644 --- a/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/IncompatiblePropertyPhpDocTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\Generics\TemplateTypeCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -31,9 +34,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), $typeAliasResolver, diff --git a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php index 4153877cea..e45ccb2af7 100644 --- a/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/InvalidPhpDocVarTagTypeRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPStan\Type\FileTypeMapper; @@ -27,9 +30,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new GenericObjectTypeCheck(), new MissingTypehintCheck(true, [], true), diff --git a/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php b/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php index e23fa3eb55..54d9265e74 100644 --- a/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/MethodAssertRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\Generics\GenericObjectTypeCheck; use PHPStan\Rules\MissingTypehintCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -25,9 +28,9 @@ protected function getRule(): Rule new UnresolvableTypeHelper(), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new MissingTypehintCheck(true, [], true), new GenericObjectTypeCheck(), diff --git a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php index 7f80bf1577..ffc3cb1ee7 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionClassRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -25,9 +28,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php index 97707a262b..6d0001a82a 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireExtendsDefinitionTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -26,9 +29,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php index c1703565d4..f11e7db805 100644 --- a/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/RequireImplementsDefinitionTraitRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -24,9 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php index dfd91efc49..34ce25d6dd 100644 --- a/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php +++ b/tests/PHPStan/Rules/PhpDoc/SealedDefinitionClassRuleTest.php @@ -2,9 +2,12 @@ namespace PHPStan\Rules\PhpDoc; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -24,9 +27,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), true, true, diff --git a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php index fc4942719b..454697fea1 100644 --- a/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php +++ b/tests/PHPStan/Rules/Playground/PromoteParameterRuleTest.php @@ -2,7 +2,9 @@ namespace PHPStan\Rules\Playground; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Node\ClassPropertiesNode; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Properties\UninitializedPropertyRule; use PHPStan\Rules\Rule; @@ -19,7 +21,7 @@ protected function getRule(): Rule $container = self::getContainer(); return new PromoteParameterRule( new UninitializedPropertyRule(new ConstructorsHelper( - $container, + new LazyExtensionsCollection($container, AdditionalConstructorsExtension::class), [], )), $container, diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php index f8ddba0d61..af320eb665 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesInAssignRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -36,9 +39,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(new LazyExtensionsCollection(self::getContainer(), ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassNameUsageExtension::class), ), new PhpVersion(PHP_VERSION_ID), discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php index a6e80a4dff..248fb8139a 100644 --- a/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/AccessStaticPropertiesRuleTest.php @@ -2,10 +2,13 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -35,9 +38,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck(self::getContainer()), + new ClassForbiddenNameCheck(new LazyExtensionsCollection(self::getContainer(), ForbiddenClassNameExtension::class)), $reflectionProvider, - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassNameUsageExtension::class), ), new PhpVersion(PHP_VERSION_ID), discoveringSymbolsTip: true, diff --git a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php index 2e9b97364c..cc91adbc0e 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertiesRuleTest.php @@ -2,11 +2,14 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\DataProvider; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion($this->phpVersion), diff --git a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php index 42d1aba91a..cd95fc3394 100644 --- a/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ExistingClassesInPropertyHookTypehintsRuleTest.php @@ -2,12 +2,15 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; use PHPStan\Rules\ClassNameCheck; use PHPStan\Rules\FunctionDefinitionCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -28,9 +31,9 @@ protected function getRule(): Rule $reflectionProvider, new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, true), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), new UnresolvableTypeHelper(), new PhpVersion(PHP_VERSION_ID), diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php index 868e3d77e0..3a268016f8 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -19,7 +21,7 @@ protected function getRule(): Rule { return new MissingReadOnlyByPhpDocPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'MissingReadOnlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php index 1f6332b72d..3f3fd0f629 100644 --- a/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/MissingReadOnlyPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +22,7 @@ protected function getRule(): Rule { return new MissingReadOnlyPropertyAssignRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'MissingReadOnlyPropertyAssign\\TestCase::setUp', 'Bug10523\\Controller::init', diff --git a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php index 78de39db51..f91453d7f9 100644 --- a/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -10,6 +12,7 @@ use PHPStan\Rules\FunctionCallParametersCheck; use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -51,9 +54,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php index d007f02c39..38b8c0de93 100644 --- a/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Properties/PropertyHookAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; use PHPStan\Rules\ClassForbiddenNameCheck; @@ -9,6 +11,7 @@ use PHPStan\Rules\FunctionCallParametersCheck; use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -49,9 +52,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ), diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php index c52d60b8f7..054998a835 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyByPhpDocPropertyAssignRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -18,7 +20,7 @@ protected function getRule(): Rule return new ReadOnlyByPhpDocPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssignPhpDoc\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php index d062d09af1..d1b8c4e22d 100644 --- a/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php +++ b/tests/PHPStan/Rules/Properties/ReadOnlyPropertyAssignRuleTest.php @@ -2,7 +2,9 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -21,7 +23,7 @@ protected function getRule(): Rule return new ReadOnlyPropertyAssignRule( new PropertyReflectionFinder(), new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'ReadonlyPropertyAssign\\TestCase::setUp', ], diff --git a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php index d1b137e35c..935b9abb47 100644 --- a/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php +++ b/tests/PHPStan/Rules/Properties/UninitializedPropertyRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Properties; +use PHPStan\DependencyInjection\LazyExtensionsCollection; +use PHPStan\Reflection\AdditionalConstructorsExtension; use PHPStan\Reflection\ConstructorsHelper; use PHPStan\Reflection\PropertyReflection; use PHPStan\Rules\Rule; @@ -20,7 +22,7 @@ protected function getRule(): Rule { return new UninitializedPropertyRule( new ConstructorsHelper( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), AdditionalConstructorsExtension::class), [ 'UninitializedProperty\\TestCase::setUp', 'Bug9619\\AdminPresenter::startup', diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php index 344f48a91e..6679ca6220 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedClassConstantUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -16,7 +17,7 @@ protected function getRule(): Rule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedClassConstantUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedClassConstantUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php index 52656ce167..1090723d0e 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -15,7 +16,7 @@ class RestrictedFunctionCallableUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php index d96412eab9..6413998e4b 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedFunctionUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedFunctionUsageRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedFunctionUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedFunctionUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php index c690bb4624..034ea6044f 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; use PHPUnit\Framework\Attributes\RequiresPhp; @@ -15,7 +16,7 @@ class RestrictedMethodCallableUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php index dd7aac599a..91794fa9eb 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedMethodUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedMethodUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedMethodUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php index 2fd50f13ad..f21e3e956f 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedPropertyUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedPropertyUsageRuleTest extends RuleTestCase protected function getRule(): TRule { return new RestrictedPropertyUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedPropertyUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php index d3bfce5900..bf0957c852 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodCallableUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -17,7 +18,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodCallableUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php index 7684f1f70e..a0eb85c2d1 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticMethodUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -17,7 +18,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticMethodUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php index 9f1e9f8fb9..9752f6917c 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedStaticPropertyUsageRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule as TRule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -16,7 +17,7 @@ protected function getRule(): TRule { $reflectionProvider = self::createReflectionProvider(); return new RestrictedStaticPropertyUsageRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedPropertyUsageExtension::class), $reflectionProvider, new RuleLevelHelper( $reflectionProvider, diff --git a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php index 660acdad20..7d02611af4 100644 --- a/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php +++ b/tests/PHPStan/Rules/RestrictedUsage/RestrictedUsageOfDeprecatedStringCastRuleTest.php @@ -2,6 +2,7 @@ namespace PHPStan\Rules\RestrictedUsage; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Rules\Rule; use PHPStan\Testing\RuleTestCase; @@ -14,7 +15,7 @@ class RestrictedUsageOfDeprecatedStringCastRuleTest extends RuleTestCase protected function getRule(): Rule { return new RestrictedUsageOfDeprecatedStringCastRule( - self::getContainer(), + new LazyExtensionsCollection(self::getContainer(), RestrictedMethodUsageExtension::class), self::createReflectionProvider(), ); } diff --git a/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php b/tests/PHPStan/Rules/TooWideTypehints/TooWidePropertyTypeRuleTest.php index 4e95d632c3..ee62bdef57 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 68caade88a..19cd5fe1b8 100644 --- a/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php +++ b/tests/PHPStan/Rules/Traits/TraitAttributesRuleTest.php @@ -2,6 +2,8 @@ namespace PHPStan\Rules\Traits; +use PHPStan\Classes\ForbiddenClassNameExtension; +use PHPStan\DependencyInjection\LazyExtensionsCollection; use PHPStan\Php\PhpVersion; use PHPStan\Rules\AttributesCheck; use PHPStan\Rules\ClassCaseSensitivityCheck; @@ -11,6 +13,7 @@ use PHPStan\Rules\NullsafeCheck; use PHPStan\Rules\PhpDoc\UnresolvableTypeHelper; use PHPStan\Rules\Properties\PropertyReflectionFinder; +use PHPStan\Rules\RestrictedUsage\RestrictedClassNameUsageExtension; use PHPStan\Rules\Rule; use PHPStan\Rules\RuleLevelHelper; use PHPStan\Testing\RuleTestCase; @@ -56,9 +59,9 @@ protected function getRule(): Rule ), new ClassNameCheck( new ClassCaseSensitivityCheck($reflectionProvider, checkInternalClassCaseSensitivity: false), - new ClassForbiddenNameCheck($container), + new ClassForbiddenNameCheck(new LazyExtensionsCollection($container, ForbiddenClassNameExtension::class)), $reflectionProvider, - $container, + new LazyExtensionsCollection($container, RestrictedClassNameUsageExtension::class), ), deprecationRulesInstalled: true, ),