Resolve unit enum defaults through generic class reflection

Amp-Thread-ID: https://ampcode.com/threads/T-01a196f7-a83c-7170-a45b-f1d9db4220df

Author: drewmt

src/Reflection/InitializerExprTypeResolver.php

@@ -2779,6 +2779,11 @@ public function getClassConstFetchTypeByReflection(Name|Expr $class, string $con
 					unset($this->currentlyResolvingClassConstant[$resolvingName]);
 					continue;
 				}
+				if ($reflectionConstant->isEnumCase()) {
+					$types[] = new EnumCaseObjectType($constantClassReflection->getName(), $constantName);
+					unset($this->currentlyResolvingClassConstant[$resolvingName]);
+					continue;
+				}
 				$reflectionConstantDeclaringClass = $reflectionConstant->getDeclaringClass();
 				$constantType = $this->getType($reflectionConstant->getValueExpression(), InitializerExprContext::fromClass($reflectionConstantDeclaringClass->getName(), $reflectionConstantDeclaringClass->getFileName() ?: null));
 				$nativeType = null;

tests/PHPStan/Reflection/InitializerExprTypeResolverTest.php

@@ -3,18 +3,61 @@
 namespace PHPStan\Reflection;
 
 use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\ClassConstFetch;
+use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Scalar\LNumber;
 use PhpParser\Node\Scalar\String_;
+use PHPStan\Analyser\ConstantResolver;
+use PHPStan\BetterReflection\Reflection\Adapter\ReflectionClass;
+use PHPStan\Php\PhpVersion;
+use PHPStan\Reflection\ReflectionProvider\DirectReflectionProviderProvider;
 use PHPStan\ShouldNotHappenException;
 use PHPStan\Testing\PHPStanTestCase;
 use PHPStan\Type\Constant\ConstantIntegerType;
+use PHPStan\Type\Constant\OversizedArrayBuilder;
 use PHPStan\Type\NeverType;
+use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry;
 use PHPStan\Type\Type;
+use PHPStan\Type\UnaryOperatorTypeSpecifyingExtensionRegistry;
+use PHPStan\Type\VerbosityLevel;
 use PHPUnit\Framework\Attributes\DataProvider;
 
 class InitializerExprTypeResolverTest extends PHPStanTestCase
 {
 
+	public function testUnitEnumDefaultWithClassAdapter(): void
+	{
+		$container = self::getContainer();
+		$classReflection = $container->getByType(ClassReflectionFactory::class)->create(
+			'RoundingMode',
+			new ReflectionClass(self::getReflector()->reflectClass('RoundingMode')),
+			null,
+			null,
+			null,
+		);
+
+		// PHP runtimes without native enum reflection use the generic class adapter.
+		$reflectionProvider = $this->createMock(ReflectionProvider::class);
+		$reflectionProvider->method('hasClass')->with('RoundingMode')->willReturn(true);
+		$reflectionProvider->method('getClass')->with('RoundingMode')->willReturn($classReflection);
+		$resolver = new InitializerExprTypeResolver(
+			$container->getByType(ConstantResolver::class),
+			new DirectReflectionProviderProvider($reflectionProvider),
+			new PhpVersion(80500),
+			$container->getByType(OperatorTypeSpecifyingExtensionRegistry::class),
+			$container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistry::class),
+			new OversizedArrayBuilder(),
+			$container->getParameter('usePathConstantsAsConstantString'),
+		);
+
+		$type = $resolver->getType(
+			new ClassConstFetch(new FullyQualified('RoundingMode'), 'HalfAwayFromZero'),
+			InitializerExprContext::createEmpty(),
+		);
+
+		$this->assertSame('RoundingMode::HalfAwayFromZero', $type->describe(VerbosityLevel::precise()));
+	}
+
 	public static function dataExplicitNever(): iterable
 	{
 		yield [

turbo-ext/src/InitializerExprTypeResolver.cpp

@@ -159,6 +159,7 @@ constexpr Method mGetReflectionConstant{"getReflectionConstant"};
 constexpr Method mGetDeclaringClass{"getDeclaringClass"};
 constexpr Method mGetFileName{"getFileName", PT_OP_GET_FILE_NAME};
 constexpr Method mGetValueExpression{"getValueExpression"};
+constexpr Method mIsEnumCase{"isEnumCase"};
 constexpr Method mGetType{"getType", PT_OP_GET_TYPE};
 constexpr Method mGetConstantPhpDocType{"getConstantPhpDocType"};
 constexpr Method mGetConstant{"getConstant"};
@@ -4757,6 +4758,20 @@ class InitializerExprTypeResolver
 					unsetArrayProperty(slots::currentlyResolvingClassConstant, resolvingName);
 					continue;
 				}
+				{
+					IETR_VAL(isEnumCase, callOn(reflectionConstant.raw(), mIsEnumCase));
+					if (zend_is_true(isEnumCase.raw())) {
+						if (UNEXPECTED(Z_TYPE_P(reflectionName.raw()) != IS_STRING)) {
+							pt_throw_should_not_happen();
+							return zv::Val();
+						}
+						zval enumCase;
+						if (UNEXPECTED(!pt_enum_case_object_type_new(&enumCase, Z_STR_P(reflectionName.raw()), constantNameString))) return zv::Val();
+						types.push(zv::Val::adopt(enumCase));
+						unsetArrayProperty(slots::currentlyResolvingClassConstant, resolvingName);
+						continue;
+					}
+				}
 				IETR_VAL(reflectionConstantDeclaringClass, callOn(reflectionConstant.raw(), mGetDeclaringClass));
 				IETR_VAL(valueExpression, callOn(reflectionConstant.raw(), mGetValueExpression));
 				IETR_VAL(declaringClassName, callOn(reflectionConstantDeclaringClass.raw(), mGetName));