Skip to content

Commit a76fdbf

Browse files
ondrejmirtesondrejmirtes
committed
Decide string numericness for the analysed PHP versions in loose comparison
ConstantStringType::isNumericString() follows the PHP version running PHPStan, so on PHP 7.4 '1 ' counted as non-numeric and '1 ' == '1' was resolved as identical even when analysing for PHP 8, where both strings are numeric and compare equal. The same-type shortcut now also requires the constant strings to be non-numeric in each of the PHP versions the comparison is resolved for. Amp-Thread-ID: https://ampcode.com/threads/T-01a1b250-12b7-7206-9d98-c1f38e89010e
1 parent 1c4477f commit a76fdbf

4 files changed

Lines changed: 171 additions & 80 deletions

File tree

‎src/Reflection/InitializerExprTypeResolver.php‎

Lines changed: 28 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -81,6 +81,7 @@
8181
use PHPStan\Type\OperatorTypeSpecifyingExtensionRegistry;
8282
use PHPStan\Type\ParserNodeTypeToPHPStanType;
8383
use PHPStan\Type\StaticType;
84+
use PHPStan\Type\StringSet;
8485
use PHPStan\Type\StringType;
8586
use PHPStan\Type\ThisType;
8687
use PHPStan\Type\Type;
@@ -1185,10 +1186,12 @@ public function resolveEqualType(Type $leftType, Type $rightType, ?PhpVersions $
11851186
return $this->resolveIdenticalType($leftType, $rightType);
11861187
}
11871188

1189+
$versions = $phpVersions !== null ? $phpVersions->getLooseComparisonVersions() : [$this->phpVersion];
1190+
11881191
// same-type sides cannot coerce - loose equals strict, except for
11891192
// two numeric strings, which compare as numbers
11901193
if (
1191-
($leftType->isString()->yes() && $rightType->isString()->yes() && ($leftType->isNumericString()->no() || $rightType->isNumericString()->no()))
1194+
($leftType->isString()->yes() && $rightType->isString()->yes() && (self::isNonNumericString($leftType, $versions) || self::isNonNumericString($rightType, $versions)))
11921195
|| ($leftType->isInteger()->yes() && $rightType->isInteger()->yes())
11931196
) {
11941197
return $this->resolveIdenticalType($leftType, $rightType);
@@ -1199,7 +1202,6 @@ public function resolveEqualType(Type $leftType, Type $rightType, ?PhpVersions $
11991202
}
12001203

12011204
// constant only when every PHP version agrees
1202-
$versions = $phpVersions !== null ? $phpVersions->getLooseComparisonVersions() : [$this->phpVersion];
12031205
$result = $leftType->looseCompare($rightType, $versions[0]);
12041206
foreach (array_slice($versions, 1) as $version) {
12051207
if (!$result->equals($leftType->looseCompare($rightType, $version))) {
@@ -1236,6 +1238,30 @@ public function resolveEqualType(Type $leftType, Type $rightType, ?PhpVersions $
12361238
return new TypeResult($result, []);
12371239
}
12381240

1241+
/**
1242+
* Whether the strings are numeric in none of the PHP versions. A constant
1243+
* string's isNumericString() follows the PHP version running PHPStan,
1244+
* while '1 ' is numeric since PHP 8.0 only.
1245+
*
1246+
* @param non-empty-list<PhpVersion> $phpVersions
1247+
*/
1248+
private static function isNonNumericString(Type $type, array $phpVersions): bool
1249+
{
1250+
if (!$type->isNumericString()->no()) {
1251+
return false;
1252+
}
1253+
1254+
foreach ($type->getConstantStrings() as $constantString) {
1255+
foreach ($phpVersions as $phpVersion) {
1256+
if (StringSet::parseNumericString($constantString->getValue(), $phpVersion) !== null) {
1257+
return false;
1258+
}
1259+
}
1260+
}
1261+
1262+
return true;
1263+
}
1264+
12391265
/**
12401266
* @param callable(Type, Type): TypeResult<BooleanType> $valueComparisonCallback
12411267
* @return TypeResult<BooleanType>

‎tests/PHPStan/Analyser/nsrt/loose-comparisons.php‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -962,4 +962,16 @@ public function sayIntersection(
962962
}
963963
}
964964

965+
/**
966+
* @param 'abc'|true $stringOrTrue
967+
* @param int<1, 5> $oneToFive
968+
* @param int<10, 20>|true $tenToTwentyOrTrue
969+
*/
970+
public function sameTypeOnOneSideOnly($stringOrTrue, $oneToFive, $tenToTwentyOrTrue): void
971+
{
972+
assertType('true', 'abc' == $stringOrTrue);
973+
assertType('true', $stringOrTrue == 'abc');
974+
assertType('bool', $oneToFive == $tenToTwentyOrTrue);
975+
}
976+
965977
}

‎turbo-ext/src/InitializerExprTypeResolver.cpp‎

Lines changed: 65 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -761,6 +761,42 @@ class InitializerExprTypeResolver
761761
return newTypeResult(newBooleanType());
762762
}
763763

764+
/* Mirrors isNonNumericString(): 1 when the strings are numeric in none of
765+
* the PHP versions, 0 when they may be, -1 = pending exception. The
766+
* versions are the list phpVersions, or the single phpVersion when it is
767+
* NULL. */
768+
static int isNonNumericString(zval *type, zval *phpVersions, zval *phpVersion)
769+
{
770+
zend_long isNumeric = triOn(type, mIsNumericString);
771+
if (UNEXPECTED(isNumeric < 0)) return -1;
772+
if (isNumeric != PT_TRI_NO) return 0;
773+
774+
zv::Val constantStrings = callOn(type, mGetConstantStrings);
775+
if (UNEXPECTED(constantStrings.isUndef() || !requireArray(constantStrings.raw()))) return -1;
776+
for (zv::ArrayEntry constantString : zv::ArrRef(constantStrings.raw())) {
777+
zv::Val value = pt_constant_string_get_value(Z_OBJ_P(constantString.value().raw()));
778+
if (UNEXPECTED(value.isUndef())) return -1;
779+
auto isNumericIn = [&](zval *version) -> int {
780+
zval number;
781+
int overflow;
782+
return pt_string_set_parse_numeric_string(Z_STR_P(value.raw()), version, &number, overflow);
783+
};
784+
if (phpVersions == NULL) {
785+
int parsed = isNumericIn(phpVersion);
786+
if (UNEXPECTED(parsed < 0)) return -1;
787+
if (parsed == 1) return 0;
788+
continue;
789+
}
790+
for (zv::ArrayEntry entry : zv::ArrRef(phpVersions)) {
791+
int parsed = isNumericIn(entry.value().raw());
792+
if (UNEXPECTED(parsed < 0)) return -1;
793+
if (parsed == 1) return 0;
794+
}
795+
}
796+
797+
return 1;
798+
}
799+
764800
/* Mirrors resolveEqualType(); phpVersions NULL stands for null. */
765801
zv::Val resolveEqualType(zval *leftType, zval *rightType, zval *phpVersions = NULL) const
766802
{
@@ -787,6 +823,20 @@ class InitializerExprTypeResolver
787823
}
788824
}
789825

826+
// $phpVersions->getLooseComparisonVersions(), or the resolver's own
827+
// version; the Type methods over a single version need no union
828+
zval *version = prop(slots::phpVersion);
829+
zv::Val versions;
830+
if (phpVersions != NULL) {
831+
IETR_VAL(representative, pt_type_call(Z_OBJ_P(phpVersions), PT_LC("getloosecomparisonversions"), 0, NULL));
832+
if (UNEXPECTED(!requireArray(representative.raw()))) return zv::Val();
833+
if (zend_hash_num_elements(Z_ARRVAL_P(representative.raw())) == 1) {
834+
version = arrayIndexForRead(representative.raw(), 0);
835+
if (UNEXPECTED(version == NULL)) return zv::Val();
836+
}
837+
versions = std::move(representative);
838+
}
839+
790840
// same-type sides cannot coerce - loose equals strict, except for
791841
// two numeric strings, which compare as numbers
792842
{
@@ -795,11 +845,13 @@ class InitializerExprTypeResolver
795845
if (leftIsString == PT_TRI_YES) {
796846
IETR_TRI(rightIsString, triOn(rightType, mIsString));
797847
if (rightIsString == PT_TRI_YES) {
798-
IETR_TRI(leftIsNumericString, triOn(leftType, mIsNumericString));
799-
identicalComparison = leftIsNumericString == PT_TRI_NO;
848+
int leftNonNumeric = isNonNumericString(leftType, versions.isUndef() ? NULL : versions.raw(), version);
849+
if (UNEXPECTED(leftNonNumeric < 0)) return zv::Val();
850+
identicalComparison = leftNonNumeric == 1;
800851
if (!identicalComparison) {
801-
IETR_TRI(rightIsNumericString, triOn(rightType, mIsNumericString));
802-
identicalComparison = rightIsNumericString == PT_TRI_NO;
852+
int rightNonNumeric = isNonNumericString(rightType, versions.isUndef() ? NULL : versions.raw(), version);
853+
if (UNEXPECTED(rightNonNumeric < 0)) return zv::Val();
854+
identicalComparison = rightNonNumeric == 1;
803855
}
804856
}
805857
}
@@ -819,19 +871,6 @@ class InitializerExprTypeResolver
819871
return resolveConstantArrayTypeComparison(leftType, rightType, false, NULL, phpVersions);
820872
}
821873

822-
// $phpVersions->getLooseComparisonVersions(), or the resolver's own
823-
// version; the Type methods over a single version need no union
824-
zval *version = prop(slots::phpVersion);
825-
zv::Val versions;
826-
if (phpVersions != NULL) {
827-
IETR_VAL(representative, pt_type_call(Z_OBJ_P(phpVersions), PT_LC("getloosecomparisonversions"), 0, NULL));
828-
if (UNEXPECTED(!requireArray(representative.raw()))) return zv::Val();
829-
if (zend_hash_num_elements(Z_ARRVAL_P(representative.raw())) == 1) {
830-
version = arrayIndexForRead(representative.raw(), 0);
831-
if (UNEXPECTED(version == NULL)) return zv::Val();
832-
}
833-
versions = std::move(representative);
834-
}
835874
bool singleVersion = versions.isUndef() || zend_hash_num_elements(Z_ARRVAL_P(versions.raw())) == 1;
836875
/* TypeCombinator::union() / intersect() of $type-><method>($version) over the versions */
837876
auto overVersions = [&](zval *type, const Method &method, bool intersect) -> zv::Val {
@@ -3706,6 +3745,15 @@ PT_MINIT_REGISTRATION(pt_register_initializer_expr_type_resolver)
37063745
PT_RETURN_VAL(InitializerExprTypeResolver::transformStaticType(type, fetchedOnType));
37073746
});
37083747

3748+
cls.method(sigs::isNonNumericString, [](INTERNAL_FUNCTION_PARAMETERS) {
3749+
zval *type, *phpVersions;
3750+
if (!zp::parse<zp::Obj, zp::Arr>(execute_data, type, phpVersions)) RETURN_THROWS();
3751+
if (UNEXPECTED(!ietrArgType(type, 1))) RETURN_THROWS();
3752+
int nonNumeric = InitializerExprTypeResolver::isNonNumericString(type, phpVersions, NULL);
3753+
if (UNEXPECTED(nonNumeric < 0)) RETURN_THROWS();
3754+
RETURN_BOOL(nonNumeric == 1);
3755+
});
3756+
37093757
cls.method(sigs::getNeverType, [](INTERNAL_FUNCTION_PARAMETERS) {
37103758
zval *leftType, *rightType;
37113759
if (!zp::parse<zp::Obj, zp::Obj>(execute_data, leftType, rightType)) RETURN_THROWS();

‎turbo-ext/src/generated/InitializerExprTypeResolver.h‎

Lines changed: 66 additions & 61 deletions
Original file line numberDiff line numberDiff line change
@@ -113,35 +113,36 @@ inline constexpr char strings[] =
113113
"PHPStan\\Type\\TypeResult\0" /* 1332 */
114114
"resolveIdenticalType\0" /* 1356 */
115115
"resolveEqualType\0" /* 1377 */
116-
"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1394 */
117-
"valueComparisonCallback\0" /* 1434 */
118-
"resolveConstantArrayTypeComparison\0" /* 1458 */
119-
"class\0" /* 1493 */
120-
"PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1499 */
121-
"constantName\0" /* 1539 */
122-
"classReflection\0" /* 1552 */
123-
"PHPStan\\Reflection\\ClassReflection\0" /* 1568 */
124-
"false\0" /* 1603 */
125-
"getClassConstFetchTypeByReflection\0" /* 1609 */
126-
"fetchedOnType\0" /* 1644 */
127-
"transformStaticType\0" /* 1658 */
128-
"getClassConstFetchType\0" /* 1678 */
129-
"getUnaryPlusType\0" /* 1701 */
130-
"getUnaryMinusType\0" /* 1718 */
131-
"getBitwiseNotType\0" /* 1736 */
132-
"getBitwiseNotTypeFromType\0" /* 1754 */
133-
"name\0" /* 1780 */
134-
"PhpParser\\Node\\Name\0" /* 1785 */
135-
"resolveName\0" /* 1805 */
136-
"PHPStan\\Type\\TypeWithClassName\0" /* 1817 */
137-
"resolveTypeByName\0" /* 1848 */
138-
"classType\0" /* 1866 */
139-
"methodReflectionCandidate\0" /* 1876 */
140-
"PHPStan\\Reflection\\MethodReflection\0" /* 1902 */
141-
"resolveTypeByNameWithLateStaticBinding\0" /* 1938 */
142-
"PHPStan\\Reflection\\ReflectionProvider\0" /* 1977 */
143-
"getReflectionProvider\0" /* 2015 */
144-
"getNeverType"; /* 2037 */
116+
"isNonNumericString\0" /* 1394 */
117+
"PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1413 */
118+
"valueComparisonCallback\0" /* 1453 */
119+
"resolveConstantArrayTypeComparison\0" /* 1477 */
120+
"class\0" /* 1512 */
121+
"PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1518 */
122+
"constantName\0" /* 1558 */
123+
"classReflection\0" /* 1571 */
124+
"PHPStan\\Reflection\\ClassReflection\0" /* 1587 */
125+
"false\0" /* 1622 */
126+
"getClassConstFetchTypeByReflection\0" /* 1628 */
127+
"fetchedOnType\0" /* 1663 */
128+
"transformStaticType\0" /* 1677 */
129+
"getClassConstFetchType\0" /* 1697 */
130+
"getUnaryPlusType\0" /* 1720 */
131+
"getUnaryMinusType\0" /* 1737 */
132+
"getBitwiseNotType\0" /* 1755 */
133+
"getBitwiseNotTypeFromType\0" /* 1773 */
134+
"name\0" /* 1799 */
135+
"PhpParser\\Node\\Name\0" /* 1804 */
136+
"resolveName\0" /* 1824 */
137+
"PHPStan\\Type\\TypeWithClassName\0" /* 1836 */
138+
"resolveTypeByName\0" /* 1867 */
139+
"classType\0" /* 1885 */
140+
"methodReflectionCandidate\0" /* 1895 */
141+
"PHPStan\\Reflection\\MethodReflection\0" /* 1921 */
142+
"resolveTypeByNameWithLateStaticBinding\0" /* 1957 */
143+
"PHPStan\\Reflection\\ReflectionProvider\0" /* 1996 */
144+
"getReflectionProvider\0" /* 2034 */
145+
"getNeverType"; /* 2056 */
145146
inline constexpr reg::PackedArg args[] = {
146147
reg::packed(0, 0, 17), /* __construct $constantResolver */
147148
reg::packed(51, 0, 78), /* __construct $reflectionProviderProvider */
@@ -244,21 +245,24 @@ inline constexpr reg::PackedArg args[] = {
244245
reg::packed(1322, 0, 560), /* resolveEqualType $rightType */
245246
reg::packed(722, MAY_BE_NULL, 734, false, false, 758), /* resolveEqualType $phpVersions */
246247
reg::packed(559, 0, 1332), /* resolveEqualType return */
247-
reg::packed(1313, 0, 1394), /* resolveConstantArrayTypeComparison $leftType */
248-
reg::packed(1322, 0, 1394), /* resolveConstantArrayTypeComparison $rightType */
249-
reg::packed(1434, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */
248+
reg::packed(840, 0, 560), /* isNonNumericString $type */
249+
reg::packed(722, MAY_BE_ARRAY), /* isNonNumericString $phpVersions */
250+
reg::packed(559, MAY_BE_BOOL), /* isNonNumericString return */
251+
reg::packed(1313, 0, 1413), /* resolveConstantArrayTypeComparison $leftType */
252+
reg::packed(1322, 0, 1413), /* resolveConstantArrayTypeComparison $rightType */
253+
reg::packed(1453, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */
250254
reg::packed(559, 0, 1332), /* resolveConstantArrayTypeComparison return */
251-
reg::packed(1493, 0, 1499), /* getClassConstFetchTypeByReflection $class */
252-
reg::packed(1539, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */
253-
reg::packed(1552, MAY_BE_NULL, 1568), /* getClassConstFetchTypeByReflection $classReflection */
255+
reg::packed(1512, 0, 1518), /* getClassConstFetchTypeByReflection $class */
256+
reg::packed(1558, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */
257+
reg::packed(1571, MAY_BE_NULL, 1587), /* getClassConstFetchTypeByReflection $classReflection */
254258
reg::packed(647, MAY_BE_CALLABLE), /* getClassConstFetchTypeByReflection $getTypeCallback */
255-
reg::packed(968, MAY_BE_BOOL, reg::NoString, false, false, 1603), /* getClassConstFetchTypeByReflection $nativeTypesPromoted */
259+
reg::packed(968, MAY_BE_BOOL, reg::NoString, false, false, 1622), /* getClassConstFetchTypeByReflection $nativeTypesPromoted */
256260
reg::packed(559, 0, 560), /* getClassConstFetchTypeByReflection return */
257261
reg::packed(840, 0, 560), /* transformStaticType $type */
258-
reg::packed(1644, 0, 560), /* transformStaticType $fetchedOnType */
262+
reg::packed(1663, 0, 560), /* transformStaticType $fetchedOnType */
259263
reg::packed(559, 0, 560), /* transformStaticType return */
260-
reg::packed(1493, 0, 1499), /* getClassConstFetchType $class */
261-
reg::packed(1539, MAY_BE_STRING), /* getClassConstFetchType $constantName */
264+
reg::packed(1512, 0, 1518), /* getClassConstFetchType $class */
265+
reg::packed(1558, MAY_BE_STRING), /* getClassConstFetchType $constantName */
262266
reg::packed(586, MAY_BE_NULL | MAY_BE_STRING), /* getClassConstFetchType $className */
263267
reg::packed(647, MAY_BE_CALLABLE), /* getClassConstFetchType $getTypeCallback */
264268
reg::packed(559, 0, 560), /* getClassConstFetchType return */
@@ -273,17 +277,17 @@ inline constexpr reg::PackedArg args[] = {
273277
reg::packed(559, 0, 560), /* getBitwiseNotType return */
274278
reg::packed(813, 0, 560), /* getBitwiseNotTypeFromType $exprType */
275279
reg::packed(559, 0, 560), /* getBitwiseNotTypeFromType return */
276-
reg::packed(1780, 0, 1785), /* resolveName $name */
277-
reg::packed(1552, MAY_BE_NULL, 1568), /* resolveName $classReflection */
280+
reg::packed(1799, 0, 1804), /* resolveName $name */
281+
reg::packed(1571, MAY_BE_NULL, 1587), /* resolveName $classReflection */
278282
reg::packed(559, MAY_BE_STRING), /* resolveName return */
279-
reg::packed(1780, 0, 1785), /* resolveTypeByName $name */
280-
reg::packed(1552, MAY_BE_NULL, 1568), /* resolveTypeByName $classReflection */
281-
reg::packed(559, 0, 1817), /* resolveTypeByName return */
282-
reg::packed(1493, 0, 1785), /* resolveTypeByNameWithLateStaticBinding $class */
283-
reg::packed(1866, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */
284-
reg::packed(1876, 0, 1902), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */
283+
reg::packed(1799, 0, 1804), /* resolveTypeByName $name */
284+
reg::packed(1571, MAY_BE_NULL, 1587), /* resolveTypeByName $classReflection */
285+
reg::packed(559, 0, 1836), /* resolveTypeByName return */
286+
reg::packed(1512, 0, 1804), /* resolveTypeByNameWithLateStaticBinding $class */
287+
reg::packed(1885, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */
288+
reg::packed(1895, 0, 1921), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */
285289
reg::packed(559, 0, 560), /* resolveTypeByNameWithLateStaticBinding return */
286-
reg::packed(559, 0, 1977), /* getReflectionProvider return */
290+
reg::packed(559, 0, 1996), /* getReflectionProvider return */
287291
reg::packed(1313, 0, 560), /* getNeverType $leftType */
288292
reg::packed(1322, 0, 560), /* getNeverType $rightType */
289293
reg::packed(559, 0, 560), /* getNeverType return */
@@ -319,19 +323,20 @@ inline constexpr sigtab::Sig getShiftLeftType = { { 1278 /* getShiftLeftType */,
319323
inline constexpr sigtab::Sig getShiftRightType = { { 1295 /* getShiftRightType */, 3, 90, 3, 93, ZEND_ACC_PUBLIC } };
320324
inline constexpr sigtab::Sig resolveIdenticalType = { { 1356 /* resolveIdenticalType */, 2, 94, 2, 96, ZEND_ACC_PUBLIC } };
321325
inline constexpr sigtab::Sig resolveEqualType = { { 1377 /* resolveEqualType */, 2, 97, 3, 100, ZEND_ACC_PUBLIC } };
322-
inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1458 /* resolveConstantArrayTypeComparison */, 3, 101, 3, 104, ZEND_ACC_PRIVATE } };
323-
inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1609 /* getClassConstFetchTypeByReflection */, 4, 105, 5, 110, ZEND_ACC_PUBLIC } };
324-
inline constexpr sigtab::Sig transformStaticType = { { 1658 /* transformStaticType */, 2, 111, 2, 113, ZEND_ACC_PRIVATE } };
325-
inline constexpr sigtab::Sig getClassConstFetchType = { { 1678 /* getClassConstFetchType */, 4, 114, 4, 118, ZEND_ACC_PUBLIC } };
326-
inline constexpr sigtab::Sig getUnaryPlusType = { { 1701 /* getUnaryPlusType */, 2, 119, 2, 121, ZEND_ACC_PUBLIC } };
327-
inline constexpr sigtab::Sig getUnaryMinusType = { { 1718 /* getUnaryMinusType */, 2, 122, 2, 124, ZEND_ACC_PUBLIC } };
328-
inline constexpr sigtab::Sig getBitwiseNotType = { { 1736 /* getBitwiseNotType */, 2, 125, 2, 127, ZEND_ACC_PUBLIC } };
329-
inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 1754 /* getBitwiseNotTypeFromType */, 1, 128, 1, 129, ZEND_ACC_PUBLIC } };
330-
inline constexpr sigtab::Sig resolveName = { { 1805 /* resolveName */, 2, 130, 2, 132, ZEND_ACC_PRIVATE } };
331-
inline constexpr sigtab::Sig resolveTypeByName = { { 1848 /* resolveTypeByName */, 2, 133, 2, 135, ZEND_ACC_PRIVATE } };
332-
inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 1938 /* resolveTypeByNameWithLateStaticBinding */, 3, 136, 3, 139, ZEND_ACC_PRIVATE } };
333-
inline constexpr sigtab::Sig getReflectionProvider = { { 2015 /* getReflectionProvider */, 0, 140, 0, 140, ZEND_ACC_PRIVATE } };
334-
inline constexpr sigtab::Sig getNeverType = { { 2037 /* getNeverType */, 2, 141, 2, 143, ZEND_ACC_PRIVATE } };
326+
inline constexpr sigtab::Sig isNonNumericString = { { 1394 /* isNonNumericString */, 2, 101, 2, 103, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } };
327+
inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1477 /* resolveConstantArrayTypeComparison */, 3, 104, 3, 107, ZEND_ACC_PRIVATE } };
328+
inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1628 /* getClassConstFetchTypeByReflection */, 4, 108, 5, 113, ZEND_ACC_PUBLIC } };
329+
inline constexpr sigtab::Sig transformStaticType = { { 1677 /* transformStaticType */, 2, 114, 2, 116, ZEND_ACC_PRIVATE } };
330+
inline constexpr sigtab::Sig getClassConstFetchType = { { 1697 /* getClassConstFetchType */, 4, 117, 4, 121, ZEND_ACC_PUBLIC } };
331+
inline constexpr sigtab::Sig getUnaryPlusType = { { 1720 /* getUnaryPlusType */, 2, 122, 2, 124, ZEND_ACC_PUBLIC } };
332+
inline constexpr sigtab::Sig getUnaryMinusType = { { 1737 /* getUnaryMinusType */, 2, 125, 2, 127, ZEND_ACC_PUBLIC } };
333+
inline constexpr sigtab::Sig getBitwiseNotType = { { 1755 /* getBitwiseNotType */, 2, 128, 2, 130, ZEND_ACC_PUBLIC } };
334+
inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 1773 /* getBitwiseNotTypeFromType */, 1, 131, 1, 132, ZEND_ACC_PUBLIC } };
335+
inline constexpr sigtab::Sig resolveName = { { 1824 /* resolveName */, 2, 133, 2, 135, ZEND_ACC_PRIVATE } };
336+
inline constexpr sigtab::Sig resolveTypeByName = { { 1867 /* resolveTypeByName */, 2, 136, 2, 138, ZEND_ACC_PRIVATE } };
337+
inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 1957 /* resolveTypeByNameWithLateStaticBinding */, 3, 139, 3, 142, ZEND_ACC_PRIVATE } };
338+
inline constexpr sigtab::Sig getReflectionProvider = { { 2034 /* getReflectionProvider */, 0, 143, 0, 143, ZEND_ACC_PRIVATE } };
339+
inline constexpr sigtab::Sig getNeverType = { { 2056 /* getNeverType */, 2, 144, 2, 146, ZEND_ACC_PRIVATE } };
335340
} // namespace sig
336341

337342
} // namespace ptdecl::InitializerExprTypeResolver

0 commit comments

Comments
 (0)