From 1cb5faf3b3d84b12ede1537252188d4224287740 Mon Sep 17 00:00:00 2001 From: Sander Muller Date: Sun, 11 Oct 2026 19:58:07 +0200 Subject: [PATCH 1/2] Stop the recursion when an enum case value reads itself ClassReflection::getEnumCase() and getEnumCases() now resolve a case value through InitializerExprTypeResolver::getEnumCaseValueType(). It uses the currentlyResolvingClassConstant guard of class constants. Before, a case value that read itself, directly or through other cases, recursed until the call stack limit or the memory limit stopped the process. Now the read of the case that is being resolved gives mixed, as the read of a class constant that is being resolved does. The Turbo extension mirrors the change. Co-Authored-By: Claude Opus 5.5 (1M context) --- src/Reflection/ClassReflection.php | 4 +- .../InitializerExprTypeResolver.php | 19 + tests/PHPStan/Analyser/nsrt/bug-15458.php | 62 ++ .../Rules/Classes/EnumSanityRuleTest.php | 31 + .../PHPStan/Rules/Classes/data/bug-15458.php | 40 ++ turbo-ext/src/ClassReflection.cpp | 28 +- turbo-ext/src/InitializerExprTypeResolver.cpp | 40 ++ .../generated/InitializerExprTypeResolver.h | 531 +++++++++--------- turbo-ext/src/support.h | 3 + 9 files changed, 487 insertions(+), 271 deletions(-) create mode 100644 tests/PHPStan/Analyser/nsrt/bug-15458.php create mode 100644 tests/PHPStan/Rules/Classes/data/bug-15458.php 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/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 @@ += 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 @@ += 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(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; @@ -345,56 +353,57 @@ using Sig = reg::Sig; 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); From 5230ed7c33a33c4744fcf30b36094c1915ddc130 Mon Sep 17 00:00:00 2001 From: Markus Staab Date: Fri, 16 Oct 2026 10:17:09 +0200 Subject: [PATCH 2/2] Bump expected turbo version --- src/Turbo/TurboExtensionEnabler.php | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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;