Read class constant type when generalizing the type for dynamicConstantNames

Author: ondrejmirtes

src/Analyser/ConstantResolver.php

@@ -20,6 +20,7 @@
 use PHPStan\Type\UnionType;
 use function array_key_exists;
 use function in_array;
+use function sprintf;
 use const INF;
 use const NAN;
 use const PHP_INT_SIZE;
@@ -299,6 +300,22 @@ public function resolveConstantType(string $constantName, Type $constantType): T
 return $constantType;
 }
 
+public function resolveClassConstantType(string $className, string $constantName, Type $constantType, ?Type $nativeType): Type
+{
+$lookupConstantName = sprintf('%s::%s', $className, $constantName);
+if (in_array($lookupConstantName, $this->dynamicConstantNames, true)) {
+if ($nativeType !== null) {
+return $nativeType;
+}
+
+if ($constantType->isConstantValue()->yes()) {
+return $constantType->generalize(GeneralizePrecision::lessSpecific());
+}
+}
+
+return $constantType;
+}
+
 private function getReflectionProvider(): ReflectionProvider
 {
 return $this->reflectionProviderProvider->getReflectionProvider();

src/Reflection/InitializerExprTypeResolver.php

@@ -61,6 +61,7 @@
 use PHPStan\Type\ThisType;
 use PHPStan\Type\Type;
 use PHPStan\Type\TypeCombinator;
+use PHPStan\Type\TypehintHelper;
 use PHPStan\Type\TypeTraverser;
 use PHPStan\Type\TypeUtils;
 use PHPStan\Type\TypeWithClassName;
@@ -78,7 +79,6 @@
 use function is_int;
 use function max;
 use function min;
-use function sprintf;
 use function strtolower;
 use const INF;
 
@@ -1883,9 +1883,15 @@ function (Type $type, callable $traverse): Type {
 }
 $reflectionConstantDeclaringClass = $reflectionConstant->getDeclaringClass();
 $constantType = $this->getType($reflectionConstant->getValueExpression(), InitializerExprContext::fromClass($reflectionConstantDeclaringClass->getName(), $reflectionConstantDeclaringClass->getFileName() ?: null));
-$types[] = $this->constantResolver->resolveConstantType(
-sprintf('%s::%s', $constantClassReflection->getName(), $constantName),
+$nativeType = null;
+if ($reflectionConstant->getType() !== null) {
+$nativeType = TypehintHelper::decideTypeFromReflection($reflectionConstant->getType(), null, $constantClassReflection);
+}
+$types[] = $this->constantResolver->resolveClassConstantType(
+$constantClassReflection->getName(),
+$constantName,
 $constantType,
+$nativeType,
 );
 continue;
 }
@@ -1909,9 +1915,15 @@ function (Type $type, callable $traverse): Type {
 $constantType = $this->getType($constantReflection->getValueExpr(), InitializerExprContext::fromClassReflection($constantReflection->getDeclaringClass()));
 }
 
-$constantType = $this->constantResolver->resolveConstantType(
-sprintf('%s::%s', $constantClassReflection->getName(), $constantName),
+$nativeType = null;
+if ($constantReflection instanceof ClassConstantReflection) {
+$nativeType = $constantReflection->getNativeType();
+}
+$constantType = $this->constantResolver->resolveClassConstantType(
+$constantClassReflection->getName(),
+$constantName,
 $constantType,
+$nativeType,
 );
 $types[] = $constantType;
 }

tests/PHPStan/Analyser/LegacyNodeScopeResolverTest.php

@@ -8413,6 +8413,52 @@ public function testDynamicConstants(
 );
 }
 
+public function dataDynamicConstantsWithNativeTypes(): array
+{
+return [
+[
+'int',
+'DynamicConstantNativeTypes\Foo::FOO',
+],
+[
+'int|string',
+'DynamicConstantNativeTypes\Foo::BAR',
+],
+[
+'int',
+'$foo::FOO',
+],
+[
+'int|string',
+'$foo::BAR',
+],
+];
+}
+
+/**
+ * @dataProvider dataDynamicConstantsWithNativeTypes
+ */
+public function testDynamicConstantsWithNativeTypes(
+string $description,
+string $expression,
+): void
+{
+if (PHP_VERSION_ID < 80300) {
+$this->markTestSkipped('Test requires PHP 8.3.');
+}
+
+$this->assertTypes(
+__DIR__ . '/data/dynamic-constant-native-types.php',
+$description,
+$expression,
+'die',
+[
+'DynamicConstantNativeTypes\Foo::FOO',
+'DynamicConstantNativeTypes\Foo::BAR',
+],
+);
+}
+
 public function dataIsset(): array
 {
 return [

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

@@ -0,0 +1,15 @@
+<?php // lint >= 8.3
+
+namespace DynamicConstantNativeTypes;
+
+final class Foo
+{
+
+public const int FOO = 123;
+public const int|string BAR = 123;
+
+}
+
+function (Foo $foo): void {
+die;
+};