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