Simplify

conf/config.neon

@@ -486,11 +486,10 @@ services:
 
 	-
 		class: PHPStan\Analyser\ConstantResolver
-		factory: PHPStan\Analyser\ContainerConstantResolver
+		factory: @PHPStan\Analyser\ConstantResolverFactory::create()
 
 	-
-		class: PHPStan\Analyser\ConstantResolverProvider
-		factory: PHPStan\Analyser\LazyConstantResolverProvider
+		class: PHPStan\Analyser\ConstantResolverFactory
 
 	-
 		implement: PHPStan\Analyser\ResultCache\ResultCacheManagerFactory

src/Analyser/ConstantResolver.php

@@ -4,6 +4,7 @@
 
 use PhpParser\Node\Name;
 use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
 use PHPStan\Type\Accessory\AccessoryNonEmptyStringType;
 use PHPStan\Type\Constant\ConstantIntegerType;
 use PHPStan\Type\Constant\ConstantStringType;
@@ -17,24 +18,24 @@
 use function in_array;
 use const PHP_INT_SIZE;
 
-abstract class ConstantResolver
+class ConstantResolver
 {
 
-	/** @var string[] */
-	private ?array $dynamicConstantNames = null;
-
-	public function __construct(private ReflectionProvider $reflectionProvider)
+	/**
+	 * @param string[] $dynamicConstantNames
+	 */
+	public function __construct(private ReflectionProviderProvider $reflectionProviderProvider, private array $dynamicConstantNames)
 	{
 	}
 
 	public function resolveConstant(Name $name, ?Scope $scope): ?Type
 	{
-		if (!$this->reflectionProvider->hasConstant($name, $scope)) {
+		if (!$this->getReflectionProvider()->hasConstant($name, $scope)) {
 			return null;
 		}
 
 		/** @var string $resolvedConstantName */
-		$resolvedConstantName = $this->reflectionProvider->resolveConstantName($name, $scope);
+		$resolvedConstantName = $this->getReflectionProvider()->resolveConstantName($name, $scope);
 		// core, https://www.php.net/manual/en/reserved.constants.php
 		if ($resolvedConstantName === 'PHP_VERSION') {
 			return new IntersectionType([
@@ -245,32 +246,23 @@ public function resolveConstant(Name $name, ?Scope $scope): ?Type
 			return IntegerRangeType::fromInterval(1, null);
 		}
 
-		$constantType = $this->reflectionProvider->getConstant($name, $scope)->getValueType();
+		$constantType = $this->getReflectionProvider()->getConstant($name, $scope)->getValueType();
 
 		return $this->resolveConstantType($resolvedConstantName, $constantType);
 	}
 
 	public function resolveConstantType(string $constantName, Type $constantType): Type
 	{
-		if ($constantType instanceof ConstantType && $this->isDynamicConstantName($constantName)) {
+		if ($constantType instanceof ConstantType && in_array($constantName, $this->dynamicConstantNames, true)) {
 			return $constantType->generalize(GeneralizePrecision::lessSpecific());
 		}
 
 		return $constantType;
 	}
 
-	private function isDynamicConstantName(string $constantName): bool
+	private function getReflectionProvider(): ReflectionProvider
 	{
-		if ($this->dynamicConstantNames === null) {
-			$this->dynamicConstantNames = $this->getDynamicConstantNames();
-		}
-
-		return in_array($constantName, $this->dynamicConstantNames, true);
+		return $this->reflectionProviderProvider->getReflectionProvider();
 	}
 
-	/**
-	 * @return string[]
-	 */
-	abstract protected function getDynamicConstantNames(): array;
-
 }

src/Analyser/ConstantResolverFactory.php

@@ -0,0 +1,26 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\DependencyInjection\Container;
+use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
+
+class ConstantResolverFactory
+{
+
+	public function __construct(
+		private ReflectionProviderProvider $reflectionProviderProvider,
+		private Container $container,
+	)
+	{
+	}
+
+	public function create(): ConstantResolver
+	{
+		return new ConstantResolver(
+			$this->reflectionProviderProvider,
+			$this->container->getParameter('dynamicConstantNames'),
+		);
+	}
+
+}

src/DependencyInjection/ValidateIgnoredErrorsExtension.php

@@ -7,8 +7,7 @@
 use Nette\DI\CompilerExtension;
 use Nette\Utils\RegexpException;
 use Nette\Utils\Strings;
-use PHPStan\Analyser\DirectConstantResolver;
-use PHPStan\Analyser\DirectConstantResolverProvider;
+use PHPStan\Analyser\ConstantResolver;
 use PHPStan\Analyser\NameScope;
 use PHPStan\Command\IgnoredRegexValidator;
 use PHPStan\PhpDoc\DirectTypeNodeResolverExtensionRegistryProvider;
@@ -52,6 +51,7 @@ public function loadConfiguration(): void
 		/** @throws void */
 		$parser = Llk::load(new Read('hoa://Library/Regex/Grammar.pp'));
 		$reflectionProvider = new DummyReflectionProvider();
+		$reflectionProviderProvider = new DirectReflectionProviderProvider($reflectionProvider);
 		ReflectionProviderStaticAccessor::registerInstance($reflectionProvider);
 		$ignoredRegexValidator = new IgnoredRegexValidator(
 			$parser,
@@ -69,7 +69,7 @@ public function getExtensions(): array
 
 						},
 					),
-					new DirectReflectionProviderProvider($reflectionProvider),
+					$reflectionProviderProvider,
 					new DirectTypeAliasResolverProvider(new class implements TypeAliasResolver {
 
 						public function hasTypeAlias(string $aliasName, ?string $classNameScope): bool
@@ -83,7 +83,7 @@ public function resolveTypeAlias(string $aliasName, NameScope $nameScope): ?Type
 						}
 
 					}),
-					new DirectConstantResolverProvider(new DirectConstantResolver($reflectionProvider, [])),
+					new ConstantResolver($reflectionProviderProvider, []),
 				),
 			),
 		);

src/PhpDoc/TypeNodeResolver.php

@@ -9,7 +9,6 @@
 use Nette\Utils\Strings;
 use PhpParser\Node\Name;
 use PHPStan\Analyser\ConstantResolver;
-use PHPStan\Analyser\ConstantResolverProvider;
 use PHPStan\Analyser\NameScope;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprArrayNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprFalseNode;
@@ -104,7 +103,7 @@ public function __construct(
 		private TypeNodeResolverExtensionRegistryProvider $extensionRegistryProvider,
 		private ReflectionProvider\ReflectionProviderProvider $reflectionProviderProvider,
 		private TypeAliasResolverProvider $typeAliasResolverProvider,
-		private ConstantResolverProvider $constantResolverProvider,
+		private ConstantResolver $constantResolver,
 	)
 	{
 	}
@@ -388,7 +387,7 @@ private function tryResolveConstant(string $name, NameScope $nameScope): ?Type
 	{
 		foreach ($nameScope->resolveConstantNames($name) as $constName) {
 			$nameNode = new Name\FullyQualified(explode('\\', $constName));
-			$constType = $this->getConstantResolver()->resolveConstant($nameNode, null);
+			$constType = $this->constantResolver->resolveConstant($nameNode, null);
 			if ($constType !== null) {
 				return $constType;
 			}
@@ -944,9 +943,4 @@ private function getTypeAliasResolver(): TypeAliasResolver
 		return $this->typeAliasResolverProvider->getTypeAliasResolver();
 	}
 
-	private function getConstantResolver(): ConstantResolver
-	{
-		return $this->constantResolverProvider->getConstantResolver();
-	}
-
 }

src/Testing/PHPStanTestCase.php

@@ -3,8 +3,7 @@
 namespace PHPStan\Testing;
 
 use PhpParser\PrettyPrinter\Standard;
-use PHPStan\Analyser\ContainerConstantResolver;
-use PHPStan\Analyser\DirectConstantResolver;
+use PHPStan\Analyser\ConstantResolver;
 use PHPStan\Analyser\DirectScopeFactory;
 use PHPStan\Analyser\Error;
 use PHPStan\Analyser\MutatingScope;
@@ -27,6 +26,7 @@
 use PHPStan\PhpDoc\TypeNodeResolver;
 use PHPStan\PhpDoc\TypeStringResolver;
 use PHPStan\Reflection\ReflectionProvider;
+use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider;
 use PHPStan\Rules\Properties\PropertyReflectionFinder;
 use PHPStan\Type\TypeAliasResolver;
 use PHPStan\Type\UsefulTypeAliasResolver;
@@ -156,10 +156,8 @@ public function createScopeFactory(ReflectionProvider $reflectionProvider, TypeS
 	{
 		$container = self::getContainer();
 
-		if (count($dynamicConstantNames) > 0) {
-			$constantResolver = new DirectConstantResolver($reflectionProvider, $dynamicConstantNames);
-		} else {
-			$constantResolver = new ContainerConstantResolver($reflectionProvider, $container);
+		if (count($dynamicConstantNames) === 0) {
+			$dynamicConstantNames = $container->getParameter('dynamicConstantNames');
 		}
 
 		return new DirectScopeFactory(
@@ -175,7 +173,7 @@ public function createScopeFactory(ReflectionProvider $reflectionProvider, TypeS
 			$this->shouldTreatPhpDocTypesAsCertain(),
 			$container->getByType(PhpVersion::class),
 			$container->getParameter('featureToggles')['explicitMixedInUnknownGenericNew'],
-			$constantResolver,
+			new ConstantResolver(new DirectReflectionProviderProvider($reflectionProvider), $dynamicConstantNames),
 		);
 	}