dynamicConstantNames - allow specifying constant type

Author: ssigwart

src/Analyser/ConstantResolver.php

@@ -4,8 +4,10 @@
 
 use PhpParser\Node\Name;
 use PHPStan\DependencyInjection\AutowiredService;
+use PHPStan\DependencyInjection\Container;
 use PHPStan\Php\ComposerPhpVersionFactory;
 use PHPStan\Php\PhpVersion;
+use PHPStan\PhpDoc\TypeStringResolver;
 use PHPStan\Reflection\NamespaceAnswerer;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Reflection\ReflectionProvider\ReflectionProviderProvider;
@@ -50,6 +52,7 @@ public function __construct(
 		private array $dynamicConstantNames,
 		private int|array|null $phpVersion,
 		private ComposerPhpVersionFactory $composerPhpVersionFactory,
+		private ?Container $container,
 	)
 	{
 	}
@@ -404,8 +407,18 @@ private function getMaxPhpVersion(): ?PhpVersion
 
 	public function resolveConstantType(string $constantName, Type $constantType): Type
 	{
-		if ($constantType->isConstantValue()->yes() && in_array($constantName, $this->dynamicConstantNames, true)) {
-			return $constantType->generalize(GeneralizePrecision::lessSpecific());
+		if ($constantType->isConstantValue()->yes()) {
+			if (array_key_exists($constantName, $this->dynamicConstantNames)) {
+				$phpdocTypes = $this->dynamicConstantNames[$constantName];
+				if ($this->container !== null) {
+					$typeStringResolver = $this->container->getByType(TypeStringResolver::class);
+					return $typeStringResolver->resolve($phpdocTypes, new NameScope(null, [], null));
+				}
+				return $constantType;
+			}
+			if (in_array($constantName, $this->dynamicConstantNames, true)) {
+				return $constantType->generalize(GeneralizePrecision::lessSpecific());
+			}
 		}
 
 		return $constantType;
@@ -414,6 +427,22 @@ public function resolveConstantType(string $constantName, Type $constantType): T
 	public function resolveClassConstantType(string $className, string $constantName, Type $constantType, ?Type $nativeType): Type
 	{
 		$lookupConstantName = sprintf('%s::%s', $className, $constantName);
+		if (array_key_exists($lookupConstantName, $this->dynamicConstantNames)) {
+			if ($constantType->isConstantValue()->yes()) {
+				$phpdocTypes = $this->dynamicConstantNames[$lookupConstantName];
+				if ($this->container !== null) {
+					$typeStringResolver = $this->container->getByType(TypeStringResolver::class);
+					return $typeStringResolver->resolve($phpdocTypes, new NameScope(null, [], $className));
+				}
+			}
+
+			if ($nativeType !== null) {
+				return $nativeType;
+			}
+			
+			return $constantType;
+		}
+
 		if (in_array($lookupConstantName, $this->dynamicConstantNames, true)) {
 			if ($nativeType !== null) {
 				return $nativeType;

src/Analyser/ConstantResolverFactory.php

@@ -27,6 +27,7 @@ public function create(): ConstantResolver
 			$this->container->getParameter('dynamicConstantNames'),
 			$this->container->getParameter('phpVersion'),
 			$composerFactory,
+			$this->container,
 		);
 	}
 

src/Analyser/MutatingScope.php

@@ -6209,6 +6209,11 @@ public function getConstantReflection(Type $typeWithConstant, string $constantNa
 		return $typeWithConstant->getConstant($constantName);
 	}
 
+	public function getConstantExplicitTypeFromConfig(string $constantName, Type $constantType): Type
+	{
+		return $this->constantResolver->resolveConstantType($constantName, $constantType);
+	}
+
 	/**
 	 * @return array<string, ExpressionTypeHolder>
 	 */

src/Analyser/Scope.php

@@ -81,6 +81,8 @@ public function getMethodReflection(Type $typeWithMethod, string $methodName): ?
 
 	public function getConstantReflection(Type $typeWithConstant, string $constantName): ?ClassConstantReflection;
 
+	public function getConstantExplicitTypeFromConfig(string $constantName, Type $constantType): Type;
+
 	public function getIterableKeyType(Type $iteratee): Type;
 
 	public function getIterableValueType(Type $iteratee): Type;

src/DependencyInjection/ValidateIgnoredErrorsExtension.php

@@ -69,7 +69,7 @@ public function loadConfiguration(): void
 		ReflectionProviderStaticAccessor::registerInstance($reflectionProvider);
 		PhpVersionStaticAccessor::registerInstance(new PhpVersion(PHP_VERSION_ID));
 		$composerPhpVersionFactory = new ComposerPhpVersionFactory([]);
-		$constantResolver = new ConstantResolver($reflectionProviderProvider, [], null, $composerPhpVersionFactory);
+		$constantResolver = new ConstantResolver($reflectionProviderProvider, [], null, $composerPhpVersionFactory, null);
 
 		$phpDocParserConfig = new ParserConfig([]);
 		$ignoredRegexValidator = new IgnoredRegexValidator(

src/Testing/PHPStanTestCase.php

@@ -140,7 +140,7 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider
 
 		$reflectionProviderProvider = new DirectReflectionProviderProvider($reflectionProvider);
 		$composerPhpVersionFactory = $container->getByType(ComposerPhpVersionFactory::class);
-		$constantResolver = new ConstantResolver($reflectionProviderProvider, $dynamicConstantNames, null, $composerPhpVersionFactory);
+		$constantResolver = new ConstantResolver($reflectionProviderProvider, $dynamicConstantNames, null, $composerPhpVersionFactory, $container);
 
 		$initializerExprTypeResolver = new InitializerExprTypeResolver(
 			$constantResolver,

src/Type/Php/DefineConstantTypeSpecifyingExtension.php

@@ -52,11 +52,17 @@ public function specifyTypes(
 			return new SpecifiedTypes([], []);
 		}
 
+		$valueType = $scope->getType($node->getArgs()[1]->value);
+		$finalType = $scope->getConstantExplicitTypeFromConfig(
+			$constantName->getValue(),
+			$valueType,
+		);
+
 		return $this->typeSpecifier->create(
 			new Node\Expr\ConstFetch(
 				new Node\Name\FullyQualified($constantName->getValue()),
 			),
-			$scope->getType($node->getArgs()[1]->value),
+			$finalType,
 			TypeSpecifierContext::createTruthy(),
 			$scope,
 		)->setAlwaysOverwriteTypes();

tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php

@@ -8247,6 +8247,10 @@ public static function dataDynamicConstants(): array
 				'string',
 				'DynamicConstants\DynamicConstantClass::DYNAMIC_CONSTANT_IN_CLASS',
 			],
+			[
+				'string|null',
+				'DynamicConstants\DynamicConstantClass::DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES_IN_CLASS',
+			],
 			[
 				"'abc123def'",
 				'DynamicConstants\DynamicConstantClass::PURE_CONSTANT_IN_CLASS',
@@ -8256,13 +8260,17 @@ public static function dataDynamicConstants(): array
 				'DynamicConstants\NoDynamicConstantClass::DYNAMIC_CONSTANT_IN_CLASS',
 			],
 			[
-				'false',
+				'bool',
 				'GLOBAL_DYNAMIC_CONSTANT',
 			],
 			[
 				'123',
 				'GLOBAL_PURE_CONSTANT',
 			],
+			[
+				'string|null',
+				'GLOBAL_DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES',
+			],
 		];
 	}
 
@@ -8278,8 +8286,10 @@ public function testDynamicConstants(
 			$expression,
 			'die',
 			[
-				'DynamicConstants\\DynamicConstantClass::DYNAMIC_CONSTANT_IN_CLASS',
-				'GLOBAL_DYNAMIC_CONSTANT',
+				0 => 'DynamicConstants\\DynamicConstantClass::DYNAMIC_CONSTANT_IN_CLASS',
+				1 => 'GLOBAL_DYNAMIC_CONSTANT',
+				'DynamicConstants\\DynamicConstantClass::DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES_IN_CLASS' => 'string|null',
+				'GLOBAL_DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES' => 'string|null',
 			],
 		);
 	}

tests/PHPStan/Analyser/data/dynamic-constant.php

@@ -4,10 +4,12 @@
 
 define('GLOBAL_PURE_CONSTANT', 123);
 define('GLOBAL_DYNAMIC_CONSTANT', false);
+define('GLOBAL_DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES', null);
 
 class DynamicConstantClass
 {
 	const DYNAMIC_CONSTANT_IN_CLASS = 'abcdef';
+	const DYNAMIC_CONSTANT_WITH_EXPLICIT_TYPES_IN_CLASS = 'xyz';
 	const PURE_CONSTANT_IN_CLASS = 'abc123def';
 }