diff --git a/src/Reflection/ClassReflection.php b/src/Reflection/ClassReflection.php
index 064cec277ec..fbcd2da0a12 100644
--- a/src/Reflection/ClassReflection.php
+++ b/src/Reflection/ClassReflection.php
@@ -1053,7 +1053,7 @@ public function getEnumCases(): array
 		foreach ($this->reflection->getCases() as $case) {
 			$valueType = null;
 			if ($case instanceof ReflectionEnumBackedCase && $case->hasBackingValue()) {
-				$valueType = $this->initializerExprTypeResolver->getType($case->getValueExpression(), $initializerExprContext);
+				$valueType = $this->initializerExprTypeResolver->getEnumCaseValueType($this->getName(), $case->getName(), $case->getValueExpression(), $initializerExprContext);
 			}
 			$caseName = $case->getName();
 			$attributes = $this->attributeReflectionFactory->fromNativeReflection($case->getAttributes(), InitializerExprContext::fromClass($this->getName(), $this->getFileName()));
@@ -1080,7 +1080,7 @@ public function getEnumCase(string $name): EnumCaseReflection
 		$case = $this->reflection->getCase($name);
 		$valueType = null;
 		if ($case instanceof ReflectionEnumBackedCase && $case->hasBackingValue()) {
-			$valueType = $this->initializerExprTypeResolver->getType($case->getValueExpression(), InitializerExprContext::fromClassReflection($this));
+			$valueType = $this->initializerExprTypeResolver->getEnumCaseValueType($this->getName(), $name, $case->getValueExpression(), InitializerExprContext::fromClassReflection($this));
 		}
 
 		$attributes = $this->attributeReflectionFactory->fromNativeReflection($case->getAttributes(), InitializerExprContext::fromClass($this->getName(), $this->getFileName()));
diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php
index 0193e0e902c..7440726aa83 100644
--- a/src/Reflection/InitializerExprTypeResolver.php
+++ b/src/Reflection/InitializerExprTypeResolver.php
@@ -514,6 +514,25 @@ public function getType(Expr $expr, InitializerExprContext $context): Type
 		return new MixedType();
 	}
 
+	/**
+	 * Resolves the backing value of an enum case. A read of the case while
+	 * its value is being resolved gives mixed - like a class constant does - to prevent endless recursions.
+	 */
+	public function getEnumCaseValueType(string $className, string $caseName, Expr $valueExpr, InitializerExprContext $context): Type
+	{
+		$resolvingName = sprintf('%s::%s', $className, $caseName);
+		if (array_key_exists($resolvingName, $this->currentlyResolvingClassConstant)) {
+			return new MixedType();
+		}
+
+		$this->currentlyResolvingClassConstant[$resolvingName] = true;
+		try {
+			return $this->getType($valueExpr, $context);
+		} finally {
+			unset($this->currentlyResolvingClassConstant[$resolvingName]);
+		}
+	}
+
 	/**
 	 * @param callable(Expr): Type $getTypeCallback
 	 */
diff --git a/src/Turbo/TurboExtensionEnabler.php b/src/Turbo/TurboExtensionEnabler.php
index 25e6990b99e..22991812fa2 100644
--- a/src/Turbo/TurboExtensionEnabler.php
+++ b/src/Turbo/TurboExtensionEnabler.php
@@ -33,7 +33,7 @@
 final class TurboExtensionEnabler
 {
 
-	public const EXPECTED_EXTENSION_VERSION = '55df31e';
+	public const EXPECTED_EXTENSION_VERSION = '1cb5faf';
 
 	private static bool $active = false;
 
diff --git a/tests/PHPStan/Analyser/nsrt/bug-15458.php b/tests/PHPStan/Analyser/nsrt/bug-15458.php
new file mode 100644
index 00000000000..f7f1bafeab5
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/bug-15458.php
@@ -0,0 +1,62 @@
+<?php // lint >= 8.2
+
+namespace Bug15458Types;
+
+use function PHPStan\Testing\assertType;
+
+enum E: string
+{
+	case A = self::A->value;
+}
+
+enum IntBacked: int
+{
+	case A = self::A->value;
+}
+
+enum Mutual: string
+{
+	case A = self::B->value;
+	case B = self::A->value;
+}
+
+enum CrossA: string
+{
+	case A = CrossB::B->value;
+}
+
+enum CrossB: string
+{
+	case B = CrossA::A->value;
+}
+
+enum Concat: string
+{
+	case A = self::A->value . 'x';
+}
+
+enum ForwardReference: string
+{
+	case A = self::B->value . 'a';
+	case B = 'b';
+}
+
+class ConstantConcat
+{
+	const A = self::A . 'x';
+}
+
+function (Mutual $mutual, ForwardReference $forwardReference): void {
+	assertType('mixed', E::A->value);
+	assertType('mixed', IntBacked::A->value);
+	assertType('mixed', Mutual::A->value);
+	assertType('mixed', Mutual::B->value);
+	assertType('mixed', $mutual->value);
+	assertType('mixed', CrossA::A->value);
+	assertType('mixed', CrossB::B->value);
+	assertType('non-falsy-string', Concat::A->value);
+	assertType('non-falsy-string', ConstantConcat::A);
+	assertType("'ba'", ForwardReference::A->value);
+	assertType("'b'", ForwardReference::B->value);
+	assertType("'b'|'ba'", $forwardReference->value);
+};
diff --git a/tests/PHPStan/Rules/Classes/EnumSanityRuleTest.php b/tests/PHPStan/Rules/Classes/EnumSanityRuleTest.php
index 1d4ff07cc78..7666794bc7c 100644
--- a/tests/PHPStan/Rules/Classes/EnumSanityRuleTest.php
+++ b/tests/PHPStan/Rules/Classes/EnumSanityRuleTest.php
@@ -190,4 +190,35 @@ public function testBug11891(): void
 		]);
 	}
 
+	#[RequiresPhp('>= 8.2.0')]
+	public function testBug15458(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-15458.php'], [
+			[
+				'Enum case Bug15458\E::A value mixed does not match the "string" type.',
+				7,
+			],
+			[
+				'Enum case Bug15458\IntBacked::A value mixed does not match the "int" type.',
+				12,
+			],
+			[
+				'Enum case Bug15458\Mutual::A value mixed does not match the "string" type.',
+				17,
+			],
+			[
+				'Enum case Bug15458\Mutual::B value mixed does not match the "string" type.',
+				18,
+			],
+			[
+				'Enum case Bug15458\CrossA::A value mixed does not match the "string" type.',
+				23,
+			],
+			[
+				'Enum case Bug15458\CrossB::B value mixed does not match the "string" type.',
+				28,
+			],
+		]);
+	}
+
 }
diff --git a/tests/PHPStan/Rules/Classes/data/bug-15458.php b/tests/PHPStan/Rules/Classes/data/bug-15458.php
new file mode 100644
index 00000000000..45e2142682c
--- /dev/null
+++ b/tests/PHPStan/Rules/Classes/data/bug-15458.php
@@ -0,0 +1,40 @@
+<?php // lint >= 8.2
+
+namespace Bug15458;
+
+enum E: string
+{
+	case A = self::A->value;
+}
+
+enum IntBacked: int
+{
+	case A = self::A->value;
+}
+
+enum Mutual: string
+{
+	case A = self::B->value;
+	case B = self::A->value;
+}
+
+enum CrossA: string
+{
+	case A = CrossB::B->value;
+}
+
+enum CrossB: string
+{
+	case B = CrossA::A->value;
+}
+
+enum Concat: string
+{
+	case A = self::A->value . 'x';
+}
+
+enum ForwardReference: string
+{
+	case A = self::B->value . 'a';
+	case B = 'b';
+}
diff --git a/turbo-ext/src/ClassReflection.cpp b/turbo-ext/src/ClassReflection.cpp
index 34c5e3297d7..0bf66b6d821 100644
--- a/turbo-ext/src/ClassReflection.cpp
+++ b/turbo-ext/src/ClassReflection.cpp
@@ -2168,10 +2168,12 @@ class ClassReflection
 		zv::Arr cases = zv::Arr::create(countOf(reflectionCases.ref()));
 		if (reflectionCases.ref().isArray()) {
 			for (auto entry : zv::ArrRef(reflectionCases.raw())) {
-				zv::Val valueType = enumCaseValueType(entry.value(), initializerExprContext.raw());
-				if (UNEXPECTED(valueType.isUndef())) return zv::Val();
 				zv::Val caseName = callOn(entry.value(), PT_LC("getname"), 0, NULL);
 				if (UNEXPECTED(caseName.isUndef())) return zv::Val();
+				zend_string *caseNameStr = zval_get_string(caseName.raw());
+				zv::Val valueType = enumCaseValueType(entry.value(), caseNameStr, initializerExprContext.raw());
+				zend_string_release(caseNameStr);
+				if (UNEXPECTED(valueType.isUndef())) return zv::Val();
 				zv::Val attributes = enumCaseAttributes(entry.value());
 				if (UNEXPECTED(attributes.isUndef())) return zv::Val();
 				zv::Val caseReflection = newEnumCaseReflection(entry.value(), valueType.ref(), attributes.ref());
@@ -2228,7 +2230,7 @@ class ClassReflection
 		ZVAL_STR(&arg, name);
 		zv::Val case_ = reflectionCall(PT_LC("getcase"), 1, &arg);
 		if (UNEXPECTED(case_.isUndef())) return zv::Val();
-		zv::Val valueType = enumCaseValueType(case_.ref(), NULL);
+		zv::Val valueType = enumCaseValueType(case_.ref(), name, NULL);
 		if (UNEXPECTED(valueType.isUndef())) return zv::Val();
 		zv::Val attributes = enumCaseAttributes(case_.ref());
 		if (UNEXPECTED(attributes.isUndef())) return zv::Val();
@@ -2237,10 +2239,11 @@ class ClassReflection
 	}
 
 	/* $case instanceof ReflectionEnumBackedCase && $case->hasBackingValue()
-	 * ? $this->initializerExprTypeResolver->getType($case->getValueExpression(),
-	 * $context) : null — $context NULL where the twin builds it inside the
-	 * branch (getEnumCase()), the loop's shared one otherwise */
-	zv::Val enumCaseValueType(zv::Ref case_, zval *context)
+	 * ? $this->initializerExprTypeResolver->getEnumCaseValueType($this->getName(),
+	 * $caseName, $case->getValueExpression(), $context) : null — $context NULL
+	 * where the twin builds it inside the branch (getEnumCase()), the loop's
+	 * shared one otherwise */
+	zv::Val enumCaseValueType(zv::Ref case_, zend_string *caseName, zval *context)
 	{
 		bool isBackedCase;
 		if (UNEXPECTED(!pt_type_instanceof(case_.raw(), PT_CLASS_REFLECTION_ENUM_BACKED_CASE, isBackedCase))) return zv::Val();
@@ -2258,7 +2261,16 @@ class ClassReflection
 			context = ownContext.raw();
 		}
 
-		return initializerExprType(valueExpression.raw(), context);
+		zv::Val className = getName();
+		if (UNEXPECTED(className.isUndef())) return zv::Val();
+		zend_object *object = service(PT_CR_PROP_INITIALIZER_EXPR_TYPE_RESOLVER, "initializerExprTypeResolver");
+		if (UNEXPECTED(object == NULL)) return zv::Val();
+		zval resolver;
+		ZVAL_OBJ(&resolver, object);
+		zend_string *classNameStr = zval_get_string(className.raw());
+		zv::Val valueType = pt_initializer_expr_type_resolver_get_enum_case_value_type(&resolver, classNameStr, caseName, valueExpression.raw(), context);
+		zend_string_release(classNameStr);
+		return valueType;
 	}
 
 	/* $this->attributeReflectionFactory->fromNativeReflection($case->getAttributes(),
diff --git a/turbo-ext/src/InitializerExprTypeResolver.cpp b/turbo-ext/src/InitializerExprTypeResolver.cpp
index 6c39068042f..43e5e58952a 100644
--- a/turbo-ext/src/InitializerExprTypeResolver.cpp
+++ b/turbo-ext/src/InitializerExprTypeResolver.cpp
@@ -4838,6 +4838,25 @@ class InitializerExprTypeResolver
 		return getClassConstFetchTypeByReflection(class_, constantName, classReflection.raw(), getTypeCallback);
 	}
 
+	/* getEnumCaseValueType(): the case value resolved under the
+	 * currentlyResolvingClassConstant guard, mixed on re-entry */
+	zv::Val getEnumCaseValueType(zend_string *className, zend_string *caseName, zval *valueExpr, zval *context) const
+	{
+		zend_string *resolvingName = zend_string_concat3(ZSTR_VAL(className), ZSTR_LEN(className), "::", 2, ZSTR_VAL(caseName), ZSTR_LEN(caseName));
+		zv::Val resolvingNameHold = zv::Val::adoptString(resolvingName);
+		if (zend_symtable_exists(Z_ARRVAL_P(prop(slots::currentlyResolvingClassConstant)), resolvingName)) {
+			return newMixedType();
+		}
+
+		zval trueValue = {};
+		ZVAL_TRUE(&trueValue);
+		writeArrayProperty(slots::currentlyResolvingClassConstant, resolvingName, &trueValue);
+		zv::Val type = getType(valueExpr, context);
+		/* the twin's finally: released with an exception pending too */
+		unsetArrayProperty(slots::currentlyResolvingClassConstant, resolvingName);
+		return type;
+	}
+
 	/* }}} */
 
 private:
@@ -5336,6 +5355,19 @@ zv::Val pt_initializer_expr_type_resolver_get_type(zval *resolver, zval *expr, z
 	return callResolverMethod(site, resolver, PT_LC("gettype"), 2, argv);
 }
 
+zv::Val pt_initializer_expr_type_resolver_get_enum_case_value_type(zval *resolver, zend_string *className, zend_string *caseName, zval *valueExpr, zval *context)
+{
+	if (EXPECTED(isNativeResolver(resolver) && Z_TYPE_P(valueExpr) == IS_OBJECT)) {
+		return InitializerExprTypeResolver(Z_OBJ_P(resolver)).getEnumCaseValueType(className, caseName, valueExpr, context);
+	}
+	static pt_method_site site;
+	zval classNameZv, caseNameZv;
+	ZVAL_STR(&classNameZv, className);
+	ZVAL_STR(&caseNameZv, caseName);
+	zv::Args argv{&classNameZv, &caseNameZv, valueExpr, context};
+	return callResolverMethod(site, resolver, PT_LC("getenumcasevaluetype"), 4, argv);
+}
+
 zv::Val pt_initializer_expr_type_resolver_get_binary_op_type(zval *resolver, pt_ietr_binary_operator op, zval *left, zval *right, const pt_ietr_get_type &getTypeCallback)
 {
 	if (EXPECTED(isNativeResolver(resolver))) {
@@ -5641,6 +5673,14 @@ PT_MINIT_REGISTRATION(pt_register_initializer_expr_type_resolver)
 		PT_RETURN_VAL(IETR_THIS.getType(expr, context));
 	});
 
+	cls.method(sigs::getEnumCaseValueType, [](INTERNAL_FUNCTION_PARAMETERS) {
+		zend_string *className, *caseName;
+		zval *valueExpr, *context;
+		if (!zp::parse<zp::Str, zp::Str, zp::Obj, zp::Obj>(execute_data, className, caseName, valueExpr, context)) RETURN_THROWS();
+		if (UNEXPECTED(!ietrArgExpr(valueExpr, 3) || !ietrArgContext(context, 4))) RETURN_THROWS();
+		PT_RETURN_VAL(IETR_THIS.getEnumCaseValueType(className, caseName, valueExpr, context));
+	});
+
 	cls.method(sigs::getConcatType, IETR_OPERATOR_GLUE(self.getConcatType(left, right, getTypeCallback)));
 
 	cls.method(sigs::resolveConcatType, [](INTERNAL_FUNCTION_PARAMETERS) {
diff --git a/turbo-ext/src/generated/InitializerExprTypeResolver.h b/turbo-ext/src/generated/InitializerExprTypeResolver.h
index e0a1fe4e996..9d622ec5eca 100644
--- a/turbo-ext/src/generated/InitializerExprTypeResolver.h
+++ b/turbo-ext/src/generated/InitializerExprTypeResolver.h
@@ -64,101 +64,104 @@ inline constexpr char strings[] =
 	"\0" /* 559 */
 	"PHPStan\\Type\\Type\0" /* 560 */
 	"getType\0" /* 578 */
-	"left\0" /* 586 */
-	"right\0" /* 591 */
-	"getTypeCallback\0" /* 597 */
-	"getConcatType\0" /* 613 */
-	"resolveConcatType\0" /* 627 */
-	"PhpParser\\Node\\Expr\\Array_\0" /* 645 */
-	"getArrayType\0" /* 672 */
-	"PhpParser\\Node\\Expr\\Cast\0" /* 685 */
-	"getCastType\0" /* 710 */
-	"exprType\0" /* 722 */
-	"getCastObjectType\0" /* 731 */
-	"type\0" /* 749 */
-	"isNullable\0" /* 754 */
-	"isVariadic\0" /* 765 */
-	"getFunctionType\0" /* 776 */
-	"parameter\0" /* 792 */
-	"PhpParser\\Node\\Param\0" /* 802 */
-	"isParameterValueNullable\0" /* 823 */
-	"PhpParser\\Node\\Expr\\CallLike\0" /* 848 */
-	"nativeTypesPromoted\0" /* 877 */
-	"getFirstClassCallableType\0" /* 897 */
-	"function\0" /* 923 */
-	"PHPStan\\Reflection\\FunctionReflection|PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 932 */
-	"variants\0" /* 1014 */
-	"createFirstClassCallable\0" /* 1023 */
-	"getBitwiseAndType\0" /* 1048 */
-	"getBitwiseOrType\0" /* 1066 */
-	"getBitwiseXorType\0" /* 1083 */
-	"leftType\0" /* 1101 */
-	"rightType\0" /* 1110 */
-	"operationCallable\0" /* 1120 */
-	"getFiniteOrConstantScalarTypes\0" /* 1138 */
-	"getSpaceshipType\0" /* 1169 */
-	"getDivType\0" /* 1186 */
-	"getDivTypeFromTypes\0" /* 1197 */
-	"getModType\0" /* 1217 */
-	"divisorMin\0" /* 1228 */
-	"divisorMax\0" /* 1239 */
-	"getMaxModuloMagnitude\0" /* 1250 */
-	"getIntegerBounds\0" /* 1272 */
-	"getPlusType\0" /* 1289 */
-	"getMinusType\0" /* 1301 */
-	"getMulType\0" /* 1314 */
-	"getPowType\0" /* 1325 */
-	"getShiftLeftType\0" /* 1336 */
-	"getShiftRightType\0" /* 1353 */
-	"optimizeScalarType\0" /* 1371 */
-	"getNonNegativeIntegerBounds\0" /* 1390 */
-	"leftNumberType\0" /* 1418 */
-	"rightNumberType\0" /* 1433 */
-	"computeBitwiseAndRange\0" /* 1449 */
-	"computeBitwiseOrXorRange\0" /* 1472 */
-	"value\0" /* 1497 */
-	"allBitsMask\0" /* 1503 */
-	"PHPStan\\Type\\TypeResult\0" /* 1515 */
-	"resolveIdenticalType\0" /* 1539 */
-	"resolveEqualType\0" /* 1560 */
-	"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1577 */
-	"valueComparisonCallback\0" /* 1617 */
-	"resolveConstantArrayTypeComparison\0" /* 1641 */
-	"PhpParser\\Node\\Expr\\BinaryOp\0" /* 1676 */
-	"resolveCommonMath\0" /* 1705 */
-	"range\0" /* 1723 */
-	"node\0" /* 1729 */
-	"operand\0" /* 1734 */
-	"integerRangeMath\0" /* 1742 */
-	"shift\0" /* 1759 */
-	"shiftLeftOverflows\0" /* 1765 */
-	"class\0" /* 1784 */
-	"PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1790 */
-	"constantName\0" /* 1830 */
-	"classReflection\0" /* 1843 */
-	"PHPStan\\Reflection\\ClassReflection\0" /* 1859 */
-	"getClassConstFetchTypeByReflection\0" /* 1894 */
-	"className\0" /* 1929 */
-	"getClassConstFetchType\0" /* 1939 */
-	"getUnaryPlusType\0" /* 1962 */
-	"getUnaryMinusType\0" /* 1979 */
-	"getUnaryMinusTypeFromType\0" /* 1997 */
-	"getBitwiseNotType\0" /* 2023 */
-	"getBitwiseNotTypeFromType\0" /* 2041 */
-	"name\0" /* 2067 */
-	"PhpParser\\Node\\Name\0" /* 2072 */
-	"resolveName\0" /* 2092 */
-	"PHPStan\\Type\\TypeWithClassName\0" /* 2104 */
-	"resolveTypeByName\0" /* 2135 */
-	"classType\0" /* 2153 */
-	"methodReflectionCandidate\0" /* 2163 */
-	"PHPStan\\Reflection\\MethodReflection\0" /* 2189 */
-	"resolveTypeByNameWithLateStaticBinding\0" /* 2225 */
-	"toIntBound\0" /* 2264 */
-	"getTypeFromValue\0" /* 2275 */
-	"PHPStan\\Reflection\\ReflectionProvider\0" /* 2292 */
-	"getReflectionProvider\0" /* 2330 */
-	"getNeverType"; /* 2352 */
+	"className\0" /* 586 */
+	"caseName\0" /* 596 */
+	"valueExpr\0" /* 605 */
+	"getEnumCaseValueType\0" /* 615 */
+	"left\0" /* 636 */
+	"right\0" /* 641 */
+	"getTypeCallback\0" /* 647 */
+	"getConcatType\0" /* 663 */
+	"resolveConcatType\0" /* 677 */
+	"PhpParser\\Node\\Expr\\Array_\0" /* 695 */
+	"getArrayType\0" /* 722 */
+	"PhpParser\\Node\\Expr\\Cast\0" /* 735 */
+	"getCastType\0" /* 760 */
+	"exprType\0" /* 772 */
+	"getCastObjectType\0" /* 781 */
+	"type\0" /* 799 */
+	"isNullable\0" /* 804 */
+	"isVariadic\0" /* 815 */
+	"getFunctionType\0" /* 826 */
+	"parameter\0" /* 842 */
+	"PhpParser\\Node\\Param\0" /* 852 */
+	"isParameterValueNullable\0" /* 873 */
+	"PhpParser\\Node\\Expr\\CallLike\0" /* 898 */
+	"nativeTypesPromoted\0" /* 927 */
+	"getFirstClassCallableType\0" /* 947 */
+	"function\0" /* 973 */
+	"PHPStan\\Reflection\\FunctionReflection|PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 982 */
+	"variants\0" /* 1064 */
+	"createFirstClassCallable\0" /* 1073 */
+	"getBitwiseAndType\0" /* 1098 */
+	"getBitwiseOrType\0" /* 1116 */
+	"getBitwiseXorType\0" /* 1133 */
+	"leftType\0" /* 1151 */
+	"rightType\0" /* 1160 */
+	"operationCallable\0" /* 1170 */
+	"getFiniteOrConstantScalarTypes\0" /* 1188 */
+	"getSpaceshipType\0" /* 1219 */
+	"getDivType\0" /* 1236 */
+	"getDivTypeFromTypes\0" /* 1247 */
+	"getModType\0" /* 1267 */
+	"divisorMin\0" /* 1278 */
+	"divisorMax\0" /* 1289 */
+	"getMaxModuloMagnitude\0" /* 1300 */
+	"getIntegerBounds\0" /* 1322 */
+	"getPlusType\0" /* 1339 */
+	"getMinusType\0" /* 1351 */
+	"getMulType\0" /* 1364 */
+	"getPowType\0" /* 1375 */
+	"getShiftLeftType\0" /* 1386 */
+	"getShiftRightType\0" /* 1403 */
+	"optimizeScalarType\0" /* 1421 */
+	"getNonNegativeIntegerBounds\0" /* 1440 */
+	"leftNumberType\0" /* 1468 */
+	"rightNumberType\0" /* 1483 */
+	"computeBitwiseAndRange\0" /* 1499 */
+	"computeBitwiseOrXorRange\0" /* 1522 */
+	"value\0" /* 1547 */
+	"allBitsMask\0" /* 1553 */
+	"PHPStan\\Type\\TypeResult\0" /* 1565 */
+	"resolveIdenticalType\0" /* 1589 */
+	"resolveEqualType\0" /* 1610 */
+	"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1627 */
+	"valueComparisonCallback\0" /* 1667 */
+	"resolveConstantArrayTypeComparison\0" /* 1691 */
+	"PhpParser\\Node\\Expr\\BinaryOp\0" /* 1726 */
+	"resolveCommonMath\0" /* 1755 */
+	"range\0" /* 1773 */
+	"node\0" /* 1779 */
+	"operand\0" /* 1784 */
+	"integerRangeMath\0" /* 1792 */
+	"shift\0" /* 1809 */
+	"shiftLeftOverflows\0" /* 1815 */
+	"class\0" /* 1834 */
+	"PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1840 */
+	"constantName\0" /* 1880 */
+	"classReflection\0" /* 1893 */
+	"PHPStan\\Reflection\\ClassReflection\0" /* 1909 */
+	"getClassConstFetchTypeByReflection\0" /* 1944 */
+	"getClassConstFetchType\0" /* 1979 */
+	"getUnaryPlusType\0" /* 2002 */
+	"getUnaryMinusType\0" /* 2019 */
+	"getUnaryMinusTypeFromType\0" /* 2037 */
+	"getBitwiseNotType\0" /* 2063 */
+	"getBitwiseNotTypeFromType\0" /* 2081 */
+	"name\0" /* 2107 */
+	"PhpParser\\Node\\Name\0" /* 2112 */
+	"resolveName\0" /* 2132 */
+	"PHPStan\\Type\\TypeWithClassName\0" /* 2144 */
+	"resolveTypeByName\0" /* 2175 */
+	"classType\0" /* 2193 */
+	"methodReflectionCandidate\0" /* 2203 */
+	"PHPStan\\Reflection\\MethodReflection\0" /* 2229 */
+	"resolveTypeByNameWithLateStaticBinding\0" /* 2265 */
+	"toIntBound\0" /* 2304 */
+	"getTypeFromValue\0" /* 2315 */
+	"PHPStan\\Reflection\\ReflectionProvider\0" /* 2332 */
+	"getReflectionProvider\0" /* 2370 */
+	"getNeverType"; /* 2392 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 17), /* __construct $constantResolver */
 	reg::packed(51, 0, 78), /* __construct $reflectionProviderProvider */
@@ -170,172 +173,177 @@ inline constexpr reg::PackedArg args[] = {
 	reg::packed(484, 0, 489), /* getType $expr */
 	reg::packed(509, 0, 517), /* getType $context */
 	reg::packed(559, 0, 560), /* getType return */
-	reg::packed(586, 0, 489), /* getConcatType $left */
-	reg::packed(591, 0, 489), /* getConcatType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getConcatType $getTypeCallback */
+	reg::packed(586, MAY_BE_STRING), /* getEnumCaseValueType $className */
+	reg::packed(596, MAY_BE_STRING), /* getEnumCaseValueType $caseName */
+	reg::packed(605, 0, 489), /* getEnumCaseValueType $valueExpr */
+	reg::packed(509, 0, 517), /* getEnumCaseValueType $context */
+	reg::packed(559, 0, 560), /* getEnumCaseValueType return */
+	reg::packed(636, 0, 489), /* getConcatType $left */
+	reg::packed(641, 0, 489), /* getConcatType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getConcatType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getConcatType return */
-	reg::packed(586, 0, 560), /* resolveConcatType $left */
-	reg::packed(591, 0, 560), /* resolveConcatType $right */
+	reg::packed(636, 0, 560), /* resolveConcatType $left */
+	reg::packed(641, 0, 560), /* resolveConcatType $right */
 	reg::packed(559, 0, 560), /* resolveConcatType return */
-	reg::packed(484, 0, 645), /* getArrayType $expr */
-	reg::packed(597, MAY_BE_CALLABLE), /* getArrayType $getTypeCallback */
+	reg::packed(484, 0, 695), /* getArrayType $expr */
+	reg::packed(647, MAY_BE_CALLABLE), /* getArrayType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getArrayType return */
-	reg::packed(484, 0, 685), /* getCastType $expr */
-	reg::packed(597, MAY_BE_CALLABLE), /* getCastType $getTypeCallback */
+	reg::packed(484, 0, 735), /* getCastType $expr */
+	reg::packed(647, MAY_BE_CALLABLE), /* getCastType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getCastType return */
-	reg::packed(722, 0, 560), /* getCastObjectType $exprType */
+	reg::packed(772, 0, 560), /* getCastObjectType $exprType */
 	reg::packed(559, 0, 560), /* getCastObjectType return */
-	reg::packed(749, 0), /* getFunctionType $type */
-	reg::packed(754, MAY_BE_BOOL), /* getFunctionType $isNullable */
-	reg::packed(765, MAY_BE_BOOL), /* getFunctionType $isVariadic */
+	reg::packed(799, 0), /* getFunctionType $type */
+	reg::packed(804, MAY_BE_BOOL), /* getFunctionType $isNullable */
+	reg::packed(815, MAY_BE_BOOL), /* getFunctionType $isVariadic */
 	reg::packed(509, 0, 517), /* getFunctionType $context */
 	reg::packed(559, 0, 560), /* getFunctionType return */
-	reg::packed(792, 0, 802), /* isParameterValueNullable $parameter */
+	reg::packed(842, 0, 852), /* isParameterValueNullable $parameter */
 	reg::packed(559, MAY_BE_BOOL), /* isParameterValueNullable return */
-	reg::packed(484, 0, 848), /* getFirstClassCallableType $expr */
+	reg::packed(484, 0, 898), /* getFirstClassCallableType $expr */
 	reg::packed(509, 0, 517), /* getFirstClassCallableType $context */
-	reg::packed(877, MAY_BE_BOOL), /* getFirstClassCallableType $nativeTypesPromoted */
+	reg::packed(927, MAY_BE_BOOL), /* getFirstClassCallableType $nativeTypesPromoted */
 	reg::packed(559, 0, 560), /* getFirstClassCallableType return */
-	reg::packed(923, MAY_BE_NULL, 932), /* createFirstClassCallable $function */
-	reg::packed(1014, MAY_BE_ARRAY), /* createFirstClassCallable $variants */
-	reg::packed(877, MAY_BE_BOOL), /* createFirstClassCallable $nativeTypesPromoted */
+	reg::packed(973, MAY_BE_NULL, 982), /* createFirstClassCallable $function */
+	reg::packed(1064, MAY_BE_ARRAY), /* createFirstClassCallable $variants */
+	reg::packed(927, MAY_BE_BOOL), /* createFirstClassCallable $nativeTypesPromoted */
 	reg::packed(559, 0, 560), /* createFirstClassCallable return */
-	reg::packed(586, 0, 489), /* getBitwiseAndType $left */
-	reg::packed(591, 0, 489), /* getBitwiseAndType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getBitwiseAndType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getBitwiseAndType $left */
+	reg::packed(641, 0, 489), /* getBitwiseAndType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getBitwiseAndType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getBitwiseAndType return */
-	reg::packed(586, 0, 489), /* getBitwiseOrType $left */
-	reg::packed(591, 0, 489), /* getBitwiseOrType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getBitwiseOrType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getBitwiseOrType $left */
+	reg::packed(641, 0, 489), /* getBitwiseOrType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getBitwiseOrType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getBitwiseOrType return */
-	reg::packed(586, 0, 489), /* getBitwiseXorType $left */
-	reg::packed(591, 0, 489), /* getBitwiseXorType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getBitwiseXorType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getBitwiseXorType $left */
+	reg::packed(641, 0, 489), /* getBitwiseXorType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getBitwiseXorType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getBitwiseXorType return */
-	reg::packed(1101, 0, 560), /* getFiniteOrConstantScalarTypes $leftType */
-	reg::packed(1110, 0, 560), /* getFiniteOrConstantScalarTypes $rightType */
-	reg::packed(1120, MAY_BE_CALLABLE), /* getFiniteOrConstantScalarTypes $operationCallable */
+	reg::packed(1151, 0, 560), /* getFiniteOrConstantScalarTypes $leftType */
+	reg::packed(1160, 0, 560), /* getFiniteOrConstantScalarTypes $rightType */
+	reg::packed(1170, MAY_BE_CALLABLE), /* getFiniteOrConstantScalarTypes $operationCallable */
 	reg::packed(559, MAY_BE_LONG, 560), /* getFiniteOrConstantScalarTypes return */
-	reg::packed(586, 0, 489), /* getSpaceshipType $left */
-	reg::packed(591, 0, 489), /* getSpaceshipType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getSpaceshipType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getSpaceshipType $left */
+	reg::packed(641, 0, 489), /* getSpaceshipType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getSpaceshipType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getSpaceshipType return */
-	reg::packed(586, 0, 489), /* getDivType $left */
-	reg::packed(591, 0, 489), /* getDivType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getDivType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getDivType $left */
+	reg::packed(641, 0, 489), /* getDivType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getDivType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getDivType return */
-	reg::packed(586, 0, 489), /* getDivTypeFromTypes $left */
-	reg::packed(591, 0, 489), /* getDivTypeFromTypes $right */
-	reg::packed(1101, 0, 560), /* getDivTypeFromTypes $leftType */
-	reg::packed(1110, 0, 560), /* getDivTypeFromTypes $rightType */
+	reg::packed(636, 0, 489), /* getDivTypeFromTypes $left */
+	reg::packed(641, 0, 489), /* getDivTypeFromTypes $right */
+	reg::packed(1151, 0, 560), /* getDivTypeFromTypes $leftType */
+	reg::packed(1160, 0, 560), /* getDivTypeFromTypes $rightType */
 	reg::packed(559, 0, 560), /* getDivTypeFromTypes return */
-	reg::packed(586, 0, 489), /* getModType $left */
-	reg::packed(591, 0, 489), /* getModType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getModType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getModType $left */
+	reg::packed(641, 0, 489), /* getModType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getModType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getModType return */
-	reg::packed(1228, MAY_BE_NULL | MAY_BE_LONG), /* getMaxModuloMagnitude $divisorMin */
-	reg::packed(1239, MAY_BE_NULL | MAY_BE_LONG), /* getMaxModuloMagnitude $divisorMax */
+	reg::packed(1278, MAY_BE_NULL | MAY_BE_LONG), /* getMaxModuloMagnitude $divisorMin */
+	reg::packed(1289, MAY_BE_NULL | MAY_BE_LONG), /* getMaxModuloMagnitude $divisorMax */
 	reg::packed(559, MAY_BE_NULL | MAY_BE_LONG), /* getMaxModuloMagnitude return */
-	reg::packed(749, 0, 560), /* getIntegerBounds $type */
+	reg::packed(799, 0, 560), /* getIntegerBounds $type */
 	reg::packed(559, MAY_BE_NULL | MAY_BE_ARRAY), /* getIntegerBounds return */
-	reg::packed(586, 0, 489), /* getPlusType $left */
-	reg::packed(591, 0, 489), /* getPlusType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getPlusType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getPlusType $left */
+	reg::packed(641, 0, 489), /* getPlusType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getPlusType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getPlusType return */
-	reg::packed(586, 0, 489), /* getMinusType $left */
-	reg::packed(591, 0, 489), /* getMinusType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getMinusType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getMinusType $left */
+	reg::packed(641, 0, 489), /* getMinusType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getMinusType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getMinusType return */
-	reg::packed(586, 0, 489), /* getMulType $left */
-	reg::packed(591, 0, 489), /* getMulType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getMulType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getMulType $left */
+	reg::packed(641, 0, 489), /* getMulType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getMulType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getMulType return */
-	reg::packed(586, 0, 489), /* getPowType $left */
-	reg::packed(591, 0, 489), /* getPowType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getPowType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getPowType $left */
+	reg::packed(641, 0, 489), /* getPowType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getPowType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getPowType return */
-	reg::packed(586, 0, 489), /* getShiftLeftType $left */
-	reg::packed(591, 0, 489), /* getShiftLeftType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getShiftLeftType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getShiftLeftType $left */
+	reg::packed(641, 0, 489), /* getShiftLeftType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getShiftLeftType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getShiftLeftType return */
-	reg::packed(586, 0, 489), /* getShiftRightType $left */
-	reg::packed(591, 0, 489), /* getShiftRightType $right */
-	reg::packed(597, MAY_BE_CALLABLE), /* getShiftRightType $getTypeCallback */
+	reg::packed(636, 0, 489), /* getShiftRightType $left */
+	reg::packed(641, 0, 489), /* getShiftRightType $right */
+	reg::packed(647, MAY_BE_CALLABLE), /* getShiftRightType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getShiftRightType return */
-	reg::packed(749, 0, 560), /* optimizeScalarType $type */
+	reg::packed(799, 0, 560), /* optimizeScalarType $type */
 	reg::packed(559, 0, 560), /* optimizeScalarType return */
-	reg::packed(749, 0, 560), /* getNonNegativeIntegerBounds $type */
+	reg::packed(799, 0, 560), /* getNonNegativeIntegerBounds $type */
 	reg::packed(559, MAY_BE_NULL | MAY_BE_ARRAY), /* getNonNegativeIntegerBounds return */
-	reg::packed(1418, 0, 560), /* computeBitwiseAndRange $leftNumberType */
-	reg::packed(1433, 0, 560), /* computeBitwiseAndRange $rightNumberType */
+	reg::packed(1468, 0, 560), /* computeBitwiseAndRange $leftNumberType */
+	reg::packed(1483, 0, 560), /* computeBitwiseAndRange $rightNumberType */
 	reg::packed(559, MAY_BE_NULL, 560), /* computeBitwiseAndRange return */
-	reg::packed(1418, 0, 560), /* computeBitwiseOrXorRange $leftNumberType */
-	reg::packed(1433, 0, 560), /* computeBitwiseOrXorRange $rightNumberType */
+	reg::packed(1468, 0, 560), /* computeBitwiseOrXorRange $leftNumberType */
+	reg::packed(1483, 0, 560), /* computeBitwiseOrXorRange $rightNumberType */
 	reg::packed(559, MAY_BE_NULL, 560), /* computeBitwiseOrXorRange return */
-	reg::packed(1497, MAY_BE_LONG), /* allBitsMask $value */
+	reg::packed(1547, MAY_BE_LONG), /* allBitsMask $value */
 	reg::packed(559, MAY_BE_LONG), /* allBitsMask return */
-	reg::packed(1101, 0, 560), /* resolveIdenticalType $leftType */
-	reg::packed(1110, 0, 560), /* resolveIdenticalType $rightType */
-	reg::packed(559, 0, 1515), /* resolveIdenticalType return */
-	reg::packed(1101, 0, 560), /* resolveEqualType $leftType */
-	reg::packed(1110, 0, 560), /* resolveEqualType $rightType */
-	reg::packed(559, 0, 1515), /* resolveEqualType return */
-	reg::packed(1101, 0, 1577), /* resolveConstantArrayTypeComparison $leftType */
-	reg::packed(1110, 0, 1577), /* resolveConstantArrayTypeComparison $rightType */
-	reg::packed(1617, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */
-	reg::packed(559, 0, 1515), /* resolveConstantArrayTypeComparison return */
-	reg::packed(484, 0, 1676), /* resolveCommonMath $expr */
-	reg::packed(1101, 0, 560), /* resolveCommonMath $leftType */
-	reg::packed(1110, 0, 560), /* resolveCommonMath $rightType */
+	reg::packed(1151, 0, 560), /* resolveIdenticalType $leftType */
+	reg::packed(1160, 0, 560), /* resolveIdenticalType $rightType */
+	reg::packed(559, 0, 1565), /* resolveIdenticalType return */
+	reg::packed(1151, 0, 560), /* resolveEqualType $leftType */
+	reg::packed(1160, 0, 560), /* resolveEqualType $rightType */
+	reg::packed(559, 0, 1565), /* resolveEqualType return */
+	reg::packed(1151, 0, 1627), /* resolveConstantArrayTypeComparison $leftType */
+	reg::packed(1160, 0, 1627), /* resolveConstantArrayTypeComparison $rightType */
+	reg::packed(1667, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */
+	reg::packed(559, 0, 1565), /* resolveConstantArrayTypeComparison return */
+	reg::packed(484, 0, 1726), /* resolveCommonMath $expr */
+	reg::packed(1151, 0, 560), /* resolveCommonMath $leftType */
+	reg::packed(1160, 0, 560), /* resolveCommonMath $rightType */
 	reg::packed(559, 0, 560), /* resolveCommonMath return */
-	reg::packed(1723, 0, 560), /* integerRangeMath $range */
-	reg::packed(1729, 0, 1676), /* integerRangeMath $node */
-	reg::packed(1734, 0, 560), /* integerRangeMath $operand */
+	reg::packed(1773, 0, 560), /* integerRangeMath $range */
+	reg::packed(1779, 0, 1726), /* integerRangeMath $node */
+	reg::packed(1784, 0, 560), /* integerRangeMath $operand */
 	reg::packed(559, 0, 560), /* integerRangeMath return */
-	reg::packed(1497, MAY_BE_LONG), /* shiftLeftOverflows $value */
-	reg::packed(1759, MAY_BE_LONG), /* shiftLeftOverflows $shift */
+	reg::packed(1547, MAY_BE_LONG), /* shiftLeftOverflows $value */
+	reg::packed(1809, MAY_BE_LONG), /* shiftLeftOverflows $shift */
 	reg::packed(559, MAY_BE_BOOL), /* shiftLeftOverflows return */
-	reg::packed(1784, 0, 1790), /* getClassConstFetchTypeByReflection $class */
-	reg::packed(1830, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */
-	reg::packed(1843, MAY_BE_NULL, 1859), /* getClassConstFetchTypeByReflection $classReflection */
-	reg::packed(597, MAY_BE_CALLABLE), /* getClassConstFetchTypeByReflection $getTypeCallback */
+	reg::packed(1834, 0, 1840), /* getClassConstFetchTypeByReflection $class */
+	reg::packed(1880, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */
+	reg::packed(1893, MAY_BE_NULL, 1909), /* getClassConstFetchTypeByReflection $classReflection */
+	reg::packed(647, MAY_BE_CALLABLE), /* getClassConstFetchTypeByReflection $getTypeCallback */
 	reg::packed(559, 0, 560), /* getClassConstFetchTypeByReflection return */
-	reg::packed(1784, 0, 1790), /* getClassConstFetchType $class */
-	reg::packed(1830, MAY_BE_STRING), /* getClassConstFetchType $constantName */
-	reg::packed(1929, MAY_BE_NULL | MAY_BE_STRING), /* getClassConstFetchType $className */
-	reg::packed(597, MAY_BE_CALLABLE), /* getClassConstFetchType $getTypeCallback */
+	reg::packed(1834, 0, 1840), /* getClassConstFetchType $class */
+	reg::packed(1880, MAY_BE_STRING), /* getClassConstFetchType $constantName */
+	reg::packed(586, MAY_BE_NULL | MAY_BE_STRING), /* getClassConstFetchType $className */
+	reg::packed(647, MAY_BE_CALLABLE), /* getClassConstFetchType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getClassConstFetchType return */
 	reg::packed(484, 0, 489), /* getUnaryPlusType $expr */
-	reg::packed(597, MAY_BE_CALLABLE), /* getUnaryPlusType $getTypeCallback */
+	reg::packed(647, MAY_BE_CALLABLE), /* getUnaryPlusType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getUnaryPlusType return */
 	reg::packed(484, 0, 489), /* getUnaryMinusType $expr */
-	reg::packed(597, MAY_BE_CALLABLE), /* getUnaryMinusType $getTypeCallback */
+	reg::packed(647, MAY_BE_CALLABLE), /* getUnaryMinusType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getUnaryMinusType return */
 	reg::packed(484, 0, 489), /* getUnaryMinusTypeFromType $expr */
-	reg::packed(749, 0, 560), /* getUnaryMinusTypeFromType $type */
+	reg::packed(799, 0, 560), /* getUnaryMinusTypeFromType $type */
 	reg::packed(559, 0, 560), /* getUnaryMinusTypeFromType return */
 	reg::packed(484, 0, 489), /* getBitwiseNotType $expr */
-	reg::packed(597, MAY_BE_CALLABLE), /* getBitwiseNotType $getTypeCallback */
+	reg::packed(647, MAY_BE_CALLABLE), /* getBitwiseNotType $getTypeCallback */
 	reg::packed(559, 0, 560), /* getBitwiseNotType return */
-	reg::packed(722, 0, 560), /* getBitwiseNotTypeFromType $exprType */
+	reg::packed(772, 0, 560), /* getBitwiseNotTypeFromType $exprType */
 	reg::packed(559, 0, 560), /* getBitwiseNotTypeFromType return */
-	reg::packed(2067, 0, 2072), /* resolveName $name */
-	reg::packed(1843, MAY_BE_NULL, 1859), /* resolveName $classReflection */
+	reg::packed(2107, 0, 2112), /* resolveName $name */
+	reg::packed(1893, MAY_BE_NULL, 1909), /* resolveName $classReflection */
 	reg::packed(559, MAY_BE_STRING), /* resolveName return */
-	reg::packed(2067, 0, 2072), /* resolveTypeByName $name */
-	reg::packed(1843, MAY_BE_NULL, 1859), /* resolveTypeByName $classReflection */
-	reg::packed(559, 0, 2104), /* resolveTypeByName return */
-	reg::packed(1784, 0, 2072), /* resolveTypeByNameWithLateStaticBinding $class */
-	reg::packed(2153, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */
-	reg::packed(2163, 0, 2189), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */
+	reg::packed(2107, 0, 2112), /* resolveTypeByName $name */
+	reg::packed(1893, MAY_BE_NULL, 1909), /* resolveTypeByName $classReflection */
+	reg::packed(559, 0, 2144), /* resolveTypeByName return */
+	reg::packed(1834, 0, 2112), /* resolveTypeByNameWithLateStaticBinding $class */
+	reg::packed(2193, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */
+	reg::packed(2203, 0, 2229), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */
 	reg::packed(559, 0, 560), /* resolveTypeByNameWithLateStaticBinding return */
-	reg::packed(1497, MAY_BE_DOUBLE), /* toIntBound $value */
+	reg::packed(1547, MAY_BE_DOUBLE), /* toIntBound $value */
 	reg::packed(559, MAY_BE_NULL | MAY_BE_LONG), /* toIntBound return */
-	reg::packed(1497, 0), /* getTypeFromValue $value */
+	reg::packed(1547, 0), /* getTypeFromValue $value */
 	reg::packed(559, 0, 560), /* getTypeFromValue return */
-	reg::packed(559, 0, 2292), /* getReflectionProvider return */
-	reg::packed(1101, 0, 560), /* getNeverType $leftType */
-	reg::packed(1110, 0, 560), /* getNeverType $rightType */
+	reg::packed(559, 0, 2332), /* getReflectionProvider return */
+	reg::packed(1151, 0, 560), /* getNeverType $leftType */
+	reg::packed(1160, 0, 560), /* getNeverType $rightType */
 	reg::packed(559, 0, 560), /* getNeverType return */
 };
 using Sig = reg::Sig<strings, args>;
@@ -345,56 +353,57 @@ using Sig = reg::Sig<strings, args>;
 namespace sig {
 inline constexpr sigtab::Sig __construct = { { 472 /* __construct */, 7, 0, 7, reg::NoArg, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig getType = { { 578 /* getType */, 2, 7, 2, 9, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConcatType = { { 613 /* getConcatType */, 3, 10, 3, 13, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig resolveConcatType = { { 627 /* resolveConcatType */, 2, 14, 2, 16, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getArrayType = { { 672 /* getArrayType */, 2, 17, 2, 19, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getCastType = { { 710 /* getCastType */, 2, 20, 2, 22, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getCastObjectType = { { 731 /* getCastObjectType */, 1, 23, 1, 24, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getFunctionType = { { 776 /* getFunctionType */, 4, 25, 4, 29, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig isParameterValueNullable = { { 823 /* isParameterValueNullable */, 1, 30, 1, 31, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getFirstClassCallableType = { { 897 /* getFirstClassCallableType */, 3, 32, 3, 35, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig createFirstClassCallable = { { 1023 /* createFirstClassCallable */, 3, 36, 3, 39, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBitwiseAndType = { { 1048 /* getBitwiseAndType */, 3, 40, 3, 43, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBitwiseOrType = { { 1066 /* getBitwiseOrType */, 3, 44, 3, 47, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBitwiseXorType = { { 1083 /* getBitwiseXorType */, 3, 48, 3, 51, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getFiniteOrConstantScalarTypes = { { 1138 /* getFiniteOrConstantScalarTypes */, 3, 52, 3, 55, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getSpaceshipType = { { 1169 /* getSpaceshipType */, 3, 56, 3, 59, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getDivType = { { 1186 /* getDivType */, 3, 60, 3, 63, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getDivTypeFromTypes = { { 1197 /* getDivTypeFromTypes */, 4, 64, 4, 68, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getModType = { { 1217 /* getModType */, 3, 69, 3, 72, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getMaxModuloMagnitude = { { 1250 /* getMaxModuloMagnitude */, 2, 73, 2, 75, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getIntegerBounds = { { 1272 /* getIntegerBounds */, 1, 76, 1, 77, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getPlusType = { { 1289 /* getPlusType */, 3, 78, 3, 81, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getMinusType = { { 1301 /* getMinusType */, 3, 82, 3, 85, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getMulType = { { 1314 /* getMulType */, 3, 86, 3, 89, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getPowType = { { 1325 /* getPowType */, 3, 90, 3, 93, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getShiftLeftType = { { 1336 /* getShiftLeftType */, 3, 94, 3, 97, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getShiftRightType = { { 1353 /* getShiftRightType */, 3, 98, 3, 101, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig optimizeScalarType = { { 1371 /* optimizeScalarType */, 1, 102, 1, 103, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getNonNegativeIntegerBounds = { { 1390 /* getNonNegativeIntegerBounds */, 1, 104, 1, 105, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig computeBitwiseAndRange = { { 1449 /* computeBitwiseAndRange */, 2, 106, 2, 108, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig computeBitwiseOrXorRange = { { 1472 /* computeBitwiseOrXorRange */, 2, 109, 2, 111, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig allBitsMask = { { 1503 /* allBitsMask */, 1, 112, 1, 113, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig resolveIdenticalType = { { 1539 /* resolveIdenticalType */, 2, 114, 2, 116, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig resolveEqualType = { { 1560 /* resolveEqualType */, 2, 117, 2, 119, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1641 /* resolveConstantArrayTypeComparison */, 3, 120, 3, 123, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig resolveCommonMath = { { 1705 /* resolveCommonMath */, 3, 124, 3, 127, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig integerRangeMath = { { 1742 /* integerRangeMath */, 3, 128, 3, 131, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig shiftLeftOverflows = { { 1765 /* shiftLeftOverflows */, 2, 132, 2, 134, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1894 /* getClassConstFetchTypeByReflection */, 4, 135, 4, 139, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getClassConstFetchType = { { 1939 /* getClassConstFetchType */, 4, 140, 4, 144, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getUnaryPlusType = { { 1962 /* getUnaryPlusType */, 2, 145, 2, 147, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getUnaryMinusType = { { 1979 /* getUnaryMinusType */, 2, 148, 2, 150, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getUnaryMinusTypeFromType = { { 1997 /* getUnaryMinusTypeFromType */, 2, 151, 2, 153, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBitwiseNotType = { { 2023 /* getBitwiseNotType */, 2, 154, 2, 156, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 2041 /* getBitwiseNotTypeFromType */, 1, 157, 1, 158, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig resolveName = { { 2092 /* resolveName */, 2, 159, 2, 161, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig resolveTypeByName = { { 2135 /* resolveTypeByName */, 2, 162, 2, 164, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 2225 /* resolveTypeByNameWithLateStaticBinding */, 3, 165, 3, 168, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig toIntBound = { { 2264 /* toIntBound */, 1, 169, 1, 170, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
-inline constexpr sigtab::Sig getTypeFromValue = { { 2275 /* getTypeFromValue */, 1, 171, 1, 172, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getReflectionProvider = { { 2330 /* getReflectionProvider */, 0, 173, 0, 173, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig getNeverType = { { 2352 /* getNeverType */, 2, 174, 2, 176, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getEnumCaseValueType = { { 615 /* getEnumCaseValueType */, 4, 10, 4, 14, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConcatType = { { 663 /* getConcatType */, 3, 15, 3, 18, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig resolveConcatType = { { 677 /* resolveConcatType */, 2, 19, 2, 21, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getArrayType = { { 722 /* getArrayType */, 2, 22, 2, 24, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getCastType = { { 760 /* getCastType */, 2, 25, 2, 27, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getCastObjectType = { { 781 /* getCastObjectType */, 1, 28, 1, 29, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getFunctionType = { { 826 /* getFunctionType */, 4, 30, 4, 34, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig isParameterValueNullable = { { 873 /* isParameterValueNullable */, 1, 35, 1, 36, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getFirstClassCallableType = { { 947 /* getFirstClassCallableType */, 3, 37, 3, 40, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig createFirstClassCallable = { { 1073 /* createFirstClassCallable */, 3, 41, 3, 44, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBitwiseAndType = { { 1098 /* getBitwiseAndType */, 3, 45, 3, 48, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBitwiseOrType = { { 1116 /* getBitwiseOrType */, 3, 49, 3, 52, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBitwiseXorType = { { 1133 /* getBitwiseXorType */, 3, 53, 3, 56, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getFiniteOrConstantScalarTypes = { { 1188 /* getFiniteOrConstantScalarTypes */, 3, 57, 3, 60, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getSpaceshipType = { { 1219 /* getSpaceshipType */, 3, 61, 3, 64, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getDivType = { { 1236 /* getDivType */, 3, 65, 3, 68, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getDivTypeFromTypes = { { 1247 /* getDivTypeFromTypes */, 4, 69, 4, 73, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getModType = { { 1267 /* getModType */, 3, 74, 3, 77, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getMaxModuloMagnitude = { { 1300 /* getMaxModuloMagnitude */, 2, 78, 2, 80, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getIntegerBounds = { { 1322 /* getIntegerBounds */, 1, 81, 1, 82, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getPlusType = { { 1339 /* getPlusType */, 3, 83, 3, 86, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getMinusType = { { 1351 /* getMinusType */, 3, 87, 3, 90, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getMulType = { { 1364 /* getMulType */, 3, 91, 3, 94, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getPowType = { { 1375 /* getPowType */, 3, 95, 3, 98, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getShiftLeftType = { { 1386 /* getShiftLeftType */, 3, 99, 3, 102, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getShiftRightType = { { 1403 /* getShiftRightType */, 3, 103, 3, 106, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig optimizeScalarType = { { 1421 /* optimizeScalarType */, 1, 107, 1, 108, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getNonNegativeIntegerBounds = { { 1440 /* getNonNegativeIntegerBounds */, 1, 109, 1, 110, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig computeBitwiseAndRange = { { 1499 /* computeBitwiseAndRange */, 2, 111, 2, 113, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig computeBitwiseOrXorRange = { { 1522 /* computeBitwiseOrXorRange */, 2, 114, 2, 116, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig allBitsMask = { { 1553 /* allBitsMask */, 1, 117, 1, 118, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig resolveIdenticalType = { { 1589 /* resolveIdenticalType */, 2, 119, 2, 121, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig resolveEqualType = { { 1610 /* resolveEqualType */, 2, 122, 2, 124, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1691 /* resolveConstantArrayTypeComparison */, 3, 125, 3, 128, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig resolveCommonMath = { { 1755 /* resolveCommonMath */, 3, 129, 3, 132, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig integerRangeMath = { { 1792 /* integerRangeMath */, 3, 133, 3, 136, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig shiftLeftOverflows = { { 1815 /* shiftLeftOverflows */, 2, 137, 2, 139, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1944 /* getClassConstFetchTypeByReflection */, 4, 140, 4, 144, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getClassConstFetchType = { { 1979 /* getClassConstFetchType */, 4, 145, 4, 149, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getUnaryPlusType = { { 2002 /* getUnaryPlusType */, 2, 150, 2, 152, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getUnaryMinusType = { { 2019 /* getUnaryMinusType */, 2, 153, 2, 155, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getUnaryMinusTypeFromType = { { 2037 /* getUnaryMinusTypeFromType */, 2, 156, 2, 158, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBitwiseNotType = { { 2063 /* getBitwiseNotType */, 2, 159, 2, 161, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 2081 /* getBitwiseNotTypeFromType */, 1, 162, 1, 163, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig resolveName = { { 2132 /* resolveName */, 2, 164, 2, 166, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig resolveTypeByName = { { 2175 /* resolveTypeByName */, 2, 167, 2, 169, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 2265 /* resolveTypeByNameWithLateStaticBinding */, 3, 170, 3, 173, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig toIntBound = { { 2304 /* toIntBound */, 1, 174, 1, 175, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
+inline constexpr sigtab::Sig getTypeFromValue = { { 2315 /* getTypeFromValue */, 1, 176, 1, 177, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getReflectionProvider = { { 2370 /* getReflectionProvider */, 0, 178, 0, 178, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getNeverType = { { 2392 /* getNeverType */, 2, 179, 2, 181, ZEND_ACC_PRIVATE } };
 } // namespace sig
 
 } // namespace ptdecl::InitializerExprTypeResolver
diff --git a/turbo-ext/src/support.h b/turbo-ext/src/support.h
index 6980dfcbf72..1090ddfb29c 100644
--- a/turbo-ext/src/support.h
+++ b/turbo-ext/src/support.h
@@ -3998,6 +3998,9 @@ enum pt_ietr_binary_operator : uint8_t
  * borrowed and of the twin's parameter types, NULL-free: PHP null as an
  * IS_NULL zval; $constantName a string zval); UNDEF = pending exception */
 zv::Val pt_initializer_expr_type_resolver_get_type(zval *resolver, zval *expr, zval *context);
+/* ->getEnumCaseValueType($className, $caseName, $valueExpr, $context), the
+ * same dispatch; the strings borrowed */
+zv::Val pt_initializer_expr_type_resolver_get_enum_case_value_type(zval *resolver, zend_string *className, zend_string *caseName, zval *valueExpr, zval *context);
 zv::Val pt_initializer_expr_type_resolver_get_binary_op_type(zval *resolver, pt_ietr_binary_operator op, zval *left, zval *right, const pt_ietr_get_type &getTypeCallback);
 zv::Val pt_initializer_expr_type_resolver_resolve_concat_type(zval *resolver, zval *left, zval *right);
 zv::Val pt_initializer_expr_type_resolver_resolve_identical_type(zval *resolver, zval *leftType, zval *rightType);