From 0de2e0ee63617a8acec48cfaa3cb0e983e06f793 Mon Sep 17 00:00:00 2001 From: "ondrej@mirtes.cz" Date: Mon, 9 Nov 2026 06:20:49 +0000 Subject: [PATCH 1/4] Add build rule declaring native types from PHPDoc types Reports parameters, return types and properties without a native type when their PHPDoc type can be declared natively, and fixes them: declares the native type and removes the PHPDoc tag when the native type says the same. Return and property types are added only where nothing can override them, parameter types only when contravariant with the overridden methods. Amp-Thread-ID: https://ampcode.com/threads/T-01a1bed4-966e-7640-a834-06bba746e1f1 --- build/PHPStan/Build/MissingNativeTypeRule.php | 476 ++++++++++++++++++ .../Build/MissingNativeTypeRuleTest.php | 157 ++++++ .../Build/data/missing-native-type.php | 332 ++++++++++++ .../Build/data/missing-native-type.php.fixed | 296 +++++++++++ 4 files changed, 1261 insertions(+) create mode 100644 build/PHPStan/Build/MissingNativeTypeRule.php create mode 100644 tests/PHPStan/Build/MissingNativeTypeRuleTest.php create mode 100644 tests/PHPStan/Build/data/missing-native-type.php create mode 100644 tests/PHPStan/Build/data/missing-native-type.php.fixed diff --git a/build/PHPStan/Build/MissingNativeTypeRule.php b/build/PHPStan/Build/MissingNativeTypeRule.php new file mode 100644 index 00000000000..44b3027e01b --- /dev/null +++ b/build/PHPStan/Build/MissingNativeTypeRule.php @@ -0,0 +1,476 @@ + + */ +final class MissingNativeTypeRule implements Rule +{ + + private const PARAM_TAGS = ['@param', '@phpstan-param', '@psalm-param']; + + private const RETURN_TAGS = ['@return', '@phpstan-return', '@psalm-return']; + + private const VAR_TAGS = ['@var', '@phpstan-var', '@psalm-var']; + + public function __construct( + private PhpVersion $phpVersion, + private PhpDocEditor $phpDocEditor, + private MissingTypehintCheck $missingTypehintCheck, + ) + { + } + + public function getNodeType(): string + { + return Node::class; + } + + public function processNode(Node $node, Scope $scope): array + { + if ($node instanceof InClassMethodNode) { + if ($scope->isInTrait()) { + // one fix of the trait for each class using it + return []; + } + + $classReflection = $node->getClassReflection(); + $methodName = $node->getOriginalNode()->name->toString(); + return $this->processFunctionLike( + $node->getOriginalNode(), + $node->getMethodReflection(), + $classReflection, + sprintf('Method %s::%s()', $classReflection->getDisplayName(), $methodName), + ); + } + + if ($node instanceof InFunctionNode) { + return $this->processFunctionLike( + $node->getOriginalNode(), + $node->getFunctionReflection(), + null, + sprintf('Function %s()', $node->getFunctionReflection()->getName()), + ); + } + + if ($node instanceof ClassPropertyNode) { + return $this->processProperty($node, $scope); + } + + return []; + } + + /** + * @return list + */ + private function processFunctionLike( + Node\Stmt\ClassMethod|Node\Stmt\Function_ $functionNode, + PhpFunctionFromParserNodeReflection $function, + ?ClassReflection $classReflection, + string $functionDescription, + ): array + { + $lowercasedName = strtolower($functionNode->name->toString()); + $isMethod = $functionNode instanceof Node\Stmt\ClassMethod; + if ($isMethod && str_starts_with($lowercasedName, '__') && !in_array($lowercasedName, ['__construct', '__invoke'], true)) { + // PHP checks the native types of magic methods + return []; + } + + $ancestorMethods = $classReflection !== null ? $this->getAncestorMethods($classReflection, $functionNode->name->toString()) : []; + + /** @var array $paramTypeNodes */ + $paramTypeNodes = []; + $sameParamNames = []; + $descriptions = []; + $parameters = $function->getParameters(); + foreach ($functionNode->params as $i => $paramNode) { + if ($paramNode->type !== null || $paramNode->byRef || !isset($parameters[$i])) { + // the type of a parameter passed by reference describes the variable after the call too + continue; + } + + $parameter = $parameters[$i]; + $type = $parameter->getType(); + // a promoted parameter declares a property too + $position = $paramNode->isPromoted() ? NativeTypePosition::property($this->phpVersion) : NativeTypePosition::parameter($this->phpVersion); + $typeNode = $type->toNativePhpTypeNode($position); + if ($typeNode === null) { + continue; + } + + $nativeType = ParserNodeTypeToPHPStanType::resolve($typeNode, $classReflection); + if (!$nativeType->isSuperTypeOf($type)->yes()) { + continue; + } + + $defaultValue = $parameter->getDefaultValue(); + if ($defaultValue !== null && !$nativeType->isSuperTypeOf($defaultValue)->yes()) { + continue; + } + + if (!self::isContravariant($nativeType, $i, $ancestorMethods)) { + continue; + } + + if ($paramNode->isPromoted() && $classReflection !== null && !$this->canDeclarePropertyType($classReflection, $parameter->getName(), ($paramNode->flags & Modifiers::PRIVATE) !== 0)) { + continue; + } + + $paramTypeNodes[$i] = $typeNode; + $descriptions[] = sprintf('%s %s$%s', self::printTypeNode($typeNode), $parameter->isVariadic() ? '...' : '', $parameter->getName()); + if (!$this->isSameType($nativeType, $type)) { + continue; + } + + $sameParamNames[] = $parameter->getName(); + } + + $returnTypeNode = null; + $isSameReturnType = false; + if ( + $functionNode->returnType === null + && !in_array($lowercasedName, ['__construct', '__destruct'], true) + && (!$functionNode instanceof Node\Stmt\ClassMethod || $classReflection === null || !self::canBeOverridden($classReflection, $functionNode)) + ) { + $returnType = $function->getReturnType(); + $returnTypeNode = $returnType->toNativePhpTypeNode(NativeTypePosition::returnType($this->phpVersion)); + if ($returnTypeNode !== null) { + $nativeReturnType = ParserNodeTypeToPHPStanType::resolve($returnTypeNode, $classReflection); + if (!$nativeReturnType->isSuperTypeOf($returnType)->yes() || !self::isCovariant($nativeReturnType, $ancestorMethods)) { + $returnTypeNode = null; + } else { + $descriptions[] = sprintf('return type %s', self::printTypeNode($returnTypeNode)); + $isSameReturnType = $this->isSameType($nativeReturnType, $returnType); + } + } + } + + if ($descriptions === []) { + return []; + } + + return [ + RuleErrorBuilder::message(sprintf('%s is missing native types: %s.', $functionDescription, implode(', ', $descriptions))) + ->identifier('phpstan.missingNativeType') + ->fixNode($functionNode, function (Node\Stmt\ClassMethod|Node\Stmt\Function_ $functionNode) use ($paramTypeNodes, $sameParamNames, $returnTypeNode, $isSameReturnType) { + foreach ($paramTypeNodes as $i => $typeNode) { + $param = $functionNode->params[$i]; + if ($param->flags === 0 && $param->attrGroups === []) { + $param->type = $typeNode; + continue; + } + + // the format-preserving printer would insert the type before the modifiers and attributes + $functionNode->params[$i] = new Node\Param($param->var, $param->default, $typeNode, $param->byRef, $param->variadic, flags: $param->flags, attrGroups: array_values($param->attrGroups), hooks: $param->hooks); + } + if ($returnTypeNode !== null) { + $functionNode->returnType = $returnTypeNode; + } + + if ($sameParamNames !== [] || $isSameReturnType) { + $sameParamTagNames = array_map(static fn (string $name): string => '$' . $name, $sameParamNames); + $this->removePhpDocTags($functionNode, static function (PhpDocTagNode $tag) use ($sameParamTagNames, $isSameReturnType): bool { + $value = $tag->value; + if ($value instanceof ParamTagValueNode) { + return in_array($tag->name, self::PARAM_TAGS, true) + && $value->description === '' + && in_array($value->parameterName, $sameParamTagNames, true); + } + + return $isSameReturnType + && $value instanceof ReturnTagValueNode + && in_array($tag->name, self::RETURN_TAGS, true) + && $value->description === ''; + }); + } + + return $functionNode; + }) + ->build(), + ]; + } + + /** + * @return list + */ + private function processProperty(ClassPropertyNode $node, Scope $scope): array + { + $propertyNode = $node->getOriginalNode()->getAttribute('originalPropertyStmt'); + if ( + !$propertyNode instanceof Node\Stmt\Property + || $propertyNode->type !== null + || count($propertyNode->props) !== 1 + || $node->hasHooks() + || $node->isDeclaredInTrait() + ) { + return []; + } + + $type = $node->getPhpDocType(); + if ($type === null) { + return []; + } + + $classReflection = $node->getClassReflection(); + if (!$this->canDeclarePropertyType($classReflection, $node->getName(), $node->isPrivate())) { + return []; + } + + $typeNode = $type->toNativePhpTypeNode(NativeTypePosition::property($this->phpVersion)); + if ($typeNode === null) { + return []; + } + + $nativeType = ParserNodeTypeToPHPStanType::resolve($typeNode, $classReflection); + if (!$nativeType->isSuperTypeOf($type)->yes()) { + return []; + } + + $default = $node->getDefault(); + $addNullDefault = false; + if ($default !== null) { + if (!$nativeType->isSuperTypeOf($scope->getType($default))->yes()) { + return []; + } + } elseif (!$nativeType->isNull()->no()) { + // a property without a native type is null until it is assigned, a typed one would be uninitialized + $addNullDefault = true; + } elseif ($node->isStatic()) { + // nothing reports reading an uninitialized static property + return []; + } + + $isSameType = $this->isSameType($nativeType, $type); + + return [ + RuleErrorBuilder::message(sprintf('Property %s::$%s is missing native type %s.', $classReflection->getDisplayName(), $node->getName(), self::printTypeNode($typeNode))) + ->identifier('phpstan.missingNativeType') + ->fixNode($propertyNode, function (Node\Stmt\Property $propertyNode) use ($typeNode, $addNullDefault, $isSameType) { + $propertyNode->type = $typeNode; + if ($addNullDefault) { + $propertyNode->props[0]->default = new ConstFetch(new Name('null')); + } + + if ($isSameType) { + $this->removePhpDocTags($propertyNode, static fn (PhpDocTagNode $tag): bool => in_array($tag->name, self::VAR_TAGS, true) + && $tag->value instanceof VarTagValueNode + && $tag->value->description === ''); + } + + return $propertyNode; + }) + ->build(), + ]; + } + + /** + * @param callable(PhpDocTagNode): bool $shouldRemove + */ + private function removePhpDocTags(Node $node, callable $shouldRemove): void + { + $this->phpDocEditor->edit($node, static function (PhpDocAstNode $phpDocNode) use ($shouldRemove): ?PhpDocNode { + if (!$phpDocNode instanceof PhpDocNode) { + return null; + } + + $children = array_values(array_filter( + $phpDocNode->children, + static fn (PhpDocChildNode $child): bool => !$child instanceof PhpDocTagNode || !$shouldRemove($child), + )); + + // the empty line that separated the removed tags from the description + while ($children !== [] && $children[count($children) - 1] instanceof PhpDocTextNode && trim($children[count($children) - 1]->text) === '') { + array_pop($children); + } + + $phpDocNode->children = $children; + + return $phpDocNode; + }); + } + + /** + * A property type must stay the same in child classes, and a parent property needs the same type too. + */ + private function canDeclarePropertyType(ClassReflection $classReflection, string $propertyName, bool $isPrivate): bool + { + if (!$isPrivate && !self::isFinal($classReflection)) { + return false; + } + + foreach ($classReflection->getParents() as $parent) { + if ($parent->hasNativeProperty($propertyName) && !$parent->getNativeProperty($propertyName)->isPrivate()) { + return false; + } + } + + return true; + } + + /** + * @return list variants of the parent and interface methods the method has to be compatible with + */ + private function getAncestorMethods(ClassReflection $classReflection, string $methodName): array + { + $isConstructor = strtolower($methodName) === '__construct'; + $variants = []; + foreach ([...$classReflection->getParents(), ...array_values($classReflection->getInterfaces())] as $ancestor) { + if (!$ancestor->hasNativeMethod($methodName)) { + continue; + } + + $method = $ancestor->getNativeMethod($methodName); + if ($method->isPrivate()) { + continue; + } + + $isAbstract = $method->isAbstract(); + if ($isConstructor && !$ancestor->isInterface() && $isAbstract !== true && !($isAbstract instanceof TrinaryLogic && $isAbstract->yes())) { + // PHP checks the signature of a constructor only against an abstract one + continue; + } + + foreach ($method->getVariants() as $variant) { + $variants[] = $variant; + } + } + + return $variants; + } + + /** + * @param list $ancestorMethods + */ + private static function isContravariant(Type $nativeType, int $position, array $ancestorMethods): bool + { + foreach ($ancestorMethods as $ancestorMethod) { + $ancestorParameters = $ancestorMethod->getParameters(); + $ancestorParameter = $ancestorParameters[$position] ?? null; + if ($ancestorParameter === null) { + $lastParameter = $ancestorParameters[count($ancestorParameters) - 1] ?? null; + if ($lastParameter === null || !$lastParameter->isVariadic()) { + continue; + } + + $ancestorParameter = $lastParameter; + } + + if (!$nativeType->isSuperTypeOf($ancestorParameter->getNativeType())->yes()) { + return false; + } + } + + return true; + } + + /** + * @param list $ancestorMethods + */ + private static function isCovariant(Type $nativeReturnType, array $ancestorMethods): bool + { + foreach ($ancestorMethods as $ancestorMethod) { + if (!$ancestorMethod->getNativeReturnType()->isSuperTypeOf($nativeReturnType)->yes()) { + return false; + } + } + + return true; + } + + private static function canBeOverridden(ClassReflection $classReflection, Node\Stmt\ClassMethod $method): bool + { + return !$method->isPrivate() && !$method->isFinal() && !self::isFinal($classReflection); + } + + private static function isFinal(ClassReflection $classReflection): bool + { + return $classReflection->isFinalByKeyword() || $classReflection->isAnonymous() || $classReflection->isEnum(); + } + + /** + * Whether the PHPDoc type says nothing more than the native type. An explicit `mixed[]` says more than `array`: + * they accept the same values, but only the former has a value type. + */ + private function isSameType(Type $nativeType, Type $phpDocType): bool + { + return $nativeType->isSuperTypeOf($phpDocType)->yes() + && $phpDocType->isSuperTypeOf($nativeType)->yes() + && count($this->missingTypehintCheck->getIterableTypesWithMissingValueTypehint($nativeType)) === count($this->missingTypehintCheck->getIterableTypesWithMissingValueTypehint($phpDocType)); + } + + private static function printTypeNode(Identifier|Name|ComplexType $node): string + { + if ($node instanceof Node\NullableType) { + return '?' . self::printTypeNode($node->type); + } + + if ($node instanceof Node\UnionType) { + return implode('|', array_map(static fn (Identifier|Name|Node\IntersectionType $member): string => $member instanceof Node\IntersectionType ? '(' . self::printTypeNode($member) . ')' : self::printTypeNode($member), $node->types)); + } + + if ($node instanceof Node\IntersectionType) { + return implode('&', array_map(static fn (Identifier|Name $member): string => self::printTypeNode($member), $node->types)); + } + + if ($node instanceof Identifier || $node instanceof Name) { + return $node->toString(); + } + + throw new ShouldNotHappenException(); + } + +} diff --git a/tests/PHPStan/Build/MissingNativeTypeRuleTest.php b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php new file mode 100644 index 00000000000..818c112c420 --- /dev/null +++ b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php @@ -0,0 +1,157 @@ + + */ +class MissingNativeTypeRuleTest extends RuleTestCase +{ + + protected function getRule(): Rule + { + return new MissingNativeTypeRule( + new PhpVersion(80200), + self::getContainer()->getByType(PhpDocEditor::class), + self::getContainer()->getByType(MissingTypehintCheck::class), + ); + } + + public function testRule(): void + { + $this->analyse([__DIR__ . '/data/missing-native-type.php'], [ + [ + 'Method MissingNativeType\SameTypes::doFoo() is missing native types: int $a, return type string.', + 15, + ], + [ + 'Method MissingNativeType\SameTypes::doBar() is missing native types: stdClass $o, ?Countable $c.', + 26, + ], + [ + 'Method MissingNativeType\SameTypes::withDescription() is missing native types: int $a.', + 31, + ], + [ + 'Method MissingNativeType\SameTypes::nullDefault() is missing native types: ?int $a.', + 36, + ], + [ + 'Method MissingNativeType\SameTypes::variadic() is missing native types: string ...$parts.', + 41, + ], + [ + 'Method MissingNativeType\SameTypes::explicitMixed() is missing native types: mixed $a.', + 46, + ], + [ + 'Method MissingNativeType\SameTypes::callable() is missing native types: callable $cb.', + 51, + ], + [ + 'Method MissingNativeType\SameTypes::returnStatic() is missing native types: return type MissingNativeType\SameTypes.', + 56, + ], + [ + 'Method MissingNativeType\SameTypes::returnVoid() is missing native types: return type void.', + 62, + ], + [ + 'Method MissingNativeType\MoreSpecificTypes::doFoo() is missing native types: string $s, ?int $i, return type array.', + 76, + ], + [ + 'Method MissingNativeType\MoreSpecificTypes::template() is missing native types: object $o, return type object.', + 86, + ], + [ + 'Method MissingNativeType\MoreSpecificTypes::returnThis() is missing native types: return type static.', + 92, + ], + [ + 'Method MissingNativeType\ParentClass::overridable() is missing native types: int $a.', + 146, + ], + [ + 'Method MissingNativeType\ParentClass::privateMethod() is missing native types: int $a, return type int.', + 155, + ], + [ + 'Method MissingNativeType\ParentClass::finalMethod() is missing native types: int $a, return type int.', + 164, + ], + [ + 'Method MissingNativeType\ChildClass::untyped() is missing native types: return type int.', + 178, + ], + [ + 'Method MissingNativeType\ChildClass::typed() is missing native types: int $a.', + 187, + ], + [ + 'Method MissingNativeType\ChildClass::__construct() is missing native types: int $a.', + 193, + ], + [ + 'Method MissingNativeType\SomeInterface::doFoo() is missing native types: int $a.', + 206, + ], + [ + 'Function MissingNativeType\doFoo() is missing native types: int $a, return type int.', + 214, + ], + [ + 'Property MissingNativeType\Properties::$a is missing native type int.', + 223, + ], + [ + 'Property MissingNativeType\Properties::$nullable is missing native type ?stdClass.', + 226, + ], + [ + 'Property MissingNativeType\Properties::$moreSpecific is missing native type string.', + 229, + ], + [ + 'Property MissingNativeType\Properties::$noDefault is missing native type stdClass.', + 232, + ], + [ + 'Property MissingNativeType\Properties::$staticNullable is missing native type ?stdClass.', + 238, + ], + [ + 'Property MissingNativeType\Properties::$withDescription is missing native type int.', + 250, + ], + [ + 'Property MissingNativeType\NonFinalProperties::$private is missing native type int.', + 263, + ], + [ + 'Method MissingNativeType\PromotedProperties::__construct() is missing native types: int $a.', + 274, + ], + [ + 'Method MissingNativeType\NonFinalPromotedProperties::__construct() is missing native types: int $a.', + 287, + ], + [ + 'Method MissingNativeType\ExplicitMixedValueType::doFoo() is missing native types: array $a, return type array.', + 327, + ], + ]); + } + + public function testFix(): void + { + $this->fix(__DIR__ . '/data/missing-native-type.php', __DIR__ . '/data/missing-native-type.php.fixed'); + } + +} diff --git a/tests/PHPStan/Build/data/missing-native-type.php b/tests/PHPStan/Build/data/missing-native-type.php new file mode 100644 index 00000000000..829b6bf3e97 --- /dev/null +++ b/tests/PHPStan/Build/data/missing-native-type.php @@ -0,0 +1,332 @@ += 8.0 + +namespace MissingNativeType; + +use Countable; +use stdClass; + +final class SameTypes +{ + + /** + * @param int $a + * @return string + */ + public function doFoo($a) + { + return (string) $a; + } + + /** + * Keeps the description. + * + * @param stdClass $o + * @param Countable|null $c + */ + public function doBar($o, $c): void + { + } + + /** @param int $a the amount */ + public function withDescription($a): void + { + } + + /** @param int $a */ + public function nullDefault($a = null): void + { + } + + /** @param string ...$parts */ + public function variadic(...$parts): void + { + } + + /** @param mixed $a */ + public function explicitMixed($a): void + { + } + + /** @param callable $cb */ + public function callable($cb): void + { + } + + /** @return static */ + public function returnStatic() + { + return $this; + } + + /** @return void */ + public function returnVoid() + { + } + +} + +final class MoreSpecificTypes +{ + + /** + * @param non-empty-string $s + * @param positive-int|null $i + * @return list + */ + public function doFoo($s, $i) + { + return []; + } + + /** + * @template T of object + * @param T $o + * @return T + */ + public function template($o) + { + return $o; + } + + /** @return $this */ + public function returnThis() + { + return $this; + } + +} + +final class NotConvertible +{ + + /** + * @param resource $r + * @param int $byRef + * @param int $d + */ + public function doFoo($r, &$byRef, $d = 'foo', $noPhpDoc = 1): void + { + } + + /** @param string $name */ + public function __get($name) + { + return 1; + } + + /** @return string */ + public function __toString() + { + return ''; + } + +} + +class ParentClass +{ + + public function untyped($a) + { + return $a; + } + + public function typed(int $a): int + { + return $a; + } + + public function __construct($a) + { + } + + /** + * @param int $a + * @return int + */ + public function overridable($a) + { + return $a; + } + + /** + * @param int $a + * @return int + */ + private function privateMethod($a) + { + return $a; + } + + /** + * @param int $a + * @return int + */ + final public function finalMethod($a) + { + return $a; + } + +} + +final class ChildClass extends ParentClass +{ + + /** + * @param int $a + * @return int + */ + public function untyped($a) + { + return $a; + } + + /** + * @param positive-int $a + * @return positive-int + */ + public function typed($a): int + { + return 1; + } + + /** @param int $a */ + public function __construct($a) + { + } + +} + +interface SomeInterface +{ + + /** + * @param int $a + * @return int + */ + public function doFoo($a); + +} + +/** + * @param int $a + * @return int + */ +function doFoo($a) +{ + return $a; +} + +final class Properties +{ + + /** @var int */ + private $a = 1; + + /** @var stdClass|null */ + private $nullable; + + /** @var non-empty-string */ + private $moreSpecific = 'foo'; + + /** @var stdClass */ + private $noDefault; + + /** @var stdClass */ + private static $staticNoDefault; + + /** @var stdClass|null */ + private static $staticNullable; + + /** @var int */ + private $wrongDefault = 'foo'; + + /** @var int */ + private $b = 1, $c = 2; + + /** @var callable */ + private $callable; + + /** @var int the description */ + public $withDescription = 1; + + public function __construct(stdClass $noDefault) + { + $this->noDefault = $noDefault; + } + +} + +class NonFinalProperties +{ + + /** @var int */ + private $private = 1; + + /** @var int */ + protected $protected = 1; + +} + +final class PromotedProperties +{ + + /** @param int $a */ + public function __construct(private $a) + { + } + +} + +class NonFinalPromotedProperties +{ + + /** + * @param int $a + * @param int $b + */ + public function __construct(private $a, public $b) + { + } + +} + +trait SomeTrait +{ + + /** @param int $a */ + public function doFoo($a): void + { + } + +} + +final class UsesTrait +{ + + use SomeTrait; + +} + +final class PromotedCallable +{ + + /** @param callable $cb */ + public function __construct(private $cb) + { + } + +} + +final class ExplicitMixedValueType +{ + + /** + * @param mixed[] $a + * @return array + */ + public function doFoo($a) + { + return $a; + } + +} diff --git a/tests/PHPStan/Build/data/missing-native-type.php.fixed b/tests/PHPStan/Build/data/missing-native-type.php.fixed new file mode 100644 index 00000000000..c7a3428829f --- /dev/null +++ b/tests/PHPStan/Build/data/missing-native-type.php.fixed @@ -0,0 +1,296 @@ += 8.0 + +namespace MissingNativeType; + +use Countable; +use stdClass; + +final class SameTypes +{ + + public function doFoo(int $a): string + { + return (string) $a; + } + + /** + * Keeps the description. + */ + public function doBar(stdClass $o, ?Countable $c): void + { + } + + /** @param int $a the amount */ + public function withDescription(int $a): void + { + } + + public function nullDefault(?int $a = null): void + { + } + + public function variadic(string ...$parts): void + { + } + + public function explicitMixed(mixed $a): void + { + } + + public function callable(callable $cb): void + { + } + + public function returnStatic(): SameTypes + { + return $this; + } + + public function returnVoid(): void + { + } + +} + +final class MoreSpecificTypes +{ + + /** + * @param non-empty-string $s + * @param positive-int|null $i + * @return list + */ + public function doFoo(string $s, ?int $i): array + { + return []; + } + + /** + * @template T of object + * @param T $o + * @return T + */ + public function template(object $o): object + { + return $o; + } + + /** @return $this */ + public function returnThis(): static + { + return $this; + } + +} + +final class NotConvertible +{ + + /** + * @param resource $r + * @param int $byRef + * @param int $d + */ + public function doFoo($r, &$byRef, $d = 'foo', $noPhpDoc = 1): void + { + } + + /** @param string $name */ + public function __get($name) + { + return 1; + } + + /** @return string */ + public function __toString() + { + return ''; + } + +} + +class ParentClass +{ + + public function untyped($a) + { + return $a; + } + + public function typed(int $a): int + { + return $a; + } + + public function __construct($a) + { + } + + /** + * @return int + */ + public function overridable(int $a) + { + return $a; + } + + private function privateMethod(int $a): int + { + return $a; + } + + final public function finalMethod(int $a): int + { + return $a; + } + +} + +final class ChildClass extends ParentClass +{ + + /** + * @param int $a + */ + public function untyped($a): int + { + return $a; + } + + /** + * @param positive-int $a + * @return positive-int + */ + public function typed(int $a): int + { + return 1; + } + + public function __construct(int $a) + { + } + +} + +interface SomeInterface +{ + + /** + * @return int + */ + public function doFoo(int $a); + +} + +function doFoo(int $a): int +{ + return $a; +} + +final class Properties +{ + + private int $a = 1; + + private ?stdClass $nullable = null; + + /** @var non-empty-string */ + private string $moreSpecific = 'foo'; + + private stdClass $noDefault; + + /** @var stdClass */ + private static $staticNoDefault; + + private static ?stdClass $staticNullable = null; + + /** @var int */ + private $wrongDefault = 'foo'; + + /** @var int */ + private $b = 1, $c = 2; + + /** @var callable */ + private $callable; + + /** @var int the description */ + public int $withDescription = 1; + + public function __construct(stdClass $noDefault) + { + $this->noDefault = $noDefault; + } + +} + +class NonFinalProperties +{ + + private int $private = 1; + + /** @var int */ + protected $protected = 1; + +} + +final class PromotedProperties +{ + + public function __construct(private int $a) + { + } + +} + +class NonFinalPromotedProperties +{ + + /** + * @param int $b + */ + public function __construct(private int $a, public $b) + { + } + +} + +trait SomeTrait +{ + + /** @param int $a */ + public function doFoo($a): void + { + } + +} + +final class UsesTrait +{ + + use SomeTrait; + +} + +final class PromotedCallable +{ + + /** @param callable $cb */ + public function __construct(private $cb) + { + } + +} + +final class ExplicitMixedValueType +{ + + /** + * @param mixed[] $a + * @return array + */ + public function doFoo(array $a): array + { + return $a; + } + +} From e1a24b8be884a96aeeb8fc67030855f9ec81bfa2 Mon Sep 17 00:00:00 2001 From: "ondrej@mirtes.cz" Date: Mon, 9 Nov 2026 06:20:49 +0000 Subject: [PATCH 2/4] Declare native types from PHPDoc types Fixed by MissingNativeTypeRule, now registered in build/phpstan.neon. The turbo extension declarations are regenerated for the shadowed classes whose signatures changed. The native MutatingScope::pushInFunctionCall() declares the same parameter type as NodeCallbackScope's override, and the native IntegerRangeType::createAll*() accept only int|float like their twin. Amp-Thread-ID: https://ampcode.com/threads/T-01a1bed4-966e-7640-a834-06bba746e1f1 --- build/phpstan.neon | 1 + src/Analyser/ArgumentsHandler.php | 23 +- src/Analyser/CalledMethodProcessor.php | 2 +- src/Analyser/Error.php | 5 +- src/Analyser/Ignore/IgnoredError.php | 2 +- src/Analyser/ImpurePoint.php | 5 +- src/Analyser/InternalError.php | 5 +- src/Analyser/InternalThrowPoint.php | 5 +- src/Analyser/MutatingScope.php | 11 +- src/Analyser/NodeCallbackScope.php | 5 +- .../ResultCache/ResultCacheManager.php | 6 +- src/Analyser/Scope.php | 8 +- src/Analyser/StmtHandler/TraitUseHandler.php | 2 +- src/Analyser/ThrowPoint.php | 5 +- src/Analyser/VariableFlow.php | 3 +- src/Analyser/VariableLivenessResolver.php | 3 +- src/Analyser/VariableWriteOffset.php | 5 +- src/Cache/ArenaCache.php | 8 +- src/Cache/Cache.php | 8 +- src/Cache/CacheItem.php | 10 +- src/Cache/CacheStorage.php | 4 +- src/Cache/FileCacheStorage.php | 8 +- src/Cache/MemoryCacheStorage.php | 10 +- src/Collectors/CollectedData.php | 8 +- src/Collectors/CollectorWithPaths.php | 2 +- .../ExportedNode/ExportedAttributeNode.php | 5 +- .../ExportedClassConstantNode.php | 5 +- .../ExportedClassConstantsNode.php | 5 +- .../ExportedNode/ExportedClassNode.php | 5 +- .../ExportedNode/ExportedConstantNode.php | 5 +- .../ExportedNode/ExportedConstantsNode.php | 5 +- .../ExportedNode/ExportedEnumCaseNode.php | 5 +- .../ExportedNode/ExportedEnumNode.php | 5 +- .../ExportedNode/ExportedFunctionNode.php | 5 +- .../ExportedNode/ExportedInterfaceNode.php | 5 +- .../ExportedNode/ExportedMethodNode.php | 5 +- .../ExportedNode/ExportedParameterNode.php | 5 +- .../ExportedNode/ExportedPhpDocNode.php | 5 +- .../ExportedNode/ExportedPropertiesNode.php | 5 +- .../ExportedNode/ExportedPropertyHookNode.php | 5 +- .../ExportedNode/ExportedTraitNode.php | 5 +- .../ExportedTraitUseAdaptation.php | 5 +- .../AttributeServicesDirectoriesResolver.php | 3 +- .../AttributeServicesRegistrar.php | 7 +- .../BleedingEdgeToggle.php | 2 +- src/DependencyInjection/ContainerFactory.php | 6 +- .../MemoizingContainer.php | 6 +- .../Nette/NetteContainer.php | 12 +- .../ProjectConfigHelper.php | 3 +- src/Internal/Silencer.php | 2 +- src/Node/ClassPropertyNode.php | 5 +- src/Node/FunctionCallableNode.php | 5 +- src/Node/InstantiationCallableNode.php | 5 +- src/Node/Method/MethodCall.php | 5 +- src/Node/MethodCallableNode.php | 5 +- src/Node/Property/PropertyRead.php | 5 +- src/Node/Property/PropertyWrite.php | 5 +- src/Node/PropertyHookStatementNode.php | 5 +- src/Node/StaticMethodCallableNode.php | 10 +- src/Node/Variable/VariableWrite.php | 6 +- .../SourceLocator/CachingVisitor.php | 5 +- .../FileReadTrapStreamWrapper.php | 32 +- .../InitializerExprTypeResolver.php | 5 +- .../CollectedConstantConditionError.php | 2 +- .../ConstantConditionInTraitCollector.php | 4 +- ...FunctionCallConstantConditionCollector.php | 4 +- .../ImpossibleCheckTypeReportedCollector.php | 2 +- ...mpossibleCheckTypeStaticMethodCallRule.php | 3 +- ...onstructorWithoutImpurePointsCollector.php | 2 +- .../FunctionWithoutImpurePointsCollector.php | 2 +- .../MethodWithoutImpurePointsCollector.php | 2 +- .../PossiblyPureFuncCallCollector.php | 2 +- .../PossiblyPureMethodCallCollector.php | 2 +- .../DeadCode/PossiblyPureNewCollector.php | 2 +- .../PossiblyPureStaticCallCollector.php | 2 +- src/Rules/FunctionDefinitionCheck.php | 3 +- ...dArgumentParameterMethodCallsCollector.php | 2 +- ...rridingMethodRenamesParameterCollector.php | 2 +- src/Rules/Methods/StaticMethodCallCheck.php | 3 +- src/Rules/NonStringableDynamicAccessCheck.php | 7 +- src/Rules/Properties/PropertyDescriptor.php | 5 +- .../Properties/PropertyReflectionFinder.php | 12 +- .../Traits/TraitDeclarationCollector.php | 2 +- src/Rules/Whitespace/FileWhitespaceRule.php | 5 +- src/Testing/TypeInferenceTestCase.php | 3 +- src/Testing/functions.php | 16 +- src/Turbo/ForkedChild.php | 3 +- src/Type/Constant/ConstantArrayType.php | 5 +- src/Type/ConstantTypeHelper.php | 5 +- src/Type/FileTypeMapper.php | 2 +- .../UnresolvedTemplateArgumentType.php | 5 +- src/Type/IntegerRangeType.php | 16 +- src/Type/LateResolvableArrayShapeType.php | 5 +- src/Type/LateResolvableObjectShapeType.php | 5 +- src/Type/NativePhpTypeNodeHelper.php | 6 +- src/Type/ParserNodeTypeToPHPStanType.php | 5 +- .../BcMathStringOrNullReturnTypeExtension.php | 4 +- src/debugScope.php | 3 +- src/dumpType.php | 15 +- tests/PHPStan/Analyser/AnalyserTest.php | 2 +- tests/PHPStan/Analyser/AssertStubTest.php | 5 +- tests/PHPStan/Analyser/Bug10922Test.php | 5 +- tests/PHPStan/Analyser/Bug10980Test.php | 5 +- tests/PHPStan/Analyser/Bug11009Test.php | 5 +- tests/PHPStan/Analyser/Bug14446Test.php | 5 +- tests/PHPStan/Analyser/Bug15297Php73Test.php | 5 +- tests/PHPStan/Analyser/Bug9307Test.php | 5 +- .../Analyser/ClassConstantStubFileTest.php | 5 +- .../CollectedDataReuse/FirstCollector.php | 2 +- .../CollectedDataReuse/SecondCollector.php | 2 +- ...onditionalReturnTypeFromMethodStubTest.php | 5 +- .../DoNotPolluteScopeWithBlockTest.php | 5 +- ...memberPossiblyImpureFunctionValuesTest.php | 5 +- .../DynamicConstantsNativeTypesTest.php | 5 +- .../PHPStan/Analyser/DynamicConstantsTest.php | 5 +- .../DynamicMethodThrowTypeExtensionTest.php | 5 +- ...icReturnTypeExtensionTypeInferenceTest.php | 5 +- .../ExpressionTypeResolverExtensionTest.php | 5 +- ...losureSignatureFromUsagesToggleOffTest.php | 5 +- ...StaticVariablesFromUsagesToggleOffTest.php | 5 +- ...CalledFunctionWithoutImplicitThrowTest.php | 5 +- .../Analyser/LooseConstComparisonPhp7Test.php | 5 +- .../Analyser/LooseConstComparisonPhp8Test.php | 5 +- ...peSpecifyingExtensionTypeInferenceTest.php | 5 +- .../Analyser/ParamClosureThisStubsTest.php | 5 +- tests/PHPStan/Analyser/ParamOutTypeTest.php | 5 +- .../ParameterClosureThisExtensionTest.php | 5 +- ...rClosureTypeExtensionArrowFunctionTest.php | 5 +- .../ParameterClosureTypeExtensionTest.php | 5 +- .../ParameterOutTypeExtensionTest.php | 5 +- tests/PHPStan/Analyser/PathConstantsTest.php | 5 +- .../Analyser/ReflectionParameterPhp7Test.php | 5 +- ...tringKeyCastingDetectTypeInferenceTest.php | 5 +- ...ringKeyCastingPreventTypeInferenceTest.php | 5 +- ...hpVersionRangeReturnTypeExtensionsTest.php | 5 +- tests/PHPStan/Analyser/SubstrPhp7Test.php | 5 +- tests/PHPStan/Analyser/SubstrPhp8Test.php | 5 +- .../ThrowsTagFromNativeFunctionStubTest.php | 5 +- tests/PHPStan/Analyser/TraitStubFilesTest.php | 5 +- ...cifyingExtensionTypeInferenceFalseTest.php | 5 +- ...ecifyingExtensionTypeInferenceNullTest.php | 5 +- ...ecifyingExtensionTypeInferenceTrueTest.php | 5 +- ...peSpecifyingExtensionTypeInferenceTest.php | 5 +- .../PHPStan/Collectors/UniversalCollector.php | 6 +- ...edSubTypesClassReflectionExtensionTest.php | 5 +- ...ckedEnumFromParameterTypeToggleOffTest.php | 5 +- .../ReflectionProviderGoldenTest.php | 7 +- tests/PHPStan/Rules/UniversalRule.php | 6 +- .../Testing/TypeInferenceTestCaseTest.php | 5 +- tests/PHPStan/Tests/AssertionClass.php | 3 +- .../Type/Constant/ConstantArrayTypeTest.php | 6 +- tests/PHPStan/Type/FileTypeMapperTest.php | 10 +- turbo-ext/src/IntegerRangeType.cpp | 8 +- turbo-ext/src/MutatingScope.cpp | 3 +- turbo-ext/src/generated/ArenaCache.h | 4 +- turbo-ext/src/generated/ArgumentsHandler.h | 354 ++--- .../src/generated/CalledMethodProcessor.h | 21 +- turbo-ext/src/generated/ConstantArrayType.h | 97 +- turbo-ext/src/generated/ConstantTypeHelper.h | 2 +- turbo-ext/src/generated/ForkedChild.h | 7 +- turbo-ext/src/generated/ImpurePoint.h | 18 +- .../generated/InitializerExprTypeResolver.h | 259 ++-- turbo-ext/src/generated/IntegerRangeType.h | 8 +- turbo-ext/src/generated/InternalThrowPoint.h | 20 +- .../generated/LateResolvableArrayShapeType.h | 6 +- turbo-ext/src/generated/MutatingScope.h | 1306 +++++++++-------- turbo-ext/src/generated/NodeCallbackScope.h | 25 +- turbo-ext/src/generated/ThrowPoint.h | 20 +- turbo-ext/src/generated/TraitUseHandler.h | 21 +- .../UnresolvedTemplateArgumentType.h | 716 ++++----- turbo-ext/src/generated/VariableFlow.h | 2 +- .../src/generated/VariableLivenessResolver.h | 2 +- turbo-ext/src/generated/VariableWriteOffset.h | 6 +- 173 files changed, 1666 insertions(+), 2049 deletions(-) diff --git a/build/phpstan.neon b/build/phpstan.neon index 68f45008c4e..8ac6206fe4f 100644 --- a/build/phpstan.neon +++ b/build/phpstan.neon @@ -240,6 +240,7 @@ rules: - PHPStan\Build\MemoizationPropertyRule - PHPStan\Build\OrChainIdenticalComparisonToInArrayRule - PHPStan\Build\NoPhpVersionInjectionInScopeAwareExtensionRule + - PHPStan\Build\MissingNativeTypeRule services: - diff --git a/src/Analyser/ArgumentsHandler.php b/src/Analyser/ArgumentsHandler.php index 12c8c49a665..aab4f5f2c5b 100644 --- a/src/Analyser/ArgumentsHandler.php +++ b/src/Analyser/ArgumentsHandler.php @@ -126,7 +126,6 @@ public function __construct( } /** - * @param MethodReflection|FunctionReflection|null $calleeReflection * @param ParametersAcceptor[] $parametersAcceptors * @param ParametersAcceptor[]|null $namedArgumentsVariants * @param callable(Node $node, Scope $scope): void $nodeCallback @@ -135,7 +134,7 @@ public function __construct( public function processArgs( NodeScopeResolver $nodeScopeResolver, Node\Stmt $stmt, - $calleeReflection, + MethodReflection|FunctionReflection|null $calleeReflection, ?ExtendedMethodReflection $nakedMethodReflection, array $parametersAcceptors, ?array $namedArgumentsVariants, @@ -1096,10 +1095,7 @@ public function processDroppedArgs( } } - /** - * @param MethodReflection|FunctionReflection|null $calleeReflection - */ - private function callCallbackImmediately(?ParameterReflection $parameter, ?Type $parameterType, $calleeReflection): bool + private function callCallbackImmediately(?ParameterReflection $parameter, ?Type $parameterType, MethodReflection|FunctionReflection|null $calleeReflection): bool { $parameterCallableType = null; if ($parameterType !== null && $calleeReflection instanceof FunctionReflection) { @@ -1135,10 +1131,7 @@ private function shouldInvalidateCallbackExpressions(?ParameterReflection $param return true; } - /** - * @param MethodReflection|FunctionReflection|null $calleeReflection - */ - private function getParameterTypeFromParameterClosureTypeExtension(CallLike $callLike, $calleeReflection, ParameterReflection $parameter, MutatingScope $scope): ?Type + private function getParameterTypeFromParameterClosureTypeExtension(CallLike $callLike, MethodReflection|FunctionReflection|null $calleeReflection, ParameterReflection $parameter, MutatingScope $scope): ?Type { if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { foreach ($this->functionParameterClosureTypeExtensions->getAll() as $functionParameterClosureTypeExtension) { @@ -1176,10 +1169,7 @@ private function getParameterTypeFromParameterClosureTypeExtension(CallLike $cal return null; } - /** - * @param MethodReflection|FunctionReflection|null $calleeReflection - */ - private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflection, ParameterReflection $currentParameter, MutatingScope $scope): ?Type + private function getParameterOutExtensionsType(CallLike $callLike, MethodReflection|FunctionReflection|null $calleeReflection, ParameterReflection $currentParameter, MutatingScope $scope): ?Type { $paramOutTypes = []; if ($callLike instanceof FuncCall && $calleeReflection instanceof FunctionReflection) { @@ -1231,12 +1221,9 @@ private function getParameterOutExtensionsType(CallLike $callLike, $calleeReflec return null; } - /** - * @param FunctionReflection|MethodReflection|null $calleeReflection - */ private function resolveClosureThisType( ?CallLike $call, - $calleeReflection, + FunctionReflection|MethodReflection|null $calleeReflection, ParameterReflection $parameter, MutatingScope $scope, ): ?Type diff --git a/src/Analyser/CalledMethodProcessor.php b/src/Analyser/CalledMethodProcessor.php index 0b42b79de7a..1738c3db320 100644 --- a/src/Analyser/CalledMethodProcessor.php +++ b/src/Analyser/CalledMethodProcessor.php @@ -130,7 +130,7 @@ public function clearCalledMethodResults(): void * @param Node[]|Node|scalar|null $node * @param callable(Node $node, Scope $scope): void $nodeCallback */ - private function processNodesForCalledMethod(NodeScopeResolver $nodeScopeResolver, $node, ExpressionResultStorage $storage, string $fileName, MethodReflection $methodReflection, callable $nodeCallback): void + private function processNodesForCalledMethod(NodeScopeResolver $nodeScopeResolver, Node|int|float|string|bool|array|null $node, ExpressionResultStorage $storage, string $fileName, MethodReflection $methodReflection, callable $nodeCallback): void { if ($node instanceof Node) { $declaringClass = $methodReflection->getDeclaringClass(); diff --git a/src/Analyser/Error.php b/src/Analyser/Error.php index b7ba807a7fe..2ed1201796c 100644 --- a/src/Analyser/Error.php +++ b/src/Analyser/Error.php @@ -417,12 +417,9 @@ private function renameFixedFile(string $oldFile, string $newFile): array ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'message' => $this->message, diff --git a/src/Analyser/Ignore/IgnoredError.php b/src/Analyser/Ignore/IgnoredError.php index 9476547059d..589c50da7fb 100644 --- a/src/Analyser/Ignore/IgnoredError.php +++ b/src/Analyser/Ignore/IgnoredError.php @@ -36,7 +36,7 @@ public static function getIgnoredErrorLabel(array|string $ignoredError): string * @param mixed[]|string $ignoredError * @return string Representation of the ignored error */ - public static function stringifyPattern($ignoredError): string + public static function stringifyPattern(string|array $ignoredError): string { if (!is_array($ignoredError)) { return $ignoredError; diff --git a/src/Analyser/ImpurePoint.php b/src/Analyser/ImpurePoint.php index 04e25571d63..40190ae2422 100644 --- a/src/Analyser/ImpurePoint.php +++ b/src/Analyser/ImpurePoint.php @@ -33,10 +33,7 @@ public function getScope(): Scope return $this->scope; } - /** - * @return Node\Expr|Node\Stmt|VirtualNode - */ - public function getNode() + public function getNode(): Node\Expr|Node\Stmt|VirtualNode { return $this->node; } diff --git a/src/Analyser/InternalError.php b/src/Analyser/InternalError.php index 6aaad7240d6..c28f5688442 100644 --- a/src/Analyser/InternalError.php +++ b/src/Analyser/InternalError.php @@ -87,12 +87,9 @@ public static function decode(array $json): self return new self($json['message'], $json['contextDescription'], $json['trace'], $json['traceAsString'], $json['shouldReportBug']); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'message' => $this->message, diff --git a/src/Analyser/InternalThrowPoint.php b/src/Analyser/InternalThrowPoint.php index 17d03489df3..f16a60bcc93 100644 --- a/src/Analyser/InternalThrowPoint.php +++ b/src/Analyser/InternalThrowPoint.php @@ -71,10 +71,7 @@ public function getType(): Type return $this->type; } - /** - * @return Node\Expr|Node\Stmt - */ - public function getNode() + public function getNode(): Node\Expr|Node\Stmt { return $this->node; } diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php index c7319e2bb99..aca57a7708c 100644 --- a/src/Analyser/MutatingScope.php +++ b/src/Analyser/MutatingScope.php @@ -1690,9 +1690,8 @@ public function resolveTypeByName(Name $name): TypeWithClassName /** * @api - * @param mixed $value */ - public function getTypeFromValue($value): Type + public function getTypeFromValue(mixed $value): Type { return ConstantTypeHelper::getTypeFromValue($value); } @@ -1716,10 +1715,7 @@ public function getTrackedExpressionType(Expr $node): Type return $this->expressionTypes[$this->getNodeKey($node)]->getType(); } - /** - * @param MethodReflection|FunctionReflection|null $reflection - */ - public function pushInFunctionCall($reflection, ?ParameterReflection $parameter, bool $rememberTypes): self + public function pushInFunctionCall(MethodReflection|FunctionReflection|null $reflection, ?ParameterReflection $parameter, bool $rememberTypes): self { $stack = $this->inFunctionCallsStack; $stack[] = [$reflection, $parameter]; @@ -2769,9 +2765,8 @@ public function isParameterValueNullable(Node\Param $parameter): bool /** * @api - * @param Node\Name|Node\Identifier|Node\ComplexType|null $type */ - public function getFunctionType($type, bool $isNullable, bool $isVariadic): Type + public function getFunctionType(Name|Identifier|ComplexType|null $type, bool $isNullable, bool $isVariadic): Type { if ($isVariadic) { if (!$this->getPhpVersion()->supportsNamedArguments()->no()) { diff --git a/src/Analyser/NodeCallbackScope.php b/src/Analyser/NodeCallbackScope.php index 689b7241cb6..872a2e58ece 100644 --- a/src/Analyser/NodeCallbackScope.php +++ b/src/Analyser/NodeCallbackScope.php @@ -271,10 +271,7 @@ private function preprocessScope(MutatingScope $scope): Scope return $scope; } - /** - * @param MethodReflection|FunctionReflection|null $reflection - */ - public function pushInFunctionCall($reflection, ?ParameterReflection $parameter, bool $rememberTypes): self + public function pushInFunctionCall(MethodReflection|FunctionReflection|null $reflection, ?ParameterReflection $parameter, bool $rememberTypes): self { /** @var self $scope */ $scope = parent::pushInFunctionCall($reflection, $parameter, $rememberTypes); diff --git a/src/Analyser/ResultCache/ResultCacheManager.php b/src/Analyser/ResultCache/ResultCacheManager.php index 0c803ff8ee4..2221f0fd48c 100644 --- a/src/Analyser/ResultCache/ResultCacheManager.php +++ b/src/Analyser/ResultCache/ResultCacheManager.php @@ -1853,10 +1853,9 @@ private function encodeValueDependencies(array $valueDependencies, ResultCachePa } /** - * @param mixed $encoded * @return list, declarations: list}> */ - private function decodeValueDependencies($encoded, ResultCachePathTransformer $transformer): array + private function decodeValueDependencies(mixed $encoded, ResultCachePathTransformer $transformer): array { if (!is_array($encoded) || !is_array($encoded['paths'] ?? null) || !is_array($encoded['entries'] ?? null)) { throw new RuntimeException('The value dependencies are malformed.'); @@ -2326,10 +2325,9 @@ private function encodeDependencyGraph(array $invertedDependencies, ResultCacheP } /** - * @param mixed $dependencyGraph * @return array, usedTraitDependentFiles?: list}> */ - private function decodeDependencyGraph($dependencyGraph, ResultCachePathTransformer $transformer): array + private function decodeDependencyGraph(mixed $dependencyGraph, ResultCachePathTransformer $transformer): array { if (!is_array($dependencyGraph) || !is_array($dependencyGraph['paths'] ?? null) || !is_array($dependencyGraph['entries'] ?? null)) { throw new RuntimeException('The dependency graph is malformed.'); diff --git a/src/Analyser/Scope.php b/src/Analyser/Scope.php index dfe3b864ce9..f8c07cdf3c1 100644 --- a/src/Analyser/Scope.php +++ b/src/Analyser/Scope.php @@ -197,10 +197,8 @@ public function resolveTypeByName(Name $name): TypeWithClassName; * Converts runtime PHP values to their corresponding constant types: * integers become ConstantIntegerType, strings become ConstantStringType, * arrays become ConstantArrayType (if small enough), etc. - * - * @param mixed $value */ - public function getTypeFromValue($value): Type; + public function getTypeFromValue(mixed $value): Type; /** * Returns whether an expression has a tracked type in this scope. @@ -276,10 +274,8 @@ public function isParameterValueNullable(Param $parameter): bool; * Handles named types, identifier types (int, string, etc.), union types, * intersection types, and nullable types. The $isNullable flag adds null * to the type, and $isVariadic wraps the type in an array. - * - * @param Node\Name|Node\Identifier|Node\ComplexType|null $type */ - public function getFunctionType($type, bool $isNullable, bool $isVariadic): Type; + public function getFunctionType(Name|Node\Identifier|Node\ComplexType|null $type, bool $isNullable, bool $isVariadic): Type; /** * Returns whether the given expression is currently being assigned to. diff --git a/src/Analyser/StmtHandler/TraitUseHandler.php b/src/Analyser/StmtHandler/TraitUseHandler.php index 9630ba19ff7..f3aa01cf80c 100644 --- a/src/Analyser/StmtHandler/TraitUseHandler.php +++ b/src/Analyser/StmtHandler/TraitUseHandler.php @@ -170,7 +170,7 @@ private function processTraitUse(NodeScopeResolver $nodeScopeResolver, Node\Stmt * @param callable(Node $node, Scope $scope): void $nodeCallback * @param list $dependencies what the walked trait statements depend on */ - private function processNodesForTraitUse(NodeScopeResolver $nodeScopeResolver, $node, ClassReflection $traitReflection, MutatingScope $scope, ExpressionResultStorage $storage, array $adaptations, callable $nodeCallback, array &$dependencies): void + private function processNodesForTraitUse(NodeScopeResolver $nodeScopeResolver, Node|int|float|string|bool|array|null $node, ClassReflection $traitReflection, MutatingScope $scope, ExpressionResultStorage $storage, array $adaptations, callable $nodeCallback, array &$dependencies): void { if ($node instanceof Node) { if ($node instanceof Node\Stmt\Trait_ && $traitReflection->getName() === (string) $node->namespacedName && $traitReflection->getNativeReflection()->getStartLine() === $node->getStartLine()) { diff --git a/src/Analyser/ThrowPoint.php b/src/Analyser/ThrowPoint.php index dc5bcf462f9..5e2ee1965f0 100644 --- a/src/Analyser/ThrowPoint.php +++ b/src/Analyser/ThrowPoint.php @@ -55,10 +55,7 @@ public function getType(): Type return $this->type; } - /** - * @return Node\Expr|Node\Stmt - */ - public function getNode() + public function getNode(): Node\Expr|Node\Stmt { return $this->node; } diff --git a/src/Analyser/VariableFlow.php b/src/Analyser/VariableFlow.php index 158d1ec2305..7f9456b8638 100644 --- a/src/Analyser/VariableFlow.php +++ b/src/Analyser/VariableFlow.php @@ -83,8 +83,7 @@ public static function arrow(ArrowFunction $arrow, ?self $body, ?self $outputs): return new VariableControlFlow(self::ARROW, [$body, $outputs], arrow: $arrow); } - /** @param int|string|null $offset */ - public static function read(string $name, ?int $targetId = null, bool $container = false, $offset = null): ?self + public static function read(string $name, ?int $targetId = null, bool $container = false, int|string|null $offset = null): ?self { if ($name === 'this' || in_array($name, Scope::SUPERGLOBAL_VARIABLES, true)) { return null; diff --git a/src/Analyser/VariableLivenessResolver.php b/src/Analyser/VariableLivenessResolver.php index 24225d45efa..caffe6b4850 100644 --- a/src/Analyser/VariableLivenessResolver.php +++ b/src/Analyser/VariableLivenessResolver.php @@ -489,8 +489,7 @@ private function passBindingProbes(array $next, string $name, ?VariableWrite $wr return $next; } - /** @param int|string $offset */ - private static function offsetKey($offset): string + private static function offsetKey(int|string $offset): string { return (is_int($offset) ? 'i:' : 's:') . $offset; } diff --git a/src/Analyser/VariableWriteOffset.php b/src/Analyser/VariableWriteOffset.php index 1263adbabca..6405e5e82ed 100644 --- a/src/Analyser/VariableWriteOffset.php +++ b/src/Analyser/VariableWriteOffset.php @@ -17,10 +17,7 @@ final class VariableWriteOffset { - /** - * @return int|string|null - */ - public static function fromType(Type $dimType) + public static function fromType(Type $dimType): int|string|null { $keyType = $dimType->toArrayKey(); if (!$keyType->isConstantScalarValue()->yes()) { diff --git a/src/Cache/ArenaCache.php b/src/Cache/ArenaCache.php index fbe7ebea16d..39e76672e6f 100644 --- a/src/Cache/ArenaCache.php +++ b/src/Cache/ArenaCache.php @@ -61,20 +61,16 @@ public static function lookup(string $key): mixed /** * Publishes the value unless the key already has one - the first publish wins. - * - * @param mixed $value */ - public static function publish(string $key, $value): void + public static function publish(string $key, mixed $value): void { } /** * Publishes the value in place of the one the key has - for a value just * computed because the published one was out of date. - * - * @param mixed $value */ - public static function replace(string $key, $value): void + public static function replace(string $key, mixed $value): void { } diff --git a/src/Cache/Cache.php b/src/Cache/Cache.php index 697df298015..645bdbedbf7 100644 --- a/src/Cache/Cache.php +++ b/src/Cache/Cache.php @@ -20,10 +20,8 @@ public function __construct( /** * @param non-empty-string $key - * - * @return mixed|null */ - public function load(string $key, string $variableKey) + public function load(string $key, string $variableKey): mixed { // Every entry is also shared across the run's parallel workers // through the shared-memory arena (turbo extension only; the seam is @@ -58,10 +56,8 @@ public function load(string $key, string $variableKey) /** * @param non-empty-string $key - * - * @param mixed $data */ - public function save(string $key, string $variableKey, $data): void + public function save(string $key, string $variableKey, mixed $data): void { $this->storage->save($key, $variableKey, $data); diff --git a/src/Cache/CacheItem.php b/src/Cache/CacheItem.php index 101bbfe2fd3..d6277f04aa6 100644 --- a/src/Cache/CacheItem.php +++ b/src/Cache/CacheItem.php @@ -5,10 +5,7 @@ final class CacheItem { - /** - * @param mixed $data - */ - public function __construct(private string $variableKey, private $data) + public function __construct(private string $variableKey, private mixed $data) { } @@ -17,10 +14,7 @@ public function isVariableKeyValid(string $variableKey): bool return $this->variableKey === $variableKey; } - /** - * @return mixed - */ - public function getData() + public function getData(): mixed { return $this->data; } diff --git a/src/Cache/CacheStorage.php b/src/Cache/CacheStorage.php index 4ac0a3dd877..4898daf9adc 100644 --- a/src/Cache/CacheStorage.php +++ b/src/Cache/CacheStorage.php @@ -14,9 +14,7 @@ public function load(string $key, string $variableKey); /** * @param non-empty-string $key - * - * @param mixed $data */ - public function save(string $key, string $variableKey, $data): void; + public function save(string $key, string $variableKey, mixed $data): void; } diff --git a/src/Cache/FileCacheStorage.php b/src/Cache/FileCacheStorage.php index 14323acbebb..de73b72e9c1 100644 --- a/src/Cache/FileCacheStorage.php +++ b/src/Cache/FileCacheStorage.php @@ -53,10 +53,7 @@ public function __construct(private string $directory) { } - /** - * @return mixed|null - */ - public function load(string $key, string $variableKey) + public function load(string $key, string $variableKey): mixed { [,, $filePath] = $this->getFilePaths($key); @@ -88,10 +85,9 @@ public function load(string $key, string $variableKey) } /** - * @param mixed $data * @throws DirectoryCreatorException */ - public function save(string $key, string $variableKey, $data): void + public function save(string $key, string $variableKey, mixed $data): void { [$firstDirectory, $secondDirectory, $path] = $this->getFilePaths($key); DirectoryCreator::ensureDirectoryExists($this->directory, 0777); diff --git a/src/Cache/MemoryCacheStorage.php b/src/Cache/MemoryCacheStorage.php index 51319426060..b3466d7ee1e 100644 --- a/src/Cache/MemoryCacheStorage.php +++ b/src/Cache/MemoryCacheStorage.php @@ -8,10 +8,7 @@ final class MemoryCacheStorage implements CacheStorage /** @var array */ private array $storage = []; - /** - * @return mixed|null - */ - public function load(string $key, string $variableKey) + public function load(string $key, string $variableKey): mixed { if (!isset($this->storage[$key])) { return null; @@ -25,10 +22,7 @@ public function load(string $key, string $variableKey) return $item->getData(); } - /** - * @param mixed $data - */ - public function save(string $key, string $variableKey, $data): void + public function save(string $key, string $variableKey, mixed $data): void { $this->storage[$key] = new CacheItem($variableKey, $data); } diff --git a/src/Collectors/CollectedData.php b/src/Collectors/CollectedData.php index ae13a94614c..a6e9c90a123 100644 --- a/src/Collectors/CollectedData.php +++ b/src/Collectors/CollectedData.php @@ -16,11 +16,10 @@ final class CollectedData implements JsonSerializable { /** - * @param mixed $data * @param class-string> $collectorType */ public function __construct( - private $data, + private mixed $data, private string $filePath, private string $collectorType, ) @@ -50,12 +49,9 @@ public function getCollectorType(): string return $this->collectorType; } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'data' => $this->data, diff --git a/src/Collectors/CollectorWithPaths.php b/src/Collectors/CollectorWithPaths.php index 48ca89d7a0f..65ee1a57d9e 100644 --- a/src/Collectors/CollectorWithPaths.php +++ b/src/Collectors/CollectorWithPaths.php @@ -32,6 +32,6 @@ interface CollectorWithPaths extends Collector * @param callable(string): string $transformPath * @return TValue */ - public static function transformCollectedDataPaths($data, callable $transformPath); + public static function transformCollectedDataPaths(mixed $data, callable $transformPath); } diff --git a/src/Dependency/ExportedNode/ExportedAttributeNode.php b/src/Dependency/ExportedNode/ExportedAttributeNode.php index 602b1e0eec3..4cff4146356 100644 --- a/src/Dependency/ExportedNode/ExportedAttributeNode.php +++ b/src/Dependency/ExportedNode/ExportedAttributeNode.php @@ -56,12 +56,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedClassConstantNode.php b/src/Dependency/ExportedNode/ExportedClassConstantNode.php index 7fbf694dcd6..26406676049 100644 --- a/src/Dependency/ExportedNode/ExportedClassConstantNode.php +++ b/src/Dependency/ExportedNode/ExportedClassConstantNode.php @@ -74,12 +74,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedClassConstantsNode.php b/src/Dependency/ExportedNode/ExportedClassConstantsNode.php index 1cd399522ab..576c647f269 100644 --- a/src/Dependency/ExportedNode/ExportedClassConstantsNode.php +++ b/src/Dependency/ExportedNode/ExportedClassConstantsNode.php @@ -87,12 +87,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedClassNode.php b/src/Dependency/ExportedNode/ExportedClassNode.php index 828f836db9f..38f3dec2737 100644 --- a/src/Dependency/ExportedNode/ExportedClassNode.php +++ b/src/Dependency/ExportedNode/ExportedClassNode.php @@ -115,12 +115,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedConstantNode.php b/src/Dependency/ExportedNode/ExportedConstantNode.php index df7b0a90aa9..01597f06c09 100644 --- a/src/Dependency/ExportedNode/ExportedConstantNode.php +++ b/src/Dependency/ExportedNode/ExportedConstantNode.php @@ -52,12 +52,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedConstantsNode.php b/src/Dependency/ExportedNode/ExportedConstantsNode.php index 8fb0271e528..e7d6e0feb05 100644 --- a/src/Dependency/ExportedNode/ExportedConstantsNode.php +++ b/src/Dependency/ExportedNode/ExportedConstantsNode.php @@ -77,12 +77,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedEnumCaseNode.php b/src/Dependency/ExportedNode/ExportedEnumCaseNode.php index 71f8d82b47c..616e09916b9 100644 --- a/src/Dependency/ExportedNode/ExportedEnumCaseNode.php +++ b/src/Dependency/ExportedNode/ExportedEnumCaseNode.php @@ -61,12 +61,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedEnumNode.php b/src/Dependency/ExportedNode/ExportedEnumNode.php index 447de77bb95..3395d6db9ec 100644 --- a/src/Dependency/ExportedNode/ExportedEnumNode.php +++ b/src/Dependency/ExportedNode/ExportedEnumNode.php @@ -91,12 +91,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedFunctionNode.php b/src/Dependency/ExportedNode/ExportedFunctionNode.php index c3bdc5c65ee..0f69c715e3a 100644 --- a/src/Dependency/ExportedNode/ExportedFunctionNode.php +++ b/src/Dependency/ExportedNode/ExportedFunctionNode.php @@ -89,12 +89,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedInterfaceNode.php b/src/Dependency/ExportedNode/ExportedInterfaceNode.php index b738a2b258d..efbc91929d1 100644 --- a/src/Dependency/ExportedNode/ExportedInterfaceNode.php +++ b/src/Dependency/ExportedNode/ExportedInterfaceNode.php @@ -69,12 +69,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedMethodNode.php b/src/Dependency/ExportedNode/ExportedMethodNode.php index 3232ae2025b..74261d9b22d 100644 --- a/src/Dependency/ExportedNode/ExportedMethodNode.php +++ b/src/Dependency/ExportedNode/ExportedMethodNode.php @@ -103,12 +103,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedParameterNode.php b/src/Dependency/ExportedNode/ExportedParameterNode.php index 666b29ec8e9..256fb5f9c7d 100644 --- a/src/Dependency/ExportedNode/ExportedParameterNode.php +++ b/src/Dependency/ExportedNode/ExportedParameterNode.php @@ -83,12 +83,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedPhpDocNode.php b/src/Dependency/ExportedNode/ExportedPhpDocNode.php index 29f18758053..eb39c2ab894 100644 --- a/src/Dependency/ExportedNode/ExportedPhpDocNode.php +++ b/src/Dependency/ExportedNode/ExportedPhpDocNode.php @@ -30,12 +30,9 @@ public function equals(ExportedNode $node): bool && $this->namespaceUses->equals($node->namespaceUses); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedPropertiesNode.php b/src/Dependency/ExportedNode/ExportedPropertiesNode.php index 0c49e3ed3df..d6f1fdf8102 100644 --- a/src/Dependency/ExportedNode/ExportedPropertiesNode.php +++ b/src/Dependency/ExportedNode/ExportedPropertiesNode.php @@ -158,12 +158,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedPropertyHookNode.php b/src/Dependency/ExportedNode/ExportedPropertyHookNode.php index 65f1d689373..b467cc63f4c 100644 --- a/src/Dependency/ExportedNode/ExportedPropertyHookNode.php +++ b/src/Dependency/ExportedNode/ExportedPropertyHookNode.php @@ -94,12 +94,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedTraitNode.php b/src/Dependency/ExportedNode/ExportedTraitNode.php index e48e889d57f..037688ff06b 100644 --- a/src/Dependency/ExportedNode/ExportedTraitNode.php +++ b/src/Dependency/ExportedNode/ExportedTraitNode.php @@ -102,12 +102,9 @@ public static function __set_state(array $properties): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/Dependency/ExportedNode/ExportedTraitUseAdaptation.php b/src/Dependency/ExportedNode/ExportedTraitUseAdaptation.php index afdcb0a7982..2314a95e927 100644 --- a/src/Dependency/ExportedNode/ExportedTraitUseAdaptation.php +++ b/src/Dependency/ExportedNode/ExportedTraitUseAdaptation.php @@ -87,12 +87,9 @@ public static function decode(array $data, ExportedNodeDecoder $decoder): self ); } - /** - * @return mixed - */ #[ReturnTypeWillChange] #[Override] - public function jsonSerialize() + public function jsonSerialize(): mixed { return [ 'type' => self::class, diff --git a/src/DependencyInjection/AttributeServices/AttributeServicesDirectoriesResolver.php b/src/DependencyInjection/AttributeServices/AttributeServicesDirectoriesResolver.php index 3107294fc34..ab57dd42f7d 100644 --- a/src/DependencyInjection/AttributeServices/AttributeServicesDirectoriesResolver.php +++ b/src/DependencyInjection/AttributeServices/AttributeServicesDirectoriesResolver.php @@ -56,10 +56,9 @@ public function __construct( } /** - * @param mixed $rawSectionValue * @throws InvalidAttributeServicesDirectoriesException */ - public function resolve($rawSectionValue): ResolvedAttributeServicesDirectories + public function resolve(mixed $rawSectionValue): ResolvedAttributeServicesDirectories { if ($rawSectionValue === null || $rawSectionValue === []) { return ResolvedAttributeServicesDirectories::createEmpty(); diff --git a/src/DependencyInjection/AttributeServices/AttributeServicesRegistrar.php b/src/DependencyInjection/AttributeServices/AttributeServicesRegistrar.php index 1b39c02ace9..897e62579bd 100644 --- a/src/DependencyInjection/AttributeServices/AttributeServicesRegistrar.php +++ b/src/DependencyInjection/AttributeServices/AttributeServicesRegistrar.php @@ -267,10 +267,8 @@ private static function createFactory(string $factory): Statement * `Class::CONST`, `::CONST`, `Enum::Case` and `@service` strings into constants and references, * also inside the value of a referenced parameter. A parameter with such strings is inlined * like Nette does in NEON, other parameters are looked up at runtime. - * - * @return mixed */ - private static function createArgument(ContainerBuilder $builder, string $ref) + private static function createArgument(ContainerBuilder $builder, string $ref): mixed { $deferred = self::createDeferredParameter($builder, $ref); if (is_string($deferred)) { @@ -309,10 +307,9 @@ private static function isFiltered(mixed $value, mixed $filtered): bool * `%foo.bar%` becomes `$this->getParameter('foo')['bar']` and `%foo%/suffix` becomes a concatenation, * mirroring how Nette itself compiles references to dynamic parameters. * - * @return PhpLiteral|string * @throws ShouldNotHappenException when the reference points at a parameter that does not exist */ - private static function createDeferredParameter(ContainerBuilder $builder, string $ref) + private static function createDeferredParameter(ContainerBuilder $builder, string $ref): PhpLiteral|string { $parts = preg_split('#%([\w.-]*)%#', $ref, flags: PREG_SPLIT_DELIM_CAPTURE); if ($parts === false) { diff --git a/src/DependencyInjection/BleedingEdgeToggle.php b/src/DependencyInjection/BleedingEdgeToggle.php index 0c3792fbdac..c0ab606989e 100644 --- a/src/DependencyInjection/BleedingEdgeToggle.php +++ b/src/DependencyInjection/BleedingEdgeToggle.php @@ -33,7 +33,7 @@ public static function setBleedingEdge(bool $bleedingEdge): void * @param callable(): T $callback * @return T */ - public static function withBleedingEdge(bool $bleedingEdge, callable $callback) + public static function withBleedingEdge(bool $bleedingEdge, callable $callback): mixed { $backup = self::$bleedingEdge; self::$bleedingEdge = $bleedingEdge; diff --git a/src/DependencyInjection/ContainerFactory.php b/src/DependencyInjection/ContainerFactory.php index 0a069d9ca7b..93a2eea7e29 100644 --- a/src/DependencyInjection/ContainerFactory.php +++ b/src/DependencyInjection/ContainerFactory.php @@ -432,11 +432,7 @@ private function processSchema(array $statements, bool $required = true): Schema return $parameterSchema; } - /** - * @param mixed $argument - * @return mixed - */ - private function processArgument($argument, bool $required = true) + private function processArgument(mixed $argument, bool $required = true): mixed { if ($argument instanceof Statement) { if ($argument->entity === 'schema') { diff --git a/src/DependencyInjection/MemoizingContainer.php b/src/DependencyInjection/MemoizingContainer.php index 643f4b3687c..d1d64e869d9 100644 --- a/src/DependencyInjection/MemoizingContainer.php +++ b/src/DependencyInjection/MemoizingContainer.php @@ -30,12 +30,12 @@ public function hasService(string $serviceName): bool return $this->originalContainer->hasService($serviceName); } - public function getService(string $serviceName) + public function getService(string $serviceName): mixed { return $this->servicesByName[$serviceName] ??= $this->originalContainer->getService($serviceName); } - public function getByType(string $className) + public function getByType(string $className): object { return $this->servicesByType[$className] ??= $this->originalContainer->getByType($className); } @@ -71,7 +71,7 @@ public function hasParameter(string $parameterName): bool return $this->originalContainer->hasParameter($parameterName); } - public function getParameter(string $parameterName) + public function getParameter(string $parameterName): mixed { return $this->originalContainer->getParameter($parameterName); } diff --git a/src/DependencyInjection/Nette/NetteContainer.php b/src/DependencyInjection/Nette/NetteContainer.php index c0f48b8a689..958dd9b94ad 100644 --- a/src/DependencyInjection/Nette/NetteContainer.php +++ b/src/DependencyInjection/Nette/NetteContainer.php @@ -34,10 +34,7 @@ public function hasService(string $serviceName): bool return $this->container->hasService($serviceName); } - /** - * @return mixed - */ - public function getService(string $serviceName) + public function getService(string $serviceName): mixed { try { return $this->container->getService($serviceName); @@ -51,7 +48,7 @@ public function getService(string $serviceName) * @param class-string $className * @return T */ - public function getByType(string $className) + public function getByType(string $className): object { try { return $this->container->getByType($className); @@ -108,10 +105,7 @@ public function hasParameter(string $parameterName): bool return array_key_exists($parameterName, $parameters); } - /** - * @return mixed - */ - public function getParameter(string $parameterName) + public function getParameter(string $parameterName): mixed { $parameters = $this->parameters ??= $this->container->getParameters(); diff --git a/src/DependencyInjection/ProjectConfigHelper.php b/src/DependencyInjection/ProjectConfigHelper.php index 47e84813998..67c7d98bded 100644 --- a/src/DependencyInjection/ProjectConfigHelper.php +++ b/src/DependencyInjection/ProjectConfigHelper.php @@ -42,10 +42,9 @@ public static function getServiceClassNames(array $projectConfig): array } /** - * @param mixed $definition * @return string[] */ - private static function getClassesFromConfigDefinition($definition): array + private static function getClassesFromConfigDefinition(mixed $definition): array { if (is_string($definition)) { return [$definition]; diff --git a/src/Internal/Silencer.php b/src/Internal/Silencer.php index 715e8fcd5f7..8ac1ec58ca7 100644 --- a/src/Internal/Silencer.php +++ b/src/Internal/Silencer.php @@ -27,7 +27,7 @@ final class Silencer * @param Closure(): T $callback * @return T */ - public static function call(Closure $callback) + public static function call(Closure $callback): mixed { set_error_handler(static fn (): bool => true); diff --git a/src/Node/ClassPropertyNode.php b/src/Node/ClassPropertyNode.php index 6e69c0cc0ff..0d853815894 100644 --- a/src/Node/ClassPropertyNode.php +++ b/src/Node/ClassPropertyNode.php @@ -153,10 +153,7 @@ public function getNativeType(): ?Type return $this->type; } - /** - * @return Node\Identifier|Node\Name|Node\ComplexType|null - */ - public function getNativeTypeNode() + public function getNativeTypeNode(): Node\Identifier|Node\Name|Node\ComplexType|null { return $this->originalNode->type; } diff --git a/src/Node/FunctionCallableNode.php b/src/Node/FunctionCallableNode.php index ac74cc15545..1164640ea66 100644 --- a/src/Node/FunctionCallableNode.php +++ b/src/Node/FunctionCallableNode.php @@ -23,10 +23,7 @@ public function __construct(private Name|Expr $name, private Expr\FuncCall $orig parent::__construct($attributes); } - /** - * @return Expr|Name - */ - public function getName() + public function getName(): Expr|Name { return $this->name; } diff --git a/src/Node/InstantiationCallableNode.php b/src/Node/InstantiationCallableNode.php index 83e3d64c800..b4c302fd593 100644 --- a/src/Node/InstantiationCallableNode.php +++ b/src/Node/InstantiationCallableNode.php @@ -23,10 +23,7 @@ public function __construct(private Name|Expr $class, private Expr\New_ $origina parent::__construct($attributes); } - /** - * @return Expr|Name - */ - public function getClass() + public function getClass(): Expr|Name { return $this->class; } diff --git a/src/Node/Method/MethodCall.php b/src/Node/Method/MethodCall.php index c93fa1441a3..d9f417f8697 100644 --- a/src/Node/Method/MethodCall.php +++ b/src/Node/Method/MethodCall.php @@ -22,10 +22,7 @@ public function __construct( { } - /** - * @return Node\Expr\MethodCall|StaticCall|Array_ - */ - public function getNode() + public function getNode(): Node\Expr\MethodCall|StaticCall|Array_ { return $this->node; } diff --git a/src/Node/MethodCallableNode.php b/src/Node/MethodCallableNode.php index 037605111c2..71764d57763 100644 --- a/src/Node/MethodCallableNode.php +++ b/src/Node/MethodCallableNode.php @@ -32,10 +32,7 @@ public function getVar(): Expr return $this->var; } - /** - * @return Expr|Identifier - */ - public function getName() + public function getName(): Expr|Identifier { return $this->name; } diff --git a/src/Node/Property/PropertyRead.php b/src/Node/Property/PropertyRead.php index b8d71e940b7..34715b60ed2 100644 --- a/src/Node/Property/PropertyRead.php +++ b/src/Node/Property/PropertyRead.php @@ -21,10 +21,7 @@ public function __construct( { } - /** - * @return PropertyFetch|StaticPropertyFetch - */ - public function getFetch() + public function getFetch(): PropertyFetch|StaticPropertyFetch { return $this->fetch; } diff --git a/src/Node/Property/PropertyWrite.php b/src/Node/Property/PropertyWrite.php index 02d845272ca..cd5bbc05740 100644 --- a/src/Node/Property/PropertyWrite.php +++ b/src/Node/Property/PropertyWrite.php @@ -26,10 +26,7 @@ public function __construct( { } - /** - * @return PropertyFetch|StaticPropertyFetch - */ - public function getFetch() + public function getFetch(): PropertyFetch|StaticPropertyFetch { return $this->fetch; } diff --git a/src/Node/PropertyHookStatementNode.php b/src/Node/PropertyHookStatementNode.php index 72340cb17da..55c0cfd4387 100644 --- a/src/Node/PropertyHookStatementNode.php +++ b/src/Node/PropertyHookStatementNode.php @@ -28,10 +28,7 @@ public function __construct(PropertyHook $propertyHook) parent::__construct($propertyHook->getAttributes()); } - /** - * @return null - */ - public function getReturnType() + public function getReturnType(): null { return null; } diff --git a/src/Node/StaticMethodCallableNode.php b/src/Node/StaticMethodCallableNode.php index 02573a06baf..5953a9ee138 100644 --- a/src/Node/StaticMethodCallableNode.php +++ b/src/Node/StaticMethodCallableNode.php @@ -28,18 +28,12 @@ public function __construct( parent::__construct($attributes); } - /** - * @return Expr|Name - */ - public function getClass() + public function getClass(): Expr|Name { return $this->class; } - /** - * @return Identifier|Expr - */ - public function getName() + public function getName(): Identifier|Expr { return $this->name; } diff --git a/src/Node/Variable/VariableWrite.php b/src/Node/Variable/VariableWrite.php index be952ea2e12..e5ad7f4a4e5 100644 --- a/src/Node/Variable/VariableWrite.php +++ b/src/Node/Variable/VariableWrite.php @@ -35,7 +35,6 @@ final class VariableWrite /** * @param self::KIND_* $kind - * @param int|string|null $offset */ public function __construct( private string $variableName, @@ -43,7 +42,7 @@ public function __construct( private int $id, private int $kind, private bool $offsetWrite = false, - private $offset = null, + private int|string|null $offset = null, private ?int $parentId = null, private bool $replacesOffset = true, ) @@ -81,8 +80,7 @@ public function isOffsetWrite(): bool return $this->offsetWrite; } - /** @return int|string|null */ - public function getOffset() + public function getOffset(): int|string|null { return $this->offset; } diff --git a/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php b/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php index 70b6bb71bb7..81dea56f6b6 100644 --- a/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php +++ b/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php @@ -120,11 +120,8 @@ public function enterNode(Node $node): ?int return null; } - /** - * @return null - */ #[Override] - public function leaveNode(Node $node) + public function leaveNode(Node $node): null { if (!$node instanceof Namespace_) { return null; diff --git a/src/Reflection/BetterReflection/SourceLocator/FileReadTrapStreamWrapper.php b/src/Reflection/BetterReflection/SourceLocator/FileReadTrapStreamWrapper.php index c6a470e3ffb..20906836065 100644 --- a/src/Reflection/BetterReflection/SourceLocator/FileReadTrapStreamWrapper.php +++ b/src/Reflection/BetterReflection/SourceLocator/FileReadTrapStreamWrapper.php @@ -72,7 +72,7 @@ final class FileReadTrapStreamWrapper public static function withStreamWrapperOverride( callable $executeMeWithinStreamWrapperOverride, array $streamWrapperProtocols = self::DEFAULT_STREAM_WRAPPER_PROTOCOLS, - ) + ): mixed { self::$registeredStreamWrapperProtocols = $streamWrapperProtocols; self::$autoloadLocatedFiles = []; @@ -106,12 +106,9 @@ public static function withStreamWrapperOverride( * @see https://php.net/manual/en/class.streamwrapper.php * @see https://php.net/manual/en/streamwrapper.stream-open.php * - * @param string $path - * @param string $mode - * @param int $options * @param string $openedPath */ - public function stream_open($path, $mode, $options, &$openedPath): bool + public function stream_open(string $path, string $mode, int $options, &$openedPath): bool { $exists = is_file($path) || (stream_resolve_include_path($path) !== false); @@ -128,11 +125,8 @@ public function stream_open($path, $mode, $options, &$openedPath): bool /** * Since we allow our wrapper's stream_open() to succeed, we need to * simulate a successful read so autoloaders with require() don't explode. - * - * @param int $count - * */ - public function stream_read($count): string + public function stream_read(int $count): string { $this->readFromFile = true; @@ -203,7 +197,7 @@ public function stream_close(): void * * @return mixed[]|bool */ - public function stream_stat() + public function stream_stat(): bool|array { if (self::$autoloadLocatedFiles === []) { return false; @@ -223,12 +217,10 @@ public function stream_stat() * @see https://php.net/manual/en/class.streamwrapper.php * @see https://php.net/manual/en/streamwrapper.url-stat.php * - * @param string $path - * @param int $flags * * @return mixed[]|bool */ - public function url_stat($path, $flags) + public function url_stat(string $path, int $flags): bool|array { return $this->invokeWithRealFileStreamWrapper(static function ($path, $flags) { if (($flags & STREAM_URL_STAT_QUIET) !== 0) { @@ -241,9 +233,8 @@ public function url_stat($path, $flags) /** * @param mixed[] $args - * @return mixed */ - private function invokeWithRealFileStreamWrapper(callable $cb, array $args) + private function invokeWithRealFileStreamWrapper(callable $cb, array $args): mixed { if (self::$registeredStreamWrapperProtocols === null) { throw new ShouldNotHappenException(self::class . ' not registered: cannot operate. Do not call this method directly.'); @@ -285,11 +276,7 @@ public function stream_tell(): int return $this->seekPosition; } - /** - * @param int $offset - * @param int $whence - */ - public function stream_seek($offset, $whence): bool + public function stream_seek(int $offset, int $whence): bool { switch ($whence) { // Behavior is the same for a zero-length file @@ -314,13 +301,10 @@ public function stream_seek($offset, $whence): bool } /** - * @param int $option - * @param int $arg1 - * @param int $arg2 * * @return false */ - public function stream_set_option($option, $arg1, $arg2): bool + public function stream_set_option(int $option, int $arg1, int $arg2): bool { return false; } diff --git a/src/Reflection/InitializerExprTypeResolver.php b/src/Reflection/InitializerExprTypeResolver.php index fa790ab3f44..e8bc5650d79 100644 --- a/src/Reflection/InitializerExprTypeResolver.php +++ b/src/Reflection/InitializerExprTypeResolver.php @@ -724,10 +724,7 @@ public function getCastObjectType(Type $exprType): Type return $castToObject($exprType); } - /** - * @param Name|Identifier|ComplexType|null $type - */ - public function getFunctionType($type, bool $isNullable, bool $isVariadic, InitializerExprContext $context): Type + public function getFunctionType(Name|Identifier|ComplexType|null $type, bool $isNullable, bool $isVariadic, InitializerExprContext $context): Type { if ($isNullable) { return TypeCombinator::addNull( diff --git a/src/Rules/Comparison/CollectedConstantConditionError.php b/src/Rules/Comparison/CollectedConstantConditionError.php index 5d39fbb650f..99dc9af45aa 100644 --- a/src/Rules/Comparison/CollectedConstantConditionError.php +++ b/src/Rules/Comparison/CollectedConstantConditionError.php @@ -16,7 +16,7 @@ final class CollectedConstantConditionError * @param callable(string): string $transformPath * @return Error|array */ - public static function transformPaths($error, callable $transformPath) + public static function transformPaths(Error|array $error, callable $transformPath): Error|array { if ($error instanceof Error) { return $error->transformPaths($transformPath); diff --git a/src/Rules/Comparison/ConstantConditionInTraitCollector.php b/src/Rules/Comparison/ConstantConditionInTraitCollector.php index b8a7e89f346..47f8b001a38 100644 --- a/src/Rules/Comparison/ConstantConditionInTraitCollector.php +++ b/src/Rules/Comparison/ConstantConditionInTraitCollector.php @@ -21,7 +21,7 @@ public function getNodeType(): string throw new ShouldNotHappenException(); } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { throw new ShouldNotHappenException(); } @@ -31,7 +31,7 @@ public function processNode(Node $node, Scope $scope) * @param callable(string): string $transformPath * @return array{class-string>, trait-string, string, null}|array{class-string>, trait-string, string, bool, Error|array} */ - public static function transformCollectedDataPaths($data, callable $transformPath) + public static function transformCollectedDataPaths($data, callable $transformPath): array { if (!array_key_exists(4, $data)) { return $data; diff --git a/src/Rules/Comparison/FunctionCallConstantConditionCollector.php b/src/Rules/Comparison/FunctionCallConstantConditionCollector.php index 89cf4afd704..f44b263d2d6 100644 --- a/src/Rules/Comparison/FunctionCallConstantConditionCollector.php +++ b/src/Rules/Comparison/FunctionCallConstantConditionCollector.php @@ -21,7 +21,7 @@ public function getNodeType(): string throw new ShouldNotHappenException(); } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { throw new ShouldNotHappenException(); } @@ -31,7 +31,7 @@ public function processNode(Node $node, Scope $scope) * @param callable(string): string $transformPath * @return array{class-string>, trait-string|null, string, null}|array{class-string>, trait-string|null, string, bool, Error|array} */ - public static function transformCollectedDataPaths($data, callable $transformPath) + public static function transformCollectedDataPaths($data, callable $transformPath): array { if (!array_key_exists(4, $data)) { return $data; diff --git a/src/Rules/Comparison/ImpossibleCheckTypeReportedCollector.php b/src/Rules/Comparison/ImpossibleCheckTypeReportedCollector.php index fb2f9a7b48b..7a699e82fd9 100644 --- a/src/Rules/Comparison/ImpossibleCheckTypeReportedCollector.php +++ b/src/Rules/Comparison/ImpossibleCheckTypeReportedCollector.php @@ -18,7 +18,7 @@ public function getNodeType(): string throw new ShouldNotHappenException(); } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { throw new ShouldNotHappenException(); } diff --git a/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php b/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php index c0175eaab03..ab6b0ca4c3d 100644 --- a/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php +++ b/src/Rules/Comparison/ImpossibleCheckTypeStaticMethodCallRule.php @@ -129,11 +129,10 @@ public function processNode(Node $node, Scope&NodeCallbackInvoker&CollectedDataE } /** - * @param Node\Name|Expr $class * @throws ShouldNotHappenException */ private function getMethod( - $class, + Node\Name|Expr $class, string $methodName, Scope $scope, ): MethodReflection diff --git a/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php b/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php index c048b7278ff..86c840ddcb2 100644 --- a/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php +++ b/src/Rules/DeadCode/ConstructorWithoutImpurePointsCollector.php @@ -25,7 +25,7 @@ public function getNodeType(): string return MethodReturnStatementsNode::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $method = $node->getMethodReflection(); if (!$method->isConstructor()) { diff --git a/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php b/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php index e7fcb4184ee..8d38d3bed0b 100644 --- a/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php +++ b/src/Rules/DeadCode/FunctionWithoutImpurePointsCollector.php @@ -25,7 +25,7 @@ public function getNodeType(): string return FunctionReturnStatementsNode::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $function = $node->getFunctionReflection(); if (!$function->isPure()->maybe()) { diff --git a/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php b/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php index af0f2b62013..16bc9e6614f 100644 --- a/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php +++ b/src/Rules/DeadCode/MethodWithoutImpurePointsCollector.php @@ -25,7 +25,7 @@ public function getNodeType(): string return MethodReturnStatementsNode::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $method = $node->getMethodReflection(); if (!$method->isPure()->maybe()) { diff --git a/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php b/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php index 237b09cb643..9043a90611e 100644 --- a/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php +++ b/src/Rules/DeadCode/PossiblyPureFuncCallCollector.php @@ -25,7 +25,7 @@ public function getNodeType(): string return Expression::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $expr = $node->expr; if ($expr instanceof Node\Expr\BinaryOp\Pipe) { diff --git a/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php b/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php index 6d63e769248..b7ec7c0c4c4 100644 --- a/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php +++ b/src/Rules/DeadCode/PossiblyPureMethodCallCollector.php @@ -24,7 +24,7 @@ public function getNodeType(): string return Expression::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $expr = $node->expr; if ($expr instanceof Node\Expr\BinaryOp\Pipe) { diff --git a/src/Rules/DeadCode/PossiblyPureNewCollector.php b/src/Rules/DeadCode/PossiblyPureNewCollector.php index 54d8e1da7a1..56c652f8fd3 100644 --- a/src/Rules/DeadCode/PossiblyPureNewCollector.php +++ b/src/Rules/DeadCode/PossiblyPureNewCollector.php @@ -26,7 +26,7 @@ public function getNodeType(): string return Expression::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { if (!$node->expr instanceof Node\Expr\New_) { return null; diff --git a/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php b/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php index 782bf82cfdb..e230820e2b7 100644 --- a/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php +++ b/src/Rules/DeadCode/PossiblyPureStaticCallCollector.php @@ -24,7 +24,7 @@ public function getNodeType(): string return Expression::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { $expr = $node->expr; if ($expr instanceof Node\Expr\BinaryOp\Pipe) { diff --git a/src/Rules/FunctionDefinitionCheck.php b/src/Rules/FunctionDefinitionCheck.php index 13a9dfc6238..b3c7e63c2c5 100644 --- a/src/Rules/FunctionDefinitionCheck.php +++ b/src/Rules/FunctionDefinitionCheck.php @@ -104,14 +104,13 @@ public function checkFunction( /** * @param Node\Param[] $parameters - * @param Node\Identifier|Node\Name|Node\ComplexType|null $returnTypeNode * @param Node\AttributeGroup[] $attribGroups * @return list */ public function checkAnonymousFunction( Scope $scope, array $parameters, - $returnTypeNode, + Identifier|Name|ComplexType|null $returnTypeNode, array $attribGroups, string $parameterMessage, string $returnMessage, diff --git a/src/Rules/Methods/NamedArgumentParameterMethodCallsCollector.php b/src/Rules/Methods/NamedArgumentParameterMethodCallsCollector.php index 6da034b7617..5aad0a27059 100644 --- a/src/Rules/Methods/NamedArgumentParameterMethodCallsCollector.php +++ b/src/Rules/Methods/NamedArgumentParameterMethodCallsCollector.php @@ -18,7 +18,7 @@ public function getNodeType(): string throw new ShouldNotHappenException(); } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { throw new ShouldNotHappenException(); } diff --git a/src/Rules/Methods/OverridingMethodRenamesParameterCollector.php b/src/Rules/Methods/OverridingMethodRenamesParameterCollector.php index d076548882b..2973f2cb337 100644 --- a/src/Rules/Methods/OverridingMethodRenamesParameterCollector.php +++ b/src/Rules/Methods/OverridingMethodRenamesParameterCollector.php @@ -18,7 +18,7 @@ public function getNodeType(): string throw new ShouldNotHappenException(); } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { throw new ShouldNotHappenException(); } diff --git a/src/Rules/Methods/StaticMethodCallCheck.php b/src/Rules/Methods/StaticMethodCallCheck.php index aaabe3d1e79..054d4feaf5e 100644 --- a/src/Rules/Methods/StaticMethodCallCheck.php +++ b/src/Rules/Methods/StaticMethodCallCheck.php @@ -55,13 +55,12 @@ public function __construct( } /** - * @param Name|Expr $class * @return array{list, ExtendedMethodReflection|null} */ public function check( Scope $scope, string $methodName, - $class, + Name|Expr $class, Identifier|Expr $astName, ): array { diff --git a/src/Rules/NonStringableDynamicAccessCheck.php b/src/Rules/NonStringableDynamicAccessCheck.php index e7df495ab26..87b9a8eae96 100644 --- a/src/Rules/NonStringableDynamicAccessCheck.php +++ b/src/Rules/NonStringableDynamicAccessCheck.php @@ -40,7 +40,7 @@ public function __construct( * @param 'property.nameNotString'|'staticProperty.nameNotString'|'variable.nameNotString' $identifier * @return list */ - public function checkStringCastableName(Scope $scope, Expr $name, string $messageFormat, $classNode, string $identifier): array + public function checkStringCastableName(Scope $scope, Expr $name, string $messageFormat, Name|Expr|null $classNode, string $identifier): array { if (!$this->checkNonStringableDynamicAccess) { return []; @@ -71,7 +71,7 @@ public function checkStringCastableName(Scope $scope, Expr $name, string $messag * @param 'classConstant.nameNotString'|'method.nameNotString'|'staticMethod.nameNotString' $identifier * @return list */ - public function checkStringName(Scope $scope, Expr $name, string $messageFormat, $classNode, string $identifier): array + public function checkStringName(Scope $scope, Expr $name, string $messageFormat, Name|Expr|null $classNode, string $identifier): array { if (!$this->checkNonStringableDynamicAccess) { return []; @@ -92,10 +92,9 @@ public function checkStringName(Scope $scope, Expr $name, string $messageFormat, } /** - * @param Name|Expr|null $classNode * @param 'classConstant.nameNotString'|'method.nameNotString'|'property.nameNotString'|'staticMethod.nameNotString'|'staticProperty.nameNotString'|'variable.nameNotString' $identifier */ - private function buildError(Scope $scope, Expr $name, Type $nameType, string $messageFormat, $classNode, string $identifier): IdentifierRuleError + private function buildError(Scope $scope, Expr $name, Type $nameType, string $messageFormat, Name|Expr|null $classNode, string $identifier): IdentifierRuleError { $messageArgs = []; if ($classNode !== null) { diff --git a/src/Rules/Properties/PropertyDescriptor.php b/src/Rules/Properties/PropertyDescriptor.php index d9d6e10c995..3c88f194f30 100644 --- a/src/Rules/Properties/PropertyDescriptor.php +++ b/src/Rules/Properties/PropertyDescriptor.php @@ -14,10 +14,7 @@ final class PropertyDescriptor { - /** - * @param Node\Expr\PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch - */ - public function describeProperty(PropertyReflection $property, Scope $scope, $propertyFetch): string + public function describeProperty(PropertyReflection $property, Scope $scope, Node\Expr\PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch): string { if ($propertyFetch instanceof Node\Expr\PropertyFetch) { $fetchedOnType = $scope->getType($propertyFetch->var); diff --git a/src/Rules/Properties/PropertyReflectionFinder.php b/src/Rules/Properties/PropertyReflectionFinder.php index a585c613f53..d251b34f9f7 100644 --- a/src/Rules/Properties/PropertyReflectionFinder.php +++ b/src/Rules/Properties/PropertyReflectionFinder.php @@ -18,10 +18,9 @@ final class PropertyReflectionFinder { /** - * @param Node\Expr\PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch * @return FoundPropertyReflection[] */ - public function findPropertyReflectionsFromNode($propertyFetch, Scope $scope): array + public function findPropertyReflectionsFromNode(Expr\PropertyFetch|Expr\StaticPropertyFetch $propertyFetch, Scope $scope): array { if ($propertyFetch instanceof Node\Expr\PropertyFetch) { if ($propertyFetch->name instanceof Node\Identifier) { @@ -87,10 +86,8 @@ public function findPropertyReflectionsFromNode($propertyFetch, Scope $scope): a * Variant of findPropertyReflectionFromNode() for callers that already hold * the property holder's type (e.g. from an ExpressionResult) - the receiver * is not re-read through Scope::getType(). - * - * @param Node\Expr\PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch */ - public function findPropertyReflectionFromNodeWithHolderType($propertyFetch, Type $propertyHolderType, Scope $scope): ?FoundPropertyReflection + public function findPropertyReflectionFromNodeWithHolderType(Expr\PropertyFetch|Expr\StaticPropertyFetch $propertyFetch, Type $propertyHolderType, Scope $scope): ?FoundPropertyReflection { if ($propertyFetch instanceof Node\Expr\PropertyFetch) { if ($propertyFetch->name instanceof Node\Identifier) { @@ -113,10 +110,7 @@ public function findPropertyReflectionFromNodeWithHolderType($propertyFetch, Typ return $this->findStaticPropertyReflection($propertyHolderType, $propertyFetch->name->name, $scope); } - /** - * @param Node\Expr\PropertyFetch|Node\Expr\StaticPropertyFetch $propertyFetch - */ - public function findPropertyReflectionFromNode($propertyFetch, Scope $scope): ?FoundPropertyReflection + public function findPropertyReflectionFromNode(Expr\PropertyFetch|Expr\StaticPropertyFetch $propertyFetch, Scope $scope): ?FoundPropertyReflection { if ($propertyFetch instanceof Node\Expr\PropertyFetch) { $propertyHolderType = $scope->getType($propertyFetch->var); diff --git a/src/Rules/Traits/TraitDeclarationCollector.php b/src/Rules/Traits/TraitDeclarationCollector.php index ee430f75604..677c1535a68 100644 --- a/src/Rules/Traits/TraitDeclarationCollector.php +++ b/src/Rules/Traits/TraitDeclarationCollector.php @@ -19,7 +19,7 @@ public function getNodeType(): string return Node\Stmt\Trait_::class; } - public function processNode(Node $node, Scope $scope) + public function processNode(Node $node, Scope $scope): ?array { if ($node->namespacedName === null) { return null; diff --git a/src/Rules/Whitespace/FileWhitespaceRule.php b/src/Rules/Whitespace/FileWhitespaceRule.php index f160e9372ef..d87c8ea707e 100644 --- a/src/Rules/Whitespace/FileWhitespaceRule.php +++ b/src/Rules/Whitespace/FileWhitespaceRule.php @@ -49,11 +49,8 @@ public function processNode(Node $node, Scope $scope): array /** @var Node[] */ private array $lastNodes = []; - /** - * @return int|null - */ #[Override] - public function enterNode(Node $node) + public function enterNode(Node $node): ?int { if ($node instanceof Node\Stmt\Declare_) { if ($node->stmts !== null && count($node->stmts) > 0) { diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 071bb4bb190..6728ab0d9ef 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -97,12 +97,11 @@ public static function processFile( /** * @api - * @param mixed ...$args */ public function assertFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { if ($assertType === 'type') { diff --git a/src/Testing/functions.php b/src/Testing/functions.php index 1d677b906ae..75c66a0b321 100644 --- a/src/Testing/functions.php +++ b/src/Testing/functions.php @@ -8,14 +8,12 @@ * Asserts the static type of a value. * * @phpstan-pure - * @param mixed $value - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function assertType(string $type, $value) // phpcs:ignore +function assertType(string $type, mixed $value): mixed // phpcs:ignore { return null; } @@ -27,14 +25,12 @@ function assertType(string $type, $value) // phpcs:ignore * method/function parameter phpDocs. * * @phpstan-pure - * @param mixed $value - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function assertNativeType(string $type, $value) // phpcs:ignore +function assertNativeType(string $type, mixed $value): mixed // phpcs:ignore { return null; } @@ -43,28 +39,24 @@ function assertNativeType(string $type, $value) // phpcs:ignore * Asserts a super type of a value. * * @phpstan-pure - * @param mixed $value - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function assertSuperType(string $superType, $value) // phpcs:ignore +function assertSuperType(string $superType, mixed $value): mixed // phpcs:ignore { return null; } /** * @phpstan-pure - * @param mixed $variable - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function assertVariableCertainty(TrinaryLogic $certainty, $variable) // phpcs:ignore +function assertVariableCertainty(TrinaryLogic $certainty, mixed $variable): mixed // phpcs:ignore { return null; } diff --git a/src/Turbo/ForkedChild.php b/src/Turbo/ForkedChild.php index d7b86e9e696..b0da4f97d70 100644 --- a/src/Turbo/ForkedChild.php +++ b/src/Turbo/ForkedChild.php @@ -19,10 +19,9 @@ final class ForkedChild * inherited - one waiting for threads the child never had wedges there. * Register it as the child's last shutdown function. * - * @return never * @throws TurboNotActiveException */ - public static function exitImmediately() + public static function exitImmediately(): never { throw new TurboNotActiveException(); } diff --git a/src/Type/Constant/ConstantArrayType.php b/src/Type/Constant/ConstantArrayType.php index b2148e6a59d..9657df4ff5c 100644 --- a/src/Type/Constant/ConstantArrayType.php +++ b/src/Type/Constant/ConstantArrayType.php @@ -3394,10 +3394,7 @@ private function hasRequiredKeyMissingIn(self $other): bool return false; } - /** - * @param ConstantIntegerType|ConstantStringType $otherKeyType - */ - private function getKeyIndex($otherKeyType): ?int + private function getKeyIndex(ConstantIntegerType|ConstantStringType $otherKeyType): ?int { return $this->getKeyIndexMap()[$otherKeyType->getValue()] ?? null; } diff --git a/src/Type/ConstantTypeHelper.php b/src/Type/ConstantTypeHelper.php index 04cb39180c0..ad0143cc7d3 100644 --- a/src/Type/ConstantTypeHelper.php +++ b/src/Type/ConstantTypeHelper.php @@ -31,10 +31,7 @@ final class ConstantTypeHelper { - /** - * @param mixed $value - */ - public static function getTypeFromValue($value): Type + public static function getTypeFromValue(mixed $value): Type { if (is_int($value)) { return new ConstantIntegerType($value); diff --git a/src/Type/FileTypeMapper.php b/src/Type/FileTypeMapper.php index a61ad12860e..6e5b37416e4 100644 --- a/src/Type/FileTypeMapper.php +++ b/src/Type/FileTypeMapper.php @@ -815,7 +815,7 @@ private function getTypeAliasesMap(PhpDocNode $phpDocNode): array * @param Closure(Node $node): mixed $nodeCallback * @param Closure(Node $node, mixed $callbackResult): void $endNodeCallback */ - private function processNodes($node, Closure $nodeCallback, Closure $endNodeCallback): void + private function processNodes(Node|int|float|string|bool|array|null $node, Closure $nodeCallback, Closure $endNodeCallback): void { if ($node instanceof Node) { $callbackResult = $nodeCallback($node); diff --git a/src/Type/Generic/UnresolvedTemplateArgumentType.php b/src/Type/Generic/UnresolvedTemplateArgumentType.php index 3f4c130dcbf..5df8c34fa76 100644 --- a/src/Type/Generic/UnresolvedTemplateArgumentType.php +++ b/src/Type/Generic/UnresolvedTemplateArgumentType.php @@ -2,7 +2,10 @@ namespace PHPStan\Type\Generic; +use PhpParser\Node\ComplexType; use PhpParser\Node\Expr; +use PhpParser\Node\Identifier; +use PhpParser\Node\Name; use PHPStan\Php\PhpVersion; use PHPStan\PhpDocParser\Ast\Type\TypeNode; use PHPStan\Reflection\ClassConstantReflection; @@ -297,7 +300,7 @@ public function toPhpDocNode(): TypeNode return $this->getDelegate()->toPhpDocNode(); } - public function toNativePhpTypeNode(NativeTypePosition $position) + public function toNativePhpTypeNode(NativeTypePosition $position): Identifier|Name|ComplexType|null { return $this->getDelegate()->toNativePhpTypeNode($position); } diff --git a/src/Type/IntegerRangeType.php b/src/Type/IntegerRangeType.php index 2c2dda52198..a55c900659c 100644 --- a/src/Type/IntegerRangeType.php +++ b/src/Type/IntegerRangeType.php @@ -90,10 +90,8 @@ protected static function isDisjoint(?int $minA, ?int $maxA, ?int $minB, ?int $m /** * Return the range of integers smaller than the given value - * - * @param int|float $value */ - public static function createAllSmallerThan($value): Type + public static function createAllSmallerThan(int|float $value): Type { if (is_int($value)) { return self::fromInterval(null, $value, -1); @@ -115,10 +113,8 @@ public static function createAllSmallerThan($value): Type /** * Return the range of integers smaller than or equal to the given value - * - * @param int|float $value */ - public static function createAllSmallerThanOrEqualTo($value): Type + public static function createAllSmallerThanOrEqualTo(int|float $value): Type { if (is_int($value)) { return self::fromInterval(null, $value); @@ -137,10 +133,8 @@ public static function createAllSmallerThanOrEqualTo($value): Type /** * Return the range of integers greater than the given value - * - * @param int|float $value */ - public static function createAllGreaterThan($value): Type + public static function createAllGreaterThan(int|float $value): Type { if (is_int($value)) { return self::fromInterval($value, null, 1); @@ -159,10 +153,8 @@ public static function createAllGreaterThan($value): Type /** * Return the range of integers greater than or equal to the given value - * - * @param int|float $value */ - public static function createAllGreaterThanOrEqualTo($value): Type + public static function createAllGreaterThanOrEqualTo(int|float $value): Type { if (is_int($value)) { return self::fromInterval($value, null); diff --git a/src/Type/LateResolvableArrayShapeType.php b/src/Type/LateResolvableArrayShapeType.php index d7933201dcc..f58a80c4f33 100644 --- a/src/Type/LateResolvableArrayShapeType.php +++ b/src/Type/LateResolvableArrayShapeType.php @@ -422,10 +422,7 @@ private function isImplicitMixed(Type $type): bool && $type->getSubtractedType() === null; } - /** - * @return ConstExprIntegerNode|ConstExprStringNode|ConstFetchNode|IdentifierTypeNode - */ - private static function keyNameNode(Type $keyType) + private static function keyNameNode(Type $keyType): ConstExprIntegerNode|ConstExprStringNode|ConstFetchNode|IdentifierTypeNode { $node = $keyType->toPhpDocNode(); if ($node instanceof IdentifierTypeNode) { diff --git a/src/Type/LateResolvableObjectShapeType.php b/src/Type/LateResolvableObjectShapeType.php index 7e65ab707a6..818760b90a1 100644 --- a/src/Type/LateResolvableObjectShapeType.php +++ b/src/Type/LateResolvableObjectShapeType.php @@ -271,10 +271,7 @@ public function toPhpDocNode(): TypeNode return new ObjectShapeNode($items); } - /** - * @return ConstExprStringNode|IdentifierTypeNode - */ - private static function keyNameNode(Type $keyType) + private static function keyNameNode(Type $keyType): ConstExprStringNode|IdentifierTypeNode { $node = $keyType->toPhpDocNode(); if ($node instanceof IdentifierTypeNode) { diff --git a/src/Type/NativePhpTypeNodeHelper.php b/src/Type/NativePhpTypeNodeHelper.php index e319ffac58e..1041e841551 100644 --- a/src/Type/NativePhpTypeNodeHelper.php +++ b/src/Type/NativePhpTypeNodeHelper.php @@ -25,8 +25,7 @@ final class NativePhpTypeNodeHelper { - /** @return Identifier|Name|ComplexType|null */ - public static function union(UnionType $unionType, NativeTypePosition $position) + public static function union(UnionType $unionType, NativeTypePosition $position): Identifier|Name|ComplexType|null { $nonNullTypes = []; $hasNull = false; @@ -121,8 +120,7 @@ public static function union(UnionType $unionType, NativeTypePosition $position) return new Node\UnionType($nodes); } - /** @return Identifier|Name|ComplexType|null */ - public static function intersection(IntersectionType $intersectionType, NativeTypePosition $position) + public static function intersection(IntersectionType $intersectionType, NativeTypePosition $position): Identifier|Name|ComplexType|null { if ($intersectionType->isString()->yes()) { return (new StringType())->toNativePhpTypeNode($position); diff --git a/src/Type/ParserNodeTypeToPHPStanType.php b/src/Type/ParserNodeTypeToPHPStanType.php index d9637599fc3..a3575050d80 100644 --- a/src/Type/ParserNodeTypeToPHPStanType.php +++ b/src/Type/ParserNodeTypeToPHPStanType.php @@ -18,10 +18,7 @@ final class ParserNodeTypeToPHPStanType { - /** - * @param Node\Name|Node\Identifier|Node\ComplexType|null $type - */ - public static function resolve($type, ?ClassReflection $classReflection): Type + public static function resolve(Name|Identifier|Node\ComplexType|null $type, ?ClassReflection $classReflection): Type { if ($type === null) { return new MixedType(); diff --git a/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php b/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php index 8ade43ae493..0c6fad2bec5 100644 --- a/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php +++ b/src/Type/Php/BcMathStringOrNullReturnTypeExtension.php @@ -258,10 +258,8 @@ private function getTypeForBcPowMod(FuncCall $functionCall, Scope $scope): Type /** * Utility to help us determine if value is zero. Handles cases where we pass "0.000" too. - * - * @param mixed $value */ - private function isZero($value): bool + private function isZero(mixed $value): bool { if (is_numeric($value) === false) { return false; diff --git a/src/debugScope.php b/src/debugScope.php index 6f331c97bab..259d2a3c14e 100644 --- a/src/debugScope.php +++ b/src/debugScope.php @@ -4,11 +4,10 @@ /** * @phpstan-pure - * @return mixed * * @throws void */ -function debugScope() // phpcs:ignore Squiz.Functions.GlobalFunction.Found +function debugScope(): mixed // phpcs:ignore Squiz.Functions.GlobalFunction.Found { return null; } diff --git a/src/dumpType.php b/src/dumpType.php index 943ca7e124c..cf9c9bab5db 100644 --- a/src/dumpType.php +++ b/src/dumpType.php @@ -4,45 +4,36 @@ /** * @phpstan-pure - * @param mixed $value - * @param mixed $values - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function dumpType($value, ...$values) // phpcs:ignore Squiz.Functions.GlobalFunction.Found +function dumpType(mixed $value, mixed ...$values): mixed // phpcs:ignore Squiz.Functions.GlobalFunction.Found { return null; } /** * @phpstan-pure - * @param mixed $value - * @param mixed $values - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function dumpNativeType($value, ...$values) // phpcs:ignore Squiz.Functions.GlobalFunction.Found +function dumpNativeType(mixed $value, mixed ...$values): mixed // phpcs:ignore Squiz.Functions.GlobalFunction.Found { return null; } /** * @phpstan-pure - * @param mixed $value - * @param mixed $values - * @return mixed * * @throws void */ // the parameters are consumed by the analyser, not by the function body // @phpstan-ignore function.unusedParameter, function.unusedParameter -function dumpPhpDocType($value, ...$values) // phpcs:ignore Squiz.Functions.GlobalFunction.Found +function dumpPhpDocType(mixed $value, mixed ...$values): mixed // phpcs:ignore Squiz.Functions.GlobalFunction.Found { return null; } diff --git a/tests/PHPStan/Analyser/AnalyserTest.php b/tests/PHPStan/Analyser/AnalyserTest.php index 3a800ea97a0..f18c6da5c27 100644 --- a/tests/PHPStan/Analyser/AnalyserTest.php +++ b/tests/PHPStan/Analyser/AnalyserTest.php @@ -856,7 +856,7 @@ public function testIgnoreErrorExplicitReportUnmatchedEnableMulti(): void private function runAnalyser( array $ignoreErrors, bool $reportUnmatchedIgnoredErrors, - $filePaths, + string|array $filePaths, bool $onlyFiles, bool $reportIgnoresWithoutComments = false, array $collectors = [], diff --git a/tests/PHPStan/Analyser/AssertStubTest.php b/tests/PHPStan/Analyser/AssertStubTest.php index 579e52e3593..42347d10d0f 100644 --- a/tests/PHPStan/Analyser/AssertStubTest.php +++ b/tests/PHPStan/Analyser/AssertStubTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/assert-stub.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug10922Test.php b/tests/PHPStan/Analyser/Bug10922Test.php index 6fa62ea5e7c..0e98b9a020b 100644 --- a/tests/PHPStan/Analyser/Bug10922Test.php +++ b/tests/PHPStan/Analyser/Bug10922Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-10922.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug10980Test.php b/tests/PHPStan/Analyser/Bug10980Test.php index 51422dcd452..37bfc92ca29 100644 --- a/tests/PHPStan/Analyser/Bug10980Test.php +++ b/tests/PHPStan/Analyser/Bug10980Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-10980.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug11009Test.php b/tests/PHPStan/Analyser/Bug11009Test.php index d558eb0a0f9..93c3c121fee 100644 --- a/tests/PHPStan/Analyser/Bug11009Test.php +++ b/tests/PHPStan/Analyser/Bug11009Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-11009.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug14446Test.php b/tests/PHPStan/Analyser/Bug14446Test.php index 84a421583e6..50e9b76fbcc 100644 --- a/tests/PHPStan/Analyser/Bug14446Test.php +++ b/tests/PHPStan/Analyser/Bug14446Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-14446.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug15297Php73Test.php b/tests/PHPStan/Analyser/Bug15297Php73Test.php index fbbc3c78769..f8a9429e3f0 100644 --- a/tests/PHPStan/Analyser/Bug15297Php73Test.php +++ b/tests/PHPStan/Analyser/Bug15297Php73Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-15297-php73.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Bug9307Test.php b/tests/PHPStan/Analyser/Bug9307Test.php index 1de98619ea9..57bd917d7e4 100644 --- a/tests/PHPStan/Analyser/Bug9307Test.php +++ b/tests/PHPStan/Analyser/Bug9307Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-9307.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ClassConstantStubFileTest.php b/tests/PHPStan/Analyser/ClassConstantStubFileTest.php index 2d1cb36f583..2768f8f09a1 100644 --- a/tests/PHPStan/Analyser/ClassConstantStubFileTest.php +++ b/tests/PHPStan/Analyser/ClassConstantStubFileTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/class-constant-stub-files.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/CollectedDataReuse/FirstCollector.php b/tests/PHPStan/Analyser/CollectedDataReuse/FirstCollector.php index 21dcae3ccd9..cc9b99d6225 100644 --- a/tests/PHPStan/Analyser/CollectedDataReuse/FirstCollector.php +++ b/tests/PHPStan/Analyser/CollectedDataReuse/FirstCollector.php @@ -18,7 +18,7 @@ public function getNodeType(): string return Node::class; } - public function processNode(Node $node, Scope&DependencyTracker $scope) + public function processNode(Node $node, Scope&DependencyTracker $scope): ?string { return null; } diff --git a/tests/PHPStan/Analyser/CollectedDataReuse/SecondCollector.php b/tests/PHPStan/Analyser/CollectedDataReuse/SecondCollector.php index 574e0dff4e7..b6cac8f9f21 100644 --- a/tests/PHPStan/Analyser/CollectedDataReuse/SecondCollector.php +++ b/tests/PHPStan/Analyser/CollectedDataReuse/SecondCollector.php @@ -18,7 +18,7 @@ public function getNodeType(): string return Node::class; } - public function processNode(Node $node, Scope&DependencyTracker $scope) + public function processNode(Node $node, Scope&DependencyTracker $scope): ?string { return null; } diff --git a/tests/PHPStan/Analyser/ConditionalReturnTypeFromMethodStubTest.php b/tests/PHPStan/Analyser/ConditionalReturnTypeFromMethodStubTest.php index af195681660..e91f5bca6e3 100644 --- a/tests/PHPStan/Analyser/ConditionalReturnTypeFromMethodStubTest.php +++ b/tests/PHPStan/Analyser/ConditionalReturnTypeFromMethodStubTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/conditional-return-type-stub.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DoNotPolluteScopeWithBlockTest.php b/tests/PHPStan/Analyser/DoNotPolluteScopeWithBlockTest.php index 8b94d130e04..7aeebbab4d9 100644 --- a/tests/PHPStan/Analyser/DoNotPolluteScopeWithBlockTest.php +++ b/tests/PHPStan/Analyser/DoNotPolluteScopeWithBlockTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/do-not-pollute-scope-with-block.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DoNotRememberPossiblyImpureFunctionValuesTest.php b/tests/PHPStan/Analyser/DoNotRememberPossiblyImpureFunctionValuesTest.php index 75a9797ee38..b0a0169d2e9 100644 --- a/tests/PHPStan/Analyser/DoNotRememberPossiblyImpureFunctionValuesTest.php +++ b/tests/PHPStan/Analyser/DoNotRememberPossiblyImpureFunctionValuesTest.php @@ -13,14 +13,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/do-not-remember-possibly-impure-function-values.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DynamicConstantsNativeTypesTest.php b/tests/PHPStan/Analyser/DynamicConstantsNativeTypesTest.php index 9c8afdc802c..f5e1b6048bf 100644 --- a/tests/PHPStan/Analyser/DynamicConstantsNativeTypesTest.php +++ b/tests/PHPStan/Analyser/DynamicConstantsNativeTypesTest.php @@ -15,14 +15,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/dynamic-constant-native-types.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DynamicConstantsTest.php b/tests/PHPStan/Analyser/DynamicConstantsTest.php index 714091218e8..288a2443231 100644 --- a/tests/PHPStan/Analyser/DynamicConstantsTest.php +++ b/tests/PHPStan/Analyser/DynamicConstantsTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/dynamic-constant.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DynamicMethodThrowTypeExtensionTest.php b/tests/PHPStan/Analyser/DynamicMethodThrowTypeExtensionTest.php index 5b34c77e772..7904e585997 100644 --- a/tests/PHPStan/Analyser/DynamicMethodThrowTypeExtensionTest.php +++ b/tests/PHPStan/Analyser/DynamicMethodThrowTypeExtensionTest.php @@ -20,14 +20,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/dynamic-throw-type-extension-void.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/DynamicReturnTypeExtensionTypeInferenceTest.php b/tests/PHPStan/Analyser/DynamicReturnTypeExtensionTypeInferenceTest.php index 90cd2af9f9b..de89f0e5a88 100644 --- a/tests/PHPStan/Analyser/DynamicReturnTypeExtensionTypeInferenceTest.php +++ b/tests/PHPStan/Analyser/DynamicReturnTypeExtensionTypeInferenceTest.php @@ -27,14 +27,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-15303.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ExpressionTypeResolverExtensionTest.php b/tests/PHPStan/Analyser/ExpressionTypeResolverExtensionTest.php index 6c3d707942a..edaa00ac7d5 100644 --- a/tests/PHPStan/Analyser/ExpressionTypeResolverExtensionTest.php +++ b/tests/PHPStan/Analyser/ExpressionTypeResolverExtensionTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/expression-type-resolver-extension.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Generics/ClosureSignatureFromUsagesToggleOffTest.php b/tests/PHPStan/Analyser/Generics/ClosureSignatureFromUsagesToggleOffTest.php index 5164408fa31..ef410791c57 100644 --- a/tests/PHPStan/Analyser/Generics/ClosureSignatureFromUsagesToggleOffTest.php +++ b/tests/PHPStan/Analyser/Generics/ClosureSignatureFromUsagesToggleOffTest.php @@ -21,14 +21,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/closure-byref-uses-at-invocation-off.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/Generics/StaticVariablesFromUsagesToggleOffTest.php b/tests/PHPStan/Analyser/Generics/StaticVariablesFromUsagesToggleOffTest.php index 6df98062deb..9c1e35a432e 100644 --- a/tests/PHPStan/Analyser/Generics/StaticVariablesFromUsagesToggleOffTest.php +++ b/tests/PHPStan/Analyser/Generics/StaticVariablesFromUsagesToggleOffTest.php @@ -19,14 +19,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/static-variables-from-usages-off.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ImmediatelyCalledFunctionWithoutImplicitThrowTest.php b/tests/PHPStan/Analyser/ImmediatelyCalledFunctionWithoutImplicitThrowTest.php index 8a9e2ee7a65..3d0f3b8044f 100644 --- a/tests/PHPStan/Analyser/ImmediatelyCalledFunctionWithoutImplicitThrowTest.php +++ b/tests/PHPStan/Analyser/ImmediatelyCalledFunctionWithoutImplicitThrowTest.php @@ -14,14 +14,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/immediately-called-function-without-implicit-throw.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/LooseConstComparisonPhp7Test.php b/tests/PHPStan/Analyser/LooseConstComparisonPhp7Test.php index 6e3df603fa6..f68bade5e00 100644 --- a/tests/PHPStan/Analyser/LooseConstComparisonPhp7Test.php +++ b/tests/PHPStan/Analyser/LooseConstComparisonPhp7Test.php @@ -18,14 +18,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-15667-php7.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/LooseConstComparisonPhp8Test.php b/tests/PHPStan/Analyser/LooseConstComparisonPhp8Test.php index a0e5d2065fd..e185bbcfa4a 100644 --- a/tests/PHPStan/Analyser/LooseConstComparisonPhp8Test.php +++ b/tests/PHPStan/Analyser/LooseConstComparisonPhp8Test.php @@ -16,14 +16,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-11732-php8.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/OperatorTypeSpecifyingExtensionTypeInferenceTest.php b/tests/PHPStan/Analyser/OperatorTypeSpecifyingExtensionTypeInferenceTest.php index bc2493201eb..2e2f2de4819 100644 --- a/tests/PHPStan/Analyser/OperatorTypeSpecifyingExtensionTypeInferenceTest.php +++ b/tests/PHPStan/Analyser/OperatorTypeSpecifyingExtensionTypeInferenceTest.php @@ -13,14 +13,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/operator-type-specifying-extension.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ParamClosureThisStubsTest.php b/tests/PHPStan/Analyser/ParamClosureThisStubsTest.php index b1bab04da09..7c9fcdc5e1f 100644 --- a/tests/PHPStan/Analyser/ParamClosureThisStubsTest.php +++ b/tests/PHPStan/Analyser/ParamClosureThisStubsTest.php @@ -13,14 +13,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/param-closure-this-stubs.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ParamOutTypeTest.php b/tests/PHPStan/Analyser/ParamOutTypeTest.php index 251479a95bc..8facbd75701 100644 --- a/tests/PHPStan/Analyser/ParamOutTypeTest.php +++ b/tests/PHPStan/Analyser/ParamOutTypeTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/param-out.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ParameterClosureThisExtensionTest.php b/tests/PHPStan/Analyser/ParameterClosureThisExtensionTest.php index fed715244f3..fc631535036 100644 --- a/tests/PHPStan/Analyser/ParameterClosureThisExtensionTest.php +++ b/tests/PHPStan/Analyser/ParameterClosureThisExtensionTest.php @@ -13,11 +13,8 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/parameter-closure-this-extension.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] - public function testFileAsserts(string $assertType, string $file, ...$args): void + public function testFileAsserts(string $assertType, string $file, mixed ...$args): void { $this->assertFileAsserts($assertType, $file, ...$args); } diff --git a/tests/PHPStan/Analyser/ParameterClosureTypeExtensionArrowFunctionTest.php b/tests/PHPStan/Analyser/ParameterClosureTypeExtensionArrowFunctionTest.php index 778dbf90f7c..8bfc2a30ca9 100644 --- a/tests/PHPStan/Analyser/ParameterClosureTypeExtensionArrowFunctionTest.php +++ b/tests/PHPStan/Analyser/ParameterClosureTypeExtensionArrowFunctionTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/parameter-closure-type-extension-arrow-function.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ParameterClosureTypeExtensionTest.php b/tests/PHPStan/Analyser/ParameterClosureTypeExtensionTest.php index 6079115500e..051100a6bd8 100644 --- a/tests/PHPStan/Analyser/ParameterClosureTypeExtensionTest.php +++ b/tests/PHPStan/Analyser/ParameterClosureTypeExtensionTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/parameter-closure-type-extension.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ParameterOutTypeExtensionTest.php b/tests/PHPStan/Analyser/ParameterOutTypeExtensionTest.php index 3ad3d0e1f04..a1114cf99a3 100644 --- a/tests/PHPStan/Analyser/ParameterOutTypeExtensionTest.php +++ b/tests/PHPStan/Analyser/ParameterOutTypeExtensionTest.php @@ -13,14 +13,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/param-out/parameter-out-types.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/PathConstantsTest.php b/tests/PHPStan/Analyser/PathConstantsTest.php index 6ce2116d887..ad65c86eca2 100644 --- a/tests/PHPStan/Analyser/PathConstantsTest.php +++ b/tests/PHPStan/Analyser/PathConstantsTest.php @@ -18,14 +18,11 @@ public static function dataFileAsserts(): iterable } } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ReflectionParameterPhp7Test.php b/tests/PHPStan/Analyser/ReflectionParameterPhp7Test.php index a16b513ed8b..35a992d140c 100644 --- a/tests/PHPStan/Analyser/ReflectionParameterPhp7Test.php +++ b/tests/PHPStan/Analyser/ReflectionParameterPhp7Test.php @@ -13,11 +13,8 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/nsrt/reflection-parameter-type-catch.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] - public function testFileAsserts(string $assertType, string $file, ...$args): void + public function testFileAsserts(string $assertType, string $file, mixed ...$args): void { $this->assertFileAsserts($assertType, $file, ...$args); } diff --git a/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest.php b/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest.php index 1ad96508af6..3b2a12bce8c 100644 --- a/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest.php +++ b/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingDetectTypeInferenceTest.php @@ -14,14 +14,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/report-unsafe-array-string-key-casting-detect.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingPreventTypeInferenceTest.php b/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingPreventTypeInferenceTest.php index 0f8b64b4b51..f76c819badc 100644 --- a/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingPreventTypeInferenceTest.php +++ b/tests/PHPStan/Analyser/ReportUnsafeArrayStringKeyCastingPreventTypeInferenceTest.php @@ -14,14 +14,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/report-unsafe-array-string-key-casting-prevent.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ScopePhpVersionRangeReturnTypeExtensionsTest.php b/tests/PHPStan/Analyser/ScopePhpVersionRangeReturnTypeExtensionsTest.php index 35413b50819..6a9d423e836 100644 --- a/tests/PHPStan/Analyser/ScopePhpVersionRangeReturnTypeExtensionsTest.php +++ b/tests/PHPStan/Analyser/ScopePhpVersionRangeReturnTypeExtensionsTest.php @@ -16,14 +16,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/array-unpacking-php-version-range.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/SubstrPhp7Test.php b/tests/PHPStan/Analyser/SubstrPhp7Test.php index deb4f19717e..74ee1637401 100644 --- a/tests/PHPStan/Analyser/SubstrPhp7Test.php +++ b/tests/PHPStan/Analyser/SubstrPhp7Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-13129-php7.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/SubstrPhp8Test.php b/tests/PHPStan/Analyser/SubstrPhp8Test.php index a5da5b57c8e..ea010f779a1 100644 --- a/tests/PHPStan/Analyser/SubstrPhp8Test.php +++ b/tests/PHPStan/Analyser/SubstrPhp8Test.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/bug-13129-php8.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/ThrowsTagFromNativeFunctionStubTest.php b/tests/PHPStan/Analyser/ThrowsTagFromNativeFunctionStubTest.php index a57c784dd94..ef4922f0117 100644 --- a/tests/PHPStan/Analyser/ThrowsTagFromNativeFunctionStubTest.php +++ b/tests/PHPStan/Analyser/ThrowsTagFromNativeFunctionStubTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/throws-tag-from-native-function-stub.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/TraitStubFilesTest.php b/tests/PHPStan/Analyser/TraitStubFilesTest.php index 097279e6d3b..8a4b5d8172b 100644 --- a/tests/PHPStan/Analyser/TraitStubFilesTest.php +++ b/tests/PHPStan/Analyser/TraitStubFilesTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/trait-stubs.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceFalseTest.php b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceFalseTest.php index 8b351b2a57a..fb4b6fa6459 100644 --- a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceFalseTest.php +++ b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceFalseTest.php @@ -15,14 +15,11 @@ public static function dataTypeSpecifyingExtensionsFalse(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/type-specifying-extensions-3-false.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataTypeSpecifyingExtensionsFalse')] public function testTypeSpecifyingExtensionsFalse( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceNullTest.php b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceNullTest.php index de7d4a7e4ec..e1117497da9 100644 --- a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceNullTest.php +++ b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceNullTest.php @@ -15,14 +15,11 @@ public static function dataTypeSpecifyingExtensionsNull(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/type-specifying-extensions-3-null.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataTypeSpecifyingExtensionsNull')] public function testTypeSpecifyingExtensionsNull( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceTrueTest.php b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceTrueTest.php index 25a9e8a0b2a..262fdf7e14d 100644 --- a/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceTrueTest.php +++ b/tests/PHPStan/Analyser/TypeSpecifyingExtensionTypeInferenceTrueTest.php @@ -15,14 +15,11 @@ public static function dataTypeSpecifyingExtensionsTrue(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/type-specifying-extensions-3-true.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataTypeSpecifyingExtensionsTrue')] public function testTypeSpecifyingExtensionsTrue( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Analyser/UnaryOperatorTypeSpecifyingExtensionTypeInferenceTest.php b/tests/PHPStan/Analyser/UnaryOperatorTypeSpecifyingExtensionTypeInferenceTest.php index 9661496dcb4..29bf1d2d2a1 100644 --- a/tests/PHPStan/Analyser/UnaryOperatorTypeSpecifyingExtensionTypeInferenceTest.php +++ b/tests/PHPStan/Analyser/UnaryOperatorTypeSpecifyingExtensionTypeInferenceTest.php @@ -13,14 +13,11 @@ public static function dataAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/unary-operator-type-specifying-extension.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataAsserts')] public function testAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Collectors/UniversalCollector.php b/tests/PHPStan/Collectors/UniversalCollector.php index d939fe368c8..e42a84f7a25 100644 --- a/tests/PHPStan/Collectors/UniversalCollector.php +++ b/tests/PHPStan/Collectors/UniversalCollector.php @@ -13,9 +13,6 @@ class UniversalCollector implements Collector { - /** @phpstan-var class-string */ - private $nodeType; - /** @var (callable(TNodeType, Scope): TValue) */ private $processNodeCallback; @@ -23,9 +20,8 @@ class UniversalCollector implements Collector * @param class-string $nodeType * @param (callable(TNodeType, Scope): TValue) $processNodeCallback */ - public function __construct(string $nodeType, callable $processNodeCallback) + public function __construct(private string $nodeType, callable $processNodeCallback) { - $this->nodeType = $nodeType; $this->processNodeCallback = $processNodeCallback; } diff --git a/tests/PHPStan/Reflection/AllowedSubTypesClassReflectionExtensionTest.php b/tests/PHPStan/Reflection/AllowedSubTypesClassReflectionExtensionTest.php index 5ca035e52ca..251cec1126e 100644 --- a/tests/PHPStan/Reflection/AllowedSubTypesClassReflectionExtensionTest.php +++ b/tests/PHPStan/Reflection/AllowedSubTypesClassReflectionExtensionTest.php @@ -13,14 +13,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/allowed-sub-types.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Reflection/Php/BackedEnumFromParameterTypeToggleOffTest.php b/tests/PHPStan/Reflection/Php/BackedEnumFromParameterTypeToggleOffTest.php index a5d548e4702..b1ea31d1202 100644 --- a/tests/PHPStan/Reflection/Php/BackedEnumFromParameterTypeToggleOffTest.php +++ b/tests/PHPStan/Reflection/Php/BackedEnumFromParameterTypeToggleOffTest.php @@ -21,14 +21,11 @@ public static function dataFileAsserts(): iterable yield from self::gatherAssertTypes(__DIR__ . '/data/backed-enum-from-parameter-type-off.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataFileAsserts')] public function testFileAsserts( string $assertType, string $file, - ...$args, + mixed ...$args, ): void { $this->assertFileAsserts($assertType, $file, ...$args); diff --git a/tests/PHPStan/Reflection/ReflectionProviderGoldenTest.php b/tests/PHPStan/Reflection/ReflectionProviderGoldenTest.php index 32fd46d18ed..3e893186504 100644 --- a/tests/PHPStan/Reflection/ReflectionProviderGoldenTest.php +++ b/tests/PHPStan/Reflection/ReflectionProviderGoldenTest.php @@ -335,8 +335,7 @@ private static function generateClassMethodDescription(string $classMethodName): return $result; } - /** @param FunctionReflection|ExtendedMethodReflection $reflection */ - private static function generateFunctionMethodBaseDescription($reflection): string + private static function generateFunctionMethodBaseDescription(FunctionReflection|ExtendedMethodReflection $reflection): string { $result = ''; @@ -637,7 +636,7 @@ private static function scrapeSymbolsFromStubs(array $stubFiles): array private Node\Stmt\ClassLike $classLike; #[Override] - public function enterNode(Node $node) + public function enterNode(Node $node): int|Node|array|null { if ($node instanceof Node\Stmt\ClassLike && $node->namespacedName !== null) { $this->symbols['CLASS ' . $node->namespacedName->toString()] = true; @@ -660,7 +659,7 @@ public function enterNode(Node $node) } #[Override] - public function leaveNode(Node $node) + public function leaveNode(Node $node): int|Node|array|null { if ($node instanceof Node\Stmt\ClassLike) { unset($this->classLike); diff --git a/tests/PHPStan/Rules/UniversalRule.php b/tests/PHPStan/Rules/UniversalRule.php index 26168ba8dc0..b1bc1adb584 100644 --- a/tests/PHPStan/Rules/UniversalRule.php +++ b/tests/PHPStan/Rules/UniversalRule.php @@ -12,9 +12,6 @@ class UniversalRule implements Rule { - /** @phpstan-var class-string */ - private $nodeType; - /** @var (callable(TNodeType, Scope): list) */ private $processNodeCallback; @@ -22,9 +19,8 @@ class UniversalRule implements Rule * @param class-string $nodeType * @param (callable(TNodeType, Scope): list) $processNodeCallback */ - public function __construct(string $nodeType, callable $processNodeCallback) + public function __construct(private string $nodeType, callable $processNodeCallback) { - $this->nodeType = $nodeType; $this->processNodeCallback = $processNodeCallback; } diff --git a/tests/PHPStan/Testing/TypeInferenceTestCaseTest.php b/tests/PHPStan/Testing/TypeInferenceTestCaseTest.php index 054094eebbd..0026e6c7b15 100644 --- a/tests/PHPStan/Testing/TypeInferenceTestCaseTest.php +++ b/tests/PHPStan/Testing/TypeInferenceTestCaseTest.php @@ -133,11 +133,8 @@ public static function dataSuperTypeFailed(): array return self::gatherAssertTypes(__DIR__ . '/data/assert-super-type-failed.php'); } - /** - * @param mixed ...$args - */ #[DataProvider('dataSuperTypeFailed')] - public function testSuperTypeFailed(...$args): void + public function testSuperTypeFailed(mixed ...$args): void { $this->expectException(AssertionFailedError::class); $this->assertFileAsserts(...$args); diff --git a/tests/PHPStan/Tests/AssertionClass.php b/tests/PHPStan/Tests/AssertionClass.php index 29f419fcad1..feabde919dd 100644 --- a/tests/PHPStan/Tests/AssertionClass.php +++ b/tests/PHPStan/Tests/AssertionClass.php @@ -26,10 +26,9 @@ public static function assertInt(?int $arg): bool } /** - * @param mixed $arg * @throws AssertionException */ - public function assertNotInt($arg): bool + public function assertNotInt(mixed $arg): bool { if (is_int($arg)) { throw new AssertionException(); diff --git a/tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php b/tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php index 3fe2098178b..2bd34670a53 100644 --- a/tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php +++ b/tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php @@ -1022,13 +1022,9 @@ public static function dataIsSuperTypeOfWithBleedingEdge(): array ]; } - /** - * @param ConstantArrayType|string $type - * @param Type|string $otherType - */ #[DataProvider('dataIsSuperTypeOfWithoutBleedingEdge')] #[DataProvider('dataIsSuperTypeOfWithBleedingEdge')] - public function testIsSuperTypeOf($type, $otherType, TrinaryLogic $expectedResult): void + public function testIsSuperTypeOf(ConstantArrayType|string $type, Type|string $otherType, TrinaryLogic $expectedResult): void { // Fetch the resolver - and thereby build the container - *before* entering the // bleeding-edge window. Building a container resets the global BleedingEdgeToggle to diff --git a/tests/PHPStan/Type/FileTypeMapperTest.php b/tests/PHPStan/Type/FileTypeMapperTest.php index 49658c33707..79cd9383f01 100644 --- a/tests/PHPStan/Type/FileTypeMapperTest.php +++ b/tests/PHPStan/Type/FileTypeMapperTest.php @@ -230,10 +230,7 @@ public function testNameScopeMapStoresImportsOnce(): void /** @var array */ public array $storage = []; - /** - * @return mixed|null - */ - public function load(string $key, string $variableKey) + public function load(string $key, string $variableKey): mixed { if (!isset($this->storage[$key])) { return null; @@ -247,10 +244,7 @@ public function load(string $key, string $variableKey) return $item->getData(); } - /** - * @param mixed $data - */ - public function save(string $key, string $variableKey, $data): void + public function save(string $key, string $variableKey, mixed $data): void { $this->storage[$key] = serialize(new CacheItem($variableKey, $data)); } diff --git a/turbo-ext/src/IntegerRangeType.cpp b/turbo-ext/src/IntegerRangeType.cpp index 98308b819af..5fe51a1a738 100644 --- a/turbo-ext/src/IntegerRangeType.cpp +++ b/turbo-ext/src/IntegerRangeType.cpp @@ -1308,12 +1308,14 @@ static NullableLong pt_nullable_long_arg(zend_long value, bool isNull) return isNull ? NullableLong::null() : NullableLong::of(value); } -/* the createAll*() family: one untyped $value */ +/* the createAll*() family: one int|float $value, rejected like the twin's + * declaration rejects anything else under strict_types (zp has no number kind) */ static void pt_irt_create_all(INTERNAL_FUNCTION_PARAMETERS, zv::Val (*factory)(zval *)) { zval *value; - if (!zp::parse(execute_data, value)) RETURN_THROWS(); - ZVAL_DEREF(value); + ZEND_PARSE_PARAMETERS_START(1, 1) + Z_PARAM_NUMBER(value) + ZEND_PARSE_PARAMETERS_END(); PT_RETURN_VAL(factory(value)); } diff --git a/turbo-ext/src/MutatingScope.cpp b/turbo-ext/src/MutatingScope.cpp index dfc21fc70bf..55f8ffa58d2 100644 --- a/turbo-ext/src/MutatingScope.cpp +++ b/turbo-ext/src/MutatingScope.cpp @@ -11202,6 +11202,7 @@ inline constexpr const char *trinaryLogic = "PHPStan\\TrinaryLogic"; inline constexpr const char *type = "PHPStan\\Type\\Type"; inline constexpr const char *specifiedTypes = "PHPStan\\Analyser\\SpecifiedTypes"; inline constexpr const char *parameterReflection = "PHPStan\\Reflection\\ParameterReflection"; +inline constexpr const char *methodOrFunctionReflection = "PHPStan\\Reflection\\MethodReflection|PHPStan\\Reflection\\FunctionReflection"; inline constexpr const char *phpVersions = "PHPStan\\Php\\PhpVersions"; inline constexpr const char *param = "PhpParser\\Node\\Param"; inline constexpr const char *classMethodNode = "PhpParser\\Node\\Stmt\\ClassMethod"; @@ -12704,7 +12705,7 @@ PT_MINIT_REGISTRATION(pt_register_mutating_scope) /* {{{ twin 1835-2011 */ cls.method("pushInFunctionCall", reg::Public, 3, { - reg::any("reflection"), + reg::obj("reflection", methodOrFunctionReflection, true), reg::obj("parameter", parameterReflection, true), reg::boolArg("rememberTypes"), }, msPushInFunctionCall, &returnsSelf); diff --git a/turbo-ext/src/generated/ArenaCache.h b/turbo-ext/src/generated/ArenaCache.h index 36cc66191aa..144eab43581 100644 --- a/turbo-ext/src/generated/ArenaCache.h +++ b/turbo-ext/src/generated/ArenaCache.h @@ -53,10 +53,10 @@ inline constexpr reg::PackedArg args[] = { reg::packed(45, MAY_BE_STRING), /* lookup $key */ reg::packed(6, MAY_BE_ANY), /* lookup return */ reg::packed(45, MAY_BE_STRING), /* publish $key */ - reg::packed(66, 0), /* publish $value */ + reg::packed(66, MAY_BE_ANY), /* publish $value */ reg::packed(6, MAY_BE_VOID), /* publish return */ reg::packed(45, MAY_BE_STRING), /* replace $key */ - reg::packed(66, 0), /* replace $value */ + reg::packed(66, MAY_BE_ANY), /* replace $value */ reg::packed(6, MAY_BE_VOID), /* replace return */ reg::packed(88, MAY_BE_STRING), /* lookupHash $recordKey */ reg::packed(98, MAY_BE_STRING), /* lookupHash $entryKey */ diff --git a/turbo-ext/src/generated/ArgumentsHandler.h b/turbo-ext/src/generated/ArgumentsHandler.h index d8e3af1f82b..e52057929ee 100644 --- a/turbo-ext/src/generated/ArgumentsHandler.h +++ b/turbo-ext/src/generated/ArgumentsHandler.h @@ -86,71 +86,73 @@ inline constexpr char strings[] = "stmt\0" /* 885 */ "PhpParser\\Node\\Stmt\0" /* 890 */ "calleeReflection\0" /* 910 */ - "nakedMethodReflection\0" /* 927 */ - "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 949 */ - "parametersAcceptors\0" /* 993 */ - "namedArgumentsVariants\0" /* 1013 */ - "callLike\0" /* 1036 */ - "PhpParser\\Node\\Expr\\CallLike\0" /* 1045 */ - "scope\0" /* 1074 */ - "PHPStan\\Analyser\\MutatingScope\0" /* 1080 */ - "storage\0" /* 1111 */ - "PHPStan\\Analyser\\ExpressionResultStorage\0" /* 1119 */ - "nodeCallback\0" /* 1160 */ - "context\0" /* 1173 */ - "PHPStan\\Analyser\\ExpressionContext\0" /* 1181 */ - "closureBindScopeFactory\0" /* 1216 */ - "null\0" /* 1240 */ - "\0" /* 1245 */ - "PHPStan\\Analyser\\ArgsResult\0" /* 1246 */ - "processArgs\0" /* 1274 */ - "types\0" /* 1286 */ - "unpack\0" /* 1292 */ - "hasName\0" /* 1299 */ - "originalArg\0" /* 1307 */ - "PhpParser\\Node\\Arg\0" /* 1319 */ - "i\0" /* 1338 */ - "type\0" /* 1340 */ - "PHPStan\\Type\\Type\0" /* 1345 */ - "addGatheredArgType\0" /* 1363 */ - "value\0" /* 1382 */ - "PhpParser\\Node\\Expr\0" /* 1388 */ - "argConsumesResolvedParameterType\0" /* 1408 */ - "closureExpr\0" /* 1441 */ - "gatherClosureArgType\0" /* 1453 */ - "args\0" /* 1474 */ - "PHPStan\\Reflection\\ParametersAcceptor\0" /* 1479 */ - "selectCountStableMetadataAcceptor\0" /* 1517 */ - "acceptor\0" /* 1551 */ - "arg\0" /* 1560 */ - "PHPStan\\Reflection\\ParameterReflection\0" /* 1564 */ - "matchArgParameter\0" /* 1603 */ - "selectArgsAcceptor\0" /* 1621 */ - "gatheredTypes\0" /* 1640 */ - "selectArgsMetadataAcceptor\0" /* 1654 */ - "originalCall\0" /* 1681 */ - "normalizedCall\0" /* 1694 */ - "processDroppedArgs\0" /* 1709 */ - "parameter\0" /* 1728 */ - "parameterType\0" /* 1738 */ - "callCallbackImmediately\0" /* 1752 */ - "shouldInvalidateCallbackExpressions\0" /* 1776 */ - "getParameterTypeFromParameterClosureTypeExtension\0" /* 1812 */ - "currentParameter\0" /* 1862 */ - "getParameterOutExtensionsType\0" /* 1879 */ - "call\0" /* 1909 */ - "resolveClosureThisType\0" /* 1914 */ - "position\0" /* 1937 */ - "unpackedType\0" /* 1946 */ - "isPure\0" /* 1959 */ - "observeUnpackedArgument\0" /* 1966 */ - "valueType\0" /* 1990 */ - "observeArgumentValue\0" /* 2000 */ - "findOriginalParameterType\0" /* 2021 */ - "argResults\0" /* 2047 */ - "argValue\0" /* 2058 */ - "PHPStan\\Analyser\\ExpressionResult\0" /* 2067 */ - "readArgResult"; /* 2101 */ + "PHPStan\\Reflection\\MethodReflection|PHPStan\\Reflection\\FunctionReflection\0" /* 927 */ + "nakedMethodReflection\0" /* 1001 */ + "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 1023 */ + "parametersAcceptors\0" /* 1067 */ + "namedArgumentsVariants\0" /* 1087 */ + "callLike\0" /* 1110 */ + "PhpParser\\Node\\Expr\\CallLike\0" /* 1119 */ + "scope\0" /* 1148 */ + "PHPStan\\Analyser\\MutatingScope\0" /* 1154 */ + "storage\0" /* 1185 */ + "PHPStan\\Analyser\\ExpressionResultStorage\0" /* 1193 */ + "nodeCallback\0" /* 1234 */ + "context\0" /* 1247 */ + "PHPStan\\Analyser\\ExpressionContext\0" /* 1255 */ + "closureBindScopeFactory\0" /* 1290 */ + "null\0" /* 1314 */ + "\0" /* 1319 */ + "PHPStan\\Analyser\\ArgsResult\0" /* 1320 */ + "processArgs\0" /* 1348 */ + "types\0" /* 1360 */ + "unpack\0" /* 1366 */ + "hasName\0" /* 1373 */ + "originalArg\0" /* 1381 */ + "PhpParser\\Node\\Arg\0" /* 1393 */ + "i\0" /* 1412 */ + "type\0" /* 1414 */ + "PHPStan\\Type\\Type\0" /* 1419 */ + "addGatheredArgType\0" /* 1437 */ + "value\0" /* 1456 */ + "PhpParser\\Node\\Expr\0" /* 1462 */ + "argConsumesResolvedParameterType\0" /* 1482 */ + "closureExpr\0" /* 1515 */ + "gatherClosureArgType\0" /* 1527 */ + "args\0" /* 1548 */ + "PHPStan\\Reflection\\ParametersAcceptor\0" /* 1553 */ + "selectCountStableMetadataAcceptor\0" /* 1591 */ + "acceptor\0" /* 1625 */ + "arg\0" /* 1634 */ + "PHPStan\\Reflection\\ParameterReflection\0" /* 1638 */ + "matchArgParameter\0" /* 1677 */ + "selectArgsAcceptor\0" /* 1695 */ + "gatheredTypes\0" /* 1714 */ + "selectArgsMetadataAcceptor\0" /* 1728 */ + "originalCall\0" /* 1755 */ + "normalizedCall\0" /* 1768 */ + "processDroppedArgs\0" /* 1783 */ + "parameter\0" /* 1802 */ + "parameterType\0" /* 1812 */ + "callCallbackImmediately\0" /* 1826 */ + "shouldInvalidateCallbackExpressions\0" /* 1850 */ + "getParameterTypeFromParameterClosureTypeExtension\0" /* 1886 */ + "currentParameter\0" /* 1936 */ + "getParameterOutExtensionsType\0" /* 1953 */ + "call\0" /* 1983 */ + "PHPStan\\Reflection\\FunctionReflection|PHPStan\\Reflection\\MethodReflection\0" /* 1988 */ + "resolveClosureThisType\0" /* 2062 */ + "position\0" /* 2085 */ + "unpackedType\0" /* 2094 */ + "isPure\0" /* 2107 */ + "observeUnpackedArgument\0" /* 2114 */ + "valueType\0" /* 2138 */ + "observeArgumentValue\0" /* 2148 */ + "findOriginalParameterType\0" /* 2169 */ + "argResults\0" /* 2195 */ + "argValue\0" /* 2206 */ + "PHPStan\\Analyser\\ExpressionResult\0" /* 2215 */ + "readArgResult"; /* 2249 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 25), /* __construct $templateArgumentObserver */ reg::packed(76, 0, 100), /* __construct $expressionResultFactory */ @@ -170,103 +172,103 @@ inline constexpr reg::PackedArg args[] = { reg::packed(734, 0, 759), /* __construct $closureParameterResolver */ reg::packed(832, 0, 850), /* processArgs $nodeScopeResolver */ reg::packed(885, 0, 890), /* processArgs $stmt */ - reg::packed(910, 0), /* processArgs $calleeReflection */ - reg::packed(927, MAY_BE_NULL, 949), /* processArgs $nakedMethodReflection */ - reg::packed(993, MAY_BE_ARRAY), /* processArgs $parametersAcceptors */ - reg::packed(1013, MAY_BE_NULL | MAY_BE_ARRAY), /* processArgs $namedArgumentsVariants */ - reg::packed(1036, 0, 1045), /* processArgs $callLike */ - reg::packed(1074, 0, 1080), /* processArgs $scope */ - reg::packed(1111, 0, 1119), /* processArgs $storage */ - reg::packed(1160, MAY_BE_CALLABLE), /* processArgs $nodeCallback */ - reg::packed(1173, 0, 1181), /* processArgs $context */ - reg::packed(1216, MAY_BE_NULL | MAY_BE_CALLABLE, reg::NoString, false, false, 1240), /* processArgs $closureBindScopeFactory */ - reg::packed(1245, 0, 1246), /* processArgs return */ - reg::packed(1286, MAY_BE_ARRAY, reg::NoString, true, false), /* addGatheredArgType $types */ - reg::packed(1292, MAY_BE_BOOL, reg::NoString, true, false), /* addGatheredArgType $unpack */ - reg::packed(1299, MAY_BE_BOOL, reg::NoString, true, false), /* addGatheredArgType $hasName */ - reg::packed(1307, 0, 1319), /* addGatheredArgType $originalArg */ - reg::packed(1338, MAY_BE_LONG), /* addGatheredArgType $i */ - reg::packed(1340, 0, 1345), /* addGatheredArgType $type */ - reg::packed(1245, MAY_BE_VOID), /* addGatheredArgType return */ - reg::packed(1382, 0, 1388), /* argConsumesResolvedParameterType $value */ - reg::packed(1245, MAY_BE_BOOL), /* argConsumesResolvedParameterType return */ - reg::packed(993, MAY_BE_ARRAY), /* gatherClosureArgType $parametersAcceptors */ - reg::packed(1338, MAY_BE_LONG), /* gatherClosureArgType $i */ - reg::packed(1441, 0, 1388), /* gatherClosureArgType $closureExpr */ - reg::packed(1074, 0, 1080), /* gatherClosureArgType $scope */ - reg::packed(1245, 0, 1345), /* gatherClosureArgType return */ + reg::packed(910, MAY_BE_NULL, 927), /* processArgs $calleeReflection */ + reg::packed(1001, MAY_BE_NULL, 1023), /* processArgs $nakedMethodReflection */ + reg::packed(1067, MAY_BE_ARRAY), /* processArgs $parametersAcceptors */ + reg::packed(1087, MAY_BE_NULL | MAY_BE_ARRAY), /* processArgs $namedArgumentsVariants */ + reg::packed(1110, 0, 1119), /* processArgs $callLike */ + reg::packed(1148, 0, 1154), /* processArgs $scope */ + reg::packed(1185, 0, 1193), /* processArgs $storage */ + reg::packed(1234, MAY_BE_CALLABLE), /* processArgs $nodeCallback */ + reg::packed(1247, 0, 1255), /* processArgs $context */ + reg::packed(1290, MAY_BE_NULL | MAY_BE_CALLABLE, reg::NoString, false, false, 1314), /* processArgs $closureBindScopeFactory */ + reg::packed(1319, 0, 1320), /* processArgs return */ + reg::packed(1360, MAY_BE_ARRAY, reg::NoString, true, false), /* addGatheredArgType $types */ + reg::packed(1366, MAY_BE_BOOL, reg::NoString, true, false), /* addGatheredArgType $unpack */ + reg::packed(1373, MAY_BE_BOOL, reg::NoString, true, false), /* addGatheredArgType $hasName */ + reg::packed(1381, 0, 1393), /* addGatheredArgType $originalArg */ + reg::packed(1412, MAY_BE_LONG), /* addGatheredArgType $i */ + reg::packed(1414, 0, 1419), /* addGatheredArgType $type */ + reg::packed(1319, MAY_BE_VOID), /* addGatheredArgType return */ + reg::packed(1456, 0, 1462), /* argConsumesResolvedParameterType $value */ + reg::packed(1319, MAY_BE_BOOL), /* argConsumesResolvedParameterType return */ + reg::packed(1067, MAY_BE_ARRAY), /* gatherClosureArgType $parametersAcceptors */ + reg::packed(1412, MAY_BE_LONG), /* gatherClosureArgType $i */ + reg::packed(1515, 0, 1462), /* gatherClosureArgType $closureExpr */ + reg::packed(1148, 0, 1154), /* gatherClosureArgType $scope */ + reg::packed(1319, 0, 1419), /* gatherClosureArgType return */ reg::packed(832, 0, 850), /* selectCountStableMetadataAcceptor $nodeScopeResolver */ - reg::packed(1474, MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $args */ - reg::packed(993, MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $parametersAcceptors */ - reg::packed(1013, MAY_BE_NULL | MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $namedArgumentsVariants */ - reg::packed(1074, 0, 1080), /* selectCountStableMetadataAcceptor $scope */ - reg::packed(1245, 0, 1479), /* selectCountStableMetadataAcceptor return */ - reg::packed(1551, 0, 1479), /* matchArgParameter $acceptor */ - reg::packed(1560, 0, 1319), /* matchArgParameter $arg */ - reg::packed(1338, MAY_BE_LONG), /* matchArgParameter $i */ - reg::packed(1245, MAY_BE_NULL, 1564), /* matchArgParameter return */ - reg::packed(1286, MAY_BE_ARRAY), /* selectArgsAcceptor $types */ - reg::packed(993, MAY_BE_ARRAY), /* selectArgsAcceptor $parametersAcceptors */ - reg::packed(1013, MAY_BE_NULL | MAY_BE_ARRAY), /* selectArgsAcceptor $namedArgumentsVariants */ - reg::packed(1299, MAY_BE_BOOL), /* selectArgsAcceptor $hasName */ - reg::packed(1292, MAY_BE_BOOL), /* selectArgsAcceptor $unpack */ - reg::packed(1245, 0, 1479), /* selectArgsAcceptor return */ + reg::packed(1548, MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $args */ + reg::packed(1067, MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $parametersAcceptors */ + reg::packed(1087, MAY_BE_NULL | MAY_BE_ARRAY), /* selectCountStableMetadataAcceptor $namedArgumentsVariants */ + reg::packed(1148, 0, 1154), /* selectCountStableMetadataAcceptor $scope */ + reg::packed(1319, 0, 1553), /* selectCountStableMetadataAcceptor return */ + reg::packed(1625, 0, 1553), /* matchArgParameter $acceptor */ + reg::packed(1634, 0, 1393), /* matchArgParameter $arg */ + reg::packed(1412, MAY_BE_LONG), /* matchArgParameter $i */ + reg::packed(1319, MAY_BE_NULL, 1638), /* matchArgParameter return */ + reg::packed(1360, MAY_BE_ARRAY), /* selectArgsAcceptor $types */ + reg::packed(1067, MAY_BE_ARRAY), /* selectArgsAcceptor $parametersAcceptors */ + reg::packed(1087, MAY_BE_NULL | MAY_BE_ARRAY), /* selectArgsAcceptor $namedArgumentsVariants */ + reg::packed(1373, MAY_BE_BOOL), /* selectArgsAcceptor $hasName */ + reg::packed(1366, MAY_BE_BOOL), /* selectArgsAcceptor $unpack */ + reg::packed(1319, 0, 1553), /* selectArgsAcceptor return */ reg::packed(832, 0, 850), /* selectArgsMetadataAcceptor $nodeScopeResolver */ - reg::packed(1474, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $args */ - reg::packed(1640, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $gatheredTypes */ - reg::packed(993, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $parametersAcceptors */ - reg::packed(1013, MAY_BE_NULL | MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $namedArgumentsVariants */ - reg::packed(1299, MAY_BE_BOOL), /* selectArgsMetadataAcceptor $hasName */ - reg::packed(1292, MAY_BE_BOOL), /* selectArgsMetadataAcceptor $unpack */ - reg::packed(1074, 0, 1080), /* selectArgsMetadataAcceptor $scope */ - reg::packed(1245, 0, 1479), /* selectArgsMetadataAcceptor return */ + reg::packed(1548, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $args */ + reg::packed(1714, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $gatheredTypes */ + reg::packed(1067, MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $parametersAcceptors */ + reg::packed(1087, MAY_BE_NULL | MAY_BE_ARRAY), /* selectArgsMetadataAcceptor $namedArgumentsVariants */ + reg::packed(1373, MAY_BE_BOOL), /* selectArgsMetadataAcceptor $hasName */ + reg::packed(1366, MAY_BE_BOOL), /* selectArgsMetadataAcceptor $unpack */ + reg::packed(1148, 0, 1154), /* selectArgsMetadataAcceptor $scope */ + reg::packed(1319, 0, 1553), /* selectArgsMetadataAcceptor return */ reg::packed(832, 0, 850), /* processDroppedArgs $nodeScopeResolver */ reg::packed(885, 0, 890), /* processDroppedArgs $stmt */ - reg::packed(1681, 0, 1045), /* processDroppedArgs $originalCall */ - reg::packed(1694, 0, 1045), /* processDroppedArgs $normalizedCall */ - reg::packed(1074, 0, 1080), /* processDroppedArgs $scope */ - reg::packed(1111, 0, 1119), /* processDroppedArgs $storage */ - reg::packed(1173, 0, 1181), /* processDroppedArgs $context */ - reg::packed(1245, MAY_BE_VOID), /* processDroppedArgs return */ - reg::packed(1728, MAY_BE_NULL, 1564), /* callCallbackImmediately $parameter */ - reg::packed(1738, MAY_BE_NULL, 1345), /* callCallbackImmediately $parameterType */ - reg::packed(910, 0), /* callCallbackImmediately $calleeReflection */ - reg::packed(1245, MAY_BE_BOOL), /* callCallbackImmediately return */ - reg::packed(1728, MAY_BE_NULL, 1564), /* shouldInvalidateCallbackExpressions $parameter */ - reg::packed(1245, MAY_BE_BOOL), /* shouldInvalidateCallbackExpressions return */ - reg::packed(1036, 0, 1045), /* getParameterTypeFromParameterClosureTypeExtension $callLike */ - reg::packed(910, 0), /* getParameterTypeFromParameterClosureTypeExtension $calleeReflection */ - reg::packed(1728, 0, 1564), /* getParameterTypeFromParameterClosureTypeExtension $parameter */ - reg::packed(1074, 0, 1080), /* getParameterTypeFromParameterClosureTypeExtension $scope */ - reg::packed(1245, MAY_BE_NULL, 1345), /* getParameterTypeFromParameterClosureTypeExtension return */ - reg::packed(1036, 0, 1045), /* getParameterOutExtensionsType $callLike */ - reg::packed(910, 0), /* getParameterOutExtensionsType $calleeReflection */ - reg::packed(1862, 0, 1564), /* getParameterOutExtensionsType $currentParameter */ - reg::packed(1074, 0, 1080), /* getParameterOutExtensionsType $scope */ - reg::packed(1245, MAY_BE_NULL, 1345), /* getParameterOutExtensionsType return */ - reg::packed(1909, MAY_BE_NULL, 1045), /* resolveClosureThisType $call */ - reg::packed(910, 0), /* resolveClosureThisType $calleeReflection */ - reg::packed(1728, 0, 1564), /* resolveClosureThisType $parameter */ - reg::packed(1074, 0, 1080), /* resolveClosureThisType $scope */ - reg::packed(1245, MAY_BE_NULL, 1345), /* resolveClosureThisType return */ - reg::packed(1074, 0, 1080), /* observeUnpackedArgument $scope */ - reg::packed(1551, 0, 1479), /* observeUnpackedArgument $acceptor */ - reg::packed(1937, MAY_BE_LONG), /* observeUnpackedArgument $position */ - reg::packed(1946, 0, 1345), /* observeUnpackedArgument $unpackedType */ - reg::packed(1959, MAY_BE_BOOL), /* observeUnpackedArgument $isPure */ - reg::packed(1245, 0, 1080), /* observeUnpackedArgument return */ - reg::packed(1074, 0, 1080), /* observeArgumentValue $scope */ - reg::packed(1551, 0, 1479), /* observeArgumentValue $acceptor */ - reg::packed(1728, 0, 1564), /* observeArgumentValue $parameter */ - reg::packed(1990, 0, 1345), /* observeArgumentValue $valueType */ - reg::packed(1959, MAY_BE_BOOL), /* observeArgumentValue $isPure */ - reg::packed(1245, 0, 1080), /* observeArgumentValue return */ - reg::packed(1551, 0, 1479), /* findOriginalParameterType $acceptor */ - reg::packed(1728, 0, 1564), /* findOriginalParameterType $parameter */ - reg::packed(1245, MAY_BE_NULL, 1345), /* findOriginalParameterType return */ - reg::packed(2047, MAY_BE_ARRAY), /* readArgResult $argResults */ - reg::packed(2058, 0, 1388), /* readArgResult $argValue */ - reg::packed(1245, 0, 2067), /* readArgResult return */ + reg::packed(1755, 0, 1119), /* processDroppedArgs $originalCall */ + reg::packed(1768, 0, 1119), /* processDroppedArgs $normalizedCall */ + reg::packed(1148, 0, 1154), /* processDroppedArgs $scope */ + reg::packed(1185, 0, 1193), /* processDroppedArgs $storage */ + reg::packed(1247, 0, 1255), /* processDroppedArgs $context */ + reg::packed(1319, MAY_BE_VOID), /* processDroppedArgs return */ + reg::packed(1802, MAY_BE_NULL, 1638), /* callCallbackImmediately $parameter */ + reg::packed(1812, MAY_BE_NULL, 1419), /* callCallbackImmediately $parameterType */ + reg::packed(910, MAY_BE_NULL, 927), /* callCallbackImmediately $calleeReflection */ + reg::packed(1319, MAY_BE_BOOL), /* callCallbackImmediately return */ + reg::packed(1802, MAY_BE_NULL, 1638), /* shouldInvalidateCallbackExpressions $parameter */ + reg::packed(1319, MAY_BE_BOOL), /* shouldInvalidateCallbackExpressions return */ + reg::packed(1110, 0, 1119), /* getParameterTypeFromParameterClosureTypeExtension $callLike */ + reg::packed(910, MAY_BE_NULL, 927), /* getParameterTypeFromParameterClosureTypeExtension $calleeReflection */ + reg::packed(1802, 0, 1638), /* getParameterTypeFromParameterClosureTypeExtension $parameter */ + reg::packed(1148, 0, 1154), /* getParameterTypeFromParameterClosureTypeExtension $scope */ + reg::packed(1319, MAY_BE_NULL, 1419), /* getParameterTypeFromParameterClosureTypeExtension return */ + reg::packed(1110, 0, 1119), /* getParameterOutExtensionsType $callLike */ + reg::packed(910, MAY_BE_NULL, 927), /* getParameterOutExtensionsType $calleeReflection */ + reg::packed(1936, 0, 1638), /* getParameterOutExtensionsType $currentParameter */ + reg::packed(1148, 0, 1154), /* getParameterOutExtensionsType $scope */ + reg::packed(1319, MAY_BE_NULL, 1419), /* getParameterOutExtensionsType return */ + reg::packed(1983, MAY_BE_NULL, 1119), /* resolveClosureThisType $call */ + reg::packed(910, MAY_BE_NULL, 1988), /* resolveClosureThisType $calleeReflection */ + reg::packed(1802, 0, 1638), /* resolveClosureThisType $parameter */ + reg::packed(1148, 0, 1154), /* resolveClosureThisType $scope */ + reg::packed(1319, MAY_BE_NULL, 1419), /* resolveClosureThisType return */ + reg::packed(1148, 0, 1154), /* observeUnpackedArgument $scope */ + reg::packed(1625, 0, 1553), /* observeUnpackedArgument $acceptor */ + reg::packed(2085, MAY_BE_LONG), /* observeUnpackedArgument $position */ + reg::packed(2094, 0, 1419), /* observeUnpackedArgument $unpackedType */ + reg::packed(2107, MAY_BE_BOOL), /* observeUnpackedArgument $isPure */ + reg::packed(1319, 0, 1154), /* observeUnpackedArgument return */ + reg::packed(1148, 0, 1154), /* observeArgumentValue $scope */ + reg::packed(1625, 0, 1553), /* observeArgumentValue $acceptor */ + reg::packed(1802, 0, 1638), /* observeArgumentValue $parameter */ + reg::packed(2138, 0, 1419), /* observeArgumentValue $valueType */ + reg::packed(2107, MAY_BE_BOOL), /* observeArgumentValue $isPure */ + reg::packed(1319, 0, 1154), /* observeArgumentValue return */ + reg::packed(1625, 0, 1553), /* findOriginalParameterType $acceptor */ + reg::packed(1802, 0, 1638), /* findOriginalParameterType $parameter */ + reg::packed(1319, MAY_BE_NULL, 1419), /* findOriginalParameterType return */ + reg::packed(2195, MAY_BE_ARRAY), /* readArgResult $argResults */ + reg::packed(2206, 0, 1462), /* readArgResult $argValue */ + reg::packed(1319, 0, 2215), /* readArgResult return */ }; using Sig = reg::Sig; } // namespace sigtab @@ -274,24 +276,24 @@ using Sig = reg::Sig; /* the signatures of the methods the class declares itself (a used trait's are in the trait's header) */ namespace sig { inline constexpr sigtab::Sig __construct = { { 820 /* __construct */, 16, 0, 16, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processArgs = { { 1274 /* processArgs */, 11, 16, 12, 28, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig addGatheredArgType = { { 1363 /* addGatheredArgType */, 6, 29, 6, 35, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig argConsumesResolvedParameterType = { { 1408 /* argConsumesResolvedParameterType */, 1, 36, 1, 37, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig gatherClosureArgType = { { 1453 /* gatherClosureArgType */, 4, 38, 4, 42, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig selectCountStableMetadataAcceptor = { { 1517 /* selectCountStableMetadataAcceptor */, 5, 43, 5, 48, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig matchArgParameter = { { 1603 /* matchArgParameter */, 3, 49, 3, 52, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig selectArgsAcceptor = { { 1621 /* selectArgsAcceptor */, 5, 53, 5, 58, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig selectArgsMetadataAcceptor = { { 1654 /* selectArgsMetadataAcceptor */, 8, 59, 8, 67, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig processDroppedArgs = { { 1709 /* processDroppedArgs */, 7, 68, 7, 75, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig callCallbackImmediately = { { 1752 /* callCallbackImmediately */, 3, 76, 3, 79, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig shouldInvalidateCallbackExpressions = { { 1776 /* shouldInvalidateCallbackExpressions */, 1, 80, 1, 81, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getParameterTypeFromParameterClosureTypeExtension = { { 1812 /* getParameterTypeFromParameterClosureTypeExtension */, 4, 82, 4, 86, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getParameterOutExtensionsType = { { 1879 /* getParameterOutExtensionsType */, 4, 87, 4, 91, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveClosureThisType = { { 1914 /* resolveClosureThisType */, 4, 92, 4, 96, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig observeUnpackedArgument = { { 1966 /* observeUnpackedArgument */, 5, 97, 5, 102, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig observeArgumentValue = { { 2000 /* observeArgumentValue */, 5, 103, 5, 108, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig findOriginalParameterType = { { 2021 /* findOriginalParameterType */, 2, 109, 2, 111, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig readArgResult = { { 2101 /* readArgResult */, 2, 112, 2, 114, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processArgs = { { 1348 /* processArgs */, 11, 16, 12, 28, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig addGatheredArgType = { { 1437 /* addGatheredArgType */, 6, 29, 6, 35, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig argConsumesResolvedParameterType = { { 1482 /* argConsumesResolvedParameterType */, 1, 36, 1, 37, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig gatherClosureArgType = { { 1527 /* gatherClosureArgType */, 4, 38, 4, 42, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig selectCountStableMetadataAcceptor = { { 1591 /* selectCountStableMetadataAcceptor */, 5, 43, 5, 48, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig matchArgParameter = { { 1677 /* matchArgParameter */, 3, 49, 3, 52, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig selectArgsAcceptor = { { 1695 /* selectArgsAcceptor */, 5, 53, 5, 58, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig selectArgsMetadataAcceptor = { { 1728 /* selectArgsMetadataAcceptor */, 8, 59, 8, 67, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processDroppedArgs = { { 1783 /* processDroppedArgs */, 7, 68, 7, 75, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig callCallbackImmediately = { { 1826 /* callCallbackImmediately */, 3, 76, 3, 79, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig shouldInvalidateCallbackExpressions = { { 1850 /* shouldInvalidateCallbackExpressions */, 1, 80, 1, 81, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getParameterTypeFromParameterClosureTypeExtension = { { 1886 /* getParameterTypeFromParameterClosureTypeExtension */, 4, 82, 4, 86, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getParameterOutExtensionsType = { { 1953 /* getParameterOutExtensionsType */, 4, 87, 4, 91, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveClosureThisType = { { 2062 /* resolveClosureThisType */, 4, 92, 4, 96, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig observeUnpackedArgument = { { 2114 /* observeUnpackedArgument */, 5, 97, 5, 102, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig observeArgumentValue = { { 2148 /* observeArgumentValue */, 5, 103, 5, 108, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig findOriginalParameterType = { { 2169 /* findOriginalParameterType */, 2, 109, 2, 111, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig readArgResult = { { 2249 /* readArgResult */, 2, 112, 2, 114, ZEND_ACC_PRIVATE } }; } // namespace sig } // namespace ptdecl::ArgumentsHandler diff --git a/turbo-ext/src/generated/CalledMethodProcessor.h b/turbo-ext/src/generated/CalledMethodProcessor.h index 7571f274e26..c5f7f0c8cc6 100644 --- a/turbo-ext/src/generated/CalledMethodProcessor.h +++ b/turbo-ext/src/generated/CalledMethodProcessor.h @@ -51,11 +51,12 @@ inline constexpr char strings[] = "processCalledMethod\0" /* 257 */ "clearCalledMethodResults\0" /* 277 */ "node\0" /* 302 */ - "storage\0" /* 307 */ - "PHPStan\\Analyser\\ExpressionResultStorage\0" /* 315 */ - "fileName\0" /* 356 */ - "nodeCallback\0" /* 365 */ - "processNodesForCalledMethod"; /* 378 */ + "PhpParser\\Node\0" /* 307 */ + "storage\0" /* 322 */ + "PHPStan\\Analyser\\ExpressionResultStorage\0" /* 330 */ + "fileName\0" /* 371 */ + "nodeCallback\0" /* 380 */ + "processNodesForCalledMethod"; /* 393 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 11), /* __construct $fileHelper */ reg::packed(35, 0, 42), /* __construct $parser */ @@ -65,11 +66,11 @@ inline constexpr reg::PackedArg args[] = { reg::packed(225, MAY_BE_NULL, 226), /* processCalledMethod return */ reg::packed(225, MAY_BE_VOID), /* clearCalledMethodResults return */ reg::packed(119, 0, 137), /* processNodesForCalledMethod $nodeScopeResolver */ - reg::packed(302, 0), /* processNodesForCalledMethod $node */ - reg::packed(307, 0, 315), /* processNodesForCalledMethod $storage */ - reg::packed(356, MAY_BE_STRING), /* processNodesForCalledMethod $fileName */ + reg::packed(302, MAY_BE_NULL | MAY_BE_BOOL | MAY_BE_LONG | MAY_BE_DOUBLE | MAY_BE_STRING | MAY_BE_ARRAY, 307), /* processNodesForCalledMethod $node */ + reg::packed(322, 0, 330), /* processNodesForCalledMethod $storage */ + reg::packed(371, MAY_BE_STRING), /* processNodesForCalledMethod $fileName */ reg::packed(172, 0, 189), /* processNodesForCalledMethod $methodReflection */ - reg::packed(365, MAY_BE_CALLABLE), /* processNodesForCalledMethod $nodeCallback */ + reg::packed(380, MAY_BE_CALLABLE), /* processNodesForCalledMethod $nodeCallback */ reg::packed(225, MAY_BE_VOID), /* processNodesForCalledMethod return */ }; using Sig = reg::Sig; @@ -80,7 +81,7 @@ namespace sig { inline constexpr sigtab::Sig __construct = { { 107 /* __construct */, 3, 0, 3, reg::NoArg, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig processCalledMethod = { { 257 /* processCalledMethod */, 2, 3, 2, 5, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig clearCalledMethodResults = { { 277 /* clearCalledMethodResults */, 0, 6, 0, 6, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processNodesForCalledMethod = { { 378 /* processNodesForCalledMethod */, 6, 7, 6, 13, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processNodesForCalledMethod = { { 393 /* processNodesForCalledMethod */, 6, 7, 6, 13, ZEND_ACC_PRIVATE } }; } // namespace sig } // namespace ptdecl::CalledMethodProcessor diff --git a/turbo-ext/src/generated/ConstantArrayType.h b/turbo-ext/src/generated/ConstantArrayType.h index 8a79cfce442..01a762ecf60 100644 --- a/turbo-ext/src/generated/ConstantArrayType.h +++ b/turbo-ext/src/generated/ConstantArrayType.h @@ -213,29 +213,30 @@ inline constexpr char strings[] = "other\0" /* 2285 */ "hasRequiredKeyMissingIn\0" /* 2291 */ "otherKeyType\0" /* 2315 */ - "getKeyIndex\0" /* 2328 */ - "makeOffsetRequired\0" /* 2340 */ - "makeList\0" /* 2359 */ - "makeListMaybe\0" /* 2368 */ - "mapValueType\0" /* 2382 */ - "mapKeyType\0" /* 2395 */ - "makeAllArrayKeysOptional\0" /* 2406 */ - "case\0" /* 2431 */ - "changeKeyCaseArray\0" /* 2436 */ - "filterArrayRemovingFalsey\0" /* 2455 */ - "PHPStan\\Type\\Constant\\ConstantStringType\0" /* 2481 */ - "foldConstantStringKeyCase\0" /* 2522 */ - "key\0" /* 2548 */ - "foldUnsealedKeyCase\0" /* 2552 */ - "PHPStan\\PhpDocParser\\Ast\\Type\\TypeNode\0" /* 2572 */ - "toPhpDocNode\0" /* 2611 */ - "position\0" /* 2624 */ - "PHPStan\\Type\\NativeTypePosition\0" /* 2633 */ - "toNativePhpTypeNode\0" /* 2665 */ - "value\0" /* 2685 */ - "isValidIdentifier\0" /* 2691 */ - "getFiniteTypes\0" /* 2709 */ - "hasTemplateOrLateResolvableType"; /* 2724 */ + "PHPStan\\Type\\Constant\\ConstantIntegerType|PHPStan\\Type\\Constant\\ConstantStringType\0" /* 2328 */ + "getKeyIndex\0" /* 2411 */ + "makeOffsetRequired\0" /* 2423 */ + "makeList\0" /* 2442 */ + "makeListMaybe\0" /* 2451 */ + "mapValueType\0" /* 2465 */ + "mapKeyType\0" /* 2478 */ + "makeAllArrayKeysOptional\0" /* 2489 */ + "case\0" /* 2514 */ + "changeKeyCaseArray\0" /* 2519 */ + "filterArrayRemovingFalsey\0" /* 2538 */ + "PHPStan\\Type\\Constant\\ConstantStringType\0" /* 2564 */ + "foldConstantStringKeyCase\0" /* 2605 */ + "key\0" /* 2631 */ + "foldUnsealedKeyCase\0" /* 2635 */ + "PHPStan\\PhpDocParser\\Ast\\Type\\TypeNode\0" /* 2655 */ + "toPhpDocNode\0" /* 2694 */ + "position\0" /* 2707 */ + "PHPStan\\Type\\NativeTypePosition\0" /* 2716 */ + "toNativePhpTypeNode\0" /* 2748 */ + "value\0" /* 2768 */ + "isValidIdentifier\0" /* 2774 */ + "getFiniteTypes\0" /* 2792 */ + "hasTemplateOrLateResolvableType"; /* 2807 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, MAY_BE_ARRAY), /* __construct $keyTypes */ reg::packed(9, MAY_BE_ARRAY), /* __construct $valueTypes */ @@ -404,7 +405,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(110, MAY_BE_BOOL), /* isKeyIndexMiss return */ reg::packed(2285, 0, 148), /* hasRequiredKeyMissingIn $other */ reg::packed(110, MAY_BE_BOOL), /* hasRequiredKeyMissingIn return */ - reg::packed(2315, 0), /* getKeyIndex $otherKeyType */ + reg::packed(2315, 0, 2328), /* getKeyIndex $otherKeyType */ reg::packed(110, MAY_BE_NULL | MAY_BE_LONG), /* getKeyIndex return */ reg::packed(881, 0, 254), /* makeOffsetRequired $offsetType */ reg::packed(110, 0, 148), /* makeOffsetRequired return */ @@ -415,18 +416,18 @@ inline constexpr reg::PackedArg args[] = { reg::packed(2116, MAY_BE_CALLABLE), /* mapKeyType $cb */ reg::packed(110, 0, 254), /* mapKeyType return */ reg::packed(110, 0, 254), /* makeAllArrayKeysOptional return */ - reg::packed(2431, MAY_BE_NULL | MAY_BE_LONG), /* changeKeyCaseArray $case */ + reg::packed(2514, MAY_BE_NULL | MAY_BE_LONG), /* changeKeyCaseArray $case */ reg::packed(110, 0, 254), /* changeKeyCaseArray return */ reg::packed(110, 0, 254), /* filterArrayRemovingFalsey return */ - reg::packed(479, 0, 2481), /* foldConstantStringKeyCase $type */ - reg::packed(2431, MAY_BE_NULL | MAY_BE_LONG), /* foldConstantStringKeyCase $case */ + reg::packed(479, 0, 2564), /* foldConstantStringKeyCase $type */ + reg::packed(2514, MAY_BE_NULL | MAY_BE_LONG), /* foldConstantStringKeyCase $case */ reg::packed(110, 0, 254), /* foldConstantStringKeyCase return */ - reg::packed(2548, 0, 254), /* foldUnsealedKeyCase $key */ - reg::packed(2431, MAY_BE_NULL | MAY_BE_LONG), /* foldUnsealedKeyCase $case */ + reg::packed(2631, 0, 254), /* foldUnsealedKeyCase $key */ + reg::packed(2514, MAY_BE_NULL | MAY_BE_LONG), /* foldUnsealedKeyCase $case */ reg::packed(110, 0, 254), /* foldUnsealedKeyCase return */ - reg::packed(110, 0, 2572), /* toPhpDocNode return */ - reg::packed(2624, 0, 2633), /* toNativePhpTypeNode $position */ - reg::packed(2685, MAY_BE_STRING), /* isValidIdentifier $value */ + reg::packed(110, 0, 2655), /* toPhpDocNode return */ + reg::packed(2707, 0, 2716), /* toNativePhpTypeNode $position */ + reg::packed(2768, MAY_BE_STRING), /* isValidIdentifier $value */ reg::packed(110, MAY_BE_BOOL), /* isValidIdentifier return */ reg::packed(110, MAY_BE_ARRAY), /* getFiniteTypes return */ reg::packed(110, MAY_BE_BOOL), /* hasTemplateOrLateResolvableType return */ @@ -525,22 +526,22 @@ inline constexpr sigtab::Sig getKeyIndexMap = { { 2234 /* getKeyIndexMap */, 0, inline constexpr sigtab::Sig findVerifiedKeyIndex = { { 2249 /* findVerifiedKeyIndex */, 1, 161, 1, 162, ZEND_ACC_PRIVATE } }; inline constexpr sigtab::Sig isKeyIndexMiss = { { 2270 /* isKeyIndexMiss */, 1, 163, 1, 164, ZEND_ACC_PRIVATE } }; inline constexpr sigtab::Sig hasRequiredKeyMissingIn = { { 2291 /* hasRequiredKeyMissingIn */, 1, 165, 1, 166, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getKeyIndex = { { 2328 /* getKeyIndex */, 1, 167, 1, 168, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig makeOffsetRequired = { { 2340 /* makeOffsetRequired */, 1, 169, 1, 170, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig makeList = { { 2359 /* makeList */, 0, 171, 0, 171, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig makeListMaybe = { { 2368 /* makeListMaybe */, 0, 172, 0, 172, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mapValueType = { { 2382 /* mapValueType */, 1, 173, 1, 174, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mapKeyType = { { 2395 /* mapKeyType */, 1, 175, 1, 176, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig makeAllArrayKeysOptional = { { 2406 /* makeAllArrayKeysOptional */, 0, 177, 0, 177, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig changeKeyCaseArray = { { 2436 /* changeKeyCaseArray */, 1, 178, 1, 179, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterArrayRemovingFalsey = { { 2455 /* filterArrayRemovingFalsey */, 0, 180, 0, 180, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig foldConstantStringKeyCase = { { 2522 /* foldConstantStringKeyCase */, 2, 181, 2, 183, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig foldUnsealedKeyCase = { { 2552 /* foldUnsealedKeyCase */, 2, 184, 2, 186, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig toPhpDocNode = { { 2611 /* toPhpDocNode */, 0, 187, 0, 187, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toNativePhpTypeNode = { { 2665 /* toNativePhpTypeNode */, 1, 188, 1, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isValidIdentifier = { { 2691 /* isValidIdentifier */, 1, 189, 1, 190, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig getFiniteTypes = { { 2709 /* getFiniteTypes */, 0, 191, 0, 191, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasTemplateOrLateResolvableType = { { 2724 /* hasTemplateOrLateResolvableType */, 0, 192, 0, 192, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getKeyIndex = { { 2411 /* getKeyIndex */, 1, 167, 1, 168, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig makeOffsetRequired = { { 2423 /* makeOffsetRequired */, 1, 169, 1, 170, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig makeList = { { 2442 /* makeList */, 0, 171, 0, 171, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig makeListMaybe = { { 2451 /* makeListMaybe */, 0, 172, 0, 172, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mapValueType = { { 2465 /* mapValueType */, 1, 173, 1, 174, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mapKeyType = { { 2478 /* mapKeyType */, 1, 175, 1, 176, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig makeAllArrayKeysOptional = { { 2489 /* makeAllArrayKeysOptional */, 0, 177, 0, 177, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig changeKeyCaseArray = { { 2519 /* changeKeyCaseArray */, 1, 178, 1, 179, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterArrayRemovingFalsey = { { 2538 /* filterArrayRemovingFalsey */, 0, 180, 0, 180, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig foldConstantStringKeyCase = { { 2605 /* foldConstantStringKeyCase */, 2, 181, 2, 183, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig foldUnsealedKeyCase = { { 2635 /* foldUnsealedKeyCase */, 2, 184, 2, 186, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig toPhpDocNode = { { 2694 /* toPhpDocNode */, 0, 187, 0, 187, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toNativePhpTypeNode = { { 2748 /* toNativePhpTypeNode */, 1, 188, 1, reg::NoArg, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isValidIdentifier = { { 2774 /* isValidIdentifier */, 1, 189, 1, 190, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig getFiniteTypes = { { 2792 /* getFiniteTypes */, 0, 191, 0, 191, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasTemplateOrLateResolvableType = { { 2807 /* hasTemplateOrLateResolvableType */, 0, 192, 0, 192, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::ConstantArrayType diff --git a/turbo-ext/src/generated/ConstantTypeHelper.h b/turbo-ext/src/generated/ConstantTypeHelper.h index 6dcaae721e1..b70a204bca6 100644 --- a/turbo-ext/src/generated/ConstantTypeHelper.h +++ b/turbo-ext/src/generated/ConstantTypeHelper.h @@ -33,7 +33,7 @@ inline constexpr char strings[] = "PHPStan\\Type\\GeneralizePrecision\0" /* 91 */ "unionGeneralized"; /* 124 */ inline constexpr reg::PackedArg args[] = { - reg::packed(0, 0), /* getTypeFromValue $value */ + reg::packed(0, MAY_BE_ANY), /* getTypeFromValue $value */ reg::packed(6, 0, 7), /* getTypeFromValue return */ reg::packed(0, MAY_BE_ARRAY), /* getOversizedArrayType $value */ reg::packed(6, 0, 7), /* getOversizedArrayType return */ diff --git a/turbo-ext/src/generated/ForkedChild.h b/turbo-ext/src/generated/ForkedChild.h index 79f871a2662..27537efa05e 100644 --- a/turbo-ext/src/generated/ForkedChild.h +++ b/turbo-ext/src/generated/ForkedChild.h @@ -22,16 +22,17 @@ inline void declareProperties(reg::Class &cls) /* the string and parameter tables the signatures below index into (see reg::Sig) */ namespace sigtab { inline constexpr char strings[] = - "exitImmediately"; /* 0 */ + "\0" /* 0 */ + "exitImmediately"; /* 1 */ inline constexpr reg::PackedArg args[] = { - reg::packed(0, 0), /* placeholder: C++ has no empty arrays */ + reg::packed(0, MAY_BE_NEVER), /* exitImmediately return */ }; using Sig = reg::Sig; } // namespace sigtab /* the signatures of the methods the class declares itself (a used trait's are in the trait's header) */ namespace sig { -inline constexpr sigtab::Sig exitImmediately = { { 0 /* exitImmediately */, 0, 0, 0, reg::NoArg, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig exitImmediately = { { 1 /* exitImmediately */, 0, 0, 0, 0, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; } // namespace sig } // namespace ptdecl::ForkedChild diff --git a/turbo-ext/src/generated/ImpurePoint.h b/turbo-ext/src/generated/ImpurePoint.h index 31ee40ab2fb..98ac9976fb4 100644 --- a/turbo-ext/src/generated/ImpurePoint.h +++ b/turbo-ext/src/generated/ImpurePoint.h @@ -45,10 +45,11 @@ inline constexpr char strings[] = "__construct\0" /* 80 */ "\0" /* 92 */ "getScope\0" /* 93 */ - "getNode\0" /* 102 */ - "getIdentifier\0" /* 110 */ - "getDescription\0" /* 124 */ - "isCertain"; /* 139 */ + "PhpParser\\Node\\Expr|PhpParser\\Node\\Stmt|PHPStan\\Node\\VirtualNode\0" /* 102 */ + "getNode\0" /* 167 */ + "getIdentifier\0" /* 175 */ + "getDescription\0" /* 189 */ + "isCertain"; /* 204 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 6), /* __construct $scope */ reg::packed(29, 0, 34), /* __construct $node */ @@ -56,6 +57,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(60, MAY_BE_STRING), /* __construct $description */ reg::packed(72, MAY_BE_BOOL), /* __construct $certain */ reg::packed(92, 0, 6), /* getScope return */ + reg::packed(92, 0, 102), /* getNode return */ reg::packed(92, MAY_BE_STRING), /* getIdentifier return */ reg::packed(92, MAY_BE_STRING), /* getDescription return */ reg::packed(92, MAY_BE_BOOL), /* isCertain return */ @@ -67,10 +69,10 @@ using Sig = reg::Sig; namespace sig { inline constexpr sigtab::Sig __construct = { { 80 /* __construct */, 5, 0, 5, reg::NoArg, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getScope = { { 93 /* getScope */, 0, 5, 0, 5, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getNode = { { 102 /* getNode */, 0, 6, 0, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getIdentifier = { { 110 /* getIdentifier */, 0, 6, 0, 6, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getDescription = { { 124 /* getDescription */, 0, 7, 0, 7, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isCertain = { { 139 /* isCertain */, 0, 8, 0, 8, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getNode = { { 167 /* getNode */, 0, 6, 0, 6, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getIdentifier = { { 175 /* getIdentifier */, 0, 7, 0, 7, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getDescription = { { 189 /* getDescription */, 0, 8, 0, 8, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isCertain = { { 204 /* isCertain */, 0, 9, 0, 9, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::ImpurePoint diff --git a/turbo-ext/src/generated/InitializerExprTypeResolver.h b/turbo-ext/src/generated/InitializerExprTypeResolver.h index 6065281e800..15eef8ccb92 100644 --- a/turbo-ext/src/generated/InitializerExprTypeResolver.h +++ b/turbo-ext/src/generated/InitializerExprTypeResolver.h @@ -83,66 +83,67 @@ inline constexpr char strings[] = "exprType\0" /* 813 */ "getCastObjectType\0" /* 822 */ "type\0" /* 840 */ - "isNullable\0" /* 845 */ - "isVariadic\0" /* 856 */ - "getFunctionType\0" /* 867 */ - "parameter\0" /* 883 */ - "PhpParser\\Node\\Param\0" /* 893 */ - "isParameterValueNullable\0" /* 914 */ - "PhpParser\\Node\\Expr\\CallLike\0" /* 939 */ - "nativeTypesPromoted\0" /* 968 */ - "getFirstClassCallableType\0" /* 988 */ - "function\0" /* 1014 */ - "PHPStan\\Reflection\\FunctionReflection|PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 1023 */ - "variants\0" /* 1105 */ - "createFirstClassCallable\0" /* 1114 */ - "getBitwiseAndType\0" /* 1139 */ - "getBitwiseOrType\0" /* 1157 */ - "getBitwiseXorType\0" /* 1174 */ - "getSpaceshipType\0" /* 1192 */ - "getDivType\0" /* 1209 */ - "getModType\0" /* 1220 */ - "getPlusType\0" /* 1231 */ - "getMinusType\0" /* 1243 */ - "getMulType\0" /* 1256 */ - "getPowType\0" /* 1267 */ - "getShiftLeftType\0" /* 1278 */ - "getShiftRightType\0" /* 1295 */ - "leftType\0" /* 1313 */ - "rightType\0" /* 1322 */ - "PHPStan\\Type\\TypeResult\0" /* 1332 */ - "resolveIdenticalType\0" /* 1356 */ - "resolveEqualType\0" /* 1377 */ - "isNonNumericString\0" /* 1394 */ - "PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1413 */ - "valueComparisonCallback\0" /* 1453 */ - "resolveConstantArrayTypeComparison\0" /* 1477 */ - "class\0" /* 1512 */ - "PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1518 */ - "constantName\0" /* 1558 */ - "classReflection\0" /* 1571 */ - "PHPStan\\Reflection\\ClassReflection\0" /* 1587 */ - "false\0" /* 1622 */ - "getClassConstFetchTypeByReflection\0" /* 1628 */ - "fetchedOnType\0" /* 1663 */ - "transformStaticType\0" /* 1677 */ - "getClassConstFetchType\0" /* 1697 */ - "getUnaryPlusType\0" /* 1720 */ - "getUnaryMinusType\0" /* 1737 */ - "getBitwiseNotType\0" /* 1755 */ - "getBitwiseNotTypeFromType\0" /* 1773 */ - "name\0" /* 1799 */ - "PhpParser\\Node\\Name\0" /* 1804 */ - "resolveName\0" /* 1824 */ - "PHPStan\\Type\\TypeWithClassName\0" /* 1836 */ - "resolveTypeByName\0" /* 1867 */ - "classType\0" /* 1885 */ - "methodReflectionCandidate\0" /* 1895 */ - "PHPStan\\Reflection\\MethodReflection\0" /* 1921 */ - "resolveTypeByNameWithLateStaticBinding\0" /* 1957 */ - "PHPStan\\Reflection\\ReflectionProvider\0" /* 1996 */ - "getReflectionProvider\0" /* 2034 */ - "getNeverType"; /* 2056 */ + "PhpParser\\Node\\Name|PhpParser\\Node\\Identifier|PhpParser\\Node\\ComplexType\0" /* 845 */ + "isNullable\0" /* 918 */ + "isVariadic\0" /* 929 */ + "getFunctionType\0" /* 940 */ + "parameter\0" /* 956 */ + "PhpParser\\Node\\Param\0" /* 966 */ + "isParameterValueNullable\0" /* 987 */ + "PhpParser\\Node\\Expr\\CallLike\0" /* 1012 */ + "nativeTypesPromoted\0" /* 1041 */ + "getFirstClassCallableType\0" /* 1061 */ + "function\0" /* 1087 */ + "PHPStan\\Reflection\\FunctionReflection|PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 1096 */ + "variants\0" /* 1178 */ + "createFirstClassCallable\0" /* 1187 */ + "getBitwiseAndType\0" /* 1212 */ + "getBitwiseOrType\0" /* 1230 */ + "getBitwiseXorType\0" /* 1247 */ + "getSpaceshipType\0" /* 1265 */ + "getDivType\0" /* 1282 */ + "getModType\0" /* 1293 */ + "getPlusType\0" /* 1304 */ + "getMinusType\0" /* 1316 */ + "getMulType\0" /* 1329 */ + "getPowType\0" /* 1340 */ + "getShiftLeftType\0" /* 1351 */ + "getShiftRightType\0" /* 1368 */ + "leftType\0" /* 1386 */ + "rightType\0" /* 1395 */ + "PHPStan\\Type\\TypeResult\0" /* 1405 */ + "resolveIdenticalType\0" /* 1429 */ + "resolveEqualType\0" /* 1450 */ + "isNonNumericString\0" /* 1467 */ + "PHPStan\\Type\\Constant\\ConstantArrayType\0" /* 1486 */ + "valueComparisonCallback\0" /* 1526 */ + "resolveConstantArrayTypeComparison\0" /* 1550 */ + "class\0" /* 1585 */ + "PhpParser\\Node\\Name|PhpParser\\Node\\Expr\0" /* 1591 */ + "constantName\0" /* 1631 */ + "classReflection\0" /* 1644 */ + "PHPStan\\Reflection\\ClassReflection\0" /* 1660 */ + "false\0" /* 1695 */ + "getClassConstFetchTypeByReflection\0" /* 1701 */ + "fetchedOnType\0" /* 1736 */ + "transformStaticType\0" /* 1750 */ + "getClassConstFetchType\0" /* 1770 */ + "getUnaryPlusType\0" /* 1793 */ + "getUnaryMinusType\0" /* 1810 */ + "getBitwiseNotType\0" /* 1828 */ + "getBitwiseNotTypeFromType\0" /* 1846 */ + "name\0" /* 1872 */ + "PhpParser\\Node\\Name\0" /* 1877 */ + "resolveName\0" /* 1897 */ + "PHPStan\\Type\\TypeWithClassName\0" /* 1909 */ + "resolveTypeByName\0" /* 1940 */ + "classType\0" /* 1958 */ + "methodReflectionCandidate\0" /* 1968 */ + "PHPStan\\Reflection\\MethodReflection\0" /* 1994 */ + "resolveTypeByNameWithLateStaticBinding\0" /* 2030 */ + "PHPStan\\Reflection\\ReflectionProvider\0" /* 2069 */ + "getReflectionProvider\0" /* 2107 */ + "getNeverType"; /* 2129 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 17), /* __construct $constantResolver */ reg::packed(51, 0, 78), /* __construct $reflectionProviderProvider */ @@ -175,20 +176,20 @@ inline constexpr reg::PackedArg args[] = { reg::packed(559, 0, 560), /* getCastType return */ reg::packed(813, 0, 560), /* getCastObjectType $exprType */ reg::packed(559, 0, 560), /* getCastObjectType return */ - reg::packed(840, 0), /* getFunctionType $type */ - reg::packed(845, MAY_BE_BOOL), /* getFunctionType $isNullable */ - reg::packed(856, MAY_BE_BOOL), /* getFunctionType $isVariadic */ + reg::packed(840, MAY_BE_NULL, 845), /* getFunctionType $type */ + reg::packed(918, MAY_BE_BOOL), /* getFunctionType $isNullable */ + reg::packed(929, MAY_BE_BOOL), /* getFunctionType $isVariadic */ reg::packed(509, 0, 517), /* getFunctionType $context */ reg::packed(559, 0, 560), /* getFunctionType return */ - reg::packed(883, 0, 893), /* isParameterValueNullable $parameter */ + reg::packed(956, 0, 966), /* isParameterValueNullable $parameter */ reg::packed(559, MAY_BE_BOOL), /* isParameterValueNullable return */ - reg::packed(484, 0, 939), /* getFirstClassCallableType $expr */ + reg::packed(484, 0, 1012), /* getFirstClassCallableType $expr */ reg::packed(509, 0, 517), /* getFirstClassCallableType $context */ - reg::packed(968, MAY_BE_BOOL), /* getFirstClassCallableType $nativeTypesPromoted */ + reg::packed(1041, MAY_BE_BOOL), /* getFirstClassCallableType $nativeTypesPromoted */ reg::packed(559, 0, 560), /* getFirstClassCallableType return */ - reg::packed(1014, MAY_BE_NULL, 1023), /* createFirstClassCallable $function */ - reg::packed(1105, MAY_BE_ARRAY), /* createFirstClassCallable $variants */ - reg::packed(968, MAY_BE_BOOL), /* createFirstClassCallable $nativeTypesPromoted */ + reg::packed(1087, MAY_BE_NULL, 1096), /* createFirstClassCallable $function */ + reg::packed(1178, MAY_BE_ARRAY), /* createFirstClassCallable $variants */ + reg::packed(1041, MAY_BE_BOOL), /* createFirstClassCallable $nativeTypesPromoted */ reg::packed(559, 0, 560), /* createFirstClassCallable return */ reg::packed(636, 0, 489), /* getBitwiseAndType $left */ reg::packed(641, 0, 489), /* getBitwiseAndType $right */ @@ -238,31 +239,31 @@ inline constexpr reg::PackedArg args[] = { reg::packed(641, 0, 489), /* getShiftRightType $right */ reg::packed(647, MAY_BE_CALLABLE), /* getShiftRightType $getTypeCallback */ reg::packed(559, 0, 560), /* getShiftRightType return */ - reg::packed(1313, 0, 560), /* resolveIdenticalType $leftType */ - reg::packed(1322, 0, 560), /* resolveIdenticalType $rightType */ - reg::packed(559, 0, 1332), /* resolveIdenticalType return */ - reg::packed(1313, 0, 560), /* resolveEqualType $leftType */ - reg::packed(1322, 0, 560), /* resolveEqualType $rightType */ + reg::packed(1386, 0, 560), /* resolveIdenticalType $leftType */ + reg::packed(1395, 0, 560), /* resolveIdenticalType $rightType */ + reg::packed(559, 0, 1405), /* resolveIdenticalType return */ + reg::packed(1386, 0, 560), /* resolveEqualType $leftType */ + reg::packed(1395, 0, 560), /* resolveEqualType $rightType */ reg::packed(722, MAY_BE_NULL, 734, false, false, 758), /* resolveEqualType $phpVersions */ - reg::packed(559, 0, 1332), /* resolveEqualType return */ + reg::packed(559, 0, 1405), /* resolveEqualType return */ reg::packed(840, 0, 560), /* isNonNumericString $type */ reg::packed(722, MAY_BE_ARRAY), /* isNonNumericString $phpVersions */ reg::packed(559, MAY_BE_BOOL), /* isNonNumericString return */ - reg::packed(1313, 0, 1413), /* resolveConstantArrayTypeComparison $leftType */ - reg::packed(1322, 0, 1413), /* resolveConstantArrayTypeComparison $rightType */ - reg::packed(1453, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */ - reg::packed(559, 0, 1332), /* resolveConstantArrayTypeComparison return */ - reg::packed(1512, 0, 1518), /* getClassConstFetchTypeByReflection $class */ - reg::packed(1558, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */ - reg::packed(1571, MAY_BE_NULL, 1587), /* getClassConstFetchTypeByReflection $classReflection */ + reg::packed(1386, 0, 1486), /* resolveConstantArrayTypeComparison $leftType */ + reg::packed(1395, 0, 1486), /* resolveConstantArrayTypeComparison $rightType */ + reg::packed(1526, MAY_BE_CALLABLE), /* resolveConstantArrayTypeComparison $valueComparisonCallback */ + reg::packed(559, 0, 1405), /* resolveConstantArrayTypeComparison return */ + reg::packed(1585, 0, 1591), /* getClassConstFetchTypeByReflection $class */ + reg::packed(1631, MAY_BE_STRING), /* getClassConstFetchTypeByReflection $constantName */ + reg::packed(1644, MAY_BE_NULL, 1660), /* getClassConstFetchTypeByReflection $classReflection */ reg::packed(647, MAY_BE_CALLABLE), /* getClassConstFetchTypeByReflection $getTypeCallback */ - reg::packed(968, MAY_BE_BOOL, reg::NoString, false, false, 1622), /* getClassConstFetchTypeByReflection $nativeTypesPromoted */ + reg::packed(1041, MAY_BE_BOOL, reg::NoString, false, false, 1695), /* getClassConstFetchTypeByReflection $nativeTypesPromoted */ reg::packed(559, 0, 560), /* getClassConstFetchTypeByReflection return */ reg::packed(840, 0, 560), /* transformStaticType $type */ - reg::packed(1663, 0, 560), /* transformStaticType $fetchedOnType */ + reg::packed(1736, 0, 560), /* transformStaticType $fetchedOnType */ reg::packed(559, 0, 560), /* transformStaticType return */ - reg::packed(1512, 0, 1518), /* getClassConstFetchType $class */ - reg::packed(1558, MAY_BE_STRING), /* getClassConstFetchType $constantName */ + reg::packed(1585, 0, 1591), /* getClassConstFetchType $class */ + reg::packed(1631, 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 */ @@ -277,19 +278,19 @@ inline constexpr reg::PackedArg args[] = { reg::packed(559, 0, 560), /* getBitwiseNotType return */ reg::packed(813, 0, 560), /* getBitwiseNotTypeFromType $exprType */ reg::packed(559, 0, 560), /* getBitwiseNotTypeFromType return */ - reg::packed(1799, 0, 1804), /* resolveName $name */ - reg::packed(1571, MAY_BE_NULL, 1587), /* resolveName $classReflection */ + reg::packed(1872, 0, 1877), /* resolveName $name */ + reg::packed(1644, MAY_BE_NULL, 1660), /* resolveName $classReflection */ reg::packed(559, MAY_BE_STRING), /* resolveName return */ - reg::packed(1799, 0, 1804), /* resolveTypeByName $name */ - reg::packed(1571, MAY_BE_NULL, 1587), /* resolveTypeByName $classReflection */ - reg::packed(559, 0, 1836), /* resolveTypeByName return */ - reg::packed(1512, 0, 1804), /* resolveTypeByNameWithLateStaticBinding $class */ - reg::packed(1885, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */ - reg::packed(1895, 0, 1921), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */ + reg::packed(1872, 0, 1877), /* resolveTypeByName $name */ + reg::packed(1644, MAY_BE_NULL, 1660), /* resolveTypeByName $classReflection */ + reg::packed(559, 0, 1909), /* resolveTypeByName return */ + reg::packed(1585, 0, 1877), /* resolveTypeByNameWithLateStaticBinding $class */ + reg::packed(1958, 0, 560), /* resolveTypeByNameWithLateStaticBinding $classType */ + reg::packed(1968, 0, 1994), /* resolveTypeByNameWithLateStaticBinding $methodReflectionCandidate */ reg::packed(559, 0, 560), /* resolveTypeByNameWithLateStaticBinding return */ - reg::packed(559, 0, 1996), /* getReflectionProvider return */ - reg::packed(1313, 0, 560), /* getNeverType $leftType */ - reg::packed(1322, 0, 560), /* getNeverType $rightType */ + reg::packed(559, 0, 2069), /* getReflectionProvider return */ + reg::packed(1386, 0, 560), /* getNeverType $leftType */ + reg::packed(1395, 0, 560), /* getNeverType $rightType */ reg::packed(559, 0, 560), /* getNeverType return */ }; using Sig = reg::Sig; @@ -305,38 +306,38 @@ inline constexpr sigtab::Sig resolveConcatType = { { 677 /* resolveConcatType */ inline constexpr sigtab::Sig getArrayType = { { 763 /* getArrayType */, 2, 22, 3, 25, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getCastType = { { 801 /* getCastType */, 2, 26, 2, 28, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getCastObjectType = { { 822 /* getCastObjectType */, 1, 29, 1, 30, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFunctionType = { { 867 /* getFunctionType */, 4, 31, 4, 35, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isParameterValueNullable = { { 914 /* isParameterValueNullable */, 1, 36, 1, 37, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getFirstClassCallableType = { { 988 /* getFirstClassCallableType */, 3, 38, 3, 41, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig createFirstClassCallable = { { 1114 /* createFirstClassCallable */, 3, 42, 3, 45, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getBitwiseAndType = { { 1139 /* getBitwiseAndType */, 3, 46, 3, 49, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getBitwiseOrType = { { 1157 /* getBitwiseOrType */, 3, 50, 3, 53, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getBitwiseXorType = { { 1174 /* getBitwiseXorType */, 3, 54, 3, 57, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getSpaceshipType = { { 1192 /* getSpaceshipType */, 3, 58, 3, 61, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getDivType = { { 1209 /* getDivType */, 3, 62, 3, 65, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getModType = { { 1220 /* getModType */, 3, 66, 3, 69, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPlusType = { { 1231 /* getPlusType */, 3, 70, 3, 73, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getMinusType = { { 1243 /* getMinusType */, 3, 74, 3, 77, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getMulType = { { 1256 /* getMulType */, 3, 78, 3, 81, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPowType = { { 1267 /* getPowType */, 3, 82, 3, 85, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getShiftLeftType = { { 1278 /* getShiftLeftType */, 3, 86, 3, 89, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getShiftRightType = { { 1295 /* getShiftRightType */, 3, 90, 3, 93, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig resolveIdenticalType = { { 1356 /* resolveIdenticalType */, 2, 94, 2, 96, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig resolveEqualType = { { 1377 /* resolveEqualType */, 2, 97, 3, 100, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isNonNumericString = { { 1394 /* isNonNumericString */, 2, 101, 2, 103, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1477 /* resolveConstantArrayTypeComparison */, 3, 104, 3, 107, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1628 /* getClassConstFetchTypeByReflection */, 4, 108, 5, 113, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig transformStaticType = { { 1677 /* transformStaticType */, 2, 114, 2, 116, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getClassConstFetchType = { { 1697 /* getClassConstFetchType */, 4, 117, 4, 121, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnaryPlusType = { { 1720 /* getUnaryPlusType */, 2, 122, 2, 124, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnaryMinusType = { { 1737 /* getUnaryMinusType */, 2, 125, 2, 127, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getBitwiseNotType = { { 1755 /* getBitwiseNotType */, 2, 128, 2, 130, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 1773 /* getBitwiseNotTypeFromType */, 1, 131, 1, 132, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig resolveName = { { 1824 /* resolveName */, 2, 133, 2, 135, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveTypeByName = { { 1867 /* resolveTypeByName */, 2, 136, 2, 138, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 1957 /* resolveTypeByNameWithLateStaticBinding */, 3, 139, 3, 142, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getReflectionProvider = { { 2034 /* getReflectionProvider */, 0, 143, 0, 143, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getNeverType = { { 2056 /* getNeverType */, 2, 144, 2, 146, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getFunctionType = { { 940 /* getFunctionType */, 4, 31, 4, 35, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isParameterValueNullable = { { 987 /* isParameterValueNullable */, 1, 36, 1, 37, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getFirstClassCallableType = { { 1061 /* getFirstClassCallableType */, 3, 38, 3, 41, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig createFirstClassCallable = { { 1187 /* createFirstClassCallable */, 3, 42, 3, 45, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getBitwiseAndType = { { 1212 /* getBitwiseAndType */, 3, 46, 3, 49, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getBitwiseOrType = { { 1230 /* getBitwiseOrType */, 3, 50, 3, 53, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getBitwiseXorType = { { 1247 /* getBitwiseXorType */, 3, 54, 3, 57, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getSpaceshipType = { { 1265 /* getSpaceshipType */, 3, 58, 3, 61, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getDivType = { { 1282 /* getDivType */, 3, 62, 3, 65, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getModType = { { 1293 /* getModType */, 3, 66, 3, 69, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPlusType = { { 1304 /* getPlusType */, 3, 70, 3, 73, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getMinusType = { { 1316 /* getMinusType */, 3, 74, 3, 77, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getMulType = { { 1329 /* getMulType */, 3, 78, 3, 81, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPowType = { { 1340 /* getPowType */, 3, 82, 3, 85, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getShiftLeftType = { { 1351 /* getShiftLeftType */, 3, 86, 3, 89, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getShiftRightType = { { 1368 /* getShiftRightType */, 3, 90, 3, 93, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig resolveIdenticalType = { { 1429 /* resolveIdenticalType */, 2, 94, 2, 96, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig resolveEqualType = { { 1450 /* resolveEqualType */, 2, 97, 3, 100, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isNonNumericString = { { 1467 /* isNonNumericString */, 2, 101, 2, 103, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig resolveConstantArrayTypeComparison = { { 1550 /* resolveConstantArrayTypeComparison */, 3, 104, 3, 107, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getClassConstFetchTypeByReflection = { { 1701 /* getClassConstFetchTypeByReflection */, 4, 108, 5, 113, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig transformStaticType = { { 1750 /* transformStaticType */, 2, 114, 2, 116, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getClassConstFetchType = { { 1770 /* getClassConstFetchType */, 4, 117, 4, 121, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnaryPlusType = { { 1793 /* getUnaryPlusType */, 2, 122, 2, 124, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnaryMinusType = { { 1810 /* getUnaryMinusType */, 2, 125, 2, 127, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getBitwiseNotType = { { 1828 /* getBitwiseNotType */, 2, 128, 2, 130, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getBitwiseNotTypeFromType = { { 1846 /* getBitwiseNotTypeFromType */, 1, 131, 1, 132, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig resolveName = { { 1897 /* resolveName */, 2, 133, 2, 135, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveTypeByName = { { 1940 /* resolveTypeByName */, 2, 136, 2, 138, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveTypeByNameWithLateStaticBinding = { { 2030 /* resolveTypeByNameWithLateStaticBinding */, 3, 139, 3, 142, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getReflectionProvider = { { 2107 /* getReflectionProvider */, 0, 143, 0, 143, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getNeverType = { { 2129 /* getNeverType */, 2, 144, 2, 146, ZEND_ACC_PRIVATE } }; } // namespace sig } // namespace ptdecl::InitializerExprTypeResolver diff --git a/turbo-ext/src/generated/IntegerRangeType.h b/turbo-ext/src/generated/IntegerRangeType.h index 1ce54ffa3aa..a07c2483f78 100644 --- a/turbo-ext/src/generated/IntegerRangeType.h +++ b/turbo-ext/src/generated/IntegerRangeType.h @@ -122,13 +122,13 @@ inline constexpr reg::PackedArg args[] = { reg::packed(75, MAY_BE_NULL | MAY_BE_LONG), /* isDisjoint $maxB */ reg::packed(80, MAY_BE_BOOL, reg::NoString, false, false, 99), /* isDisjoint $touchingIsDisjoint */ reg::packed(28, MAY_BE_BOOL), /* isDisjoint return */ - reg::packed(115, 0), /* createAllSmallerThan $value */ + reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllSmallerThan $value */ reg::packed(28, 0, 29), /* createAllSmallerThan return */ - reg::packed(115, 0), /* createAllSmallerThanOrEqualTo $value */ + reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllSmallerThanOrEqualTo $value */ reg::packed(28, 0, 29), /* createAllSmallerThanOrEqualTo return */ - reg::packed(115, 0), /* createAllGreaterThan $value */ + reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllGreaterThan $value */ reg::packed(28, 0, 29), /* createAllGreaterThan return */ - reg::packed(115, 0), /* createAllGreaterThanOrEqualTo $value */ + reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllGreaterThanOrEqualTo $value */ reg::packed(28, 0, 29), /* createAllGreaterThanOrEqualTo return */ reg::packed(28, 0, 223), /* toNumberSet return */ reg::packed(28, MAY_BE_NULL | MAY_BE_LONG), /* getMin return */ diff --git a/turbo-ext/src/generated/InternalThrowPoint.h b/turbo-ext/src/generated/InternalThrowPoint.h index 9dd4fd7bfad..4a3ef409176 100644 --- a/turbo-ext/src/generated/InternalThrowPoint.h +++ b/turbo-ext/src/generated/InternalThrowPoint.h @@ -56,10 +56,11 @@ inline constexpr char strings[] = "withScope\0" /* 261 */ "getScope\0" /* 271 */ "getType\0" /* 280 */ - "getNode\0" /* 288 */ - "isExplicit\0" /* 296 */ - "catchType\0" /* 307 */ - "subtractCatchType"; /* 317 */ + "PhpParser\\Node\\Expr|PhpParser\\Node\\Stmt\0" /* 288 */ + "getNode\0" /* 328 */ + "isExplicit\0" /* 336 */ + "catchType\0" /* 347 */ + "subtractCatchType"; /* 357 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 6), /* __construct $scope */ reg::packed(37, 0, 42), /* __construct $type */ @@ -83,9 +84,10 @@ inline constexpr reg::PackedArg args[] = { reg::packed(124, 0, 162), /* withScope return */ reg::packed(124, 0, 6), /* getScope return */ reg::packed(124, 0, 42), /* getType return */ + reg::packed(124, 0, 288), /* getNode return */ reg::packed(124, MAY_BE_BOOL), /* isExplicit return */ reg::packed(124, MAY_BE_BOOL), /* canContainAnyThrowable return */ - reg::packed(307, 0, 42), /* subtractCatchType $catchType */ + reg::packed(347, 0, 42), /* subtractCatchType $catchType */ reg::packed(124, 0, 162), /* subtractCatchType return */ }; using Sig = reg::Sig; @@ -101,10 +103,10 @@ inline constexpr sigtab::Sig createFromPublic = { { 244 /* createFromPublic */, inline constexpr sigtab::Sig withScope = { { 261 /* withScope */, 1, 18, 1, 19, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getScope = { { 271 /* getScope */, 0, 20, 0, 20, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getType = { { 280 /* getType */, 0, 21, 0, 21, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getNode = { { 288 /* getNode */, 0, 22, 0, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isExplicit = { { 296 /* isExplicit */, 0, 22, 0, 22, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canContainAnyThrowable = { { 89 /* canContainAnyThrowable */, 0, 23, 0, 23, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig subtractCatchType = { { 317 /* subtractCatchType */, 1, 24, 1, 25, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getNode = { { 328 /* getNode */, 0, 22, 0, 22, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isExplicit = { { 336 /* isExplicit */, 0, 23, 0, 23, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canContainAnyThrowable = { { 89 /* canContainAnyThrowable */, 0, 24, 0, 24, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig subtractCatchType = { { 357 /* subtractCatchType */, 1, 25, 1, 26, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::InternalThrowPoint diff --git a/turbo-ext/src/generated/LateResolvableArrayShapeType.h b/turbo-ext/src/generated/LateResolvableArrayShapeType.h index ca0c7fbb6c5..40f06001c26 100644 --- a/turbo-ext/src/generated/LateResolvableArrayShapeType.h +++ b/turbo-ext/src/generated/LateResolvableArrayShapeType.h @@ -71,7 +71,8 @@ inline constexpr char strings[] = "PHPStan\\PhpDocParser\\Ast\\Type\\TypeNode\0" /* 372 */ "toPhpDocNode\0" /* 411 */ "isImplicitMixed\0" /* 424 */ - "keyNameNode"; /* 440 */ + "PHPStan\\PhpDocParser\\Ast\\ConstExpr\\ConstExprIntegerNode|PHPStan\\PhpDocParser\\Ast\\ConstExpr\\ConstExprStringNode|PHPStan\\PhpDocParser\\Ast\\ConstExpr\\ConstFetchNode|PHPStan\\PhpDocParser\\Ast\\Type\\IdentifierTypeNode\0" /* 440 */ + "keyNameNode"; /* 650 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, MAY_BE_ARRAY), /* __construct $items */ reg::packed(6, MAY_BE_NULL | MAY_BE_ARRAY), /* __construct $unsealed */ @@ -103,6 +104,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(211, 0, 33), /* isImplicitMixed $type */ reg::packed(32, MAY_BE_BOOL), /* isImplicitMixed return */ reg::packed(289, 0, 33), /* keyNameNode $keyType */ + reg::packed(32, 0, 440), /* keyNameNode return */ }; using Sig = reg::Sig; } // namespace sigtab @@ -125,7 +127,7 @@ inline constexpr sigtab::Sig traverse = { { 334 /* traverse */, 1, 21, 1, 22, ZE inline constexpr sigtab::Sig traverseSimultaneously = { { 349 /* traverseSimultaneously */, 2, 23, 2, 25, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig toPhpDocNode = { { 411 /* toPhpDocNode */, 0, 26, 0, 26, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig isImplicitMixed = { { 424 /* isImplicitMixed */, 1, 27, 1, 28, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig keyNameNode = { { 440 /* keyNameNode */, 1, 29, 1, reg::NoArg, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig keyNameNode = { { 650 /* keyNameNode */, 1, 29, 1, 30, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; } // namespace sig } // namespace ptdecl::LateResolvableArrayShapeType diff --git a/turbo-ext/src/generated/MutatingScope.h b/turbo-ext/src/generated/MutatingScope.h index 185b41a21e1..15c298cca92 100644 --- a/turbo-ext/src/generated/MutatingScope.h +++ b/turbo-ext/src/generated/MutatingScope.h @@ -213,291 +213,293 @@ inline constexpr char strings[] = "hasExpressionType\0" /* 2823 */ "getTrackedExpressionType\0" /* 2841 */ "reflection\0" /* 2866 */ - "parameter\0" /* 2877 */ - "PHPStan\\Reflection\\ParameterReflection\0" /* 2887 */ - "rememberTypes\0" /* 2926 */ - "pushInFunctionCall\0" /* 2940 */ - "popInFunctionCall\0" /* 2959 */ - "className\0" /* 2977 */ - "isInClassExists\0" /* 2987 */ - "getFunctionCallStack\0" /* 3003 */ - "getFunctionCallStackWithParameters\0" /* 3024 */ - "functionName\0" /* 3059 */ - "isInFunctionExists\0" /* 3072 */ - "classReflection\0" /* 3091 */ - "enterClass\0" /* 3107 */ - "traitReflection\0" /* 3118 */ - "enterTrait\0" /* 3134 */ - "classMethod\0" /* 3145 */ - "PhpParser\\Node\\Stmt\\ClassMethod\0" /* 3157 */ - "templateTypeMap\0" /* 3189 */ - "PHPStan\\Type\\Generic\\TemplateTypeMap\0" /* 3205 */ - "phpDocParameterTypes\0" /* 3242 */ - "phpDocReturnType\0" /* 3263 */ - "throwType\0" /* 3280 */ - "deprecatedDescription\0" /* 3290 */ - "isDeprecated\0" /* 3312 */ - "isInternal\0" /* 3325 */ - "isFinal\0" /* 3336 */ - "isPure\0" /* 3344 */ - "acceptsNamedArguments\0" /* 3351 */ - "asserts\0" /* 3373 */ - "PHPStan\\Reflection\\Assertions\0" /* 3381 */ - "selfOutType\0" /* 3411 */ - "phpDocComment\0" /* 3423 */ - "parameterOutTypes\0" /* 3437 */ - "immediatelyInvokedCallableParameters\0" /* 3455 */ - "phpDocClosureThisTypeParameters\0" /* 3492 */ - "isConstructor\0" /* 3524 */ - "resolvedPhpDocBlock\0" /* 3538 */ - "PHPStan\\PhpDoc\\ResolvedPhpDocBlock\0" /* 3558 */ - "phpDocPureUnlessCallableIsImpureParameters\0" /* 3593 */ - "phpDocPureUnlessParameterPassedParameters\0" /* 3636 */ - "enterClassMethod\0" /* 3678 */ - "hook\0" /* 3695 */ - "PhpParser\\Node\\PropertyHook\0" /* 3700 */ - "propertyName\0" /* 3728 */ - "nativePropertyTypeNode\0" /* 3741 */ - "PhpParser\\Node\\Identifier|PhpParser\\Node\\Name|PhpParser\\Node\\ComplexType\0" /* 3764 */ - "phpDocPropertyType\0" /* 3837 */ - "enterPropertyHook\0" /* 3856 */ - "type\0" /* 3874 */ - "transformStaticType\0" /* 3879 */ - "functionLike\0" /* 3899 */ - "PhpParser\\Node\\FunctionLike\0" /* 3912 */ - "getRealParameterTypes\0" /* 3940 */ - "getRealParameterDefaultValues\0" /* 3962 */ - "PhpParser\\Node\\Stmt\\ClassMethod|PhpParser\\Node\\Stmt\\Function_|PhpParser\\Node\\PropertyHook\0" /* 3992 */ - "getParameterAttributes\0" /* 4082 */ - "PhpParser\\Node\\Stmt\\Function_\0" /* 4105 */ - "pureUnlessCallableIsImpureParameters\0" /* 4135 */ - "pureUnlessParameterPassedParameters\0" /* 4172 */ - "enterFunction\0" /* 4208 */ - "functionReflection\0" /* 4222 */ - "preserveConstructorScope\0" /* 4241 */ - "enterFunctionLike\0" /* 4266 */ - "namespaceName\0" /* 4284 */ - "enterNamespace\0" /* 4298 */ - "thisType\0" /* 4313 */ - "nativeThisType\0" /* 4322 */ - "scopeClasses\0" /* 4337 */ - "enterClosureBind\0" /* 4350 */ - "originalScope\0" /* 4367 */ - "restoreOriginalScopeAfterClosureBind\0" /* 4381 */ - "restoreThisScope\0" /* 4418 */ - "restoreThis\0" /* 4435 */ - "enterClosureCall\0" /* 4447 */ - "isInClosureBind\0" /* 4464 */ - "withClosureBindScopeClasses\0" /* 4480 */ - "closure\0" /* 4508 */ - "PhpParser\\Node\\Expr\\Closure\0" /* 4516 */ - "callableParameters\0" /* 4544 */ - "nativeCallableParameters\0" /* 4563 */ - "enterAnonymousFunction\0" /* 4588 */ - "enterAnonymousFunctionWithoutReflection\0" /* 4611 */ - "typeHolder\0" /* 4651 */ - "PHPStan\\Analyser\\ExpressionTypeHolder\0" /* 4662 */ - "expressionTypeIsUnchangeable\0" /* 4700 */ - "invalidateStaticExpressions\0" /* 4729 */ - "arrowFunction\0" /* 4757 */ - "PhpParser\\Node\\Expr\\ArrowFunction\0" /* 4771 */ - "enterArrowFunction\0" /* 4805 */ - "enterArrowFunctionWithoutReflection\0" /* 4824 */ - "PhpParser\\Node\\Param\0" /* 4860 */ - "isParameterValueNullable\0" /* 4881 */ - "isNullable\0" /* 4906 */ - "isVariadic\0" /* 4917 */ - "getFunctionType\0" /* 4928 */ - "index\0" /* 4944 */ - "getCallableParameterType\0" /* 4950 */ - "startIndex\0" /* 4975 */ - "buildVariadicArrayTypeFromCallableParameters\0" /* 4986 */ - "nativeType\0" /* 5031 */ - "inferredType\0" /* 5042 */ - "intersectButNotNever\0" /* 5055 */ - "PhpParser\\Node\\Expr\\Match_\0" /* 5076 */ - "condType\0" /* 5103 */ - "condNativeType\0" /* 5112 */ - "enterMatch\0" /* 5127 */ - "iteratee\0" /* 5138 */ - "iterateeType\0" /* 5147 */ - "nativeIterateeType\0" /* 5160 */ - "valueName\0" /* 5179 */ - "keyName\0" /* 5189 */ - "valueByRef\0" /* 5197 */ - "enterForeach\0" /* 5208 */ - "enterForeachKey\0" /* 5221 */ - "catchType\0" /* 5237 */ - "enterCatchType\0" /* 5247 */ - "isPlainWrite\0" /* 5262 */ - "enterExpressionAssign\0" /* 5275 */ - "exitExpressionAssign\0" /* 5297 */ - "isInExpressionAssign\0" /* 5318 */ - "isInWriteExpressionAssign\0" /* 5339 */ - "setAllowedUndefinedExpression\0" /* 5365 */ - "unsetAllowedUndefinedExpression\0" /* 5395 */ - "isUndefinedExpressionAllowed\0" /* 5427 */ - "certainty\0" /* 5456 */ - "intertwinedPropagatedFrom\0" /* 5466 */ - "assignVariable\0" /* 5492 */ - "overwriteExpression\0" /* 5507 */ - "scope\0" /* 5527 */ - "rootType\0" /* 5533 */ - "assignedExpr\0" /* 5542 */ - "rootVariableName\0" /* 5555 */ - "native\0" /* 5572 */ - "resolveIntertwinedAssignedType\0" /* 5579 */ - "dimFetch\0" /* 5610 */ - "PhpParser\\Node\\Expr\\ArrayDimFetch\0" /* 5619 */ - "isDimFetchPathReachable\0" /* 5653 */ - "unsetExpression\0" /* 5677 */ - "getStateType\0" /* 5693 */ - "getScopeStateType\0" /* 5706 */ - "getScopeStateNativeType\0" /* 5724 */ - "resolveScopeStateType\0" /* 5748 */ - "specifyExpressionType\0" /* 5770 */ - "openSpecificationScope\0" /* 5792 */ - "isSpecifyExpressionTypeNoop\0" /* 5815 */ - "specifyExpressionTypeInPlace\0" /* 5843 */ - "assignExpression\0" /* 5872 */ - "fetchedOnType\0" /* 5889 */ - "assignInitializedProperty\0" /* 5903 */ - "expressionToInvalidate\0" /* 5929 */ - "requireMoreCharacters\0" /* 5952 */ - "invalidatingClass\0" /* 5974 */ - "keepPropertyFetches\0" /* 5992 */ - "invalidateExpression\0" /* 6012 */ - "isPrivatePropertyOfDifferentClass\0" /* 6033 */ - "invalidateMethodsOnExpression\0" /* 6067 */ - "setExpressionCertaintyKeepingType\0" /* 6097 */ - "isComplexUnionType\0" /* 6131 */ - "addTypeToExpression\0" /* 6150 */ - "typeToRemove\0" /* 6170 */ - "removeTypeFromExpression\0" /* 6183 */ - "filterByTruthyValue\0" /* 6208 */ - "filterByFalseyValue\0" /* 6228 */ - "specifiedTypes\0" /* 6248 */ - "applySpecifiedTypes\0" /* 6263 */ - "specifiedExpressions\0" /* 6283 */ - "processConditionalExpressionsAfterSpecifying\0" /* 6304 */ - "getConditionalExpressions\0" /* 6349 */ - "conditionalExpressionHolders\0" /* 6375 */ - "addConditionalExpressions\0" /* 6404 */ - "exitFirstLevelStatements\0" /* 6430 */ - "isInFirstLevelStatement\0" /* 6455 */ - "otherScope\0" /* 6479 */ - "preserveVacuousConditionals\0" /* 6490 */ - "mergeWith\0" /* 6518 */ - "ours\0" /* 6528 */ - "theirs\0" /* 6533 */ - "collectAbsorbedClosures\0" /* 6540 */ - "mergeWithVariableState\0" /* 6564 */ - "differingExpressionKeys\0" /* 6587 */ - "mergedExpressionTypes\0" /* 6611 */ - "findMergedCallCandidates\0" /* 6633 */ - "candidates\0" /* 6658 */ - "mergedNativeTypes\0" /* 6669 */ - "findUninformativeMergedCalls\0" /* 6687 */ - "ourExpressionTypes\0" /* 6716 */ - "theirExpressionTypes\0" /* 6735 */ - "withoutPreciseClassConstantFetches\0" /* 6756 */ - "currentConditionalExpressions\0" /* 6791 */ - "sourceConditionalExpressions\0" /* 6821 */ - "otherExpressionTypes\0" /* 6850 */ - "preserveVacuousConditionalExpressions\0" /* 6871 */ - "ourConditionalExpressions\0" /* 6909 */ - "theirConditionalExpressions\0" /* 6935 */ - "mergeSameGuardConditionalExpressions\0" /* 6963 */ - "newConditionalExpressions\0" /* 7000 */ - "existingConditionalExpressions\0" /* 7026 */ - "mergeConditionalExpressions\0" /* 7057 */ - "calledMethodScope\0" /* 7085 */ - "mergeInitializedProperties\0" /* 7103 */ - "finallyScope\0" /* 7130 */ - "originalFinallyScope\0" /* 7143 */ - "processFinallyScope\0" /* 7164 */ - "ourVariableTypeHolders\0" /* 7184 */ - "finallyVariableTypeHolders\0" /* 7207 */ - "originalVariableTypeHolders\0" /* 7234 */ - "processFinallyScopeVariableTypeHolders\0" /* 7262 */ - "closureScope\0" /* 7301 */ - "prevScope\0" /* 7314 */ - "byRefUses\0" /* 7324 */ - "processClosureScope\0" /* 7334 */ - "finalScope\0" /* 7354 */ - "processAlwaysIterableForeachScopeWithoutPollute\0" /* 7365 */ - "writableVariableNames\0" /* 7413 */ - "generalizeWith\0" /* 7435 */ - "generalizeWithVariableState\0" /* 7450 */ - "variableTypeHolders\0" /* 7478 */ - "otherVariableTypeHolders\0" /* 7498 */ - "generalizeVariableTypeHolders\0" /* 7523 */ - "flattenUnionForGeneralization\0" /* 7553 */ - "a\0" /* 7583 */ - "b\0" /* 7585 */ - "depth\0" /* 7587 */ - "generalizeType\0" /* 7593 */ - "getArrayDepth\0" /* 7608 */ - "equals\0" /* 7622 */ - "otherConditionalExpressions\0" /* 7629 */ - "compareConditionalExpressions\0" /* 7657 */ - "compareVariableTypeHolders\0" /* 7687 */ - "propertyReflection\0" /* 7714 */ - "PHPStan\\Reflection\\PropertyReflection\0" /* 7733 */ - "canAccessProperty\0" /* 7771 */ - "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7789 */ - "canReadProperty\0" /* 7835 */ - "canWriteProperty\0" /* 7851 */ - "methodReflection\0" /* 7868 */ - "PHPStan\\Reflection\\MethodReflection\0" /* 7885 */ - "canCallMethod\0" /* 7921 */ - "constantReflection\0" /* 7935 */ - "PHPStan\\Reflection\\ClassConstantReflection\0" /* 7954 */ - "canAccessConstant\0" /* 7997 */ - "classMemberReflection\0" /* 8015 */ - "PHPStan\\Reflection\\ClassMemberReflection\0" /* 8037 */ - "canAccessClassMember\0" /* 8078 */ - "debug\0" /* 8099 */ - "typeWithMethod\0" /* 8105 */ - "methodName\0" /* 8120 */ - "filterTypeWithMethod\0" /* 8131 */ - "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8152 */ - "getMethodReflection\0" /* 8196 */ - "getNakedMethod\0" /* 8216 */ - "typeWithProperty\0" /* 8231 */ - "getPropertyReflection\0" /* 8248 */ - "getInstancePropertyReflection\0" /* 8270 */ - "getStaticPropertyReflection\0" /* 8300 */ - "typeWithConstant\0" /* 8328 */ - "constantName\0" /* 8345 */ - "getConstantReflection\0" /* 8358 */ - "constantType\0" /* 8380 */ - "getConstantExplicitTypeFromConfig\0" /* 8393 */ - "getConstantTypes\0" /* 8427 */ - "getGlobalConstantType\0" /* 8444 */ - "nameString\0" /* 8466 */ - "createGlobalConstantFetches\0" /* 8477 */ - "getNativeConstantTypes\0" /* 8505 */ - "getIterableKeyType\0" /* 8528 */ - "getIterableValueType\0" /* 8547 */ - "PHPStan\\Php\\PhpVersions\0" /* 8568 */ - "getPhpVersion\0" /* 8592 */ - "getConfiguredPhpVersionRange\0" /* 8606 */ - "isOverallPhpVersionRange\0" /* 8635 */ - "PhpParser\\Node\0" /* 8660 */ - "invokeNodeCallback\0" /* 8675 */ - "collectorType\0" /* 8694 */ - "data\0" /* 8708 */ - "emitCollectedData\0" /* 8713 */ - "extensionClass\0" /* 8731 */ - "trackValueDependency\0" /* 8746 */ - "file\0" /* 8767 */ - "trackFileDependency\0" /* 8772 */ - "directory\0" /* 8792 */ - "pattern\0" /* 8802 */ - "'*'\0" /* 8810 */ - "trackDirectoryDependency\0" /* 8814 */ - "trackClassDependency"; /* 8839 */ + "PHPStan\\Reflection\\MethodReflection|PHPStan\\Reflection\\FunctionReflection\0" /* 2877 */ + "parameter\0" /* 2951 */ + "PHPStan\\Reflection\\ParameterReflection\0" /* 2961 */ + "rememberTypes\0" /* 3000 */ + "pushInFunctionCall\0" /* 3014 */ + "popInFunctionCall\0" /* 3033 */ + "className\0" /* 3051 */ + "isInClassExists\0" /* 3061 */ + "getFunctionCallStack\0" /* 3077 */ + "getFunctionCallStackWithParameters\0" /* 3098 */ + "functionName\0" /* 3133 */ + "isInFunctionExists\0" /* 3146 */ + "classReflection\0" /* 3165 */ + "enterClass\0" /* 3181 */ + "traitReflection\0" /* 3192 */ + "enterTrait\0" /* 3208 */ + "classMethod\0" /* 3219 */ + "PhpParser\\Node\\Stmt\\ClassMethod\0" /* 3231 */ + "templateTypeMap\0" /* 3263 */ + "PHPStan\\Type\\Generic\\TemplateTypeMap\0" /* 3279 */ + "phpDocParameterTypes\0" /* 3316 */ + "phpDocReturnType\0" /* 3337 */ + "throwType\0" /* 3354 */ + "deprecatedDescription\0" /* 3364 */ + "isDeprecated\0" /* 3386 */ + "isInternal\0" /* 3399 */ + "isFinal\0" /* 3410 */ + "isPure\0" /* 3418 */ + "acceptsNamedArguments\0" /* 3425 */ + "asserts\0" /* 3447 */ + "PHPStan\\Reflection\\Assertions\0" /* 3455 */ + "selfOutType\0" /* 3485 */ + "phpDocComment\0" /* 3497 */ + "parameterOutTypes\0" /* 3511 */ + "immediatelyInvokedCallableParameters\0" /* 3529 */ + "phpDocClosureThisTypeParameters\0" /* 3566 */ + "isConstructor\0" /* 3598 */ + "resolvedPhpDocBlock\0" /* 3612 */ + "PHPStan\\PhpDoc\\ResolvedPhpDocBlock\0" /* 3632 */ + "phpDocPureUnlessCallableIsImpureParameters\0" /* 3667 */ + "phpDocPureUnlessParameterPassedParameters\0" /* 3710 */ + "enterClassMethod\0" /* 3752 */ + "hook\0" /* 3769 */ + "PhpParser\\Node\\PropertyHook\0" /* 3774 */ + "propertyName\0" /* 3802 */ + "nativePropertyTypeNode\0" /* 3815 */ + "PhpParser\\Node\\Identifier|PhpParser\\Node\\Name|PhpParser\\Node\\ComplexType\0" /* 3838 */ + "phpDocPropertyType\0" /* 3911 */ + "enterPropertyHook\0" /* 3930 */ + "type\0" /* 3948 */ + "transformStaticType\0" /* 3953 */ + "functionLike\0" /* 3973 */ + "PhpParser\\Node\\FunctionLike\0" /* 3986 */ + "getRealParameterTypes\0" /* 4014 */ + "getRealParameterDefaultValues\0" /* 4036 */ + "PhpParser\\Node\\Stmt\\ClassMethod|PhpParser\\Node\\Stmt\\Function_|PhpParser\\Node\\PropertyHook\0" /* 4066 */ + "getParameterAttributes\0" /* 4156 */ + "PhpParser\\Node\\Stmt\\Function_\0" /* 4179 */ + "pureUnlessCallableIsImpureParameters\0" /* 4209 */ + "pureUnlessParameterPassedParameters\0" /* 4246 */ + "enterFunction\0" /* 4282 */ + "functionReflection\0" /* 4296 */ + "preserveConstructorScope\0" /* 4315 */ + "enterFunctionLike\0" /* 4340 */ + "namespaceName\0" /* 4358 */ + "enterNamespace\0" /* 4372 */ + "thisType\0" /* 4387 */ + "nativeThisType\0" /* 4396 */ + "scopeClasses\0" /* 4411 */ + "enterClosureBind\0" /* 4424 */ + "originalScope\0" /* 4441 */ + "restoreOriginalScopeAfterClosureBind\0" /* 4455 */ + "restoreThisScope\0" /* 4492 */ + "restoreThis\0" /* 4509 */ + "enterClosureCall\0" /* 4521 */ + "isInClosureBind\0" /* 4538 */ + "withClosureBindScopeClasses\0" /* 4554 */ + "closure\0" /* 4582 */ + "PhpParser\\Node\\Expr\\Closure\0" /* 4590 */ + "callableParameters\0" /* 4618 */ + "nativeCallableParameters\0" /* 4637 */ + "enterAnonymousFunction\0" /* 4662 */ + "enterAnonymousFunctionWithoutReflection\0" /* 4685 */ + "typeHolder\0" /* 4725 */ + "PHPStan\\Analyser\\ExpressionTypeHolder\0" /* 4736 */ + "expressionTypeIsUnchangeable\0" /* 4774 */ + "invalidateStaticExpressions\0" /* 4803 */ + "arrowFunction\0" /* 4831 */ + "PhpParser\\Node\\Expr\\ArrowFunction\0" /* 4845 */ + "enterArrowFunction\0" /* 4879 */ + "enterArrowFunctionWithoutReflection\0" /* 4898 */ + "PhpParser\\Node\\Param\0" /* 4934 */ + "isParameterValueNullable\0" /* 4955 */ + "PhpParser\\Node\\Name|PhpParser\\Node\\Identifier|PhpParser\\Node\\ComplexType\0" /* 4980 */ + "isNullable\0" /* 5053 */ + "isVariadic\0" /* 5064 */ + "getFunctionType\0" /* 5075 */ + "index\0" /* 5091 */ + "getCallableParameterType\0" /* 5097 */ + "startIndex\0" /* 5122 */ + "buildVariadicArrayTypeFromCallableParameters\0" /* 5133 */ + "nativeType\0" /* 5178 */ + "inferredType\0" /* 5189 */ + "intersectButNotNever\0" /* 5202 */ + "PhpParser\\Node\\Expr\\Match_\0" /* 5223 */ + "condType\0" /* 5250 */ + "condNativeType\0" /* 5259 */ + "enterMatch\0" /* 5274 */ + "iteratee\0" /* 5285 */ + "iterateeType\0" /* 5294 */ + "nativeIterateeType\0" /* 5307 */ + "valueName\0" /* 5326 */ + "keyName\0" /* 5336 */ + "valueByRef\0" /* 5344 */ + "enterForeach\0" /* 5355 */ + "enterForeachKey\0" /* 5368 */ + "catchType\0" /* 5384 */ + "enterCatchType\0" /* 5394 */ + "isPlainWrite\0" /* 5409 */ + "enterExpressionAssign\0" /* 5422 */ + "exitExpressionAssign\0" /* 5444 */ + "isInExpressionAssign\0" /* 5465 */ + "isInWriteExpressionAssign\0" /* 5486 */ + "setAllowedUndefinedExpression\0" /* 5512 */ + "unsetAllowedUndefinedExpression\0" /* 5542 */ + "isUndefinedExpressionAllowed\0" /* 5574 */ + "certainty\0" /* 5603 */ + "intertwinedPropagatedFrom\0" /* 5613 */ + "assignVariable\0" /* 5639 */ + "overwriteExpression\0" /* 5654 */ + "scope\0" /* 5674 */ + "rootType\0" /* 5680 */ + "assignedExpr\0" /* 5689 */ + "rootVariableName\0" /* 5702 */ + "native\0" /* 5719 */ + "resolveIntertwinedAssignedType\0" /* 5726 */ + "dimFetch\0" /* 5757 */ + "PhpParser\\Node\\Expr\\ArrayDimFetch\0" /* 5766 */ + "isDimFetchPathReachable\0" /* 5800 */ + "unsetExpression\0" /* 5824 */ + "getStateType\0" /* 5840 */ + "getScopeStateType\0" /* 5853 */ + "getScopeStateNativeType\0" /* 5871 */ + "resolveScopeStateType\0" /* 5895 */ + "specifyExpressionType\0" /* 5917 */ + "openSpecificationScope\0" /* 5939 */ + "isSpecifyExpressionTypeNoop\0" /* 5962 */ + "specifyExpressionTypeInPlace\0" /* 5990 */ + "assignExpression\0" /* 6019 */ + "fetchedOnType\0" /* 6036 */ + "assignInitializedProperty\0" /* 6050 */ + "expressionToInvalidate\0" /* 6076 */ + "requireMoreCharacters\0" /* 6099 */ + "invalidatingClass\0" /* 6121 */ + "keepPropertyFetches\0" /* 6139 */ + "invalidateExpression\0" /* 6159 */ + "isPrivatePropertyOfDifferentClass\0" /* 6180 */ + "invalidateMethodsOnExpression\0" /* 6214 */ + "setExpressionCertaintyKeepingType\0" /* 6244 */ + "isComplexUnionType\0" /* 6278 */ + "addTypeToExpression\0" /* 6297 */ + "typeToRemove\0" /* 6317 */ + "removeTypeFromExpression\0" /* 6330 */ + "filterByTruthyValue\0" /* 6355 */ + "filterByFalseyValue\0" /* 6375 */ + "specifiedTypes\0" /* 6395 */ + "applySpecifiedTypes\0" /* 6410 */ + "specifiedExpressions\0" /* 6430 */ + "processConditionalExpressionsAfterSpecifying\0" /* 6451 */ + "getConditionalExpressions\0" /* 6496 */ + "conditionalExpressionHolders\0" /* 6522 */ + "addConditionalExpressions\0" /* 6551 */ + "exitFirstLevelStatements\0" /* 6577 */ + "isInFirstLevelStatement\0" /* 6602 */ + "otherScope\0" /* 6626 */ + "preserveVacuousConditionals\0" /* 6637 */ + "mergeWith\0" /* 6665 */ + "ours\0" /* 6675 */ + "theirs\0" /* 6680 */ + "collectAbsorbedClosures\0" /* 6687 */ + "mergeWithVariableState\0" /* 6711 */ + "differingExpressionKeys\0" /* 6734 */ + "mergedExpressionTypes\0" /* 6758 */ + "findMergedCallCandidates\0" /* 6780 */ + "candidates\0" /* 6805 */ + "mergedNativeTypes\0" /* 6816 */ + "findUninformativeMergedCalls\0" /* 6834 */ + "ourExpressionTypes\0" /* 6863 */ + "theirExpressionTypes\0" /* 6882 */ + "withoutPreciseClassConstantFetches\0" /* 6903 */ + "currentConditionalExpressions\0" /* 6938 */ + "sourceConditionalExpressions\0" /* 6968 */ + "otherExpressionTypes\0" /* 6997 */ + "preserveVacuousConditionalExpressions\0" /* 7018 */ + "ourConditionalExpressions\0" /* 7056 */ + "theirConditionalExpressions\0" /* 7082 */ + "mergeSameGuardConditionalExpressions\0" /* 7110 */ + "newConditionalExpressions\0" /* 7147 */ + "existingConditionalExpressions\0" /* 7173 */ + "mergeConditionalExpressions\0" /* 7204 */ + "calledMethodScope\0" /* 7232 */ + "mergeInitializedProperties\0" /* 7250 */ + "finallyScope\0" /* 7277 */ + "originalFinallyScope\0" /* 7290 */ + "processFinallyScope\0" /* 7311 */ + "ourVariableTypeHolders\0" /* 7331 */ + "finallyVariableTypeHolders\0" /* 7354 */ + "originalVariableTypeHolders\0" /* 7381 */ + "processFinallyScopeVariableTypeHolders\0" /* 7409 */ + "closureScope\0" /* 7448 */ + "prevScope\0" /* 7461 */ + "byRefUses\0" /* 7471 */ + "processClosureScope\0" /* 7481 */ + "finalScope\0" /* 7501 */ + "processAlwaysIterableForeachScopeWithoutPollute\0" /* 7512 */ + "writableVariableNames\0" /* 7560 */ + "generalizeWith\0" /* 7582 */ + "generalizeWithVariableState\0" /* 7597 */ + "variableTypeHolders\0" /* 7625 */ + "otherVariableTypeHolders\0" /* 7645 */ + "generalizeVariableTypeHolders\0" /* 7670 */ + "flattenUnionForGeneralization\0" /* 7700 */ + "a\0" /* 7730 */ + "b\0" /* 7732 */ + "depth\0" /* 7734 */ + "generalizeType\0" /* 7740 */ + "getArrayDepth\0" /* 7755 */ + "equals\0" /* 7769 */ + "otherConditionalExpressions\0" /* 7776 */ + "compareConditionalExpressions\0" /* 7804 */ + "compareVariableTypeHolders\0" /* 7834 */ + "propertyReflection\0" /* 7861 */ + "PHPStan\\Reflection\\PropertyReflection\0" /* 7880 */ + "canAccessProperty\0" /* 7918 */ + "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7936 */ + "canReadProperty\0" /* 7982 */ + "canWriteProperty\0" /* 7998 */ + "methodReflection\0" /* 8015 */ + "PHPStan\\Reflection\\MethodReflection\0" /* 8032 */ + "canCallMethod\0" /* 8068 */ + "constantReflection\0" /* 8082 */ + "PHPStan\\Reflection\\ClassConstantReflection\0" /* 8101 */ + "canAccessConstant\0" /* 8144 */ + "classMemberReflection\0" /* 8162 */ + "PHPStan\\Reflection\\ClassMemberReflection\0" /* 8184 */ + "canAccessClassMember\0" /* 8225 */ + "debug\0" /* 8246 */ + "typeWithMethod\0" /* 8252 */ + "methodName\0" /* 8267 */ + "filterTypeWithMethod\0" /* 8278 */ + "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8299 */ + "getMethodReflection\0" /* 8343 */ + "getNakedMethod\0" /* 8363 */ + "typeWithProperty\0" /* 8378 */ + "getPropertyReflection\0" /* 8395 */ + "getInstancePropertyReflection\0" /* 8417 */ + "getStaticPropertyReflection\0" /* 8447 */ + "typeWithConstant\0" /* 8475 */ + "constantName\0" /* 8492 */ + "getConstantReflection\0" /* 8505 */ + "constantType\0" /* 8527 */ + "getConstantExplicitTypeFromConfig\0" /* 8540 */ + "getConstantTypes\0" /* 8574 */ + "getGlobalConstantType\0" /* 8591 */ + "nameString\0" /* 8613 */ + "createGlobalConstantFetches\0" /* 8624 */ + "getNativeConstantTypes\0" /* 8652 */ + "getIterableKeyType\0" /* 8675 */ + "getIterableValueType\0" /* 8694 */ + "PHPStan\\Php\\PhpVersions\0" /* 8715 */ + "getPhpVersion\0" /* 8739 */ + "getConfiguredPhpVersionRange\0" /* 8753 */ + "isOverallPhpVersionRange\0" /* 8782 */ + "PhpParser\\Node\0" /* 8807 */ + "invokeNodeCallback\0" /* 8822 */ + "collectorType\0" /* 8841 */ + "data\0" /* 8855 */ + "emitCollectedData\0" /* 8860 */ + "extensionClass\0" /* 8878 */ + "trackValueDependency\0" /* 8893 */ + "file\0" /* 8914 */ + "trackFileDependency\0" /* 8919 */ + "directory\0" /* 8939 */ + "pattern\0" /* 8949 */ + "'*'\0" /* 8957 */ + "trackDirectoryDependency\0" /* 8961 */ + "trackClassDependency"; /* 8986 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 9), /* __construct $services */ reg::packed(40, 0, 53), /* __construct $scopeFactory */ @@ -637,165 +639,165 @@ inline constexpr reg::PackedArg args[] = { reg::packed(738, MAY_BE_STRING), /* resolveName return */ reg::packed(1520, 0, 1525), /* resolveTypeByName $name */ reg::packed(738, 0, 2751), /* resolveTypeByName return */ - reg::packed(2800, 0), /* getTypeFromValue $value */ + reg::packed(2800, MAY_BE_ANY), /* getTypeFromValue $value */ reg::packed(738, 0, 1424), /* getTypeFromValue return */ reg::packed(1707, 0, 1712), /* hasExpressionType $node */ reg::packed(738, 0, 1387), /* hasExpressionType return */ reg::packed(1707, 0, 1712), /* getTrackedExpressionType $node */ reg::packed(738, 0, 1424), /* getTrackedExpressionType return */ - reg::packed(2866, 0), /* pushInFunctionCall $reflection */ - reg::packed(2877, MAY_BE_NULL, 2887), /* pushInFunctionCall $parameter */ - reg::packed(2926, MAY_BE_BOOL), /* pushInFunctionCall $rememberTypes */ + reg::packed(2866, MAY_BE_NULL, 2877), /* pushInFunctionCall $reflection */ + reg::packed(2951, MAY_BE_NULL, 2961), /* pushInFunctionCall $parameter */ + reg::packed(3000, MAY_BE_BOOL), /* pushInFunctionCall $rememberTypes */ reg::packed(738, 0, 523), /* pushInFunctionCall return */ reg::packed(738, 0, 523), /* popInFunctionCall return */ - reg::packed(2977, MAY_BE_STRING), /* isInClassExists $className */ + reg::packed(3051, MAY_BE_STRING), /* isInClassExists $className */ reg::packed(738, MAY_BE_BOOL), /* isInClassExists return */ reg::packed(738, MAY_BE_ARRAY), /* getFunctionCallStack return */ reg::packed(738, MAY_BE_ARRAY), /* getFunctionCallStackWithParameters return */ - reg::packed(3059, MAY_BE_STRING), /* isInFunctionExists $functionName */ + reg::packed(3133, MAY_BE_STRING), /* isInFunctionExists $functionName */ reg::packed(738, MAY_BE_BOOL), /* isInFunctionExists return */ - reg::packed(3091, 0, 1065), /* enterClass $classReflection */ + reg::packed(3165, 0, 1065), /* enterClass $classReflection */ reg::packed(738, 0, 523), /* enterClass return */ - reg::packed(3118, 0, 1065), /* enterTrait $traitReflection */ + reg::packed(3192, 0, 1065), /* enterTrait $traitReflection */ reg::packed(738, 0, 523), /* enterTrait return */ - reg::packed(3145, 0, 3157), /* enterClassMethod $classMethod */ - reg::packed(3189, 0, 3205), /* enterClassMethod $templateTypeMap */ - reg::packed(3242, MAY_BE_ARRAY), /* enterClassMethod $phpDocParameterTypes */ - reg::packed(3263, MAY_BE_NULL, 1424), /* enterClassMethod $phpDocReturnType */ - reg::packed(3280, MAY_BE_NULL, 1424), /* enterClassMethod $throwType */ - reg::packed(3290, MAY_BE_NULL | MAY_BE_STRING), /* enterClassMethod $deprecatedDescription */ - reg::packed(3312, MAY_BE_BOOL), /* enterClassMethod $isDeprecated */ - reg::packed(3325, MAY_BE_BOOL), /* enterClassMethod $isInternal */ - reg::packed(3336, MAY_BE_BOOL), /* enterClassMethod $isFinal */ - reg::packed(3344, MAY_BE_NULL | MAY_BE_BOOL, reg::NoString, false, false, 222), /* enterClassMethod $isPure */ - reg::packed(3351, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterClassMethod $acceptsNamedArguments */ - reg::packed(3373, MAY_BE_NULL, 3381, false, false, 222), /* enterClassMethod $asserts */ - reg::packed(3411, MAY_BE_NULL, 1424, false, false, 222), /* enterClassMethod $selfOutType */ - reg::packed(3423, MAY_BE_NULL | MAY_BE_STRING, reg::NoString, false, false, 222), /* enterClassMethod $phpDocComment */ - reg::packed(3437, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $parameterOutTypes */ - reg::packed(3455, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $immediatelyInvokedCallableParameters */ - reg::packed(3492, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocClosureThisTypeParameters */ - reg::packed(3524, MAY_BE_BOOL, reg::NoString, false, false, 148), /* enterClassMethod $isConstructor */ - reg::packed(3538, MAY_BE_NULL, 3558, false, false, 222), /* enterClassMethod $resolvedPhpDocBlock */ - reg::packed(3593, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocPureUnlessCallableIsImpureParameters */ - reg::packed(3636, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocPureUnlessParameterPassedParameters */ + reg::packed(3219, 0, 3231), /* enterClassMethod $classMethod */ + reg::packed(3263, 0, 3279), /* enterClassMethod $templateTypeMap */ + reg::packed(3316, MAY_BE_ARRAY), /* enterClassMethod $phpDocParameterTypes */ + reg::packed(3337, MAY_BE_NULL, 1424), /* enterClassMethod $phpDocReturnType */ + reg::packed(3354, MAY_BE_NULL, 1424), /* enterClassMethod $throwType */ + reg::packed(3364, MAY_BE_NULL | MAY_BE_STRING), /* enterClassMethod $deprecatedDescription */ + reg::packed(3386, MAY_BE_BOOL), /* enterClassMethod $isDeprecated */ + reg::packed(3399, MAY_BE_BOOL), /* enterClassMethod $isInternal */ + reg::packed(3410, MAY_BE_BOOL), /* enterClassMethod $isFinal */ + reg::packed(3418, MAY_BE_NULL | MAY_BE_BOOL, reg::NoString, false, false, 222), /* enterClassMethod $isPure */ + reg::packed(3425, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterClassMethod $acceptsNamedArguments */ + reg::packed(3447, MAY_BE_NULL, 3455, false, false, 222), /* enterClassMethod $asserts */ + reg::packed(3485, MAY_BE_NULL, 1424, false, false, 222), /* enterClassMethod $selfOutType */ + reg::packed(3497, MAY_BE_NULL | MAY_BE_STRING, reg::NoString, false, false, 222), /* enterClassMethod $phpDocComment */ + reg::packed(3511, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $parameterOutTypes */ + reg::packed(3529, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $immediatelyInvokedCallableParameters */ + reg::packed(3566, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocClosureThisTypeParameters */ + reg::packed(3598, MAY_BE_BOOL, reg::NoString, false, false, 148), /* enterClassMethod $isConstructor */ + reg::packed(3612, MAY_BE_NULL, 3632, false, false, 222), /* enterClassMethod $resolvedPhpDocBlock */ + reg::packed(3667, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocPureUnlessCallableIsImpureParameters */ + reg::packed(3710, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterClassMethod $phpDocPureUnlessParameterPassedParameters */ reg::packed(738, 0, 523), /* enterClassMethod return */ - reg::packed(3695, 0, 3700), /* enterPropertyHook $hook */ - reg::packed(3728, MAY_BE_STRING), /* enterPropertyHook $propertyName */ - reg::packed(3741, MAY_BE_NULL, 3764), /* enterPropertyHook $nativePropertyTypeNode */ - reg::packed(3837, MAY_BE_NULL, 1424), /* enterPropertyHook $phpDocPropertyType */ - reg::packed(3242, MAY_BE_ARRAY), /* enterPropertyHook $phpDocParameterTypes */ - reg::packed(3280, MAY_BE_NULL, 1424), /* enterPropertyHook $throwType */ - reg::packed(3290, MAY_BE_NULL | MAY_BE_STRING), /* enterPropertyHook $deprecatedDescription */ - reg::packed(3312, MAY_BE_BOOL), /* enterPropertyHook $isDeprecated */ - reg::packed(3344, MAY_BE_NULL | MAY_BE_BOOL), /* enterPropertyHook $isPure */ - reg::packed(3423, MAY_BE_NULL | MAY_BE_STRING), /* enterPropertyHook $phpDocComment */ - reg::packed(3538, MAY_BE_NULL, 3558, false, false, 222), /* enterPropertyHook $resolvedPhpDocBlock */ + reg::packed(3769, 0, 3774), /* enterPropertyHook $hook */ + reg::packed(3802, MAY_BE_STRING), /* enterPropertyHook $propertyName */ + reg::packed(3815, MAY_BE_NULL, 3838), /* enterPropertyHook $nativePropertyTypeNode */ + reg::packed(3911, MAY_BE_NULL, 1424), /* enterPropertyHook $phpDocPropertyType */ + reg::packed(3316, MAY_BE_ARRAY), /* enterPropertyHook $phpDocParameterTypes */ + reg::packed(3354, MAY_BE_NULL, 1424), /* enterPropertyHook $throwType */ + reg::packed(3364, MAY_BE_NULL | MAY_BE_STRING), /* enterPropertyHook $deprecatedDescription */ + reg::packed(3386, MAY_BE_BOOL), /* enterPropertyHook $isDeprecated */ + reg::packed(3418, MAY_BE_NULL | MAY_BE_BOOL), /* enterPropertyHook $isPure */ + reg::packed(3497, MAY_BE_NULL | MAY_BE_STRING), /* enterPropertyHook $phpDocComment */ + reg::packed(3612, MAY_BE_NULL, 3632, false, false, 222), /* enterPropertyHook $resolvedPhpDocBlock */ reg::packed(738, 0, 523), /* enterPropertyHook return */ - reg::packed(3874, 0, 1424), /* transformStaticType $type */ + reg::packed(3948, 0, 1424), /* transformStaticType $type */ reg::packed(738, 0, 1424), /* transformStaticType return */ - reg::packed(3899, 0, 3912), /* getRealParameterTypes $functionLike */ + reg::packed(3973, 0, 3986), /* getRealParameterTypes $functionLike */ reg::packed(738, MAY_BE_ARRAY), /* getRealParameterTypes return */ - reg::packed(3899, 0, 3912), /* getRealParameterDefaultValues $functionLike */ + reg::packed(3973, 0, 3986), /* getRealParameterDefaultValues $functionLike */ reg::packed(738, MAY_BE_ARRAY), /* getRealParameterDefaultValues return */ - reg::packed(3899, 0, 3992), /* getParameterAttributes $functionLike */ + reg::packed(3973, 0, 4066), /* getParameterAttributes $functionLike */ reg::packed(738, MAY_BE_ARRAY), /* getParameterAttributes return */ - reg::packed(154, 0, 4105), /* enterFunction $function */ - reg::packed(3189, 0, 3205), /* enterFunction $templateTypeMap */ - reg::packed(3242, MAY_BE_ARRAY), /* enterFunction $phpDocParameterTypes */ - reg::packed(3263, MAY_BE_NULL, 1424), /* enterFunction $phpDocReturnType */ - reg::packed(3280, MAY_BE_NULL, 1424), /* enterFunction $throwType */ - reg::packed(3290, MAY_BE_NULL | MAY_BE_STRING), /* enterFunction $deprecatedDescription */ - reg::packed(3312, MAY_BE_BOOL), /* enterFunction $isDeprecated */ - reg::packed(3325, MAY_BE_BOOL), /* enterFunction $isInternal */ - reg::packed(3344, MAY_BE_NULL | MAY_BE_BOOL, reg::NoString, false, false, 222), /* enterFunction $isPure */ - reg::packed(3351, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterFunction $acceptsNamedArguments */ - reg::packed(3373, MAY_BE_NULL, 3381, false, false, 222), /* enterFunction $asserts */ - reg::packed(3423, MAY_BE_NULL | MAY_BE_STRING, reg::NoString, false, false, 222), /* enterFunction $phpDocComment */ - reg::packed(3437, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $parameterOutTypes */ - reg::packed(3455, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $immediatelyInvokedCallableParameters */ - reg::packed(3492, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $phpDocClosureThisTypeParameters */ - reg::packed(4135, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $pureUnlessCallableIsImpureParameters */ - reg::packed(4172, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $pureUnlessParameterPassedParameters */ + reg::packed(154, 0, 4179), /* enterFunction $function */ + reg::packed(3263, 0, 3279), /* enterFunction $templateTypeMap */ + reg::packed(3316, MAY_BE_ARRAY), /* enterFunction $phpDocParameterTypes */ + reg::packed(3337, MAY_BE_NULL, 1424), /* enterFunction $phpDocReturnType */ + reg::packed(3354, MAY_BE_NULL, 1424), /* enterFunction $throwType */ + reg::packed(3364, MAY_BE_NULL | MAY_BE_STRING), /* enterFunction $deprecatedDescription */ + reg::packed(3386, MAY_BE_BOOL), /* enterFunction $isDeprecated */ + reg::packed(3399, MAY_BE_BOOL), /* enterFunction $isInternal */ + reg::packed(3418, MAY_BE_NULL | MAY_BE_BOOL, reg::NoString, false, false, 222), /* enterFunction $isPure */ + reg::packed(3425, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterFunction $acceptsNamedArguments */ + reg::packed(3447, MAY_BE_NULL, 3455, false, false, 222), /* enterFunction $asserts */ + reg::packed(3497, MAY_BE_NULL | MAY_BE_STRING, reg::NoString, false, false, 222), /* enterFunction $phpDocComment */ + reg::packed(3511, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $parameterOutTypes */ + reg::packed(3529, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $immediatelyInvokedCallableParameters */ + reg::packed(3566, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $phpDocClosureThisTypeParameters */ + reg::packed(4209, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $pureUnlessCallableIsImpureParameters */ + reg::packed(4246, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* enterFunction $pureUnlessParameterPassedParameters */ reg::packed(738, 0, 523), /* enterFunction return */ - reg::packed(4222, 0, 163), /* enterFunctionLike $functionReflection */ - reg::packed(4241, MAY_BE_BOOL), /* enterFunctionLike $preserveConstructorScope */ + reg::packed(4296, 0, 163), /* enterFunctionLike $functionReflection */ + reg::packed(4315, MAY_BE_BOOL), /* enterFunctionLike $preserveConstructorScope */ reg::packed(738, 0, 523), /* enterFunctionLike return */ - reg::packed(4284, MAY_BE_STRING), /* enterNamespace $namespaceName */ + reg::packed(4358, MAY_BE_STRING), /* enterNamespace $namespaceName */ reg::packed(738, 0, 523), /* enterNamespace return */ - reg::packed(4313, MAY_BE_NULL, 1424), /* enterClosureBind $thisType */ - reg::packed(4322, MAY_BE_NULL, 1424), /* enterClosureBind $nativeThisType */ - reg::packed(4337, MAY_BE_ARRAY), /* enterClosureBind $scopeClasses */ + reg::packed(4387, MAY_BE_NULL, 1424), /* enterClosureBind $thisType */ + reg::packed(4396, MAY_BE_NULL, 1424), /* enterClosureBind $nativeThisType */ + reg::packed(4411, MAY_BE_ARRAY), /* enterClosureBind $scopeClasses */ reg::packed(738, 0, 523), /* enterClosureBind return */ - reg::packed(4367, 0, 523), /* restoreOriginalScopeAfterClosureBind $originalScope */ + reg::packed(4441, 0, 523), /* restoreOriginalScopeAfterClosureBind $originalScope */ reg::packed(738, 0, 523), /* restoreOriginalScopeAfterClosureBind return */ - reg::packed(4418, 0, 523), /* restoreThis $restoreThisScope */ + reg::packed(4492, 0, 523), /* restoreThis $restoreThisScope */ reg::packed(738, 0, 523), /* restoreThis return */ - reg::packed(4313, 0, 1424), /* enterClosureCall $thisType */ - reg::packed(4322, 0, 1424), /* enterClosureCall $nativeThisType */ + reg::packed(4387, 0, 1424), /* enterClosureCall $thisType */ + reg::packed(4396, 0, 1424), /* enterClosureCall $nativeThisType */ reg::packed(738, 0, 523), /* enterClosureCall return */ reg::packed(738, MAY_BE_BOOL), /* isInClosureBind return */ - reg::packed(4337, MAY_BE_ARRAY), /* withClosureBindScopeClasses $scopeClasses */ + reg::packed(4411, MAY_BE_ARRAY), /* withClosureBindScopeClasses $scopeClasses */ reg::packed(738, 0, 523), /* withClosureBindScopeClasses return */ - reg::packed(4508, 0, 4516), /* enterAnonymousFunction $closure */ - reg::packed(4544, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunction $callableParameters */ - reg::packed(4563, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* enterAnonymousFunction $nativeCallableParameters */ + reg::packed(4582, 0, 4590), /* enterAnonymousFunction $closure */ + reg::packed(4618, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunction $callableParameters */ + reg::packed(4637, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* enterAnonymousFunction $nativeCallableParameters */ reg::packed(738, 0, 523), /* enterAnonymousFunction return */ - reg::packed(4508, 0, 4516), /* enterAnonymousFunctionWithoutReflection $closure */ - reg::packed(4544, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunctionWithoutReflection $callableParameters */ - reg::packed(4563, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunctionWithoutReflection $nativeCallableParameters */ + reg::packed(4582, 0, 4590), /* enterAnonymousFunctionWithoutReflection $closure */ + reg::packed(4618, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunctionWithoutReflection $callableParameters */ + reg::packed(4637, MAY_BE_NULL | MAY_BE_ARRAY), /* enterAnonymousFunctionWithoutReflection $nativeCallableParameters */ reg::packed(738, 0, 523), /* enterAnonymousFunctionWithoutReflection return */ - reg::packed(4651, 0, 4662), /* expressionTypeIsUnchangeable $typeHolder */ + reg::packed(4725, 0, 4736), /* expressionTypeIsUnchangeable $typeHolder */ reg::packed(738, MAY_BE_BOOL), /* expressionTypeIsUnchangeable return */ reg::packed(237, MAY_BE_ARRAY), /* invalidateStaticExpressions $expressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* invalidateStaticExpressions return */ - reg::packed(4757, 0, 4771), /* enterArrowFunction $arrowFunction */ - reg::packed(4544, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunction $callableParameters */ - reg::packed(4563, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* enterArrowFunction $nativeCallableParameters */ + reg::packed(4831, 0, 4845), /* enterArrowFunction $arrowFunction */ + reg::packed(4618, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunction $callableParameters */ + reg::packed(4637, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* enterArrowFunction $nativeCallableParameters */ reg::packed(738, 0, 523), /* enterArrowFunction return */ - reg::packed(4757, 0, 4771), /* enterArrowFunctionWithoutReflection $arrowFunction */ - reg::packed(4544, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunctionWithoutReflection $callableParameters */ - reg::packed(4563, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunctionWithoutReflection $nativeCallableParameters */ + reg::packed(4831, 0, 4845), /* enterArrowFunctionWithoutReflection $arrowFunction */ + reg::packed(4618, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunctionWithoutReflection $callableParameters */ + reg::packed(4637, MAY_BE_NULL | MAY_BE_ARRAY), /* enterArrowFunctionWithoutReflection $nativeCallableParameters */ reg::packed(738, 0, 523), /* enterArrowFunctionWithoutReflection return */ - reg::packed(2877, 0, 4860), /* isParameterValueNullable $parameter */ + reg::packed(2951, 0, 4934), /* isParameterValueNullable $parameter */ reg::packed(738, MAY_BE_BOOL), /* isParameterValueNullable return */ - reg::packed(3874, 0), /* getFunctionType $type */ - reg::packed(4906, MAY_BE_BOOL), /* getFunctionType $isNullable */ - reg::packed(4917, MAY_BE_BOOL), /* getFunctionType $isVariadic */ + reg::packed(3948, MAY_BE_NULL, 4980), /* getFunctionType $type */ + reg::packed(5053, MAY_BE_BOOL), /* getFunctionType $isNullable */ + reg::packed(5064, MAY_BE_BOOL), /* getFunctionType $isVariadic */ reg::packed(738, 0, 1424), /* getFunctionType return */ - reg::packed(2877, 0, 4860), /* getCallableParameterType $parameter */ - reg::packed(4544, MAY_BE_ARRAY), /* getCallableParameterType $callableParameters */ - reg::packed(4944, MAY_BE_LONG), /* getCallableParameterType $index */ + reg::packed(2951, 0, 4934), /* getCallableParameterType $parameter */ + reg::packed(4618, MAY_BE_ARRAY), /* getCallableParameterType $callableParameters */ + reg::packed(5091, MAY_BE_LONG), /* getCallableParameterType $index */ reg::packed(738, 0, 1424), /* getCallableParameterType return */ - reg::packed(4544, MAY_BE_ARRAY), /* buildVariadicArrayTypeFromCallableParameters $callableParameters */ - reg::packed(4975, MAY_BE_LONG), /* buildVariadicArrayTypeFromCallableParameters $startIndex */ + reg::packed(4618, MAY_BE_ARRAY), /* buildVariadicArrayTypeFromCallableParameters $callableParameters */ + reg::packed(5122, MAY_BE_LONG), /* buildVariadicArrayTypeFromCallableParameters $startIndex */ reg::packed(738, 0, 1424), /* buildVariadicArrayTypeFromCallableParameters return */ - reg::packed(5031, 0, 1424), /* intersectButNotNever $nativeType */ - reg::packed(5042, 0, 1424), /* intersectButNotNever $inferredType */ + reg::packed(5178, 0, 1424), /* intersectButNotNever $nativeType */ + reg::packed(5189, 0, 1424), /* intersectButNotNever $inferredType */ reg::packed(738, 0, 1424), /* intersectButNotNever return */ - reg::packed(966, 0, 5076), /* enterMatch $expr */ - reg::packed(5103, 0, 1424), /* enterMatch $condType */ - reg::packed(5112, 0, 1424), /* enterMatch $condNativeType */ + reg::packed(966, 0, 5223), /* enterMatch $expr */ + reg::packed(5250, 0, 1424), /* enterMatch $condType */ + reg::packed(5259, 0, 1424), /* enterMatch $condNativeType */ reg::packed(738, 0, 523), /* enterMatch return */ - reg::packed(4367, 0, 523), /* enterForeach $originalScope */ - reg::packed(5138, 0, 1712), /* enterForeach $iteratee */ - reg::packed(5147, 0, 1424), /* enterForeach $iterateeType */ - reg::packed(5160, 0, 1424), /* enterForeach $nativeIterateeType */ - reg::packed(5179, MAY_BE_STRING), /* enterForeach $valueName */ - reg::packed(5189, MAY_BE_NULL | MAY_BE_STRING), /* enterForeach $keyName */ - reg::packed(5197, MAY_BE_BOOL), /* enterForeach $valueByRef */ + reg::packed(4441, 0, 523), /* enterForeach $originalScope */ + reg::packed(5285, 0, 1712), /* enterForeach $iteratee */ + reg::packed(5294, 0, 1424), /* enterForeach $iterateeType */ + reg::packed(5307, 0, 1424), /* enterForeach $nativeIterateeType */ + reg::packed(5326, MAY_BE_STRING), /* enterForeach $valueName */ + reg::packed(5336, MAY_BE_NULL | MAY_BE_STRING), /* enterForeach $keyName */ + reg::packed(5344, MAY_BE_BOOL), /* enterForeach $valueByRef */ reg::packed(738, 0, 523), /* enterForeach return */ - reg::packed(4367, 0, 523), /* enterForeachKey $originalScope */ - reg::packed(5138, 0, 1712), /* enterForeachKey $iteratee */ - reg::packed(5147, 0, 1424), /* enterForeachKey $iterateeType */ - reg::packed(5160, 0, 1424), /* enterForeachKey $nativeIterateeType */ - reg::packed(5189, MAY_BE_STRING), /* enterForeachKey $keyName */ + reg::packed(4441, 0, 523), /* enterForeachKey $originalScope */ + reg::packed(5285, 0, 1712), /* enterForeachKey $iteratee */ + reg::packed(5294, 0, 1424), /* enterForeachKey $iterateeType */ + reg::packed(5307, 0, 1424), /* enterForeachKey $nativeIterateeType */ + reg::packed(5336, MAY_BE_STRING), /* enterForeachKey $keyName */ reg::packed(738, 0, 523), /* enterForeachKey return */ - reg::packed(5237, 0, 1424), /* enterCatchType $catchType */ + reg::packed(5384, 0, 1424), /* enterCatchType $catchType */ reg::packed(1374, MAY_BE_NULL | MAY_BE_STRING), /* enterCatchType $variableName */ reg::packed(738, 0, 523), /* enterCatchType return */ reg::packed(966, 0, 1712), /* enterExpressionAssign $expr */ - reg::packed(5262, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterExpressionAssign $isPlainWrite */ + reg::packed(5409, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterExpressionAssign $isPlainWrite */ reg::packed(738, 0, 523), /* enterExpressionAssign return */ reg::packed(966, 0, 1712), /* exitExpressionAssign $expr */ reg::packed(738, 0, 523), /* exitExpressionAssign return */ @@ -810,23 +812,23 @@ inline constexpr reg::PackedArg args[] = { reg::packed(966, 0, 1712), /* isUndefinedExpressionAllowed $expr */ reg::packed(738, MAY_BE_BOOL), /* isUndefinedExpressionAllowed return */ reg::packed(1374, MAY_BE_STRING), /* assignVariable $variableName */ - reg::packed(3874, 0, 1424), /* assignVariable $type */ - reg::packed(5031, 0, 1424), /* assignVariable $nativeType */ - reg::packed(5456, 0, 1387), /* assignVariable $certainty */ - reg::packed(5466, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* assignVariable $intertwinedPropagatedFrom */ + reg::packed(3948, 0, 1424), /* assignVariable $type */ + reg::packed(5178, 0, 1424), /* assignVariable $nativeType */ + reg::packed(5603, 0, 1387), /* assignVariable $certainty */ + reg::packed(5613, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* assignVariable $intertwinedPropagatedFrom */ reg::packed(738, 0, 523), /* assignVariable return */ reg::packed(966, 0, 1712), /* overwriteExpression $expr */ - reg::packed(3874, 0, 1424), /* overwriteExpression $type */ - reg::packed(5031, 0, 1424), /* overwriteExpression $nativeType */ + reg::packed(3948, 0, 1424), /* overwriteExpression $type */ + reg::packed(5178, 0, 1424), /* overwriteExpression $nativeType */ reg::packed(738, 0, 523), /* overwriteExpression return */ - reg::packed(5527, 0, 523), /* resolveIntertwinedAssignedType $scope */ - reg::packed(5533, 0, 1424), /* resolveIntertwinedAssignedType $rootType */ - reg::packed(5542, 0, 1712), /* resolveIntertwinedAssignedType $assignedExpr */ - reg::packed(5555, MAY_BE_STRING), /* resolveIntertwinedAssignedType $rootVariableName */ - reg::packed(5572, MAY_BE_BOOL), /* resolveIntertwinedAssignedType $native */ + reg::packed(5674, 0, 523), /* resolveIntertwinedAssignedType $scope */ + reg::packed(5680, 0, 1424), /* resolveIntertwinedAssignedType $rootType */ + reg::packed(5689, 0, 1712), /* resolveIntertwinedAssignedType $assignedExpr */ + reg::packed(5702, MAY_BE_STRING), /* resolveIntertwinedAssignedType $rootVariableName */ + reg::packed(5719, MAY_BE_BOOL), /* resolveIntertwinedAssignedType $native */ reg::packed(738, 0, 1424), /* resolveIntertwinedAssignedType return */ - reg::packed(5527, 0, 523), /* isDimFetchPathReachable $scope */ - reg::packed(5610, 0, 5619), /* isDimFetchPathReachable $dimFetch */ + reg::packed(5674, 0, 523), /* isDimFetchPathReachable $scope */ + reg::packed(5757, 0, 5766), /* isDimFetchPathReachable $dimFetch */ reg::packed(738, MAY_BE_BOOL), /* isDimFetchPathReachable return */ reg::packed(966, 0, 1712), /* unsetExpression $expr */ reg::packed(738, 0, 523), /* unsetExpression return */ @@ -837,202 +839,202 @@ inline constexpr reg::PackedArg args[] = { reg::packed(966, 0, 1712), /* getScopeStateNativeType $expr */ reg::packed(738, 0, 1424), /* getScopeStateNativeType return */ reg::packed(966, 0, 1712), /* resolveScopeStateType $expr */ - reg::packed(5572, MAY_BE_BOOL), /* resolveScopeStateType $native */ + reg::packed(5719, MAY_BE_BOOL), /* resolveScopeStateType $native */ reg::packed(738, 0, 1424), /* resolveScopeStateType return */ reg::packed(966, 0, 1712), /* specifyExpressionType $expr */ - reg::packed(3874, 0, 1424), /* specifyExpressionType $type */ - reg::packed(5031, 0, 1424), /* specifyExpressionType $nativeType */ - reg::packed(5456, 0, 1387), /* specifyExpressionType $certainty */ + reg::packed(3948, 0, 1424), /* specifyExpressionType $type */ + reg::packed(5178, 0, 1424), /* specifyExpressionType $nativeType */ + reg::packed(5603, 0, 1387), /* specifyExpressionType $certainty */ reg::packed(738, 0, 523), /* specifyExpressionType return */ reg::packed(738, 0, 523), /* openSpecificationScope return */ reg::packed(966, 0, 1712), /* isSpecifyExpressionTypeNoop $expr */ - reg::packed(3874, 0, 1424), /* isSpecifyExpressionTypeNoop $type */ + reg::packed(3948, 0, 1424), /* isSpecifyExpressionTypeNoop $type */ reg::packed(738, MAY_BE_BOOL), /* isSpecifyExpressionTypeNoop return */ reg::packed(966, 0, 1712), /* specifyExpressionTypeInPlace $expr */ - reg::packed(3874, 0, 1424), /* specifyExpressionTypeInPlace $type */ - reg::packed(5031, 0, 1424), /* specifyExpressionTypeInPlace $nativeType */ - reg::packed(5456, 0, 1387), /* specifyExpressionTypeInPlace $certainty */ + reg::packed(3948, 0, 1424), /* specifyExpressionTypeInPlace $type */ + reg::packed(5178, 0, 1424), /* specifyExpressionTypeInPlace $nativeType */ + reg::packed(5603, 0, 1387), /* specifyExpressionTypeInPlace $certainty */ reg::packed(738, MAY_BE_VOID), /* specifyExpressionTypeInPlace return */ reg::packed(966, 0, 1712), /* assignExpression $expr */ - reg::packed(3874, 0, 1424), /* assignExpression $type */ - reg::packed(5031, 0, 1424), /* assignExpression $nativeType */ + reg::packed(3948, 0, 1424), /* assignExpression $type */ + reg::packed(5178, 0, 1424), /* assignExpression $nativeType */ reg::packed(738, 0, 523), /* assignExpression return */ - reg::packed(5889, 0, 1424), /* assignInitializedProperty $fetchedOnType */ - reg::packed(3728, MAY_BE_STRING), /* assignInitializedProperty $propertyName */ + reg::packed(6036, 0, 1424), /* assignInitializedProperty $fetchedOnType */ + reg::packed(3802, MAY_BE_STRING), /* assignInitializedProperty $propertyName */ reg::packed(738, 0, 523), /* assignInitializedProperty return */ - reg::packed(5929, 0, 1712), /* invalidateExpression $expressionToInvalidate */ - reg::packed(5952, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $requireMoreCharacters */ - reg::packed(5974, MAY_BE_NULL, 1065, false, false, 222), /* invalidateExpression $invalidatingClass */ - reg::packed(5992, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $keepPropertyFetches */ + reg::packed(6076, 0, 1712), /* invalidateExpression $expressionToInvalidate */ + reg::packed(6099, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $requireMoreCharacters */ + reg::packed(6121, MAY_BE_NULL, 1065, false, false, 222), /* invalidateExpression $invalidatingClass */ + reg::packed(6139, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $keepPropertyFetches */ reg::packed(738, 0, 523), /* invalidateExpression return */ reg::packed(966, 0, 1712), /* isPrivatePropertyOfDifferentClass $expr */ - reg::packed(5974, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */ + reg::packed(6121, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */ reg::packed(738, MAY_BE_BOOL), /* isPrivatePropertyOfDifferentClass return */ - reg::packed(5929, 0, 1712), /* invalidateMethodsOnExpression $expressionToInvalidate */ + reg::packed(6076, 0, 1712), /* invalidateMethodsOnExpression $expressionToInvalidate */ reg::packed(738, 0, 523), /* invalidateMethodsOnExpression return */ reg::packed(966, 0, 1712), /* setExpressionCertaintyKeepingType $expr */ - reg::packed(5456, 0, 1387), /* setExpressionCertaintyKeepingType $certainty */ + reg::packed(5603, 0, 1387), /* setExpressionCertaintyKeepingType $certainty */ reg::packed(738, 0, 523), /* setExpressionCertaintyKeepingType return */ - reg::packed(3874, 0, 1424), /* isComplexUnionType $type */ + reg::packed(3948, 0, 1424), /* isComplexUnionType $type */ reg::packed(738, MAY_BE_BOOL), /* isComplexUnionType return */ reg::packed(966, 0, 1712), /* addTypeToExpression $expr */ - reg::packed(3874, 0, 1424), /* addTypeToExpression $type */ + reg::packed(3948, 0, 1424), /* addTypeToExpression $type */ reg::packed(738, 0, 523), /* addTypeToExpression return */ reg::packed(966, 0, 1712), /* removeTypeFromExpression $expr */ - reg::packed(6170, 0, 1424), /* removeTypeFromExpression $typeToRemove */ + reg::packed(6317, 0, 1424), /* removeTypeFromExpression $typeToRemove */ reg::packed(738, 0, 523), /* removeTypeFromExpression return */ reg::packed(966, 0, 1712), /* filterByTruthyValue $expr */ reg::packed(738, 0, 523), /* filterByTruthyValue return */ reg::packed(966, 0, 1712), /* filterByFalseyValue $expr */ reg::packed(738, 0, 523), /* filterByFalseyValue return */ - reg::packed(6248, 0, 2035), /* applySpecifiedTypes $specifiedTypes */ + reg::packed(6395, 0, 2035), /* applySpecifiedTypes $specifiedTypes */ reg::packed(738, 0, 523), /* applySpecifiedTypes return */ - reg::packed(6283, MAY_BE_ARRAY), /* processConditionalExpressionsAfterSpecifying $specifiedExpressions */ + reg::packed(6430, MAY_BE_ARRAY), /* processConditionalExpressionsAfterSpecifying $specifiedExpressions */ reg::packed(738, 0, 523), /* processConditionalExpressionsAfterSpecifying return */ reg::packed(738, MAY_BE_ARRAY), /* getConditionalExpressions return */ reg::packed(1883, MAY_BE_STRING), /* addConditionalExpressions $exprString */ - reg::packed(6375, MAY_BE_ARRAY), /* addConditionalExpressions $conditionalExpressionHolders */ + reg::packed(6522, MAY_BE_ARRAY), /* addConditionalExpressions $conditionalExpressionHolders */ reg::packed(738, 0, 523), /* addConditionalExpressions return */ reg::packed(738, 0, 523), /* exitFirstLevelStatements return */ reg::packed(738, MAY_BE_BOOL), /* isInFirstLevelStatement return */ - reg::packed(6479, MAY_BE_NULL, 523), /* mergeWith $otherScope */ - reg::packed(6490, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWith $preserveVacuousConditionals */ + reg::packed(6626, MAY_BE_NULL, 523), /* mergeWith $otherScope */ + reg::packed(6637, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWith $preserveVacuousConditionals */ reg::packed(738, 0, 523), /* mergeWith return */ - reg::packed(6528, 0, 523), /* collectAbsorbedClosures $ours */ - reg::packed(6533, 0, 523), /* collectAbsorbedClosures $theirs */ + reg::packed(6675, 0, 523), /* collectAbsorbedClosures $ours */ + reg::packed(6680, 0, 523), /* collectAbsorbedClosures $theirs */ reg::packed(738, MAY_BE_NULL, 672), /* collectAbsorbedClosures return */ - reg::packed(6479, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */ - reg::packed(6490, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWithVariableState $preserveVacuousConditionals */ + reg::packed(6626, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */ + reg::packed(6637, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWithVariableState $preserveVacuousConditionals */ reg::packed(738, 0, 523), /* mergeWithVariableState return */ - reg::packed(6587, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */ - reg::packed(6611, MAY_BE_ARRAY), /* findMergedCallCandidates $mergedExpressionTypes */ + reg::packed(6734, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */ + reg::packed(6758, MAY_BE_ARRAY), /* findMergedCallCandidates $mergedExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* findMergedCallCandidates return */ - reg::packed(6658, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */ - reg::packed(6669, MAY_BE_ARRAY), /* findUninformativeMergedCalls $mergedNativeTypes */ + reg::packed(6805, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */ + reg::packed(6816, MAY_BE_ARRAY), /* findUninformativeMergedCalls $mergedNativeTypes */ reg::packed(738, MAY_BE_ARRAY), /* findUninformativeMergedCalls return */ - reg::packed(6587, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */ - reg::packed(6716, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */ - reg::packed(6735, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */ + reg::packed(6734, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */ + reg::packed(6863, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */ + reg::packed(6882, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches return */ - reg::packed(6791, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */ - reg::packed(6821, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */ - reg::packed(6850, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */ + reg::packed(6938, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */ + reg::packed(6968, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */ + reg::packed(6997, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions return */ - reg::packed(6791, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */ - reg::packed(6909, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */ - reg::packed(6935, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */ + reg::packed(6938, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */ + reg::packed(7056, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */ + reg::packed(7082, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */ reg::packed(738, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions return */ - reg::packed(7000, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */ - reg::packed(7026, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */ + reg::packed(7147, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */ + reg::packed(7173, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */ reg::packed(738, MAY_BE_ARRAY), /* mergeConditionalExpressions return */ - reg::packed(7085, 0, 523), /* mergeInitializedProperties $calledMethodScope */ + reg::packed(7232, 0, 523), /* mergeInitializedProperties $calledMethodScope */ reg::packed(738, 0, 523), /* mergeInitializedProperties return */ - reg::packed(7130, 0, 523), /* processFinallyScope $finallyScope */ - reg::packed(7143, 0, 523), /* processFinallyScope $originalFinallyScope */ + reg::packed(7277, 0, 523), /* processFinallyScope $finallyScope */ + reg::packed(7290, 0, 523), /* processFinallyScope $originalFinallyScope */ reg::packed(738, 0, 523), /* processFinallyScope return */ - reg::packed(7184, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */ - reg::packed(7207, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */ - reg::packed(7234, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */ + reg::packed(7331, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */ + reg::packed(7354, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */ + reg::packed(7381, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */ reg::packed(738, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders return */ - reg::packed(7301, 0, 523), /* processClosureScope $closureScope */ - reg::packed(7314, MAY_BE_NULL, 523), /* processClosureScope $prevScope */ - reg::packed(7324, MAY_BE_ARRAY), /* processClosureScope $byRefUses */ + reg::packed(7448, 0, 523), /* processClosureScope $closureScope */ + reg::packed(7461, MAY_BE_NULL, 523), /* processClosureScope $prevScope */ + reg::packed(7471, MAY_BE_ARRAY), /* processClosureScope $byRefUses */ reg::packed(738, 0, 523), /* processClosureScope return */ - reg::packed(7354, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */ + reg::packed(7501, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */ reg::packed(738, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute return */ - reg::packed(6479, 0, 523), /* generalizeWith $otherScope */ - reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */ + reg::packed(6626, 0, 523), /* generalizeWith $otherScope */ + reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */ reg::packed(738, 0, 523), /* generalizeWith return */ - reg::packed(6479, 0, 523), /* generalizeWithVariableState $otherScope */ - reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */ + reg::packed(6626, 0, 523), /* generalizeWithVariableState $otherScope */ + reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */ reg::packed(738, 0, 523), /* generalizeWithVariableState return */ - reg::packed(7478, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */ - reg::packed(7498, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */ - reg::packed(7413, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */ + reg::packed(7625, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */ + reg::packed(7645, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */ + reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */ reg::packed(738, MAY_BE_ARRAY), /* generalizeVariableTypeHolders return */ - reg::packed(3874, 0, 1424), /* flattenUnionForGeneralization $type */ + reg::packed(3948, 0, 1424), /* flattenUnionForGeneralization $type */ reg::packed(738, MAY_BE_ARRAY), /* flattenUnionForGeneralization return */ - reg::packed(7583, 0, 1424), /* generalizeType $a */ - reg::packed(7585, 0, 1424), /* generalizeType $b */ - reg::packed(7587, MAY_BE_LONG), /* generalizeType $depth */ + reg::packed(7730, 0, 1424), /* generalizeType $a */ + reg::packed(7732, 0, 1424), /* generalizeType $b */ + reg::packed(7734, MAY_BE_LONG), /* generalizeType $depth */ reg::packed(738, 0, 1424), /* generalizeType return */ - reg::packed(3874, 0, 1424), /* getArrayDepth $type */ + reg::packed(3948, 0, 1424), /* getArrayDepth $type */ reg::packed(738, MAY_BE_LONG), /* getArrayDepth return */ - reg::packed(6479, 0, 523), /* equals $otherScope */ + reg::packed(6626, 0, 523), /* equals $otherScope */ reg::packed(738, MAY_BE_BOOL), /* equals return */ reg::packed(278, MAY_BE_ARRAY), /* compareConditionalExpressions $conditionalExpressions */ - reg::packed(7629, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */ + reg::packed(7776, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */ reg::packed(738, MAY_BE_BOOL), /* compareConditionalExpressions return */ - reg::packed(7478, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */ - reg::packed(7498, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */ + reg::packed(7625, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */ + reg::packed(7645, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */ reg::packed(738, MAY_BE_BOOL), /* compareVariableTypeHolders return */ - reg::packed(7714, 0, 7733), /* canAccessProperty $propertyReflection */ + reg::packed(7861, 0, 7880), /* canAccessProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessProperty return */ - reg::packed(7714, 0, 7789), /* canReadProperty $propertyReflection */ + reg::packed(7861, 0, 7936), /* canReadProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canReadProperty return */ - reg::packed(7714, 0, 7789), /* canWriteProperty $propertyReflection */ + reg::packed(7861, 0, 7936), /* canWriteProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canWriteProperty return */ - reg::packed(7868, 0, 7885), /* canCallMethod $methodReflection */ + reg::packed(8015, 0, 8032), /* canCallMethod $methodReflection */ reg::packed(738, MAY_BE_BOOL), /* canCallMethod return */ - reg::packed(7935, 0, 7954), /* canAccessConstant $constantReflection */ + reg::packed(8082, 0, 8101), /* canAccessConstant $constantReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessConstant return */ - reg::packed(8015, 0, 8037), /* canAccessClassMember $classMemberReflection */ + reg::packed(8162, 0, 8184), /* canAccessClassMember $classMemberReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessClassMember return */ reg::packed(738, MAY_BE_ARRAY), /* debug return */ - reg::packed(8105, 0, 1424), /* filterTypeWithMethod $typeWithMethod */ - reg::packed(8120, MAY_BE_STRING), /* filterTypeWithMethod $methodName */ + reg::packed(8252, 0, 1424), /* filterTypeWithMethod $typeWithMethod */ + reg::packed(8267, MAY_BE_STRING), /* filterTypeWithMethod $methodName */ reg::packed(738, MAY_BE_NULL, 1424), /* filterTypeWithMethod return */ - reg::packed(8105, 0, 1424), /* getMethodReflection $typeWithMethod */ - reg::packed(8120, MAY_BE_STRING), /* getMethodReflection $methodName */ - reg::packed(738, MAY_BE_NULL, 8152), /* getMethodReflection return */ - reg::packed(8105, 0, 1424), /* getNakedMethod $typeWithMethod */ - reg::packed(8120, MAY_BE_STRING), /* getNakedMethod $methodName */ - reg::packed(738, MAY_BE_NULL, 8152), /* getNakedMethod return */ - reg::packed(8231, 0, 1424), /* getPropertyReflection $typeWithProperty */ - reg::packed(3728, MAY_BE_STRING), /* getPropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7789), /* getPropertyReflection return */ - reg::packed(8231, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */ - reg::packed(3728, MAY_BE_STRING), /* getInstancePropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7789), /* getInstancePropertyReflection return */ - reg::packed(8231, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */ - reg::packed(3728, MAY_BE_STRING), /* getStaticPropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7789), /* getStaticPropertyReflection return */ - reg::packed(8328, 0, 1424), /* getConstantReflection $typeWithConstant */ - reg::packed(8345, MAY_BE_STRING), /* getConstantReflection $constantName */ - reg::packed(738, MAY_BE_NULL, 7954), /* getConstantReflection return */ - reg::packed(8345, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */ - reg::packed(8380, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */ + reg::packed(8252, 0, 1424), /* getMethodReflection $typeWithMethod */ + reg::packed(8267, MAY_BE_STRING), /* getMethodReflection $methodName */ + reg::packed(738, MAY_BE_NULL, 8299), /* getMethodReflection return */ + reg::packed(8252, 0, 1424), /* getNakedMethod $typeWithMethod */ + reg::packed(8267, MAY_BE_STRING), /* getNakedMethod $methodName */ + reg::packed(738, MAY_BE_NULL, 8299), /* getNakedMethod return */ + reg::packed(8378, 0, 1424), /* getPropertyReflection $typeWithProperty */ + reg::packed(3802, MAY_BE_STRING), /* getPropertyReflection $propertyName */ + reg::packed(738, MAY_BE_NULL, 7936), /* getPropertyReflection return */ + reg::packed(8378, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */ + reg::packed(3802, MAY_BE_STRING), /* getInstancePropertyReflection $propertyName */ + reg::packed(738, MAY_BE_NULL, 7936), /* getInstancePropertyReflection return */ + reg::packed(8378, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */ + reg::packed(3802, MAY_BE_STRING), /* getStaticPropertyReflection $propertyName */ + reg::packed(738, MAY_BE_NULL, 7936), /* getStaticPropertyReflection return */ + reg::packed(8475, 0, 1424), /* getConstantReflection $typeWithConstant */ + reg::packed(8492, MAY_BE_STRING), /* getConstantReflection $constantName */ + reg::packed(738, MAY_BE_NULL, 8101), /* getConstantReflection return */ + reg::packed(8492, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */ + reg::packed(8527, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */ reg::packed(738, 0, 1424), /* getConstantExplicitTypeFromConfig return */ reg::packed(738, MAY_BE_ARRAY), /* getConstantTypes return */ reg::packed(1520, 0, 1525), /* getGlobalConstantType $name */ reg::packed(738, MAY_BE_NULL, 1424), /* getGlobalConstantType return */ reg::packed(1520, 0, 1525), /* createGlobalConstantFetches $name */ - reg::packed(8466, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */ + reg::packed(8613, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */ reg::packed(227, MAY_BE_NULL | MAY_BE_STRING), /* createGlobalConstantFetches $namespace */ reg::packed(738, MAY_BE_ARRAY), /* createGlobalConstantFetches return */ reg::packed(738, MAY_BE_ARRAY), /* getNativeConstantTypes return */ - reg::packed(5138, 0, 1424), /* getIterableKeyType $iteratee */ + reg::packed(5285, 0, 1424), /* getIterableKeyType $iteratee */ reg::packed(738, 0, 1424), /* getIterableKeyType return */ - reg::packed(5138, 0, 1424), /* getIterableValueType $iteratee */ + reg::packed(5285, 0, 1424), /* getIterableValueType $iteratee */ reg::packed(738, 0, 1424), /* getIterableValueType return */ - reg::packed(738, 0, 8568), /* getPhpVersion return */ + reg::packed(738, 0, 8715), /* getPhpVersion return */ reg::packed(738, MAY_BE_NULL, 1424), /* getConfiguredPhpVersionRange return */ - reg::packed(3874, 0, 1424), /* isOverallPhpVersionRange $type */ + reg::packed(3948, 0, 1424), /* isOverallPhpVersionRange $type */ reg::packed(738, MAY_BE_BOOL), /* isOverallPhpVersionRange return */ - reg::packed(1707, 0, 8660), /* invokeNodeCallback $node */ + reg::packed(1707, 0, 8807), /* invokeNodeCallback $node */ reg::packed(738, MAY_BE_VOID), /* invokeNodeCallback return */ - reg::packed(8694, MAY_BE_STRING), /* emitCollectedData $collectorType */ - reg::packed(8708, MAY_BE_ANY), /* emitCollectedData $data */ + reg::packed(8841, MAY_BE_STRING), /* emitCollectedData $collectorType */ + reg::packed(8855, MAY_BE_ANY), /* emitCollectedData $data */ reg::packed(738, MAY_BE_VOID), /* emitCollectedData return */ - reg::packed(8731, MAY_BE_STRING), /* trackValueDependency $extensionClass */ + reg::packed(8878, MAY_BE_STRING), /* trackValueDependency $extensionClass */ reg::packed(2540, MAY_BE_STRING), /* trackValueDependency $key */ reg::packed(738, MAY_BE_VOID), /* trackValueDependency return */ - reg::packed(8767, MAY_BE_STRING), /* trackFileDependency $file */ + reg::packed(8914, MAY_BE_STRING), /* trackFileDependency $file */ reg::packed(738, MAY_BE_VOID), /* trackFileDependency return */ - reg::packed(8792, MAY_BE_STRING), /* trackDirectoryDependency $directory */ - reg::packed(8802, MAY_BE_STRING, reg::NoString, false, false, 8810), /* trackDirectoryDependency $pattern */ + reg::packed(8939, MAY_BE_STRING), /* trackDirectoryDependency $directory */ + reg::packed(8949, MAY_BE_STRING, reg::NoString, false, false, 8957), /* trackDirectoryDependency $pattern */ reg::packed(738, MAY_BE_VOID), /* trackDirectoryDependency return */ - reg::packed(2977, MAY_BE_STRING), /* trackClassDependency $className */ + reg::packed(3051, MAY_BE_STRING), /* trackClassDependency $className */ reg::packed(738, MAY_BE_VOID), /* trackClassDependency return */ }; using Sig = reg::Sig; @@ -1113,134 +1115,134 @@ inline constexpr sigtab::Sig resolveTypeByName = { { 2782 /* resolveTypeByName * inline constexpr sigtab::Sig getTypeFromValue = { { 2806 /* getTypeFromValue */, 1, 138, 1, 139, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig hasExpressionType = { { 2823 /* hasExpressionType */, 1, 140, 1, 141, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getTrackedExpressionType = { { 2841 /* getTrackedExpressionType */, 1, 142, 1, 143, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig pushInFunctionCall = { { 2940 /* pushInFunctionCall */, 3, 144, 3, 147, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig popInFunctionCall = { { 2959 /* popInFunctionCall */, 0, 148, 0, 148, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInClassExists = { { 2987 /* isInClassExists */, 1, 149, 1, 150, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFunctionCallStack = { { 3003 /* getFunctionCallStack */, 0, 151, 0, 151, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFunctionCallStackWithParameters = { { 3024 /* getFunctionCallStackWithParameters */, 0, 152, 0, 152, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInFunctionExists = { { 3072 /* isInFunctionExists */, 1, 153, 1, 154, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterClass = { { 3107 /* enterClass */, 1, 155, 1, 156, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterTrait = { { 3134 /* enterTrait */, 1, 157, 1, 158, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterClassMethod = { { 3678 /* enterClassMethod */, 9, 159, 21, 180, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterPropertyHook = { { 3856 /* enterPropertyHook */, 10, 181, 11, 192, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig transformStaticType = { { 3879 /* transformStaticType */, 1, 193, 1, 194, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getRealParameterTypes = { { 3940 /* getRealParameterTypes */, 1, 195, 1, 196, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getRealParameterDefaultValues = { { 3962 /* getRealParameterDefaultValues */, 1, 197, 1, 198, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getParameterAttributes = { { 4082 /* getParameterAttributes */, 1, 199, 1, 200, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig enterFunction = { { 4208 /* enterFunction */, 8, 201, 17, 218, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterFunctionLike = { { 4266 /* enterFunctionLike */, 2, 219, 2, 221, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig enterNamespace = { { 4298 /* enterNamespace */, 1, 222, 1, 223, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterClosureBind = { { 4350 /* enterClosureBind */, 3, 224, 3, 227, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig restoreOriginalScopeAfterClosureBind = { { 4381 /* restoreOriginalScopeAfterClosureBind */, 1, 228, 1, 229, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig restoreThis = { { 4435 /* restoreThis */, 1, 230, 1, 231, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterClosureCall = { { 4447 /* enterClosureCall */, 2, 232, 2, 234, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInClosureBind = { { 4464 /* isInClosureBind */, 0, 235, 0, 235, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig withClosureBindScopeClasses = { { 4480 /* withClosureBindScopeClasses */, 1, 236, 1, 237, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterAnonymousFunction = { { 4588 /* enterAnonymousFunction */, 2, 238, 3, 241, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterAnonymousFunctionWithoutReflection = { { 4611 /* enterAnonymousFunctionWithoutReflection */, 3, 242, 3, 245, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig expressionTypeIsUnchangeable = { { 4700 /* expressionTypeIsUnchangeable */, 1, 246, 1, 247, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig invalidateStaticExpressions = { { 4729 /* invalidateStaticExpressions */, 1, 248, 1, 249, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig enterArrowFunction = { { 4805 /* enterArrowFunction */, 2, 250, 3, 253, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterArrowFunctionWithoutReflection = { { 4824 /* enterArrowFunctionWithoutReflection */, 3, 254, 3, 257, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isParameterValueNullable = { { 4881 /* isParameterValueNullable */, 1, 258, 1, 259, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFunctionType = { { 4928 /* getFunctionType */, 3, 260, 3, 263, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getCallableParameterType = { { 4950 /* getCallableParameterType */, 3, 264, 3, 267, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig buildVariadicArrayTypeFromCallableParameters = { { 4986 /* buildVariadicArrayTypeFromCallableParameters */, 2, 268, 2, 270, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig intersectButNotNever = { { 5055 /* intersectButNotNever */, 2, 271, 2, 273, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig enterMatch = { { 5127 /* enterMatch */, 3, 274, 3, 277, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterForeach = { { 5208 /* enterForeach */, 7, 278, 7, 285, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterForeachKey = { { 5221 /* enterForeachKey */, 5, 286, 5, 291, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterCatchType = { { 5247 /* enterCatchType */, 2, 292, 2, 294, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterExpressionAssign = { { 5275 /* enterExpressionAssign */, 1, 295, 2, 297, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig exitExpressionAssign = { { 5297 /* exitExpressionAssign */, 1, 298, 1, 299, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInExpressionAssign = { { 5318 /* isInExpressionAssign */, 1, 300, 1, 301, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInWriteExpressionAssign = { { 5339 /* isInWriteExpressionAssign */, 1, 302, 1, 303, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig setAllowedUndefinedExpression = { { 5365 /* setAllowedUndefinedExpression */, 1, 304, 1, 305, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig unsetAllowedUndefinedExpression = { { 5395 /* unsetAllowedUndefinedExpression */, 1, 306, 1, 307, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isUndefinedExpressionAllowed = { { 5427 /* isUndefinedExpressionAllowed */, 1, 308, 1, 309, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig assignVariable = { { 5492 /* assignVariable */, 4, 310, 5, 315, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig overwriteExpression = { { 5507 /* overwriteExpression */, 3, 316, 3, 319, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveIntertwinedAssignedType = { { 5579 /* resolveIntertwinedAssignedType */, 5, 320, 5, 325, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isDimFetchPathReachable = { { 5653 /* isDimFetchPathReachable */, 2, 326, 2, 328, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig unsetExpression = { { 5677 /* unsetExpression */, 1, 329, 1, 330, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getStateType = { { 5693 /* getStateType */, 1, 331, 1, 332, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getScopeStateType = { { 5706 /* getScopeStateType */, 1, 333, 1, 334, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getScopeStateNativeType = { { 5724 /* getScopeStateNativeType */, 1, 335, 1, 336, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveScopeStateType = { { 5748 /* resolveScopeStateType */, 2, 337, 2, 339, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig specifyExpressionType = { { 5770 /* specifyExpressionType */, 4, 340, 4, 344, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig openSpecificationScope = { { 5792 /* openSpecificationScope */, 0, 345, 0, 345, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isSpecifyExpressionTypeNoop = { { 5815 /* isSpecifyExpressionTypeNoop */, 2, 346, 2, 348, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig specifyExpressionTypeInPlace = { { 5843 /* specifyExpressionTypeInPlace */, 4, 349, 4, 353, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig assignExpression = { { 5872 /* assignExpression */, 3, 354, 3, 357, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig assignInitializedProperty = { { 5903 /* assignInitializedProperty */, 2, 358, 2, 360, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig invalidateExpression = { { 6012 /* invalidateExpression */, 1, 361, 4, 365, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isPrivatePropertyOfDifferentClass = { { 6033 /* isPrivatePropertyOfDifferentClass */, 2, 366, 2, 368, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig invalidateMethodsOnExpression = { { 6067 /* invalidateMethodsOnExpression */, 1, 369, 1, 370, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig setExpressionCertaintyKeepingType = { { 6097 /* setExpressionCertaintyKeepingType */, 2, 371, 2, 373, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isComplexUnionType = { { 6131 /* isComplexUnionType */, 1, 374, 1, 375, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig addTypeToExpression = { { 6150 /* addTypeToExpression */, 2, 376, 2, 378, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig removeTypeFromExpression = { { 6183 /* removeTypeFromExpression */, 2, 379, 2, 381, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterByTruthyValue = { { 6208 /* filterByTruthyValue */, 1, 382, 1, 383, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterByFalseyValue = { { 6228 /* filterByFalseyValue */, 1, 384, 1, 385, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig applySpecifiedTypes = { { 6263 /* applySpecifiedTypes */, 1, 386, 1, 387, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processConditionalExpressionsAfterSpecifying = { { 6304 /* processConditionalExpressionsAfterSpecifying */, 1, 388, 1, 389, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getConditionalExpressions = { { 6349 /* getConditionalExpressions */, 0, 390, 0, 390, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig addConditionalExpressions = { { 6404 /* addConditionalExpressions */, 2, 391, 2, 393, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig exitFirstLevelStatements = { { 6430 /* exitFirstLevelStatements */, 0, 394, 0, 394, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInFirstLevelStatement = { { 6455 /* isInFirstLevelStatement */, 0, 395, 0, 395, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mergeWith = { { 6518 /* mergeWith */, 1, 396, 2, 398, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig collectAbsorbedClosures = { { 6540 /* collectAbsorbedClosures */, 2, 399, 2, 401, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeWithVariableState = { { 6564 /* mergeWithVariableState */, 1, 402, 2, 404, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig findMergedCallCandidates = { { 6633 /* findMergedCallCandidates */, 2, 405, 2, 407, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig findUninformativeMergedCalls = { { 6687 /* findUninformativeMergedCalls */, 2, 408, 2, 410, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6756 /* withoutPreciseClassConstantFetches */, 3, 411, 3, 414, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 6871 /* preserveVacuousConditionalExpressions */, 3, 415, 3, 418, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 6963 /* mergeSameGuardConditionalExpressions */, 3, 419, 3, 422, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeConditionalExpressions = { { 7057 /* mergeConditionalExpressions */, 2, 423, 2, 425, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeInitializedProperties = { { 7103 /* mergeInitializedProperties */, 1, 426, 1, 427, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processFinallyScope = { { 7164 /* processFinallyScope */, 2, 428, 2, 430, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7262 /* processFinallyScopeVariableTypeHolders */, 3, 431, 3, 434, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig processClosureScope = { { 7334 /* processClosureScope */, 3, 435, 3, 438, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7365 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 439, 1, 440, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig generalizeWith = { { 7435 /* generalizeWith */, 1, 441, 2, 443, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig generalizeWithVariableState = { { 7450 /* generalizeWithVariableState */, 2, 444, 2, 446, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7523 /* generalizeVariableTypeHolders */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7553 /* flattenUnionForGeneralization */, 1, 451, 1, 452, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig generalizeType = { { 7593 /* generalizeType */, 3, 453, 3, 456, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getArrayDepth = { { 7608 /* getArrayDepth */, 1, 457, 1, 458, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig equals = { { 7622 /* equals */, 1, 459, 1, 460, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig compareConditionalExpressions = { { 7657 /* compareConditionalExpressions */, 2, 461, 2, 463, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7687 /* compareVariableTypeHolders */, 2, 464, 2, 466, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig canAccessProperty = { { 7771 /* canAccessProperty */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canReadProperty = { { 7835 /* canReadProperty */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canWriteProperty = { { 7851 /* canWriteProperty */, 1, 471, 1, 472, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canCallMethod = { { 7921 /* canCallMethod */, 1, 473, 1, 474, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessConstant = { { 7997 /* canAccessConstant */, 1, 475, 1, 476, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessClassMember = { { 8078 /* canAccessClassMember */, 1, 477, 1, 478, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig debug = { { 8099 /* debug */, 0, 479, 0, 479, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterTypeWithMethod = { { 8131 /* filterTypeWithMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getMethodReflection = { { 8196 /* getMethodReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getNakedMethod = { { 8216 /* getNakedMethod */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPropertyReflection = { { 8248 /* getPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8270 /* getInstancePropertyReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8300 /* getStaticPropertyReflection */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantReflection = { { 8358 /* getConstantReflection */, 2, 498, 2, 500, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8393 /* getConstantExplicitTypeFromConfig */, 2, 501, 2, 503, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantTypes = { { 8427 /* getConstantTypes */, 0, 504, 0, 504, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getGlobalConstantType = { { 8444 /* getGlobalConstantType */, 1, 505, 1, 506, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8477 /* createGlobalConstantFetches */, 3, 507, 3, 510, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig getNativeConstantTypes = { { 8505 /* getNativeConstantTypes */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getIterableKeyType = { { 8528 /* getIterableKeyType */, 1, 512, 1, 513, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getIterableValueType = { { 8547 /* getIterableValueType */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPhpVersion = { { 8592 /* getPhpVersion */, 0, 516, 0, 516, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8606 /* getConfiguredPhpVersionRange */, 0, 517, 0, 517, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8635 /* isOverallPhpVersionRange */, 1, 518, 1, 519, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig invokeNodeCallback = { { 8675 /* invokeNodeCallback */, 1, 520, 1, 521, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig emitCollectedData = { { 8713 /* emitCollectedData */, 2, 522, 2, 524, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackValueDependency = { { 8746 /* trackValueDependency */, 2, 525, 2, 527, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackFileDependency = { { 8772 /* trackFileDependency */, 1, 528, 1, 529, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackDirectoryDependency = { { 8814 /* trackDirectoryDependency */, 1, 530, 2, 532, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackClassDependency = { { 8839 /* trackClassDependency */, 1, 533, 1, 534, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig pushInFunctionCall = { { 3014 /* pushInFunctionCall */, 3, 144, 3, 147, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig popInFunctionCall = { { 3033 /* popInFunctionCall */, 0, 148, 0, 148, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInClassExists = { { 3061 /* isInClassExists */, 1, 149, 1, 150, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFunctionCallStack = { { 3077 /* getFunctionCallStack */, 0, 151, 0, 151, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFunctionCallStackWithParameters = { { 3098 /* getFunctionCallStackWithParameters */, 0, 152, 0, 152, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInFunctionExists = { { 3146 /* isInFunctionExists */, 1, 153, 1, 154, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterClass = { { 3181 /* enterClass */, 1, 155, 1, 156, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterTrait = { { 3208 /* enterTrait */, 1, 157, 1, 158, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterClassMethod = { { 3752 /* enterClassMethod */, 9, 159, 21, 180, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterPropertyHook = { { 3930 /* enterPropertyHook */, 10, 181, 11, 192, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig transformStaticType = { { 3953 /* transformStaticType */, 1, 193, 1, 194, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getRealParameterTypes = { { 4014 /* getRealParameterTypes */, 1, 195, 1, 196, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getRealParameterDefaultValues = { { 4036 /* getRealParameterDefaultValues */, 1, 197, 1, 198, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getParameterAttributes = { { 4156 /* getParameterAttributes */, 1, 199, 1, 200, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig enterFunction = { { 4282 /* enterFunction */, 8, 201, 17, 218, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterFunctionLike = { { 4340 /* enterFunctionLike */, 2, 219, 2, 221, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig enterNamespace = { { 4372 /* enterNamespace */, 1, 222, 1, 223, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterClosureBind = { { 4424 /* enterClosureBind */, 3, 224, 3, 227, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig restoreOriginalScopeAfterClosureBind = { { 4455 /* restoreOriginalScopeAfterClosureBind */, 1, 228, 1, 229, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig restoreThis = { { 4509 /* restoreThis */, 1, 230, 1, 231, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterClosureCall = { { 4521 /* enterClosureCall */, 2, 232, 2, 234, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInClosureBind = { { 4538 /* isInClosureBind */, 0, 235, 0, 235, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig withClosureBindScopeClasses = { { 4554 /* withClosureBindScopeClasses */, 1, 236, 1, 237, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterAnonymousFunction = { { 4662 /* enterAnonymousFunction */, 2, 238, 3, 241, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterAnonymousFunctionWithoutReflection = { { 4685 /* enterAnonymousFunctionWithoutReflection */, 3, 242, 3, 245, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig expressionTypeIsUnchangeable = { { 4774 /* expressionTypeIsUnchangeable */, 1, 246, 1, 247, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig invalidateStaticExpressions = { { 4803 /* invalidateStaticExpressions */, 1, 248, 1, 249, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig enterArrowFunction = { { 4879 /* enterArrowFunction */, 2, 250, 3, 253, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterArrowFunctionWithoutReflection = { { 4898 /* enterArrowFunctionWithoutReflection */, 3, 254, 3, 257, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isParameterValueNullable = { { 4955 /* isParameterValueNullable */, 1, 258, 1, 259, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFunctionType = { { 5075 /* getFunctionType */, 3, 260, 3, 263, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getCallableParameterType = { { 5097 /* getCallableParameterType */, 3, 264, 3, 267, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig buildVariadicArrayTypeFromCallableParameters = { { 5133 /* buildVariadicArrayTypeFromCallableParameters */, 2, 268, 2, 270, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig intersectButNotNever = { { 5202 /* intersectButNotNever */, 2, 271, 2, 273, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig enterMatch = { { 5274 /* enterMatch */, 3, 274, 3, 277, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterForeach = { { 5355 /* enterForeach */, 7, 278, 7, 285, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterForeachKey = { { 5368 /* enterForeachKey */, 5, 286, 5, 291, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterCatchType = { { 5394 /* enterCatchType */, 2, 292, 2, 294, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterExpressionAssign = { { 5422 /* enterExpressionAssign */, 1, 295, 2, 297, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig exitExpressionAssign = { { 5444 /* exitExpressionAssign */, 1, 298, 1, 299, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInExpressionAssign = { { 5465 /* isInExpressionAssign */, 1, 300, 1, 301, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInWriteExpressionAssign = { { 5486 /* isInWriteExpressionAssign */, 1, 302, 1, 303, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig setAllowedUndefinedExpression = { { 5512 /* setAllowedUndefinedExpression */, 1, 304, 1, 305, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig unsetAllowedUndefinedExpression = { { 5542 /* unsetAllowedUndefinedExpression */, 1, 306, 1, 307, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isUndefinedExpressionAllowed = { { 5574 /* isUndefinedExpressionAllowed */, 1, 308, 1, 309, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig assignVariable = { { 5639 /* assignVariable */, 4, 310, 5, 315, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig overwriteExpression = { { 5654 /* overwriteExpression */, 3, 316, 3, 319, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveIntertwinedAssignedType = { { 5726 /* resolveIntertwinedAssignedType */, 5, 320, 5, 325, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isDimFetchPathReachable = { { 5800 /* isDimFetchPathReachable */, 2, 326, 2, 328, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig unsetExpression = { { 5824 /* unsetExpression */, 1, 329, 1, 330, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getStateType = { { 5840 /* getStateType */, 1, 331, 1, 332, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getScopeStateType = { { 5853 /* getScopeStateType */, 1, 333, 1, 334, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getScopeStateNativeType = { { 5871 /* getScopeStateNativeType */, 1, 335, 1, 336, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveScopeStateType = { { 5895 /* resolveScopeStateType */, 2, 337, 2, 339, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig specifyExpressionType = { { 5917 /* specifyExpressionType */, 4, 340, 4, 344, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig openSpecificationScope = { { 5939 /* openSpecificationScope */, 0, 345, 0, 345, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isSpecifyExpressionTypeNoop = { { 5962 /* isSpecifyExpressionTypeNoop */, 2, 346, 2, 348, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig specifyExpressionTypeInPlace = { { 5990 /* specifyExpressionTypeInPlace */, 4, 349, 4, 353, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig assignExpression = { { 6019 /* assignExpression */, 3, 354, 3, 357, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig assignInitializedProperty = { { 6050 /* assignInitializedProperty */, 2, 358, 2, 360, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig invalidateExpression = { { 6159 /* invalidateExpression */, 1, 361, 4, 365, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isPrivatePropertyOfDifferentClass = { { 6180 /* isPrivatePropertyOfDifferentClass */, 2, 366, 2, 368, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig invalidateMethodsOnExpression = { { 6214 /* invalidateMethodsOnExpression */, 1, 369, 1, 370, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig setExpressionCertaintyKeepingType = { { 6244 /* setExpressionCertaintyKeepingType */, 2, 371, 2, 373, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isComplexUnionType = { { 6278 /* isComplexUnionType */, 1, 374, 1, 375, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig addTypeToExpression = { { 6297 /* addTypeToExpression */, 2, 376, 2, 378, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig removeTypeFromExpression = { { 6330 /* removeTypeFromExpression */, 2, 379, 2, 381, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterByTruthyValue = { { 6355 /* filterByTruthyValue */, 1, 382, 1, 383, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterByFalseyValue = { { 6375 /* filterByFalseyValue */, 1, 384, 1, 385, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig applySpecifiedTypes = { { 6410 /* applySpecifiedTypes */, 1, 386, 1, 387, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processConditionalExpressionsAfterSpecifying = { { 6451 /* processConditionalExpressionsAfterSpecifying */, 1, 388, 1, 389, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getConditionalExpressions = { { 6496 /* getConditionalExpressions */, 0, 390, 0, 390, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig addConditionalExpressions = { { 6551 /* addConditionalExpressions */, 2, 391, 2, 393, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig exitFirstLevelStatements = { { 6577 /* exitFirstLevelStatements */, 0, 394, 0, 394, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInFirstLevelStatement = { { 6602 /* isInFirstLevelStatement */, 0, 395, 0, 395, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mergeWith = { { 6665 /* mergeWith */, 1, 396, 2, 398, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig collectAbsorbedClosures = { { 6687 /* collectAbsorbedClosures */, 2, 399, 2, 401, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeWithVariableState = { { 6711 /* mergeWithVariableState */, 1, 402, 2, 404, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig findMergedCallCandidates = { { 6780 /* findMergedCallCandidates */, 2, 405, 2, 407, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig findUninformativeMergedCalls = { { 6834 /* findUninformativeMergedCalls */, 2, 408, 2, 410, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6903 /* withoutPreciseClassConstantFetches */, 3, 411, 3, 414, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 7018 /* preserveVacuousConditionalExpressions */, 3, 415, 3, 418, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 7110 /* mergeSameGuardConditionalExpressions */, 3, 419, 3, 422, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeConditionalExpressions = { { 7204 /* mergeConditionalExpressions */, 2, 423, 2, 425, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeInitializedProperties = { { 7250 /* mergeInitializedProperties */, 1, 426, 1, 427, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processFinallyScope = { { 7311 /* processFinallyScope */, 2, 428, 2, 430, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7409 /* processFinallyScopeVariableTypeHolders */, 3, 431, 3, 434, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processClosureScope = { { 7481 /* processClosureScope */, 3, 435, 3, 438, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7512 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 439, 1, 440, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig generalizeWith = { { 7582 /* generalizeWith */, 1, 441, 2, 443, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig generalizeWithVariableState = { { 7597 /* generalizeWithVariableState */, 2, 444, 2, 446, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7670 /* generalizeVariableTypeHolders */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7700 /* flattenUnionForGeneralization */, 1, 451, 1, 452, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig generalizeType = { { 7740 /* generalizeType */, 3, 453, 3, 456, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getArrayDepth = { { 7755 /* getArrayDepth */, 1, 457, 1, 458, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig equals = { { 7769 /* equals */, 1, 459, 1, 460, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig compareConditionalExpressions = { { 7804 /* compareConditionalExpressions */, 2, 461, 2, 463, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7834 /* compareVariableTypeHolders */, 2, 464, 2, 466, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig canAccessProperty = { { 7918 /* canAccessProperty */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canReadProperty = { { 7982 /* canReadProperty */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canWriteProperty = { { 7998 /* canWriteProperty */, 1, 471, 1, 472, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canCallMethod = { { 8068 /* canCallMethod */, 1, 473, 1, 474, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessConstant = { { 8144 /* canAccessConstant */, 1, 475, 1, 476, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessClassMember = { { 8225 /* canAccessClassMember */, 1, 477, 1, 478, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig debug = { { 8246 /* debug */, 0, 479, 0, 479, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterTypeWithMethod = { { 8278 /* filterTypeWithMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getMethodReflection = { { 8343 /* getMethodReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getNakedMethod = { { 8363 /* getNakedMethod */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPropertyReflection = { { 8395 /* getPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8417 /* getInstancePropertyReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8447 /* getStaticPropertyReflection */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantReflection = { { 8505 /* getConstantReflection */, 2, 498, 2, 500, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8540 /* getConstantExplicitTypeFromConfig */, 2, 501, 2, 503, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantTypes = { { 8574 /* getConstantTypes */, 0, 504, 0, 504, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getGlobalConstantType = { { 8591 /* getGlobalConstantType */, 1, 505, 1, 506, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8624 /* createGlobalConstantFetches */, 3, 507, 3, 510, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig getNativeConstantTypes = { { 8652 /* getNativeConstantTypes */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getIterableKeyType = { { 8675 /* getIterableKeyType */, 1, 512, 1, 513, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getIterableValueType = { { 8694 /* getIterableValueType */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPhpVersion = { { 8739 /* getPhpVersion */, 0, 516, 0, 516, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8753 /* getConfiguredPhpVersionRange */, 0, 517, 0, 517, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8782 /* isOverallPhpVersionRange */, 1, 518, 1, 519, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig invokeNodeCallback = { { 8822 /* invokeNodeCallback */, 1, 520, 1, 521, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig emitCollectedData = { { 8860 /* emitCollectedData */, 2, 522, 2, 524, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackValueDependency = { { 8893 /* trackValueDependency */, 2, 525, 2, 527, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackFileDependency = { { 8919 /* trackFileDependency */, 1, 528, 1, 529, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackDirectoryDependency = { { 8961 /* trackDirectoryDependency */, 1, 530, 2, 532, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackClassDependency = { { 8986 /* trackClassDependency */, 1, 533, 1, 534, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::MutatingScope diff --git a/turbo-ext/src/generated/NodeCallbackScope.h b/turbo-ext/src/generated/NodeCallbackScope.h index 5a8723a79d7..e5f5a14e5cc 100644 --- a/turbo-ext/src/generated/NodeCallbackScope.h +++ b/turbo-ext/src/generated/NodeCallbackScope.h @@ -65,12 +65,13 @@ inline constexpr char strings[] = "PHPStan\\Analyser\\Scope\0" /* 390 */ "preprocessScope\0" /* 413 */ "reflection\0" /* 429 */ - "parameter\0" /* 440 */ - "PHPStan\\Reflection\\ParameterReflection\0" /* 450 */ - "rememberTypes\0" /* 489 */ - "pushInFunctionCall\0" /* 503 */ - "popInFunctionCall\0" /* 522 */ - "getParentScope"; /* 540 */ + "PHPStan\\Reflection\\MethodReflection|PHPStan\\Reflection\\FunctionReflection\0" /* 440 */ + "parameter\0" /* 514 */ + "PHPStan\\Reflection\\ParameterReflection\0" /* 524 */ + "rememberTypes\0" /* 563 */ + "pushInFunctionCall\0" /* 577 */ + "popInFunctionCall\0" /* 596 */ + "getParentScope"; /* 614 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 1), /* toNodeCallbackScope return */ reg::packed(56, 0, 62), /* seedWalkScope $scope */ @@ -100,9 +101,9 @@ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 1), /* filterByFalseyValue return */ reg::packed(56, 0, 62), /* preprocessScope $scope */ reg::packed(0, 0, 390), /* preprocessScope return */ - reg::packed(429, 0), /* pushInFunctionCall $reflection */ - reg::packed(440, MAY_BE_NULL, 450), /* pushInFunctionCall $parameter */ - reg::packed(489, MAY_BE_BOOL), /* pushInFunctionCall $rememberTypes */ + reg::packed(429, MAY_BE_NULL, 440), /* pushInFunctionCall $reflection */ + reg::packed(514, MAY_BE_NULL, 524), /* pushInFunctionCall $parameter */ + reg::packed(563, MAY_BE_BOOL), /* pushInFunctionCall $rememberTypes */ reg::packed(0, 0, 1), /* pushInFunctionCall return */ reg::packed(0, 0, 1), /* popInFunctionCall return */ reg::packed(0, MAY_BE_NULL, 62), /* getParentScope return */ @@ -126,9 +127,9 @@ inline constexpr sigtab::Sig getKeepVoidType = { { 334 /* getKeepVoidType */, 1, inline constexpr sigtab::Sig filterByTruthyValue = { { 350 /* filterByTruthyValue */, 1, 22, 1, 23, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig filterByFalseyValue = { { 370 /* filterByFalseyValue */, 1, 24, 1, 25, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig preprocessScope = { { 413 /* preprocessScope */, 1, 26, 1, 27, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig pushInFunctionCall = { { 503 /* pushInFunctionCall */, 3, 28, 3, 31, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig popInFunctionCall = { { 522 /* popInFunctionCall */, 0, 32, 0, 32, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getParentScope = { { 540 /* getParentScope */, 0, 33, 0, 33, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig pushInFunctionCall = { { 577 /* pushInFunctionCall */, 3, 28, 3, 31, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig popInFunctionCall = { { 596 /* popInFunctionCall */, 0, 32, 0, 32, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getParentScope = { { 614 /* getParentScope */, 0, 33, 0, 33, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::NodeCallbackScope diff --git a/turbo-ext/src/generated/ThrowPoint.h b/turbo-ext/src/generated/ThrowPoint.h index 5d7d473333c..5ab3bc9e78e 100644 --- a/turbo-ext/src/generated/ThrowPoint.h +++ b/turbo-ext/src/generated/ThrowPoint.h @@ -51,10 +51,11 @@ inline constexpr char strings[] = "createImplicit\0" /* 165 */ "getScope\0" /* 180 */ "getType\0" /* 189 */ - "getNode\0" /* 197 */ - "isExplicit\0" /* 205 */ - "catchType\0" /* 216 */ - "subtractCatchType"; /* 226 */ + "PhpParser\\Node\\Expr|PhpParser\\Node\\Stmt\0" /* 197 */ + "getNode\0" /* 237 */ + "isExplicit\0" /* 245 */ + "catchType\0" /* 256 */ + "subtractCatchType"; /* 266 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 6), /* __construct $scope */ reg::packed(29, 0, 34), /* __construct $type */ @@ -72,9 +73,10 @@ inline constexpr reg::PackedArg args[] = { reg::packed(116, 0, 117), /* createImplicit return */ reg::packed(116, 0, 6), /* getScope return */ reg::packed(116, 0, 34), /* getType return */ + reg::packed(116, 0, 197), /* getNode return */ reg::packed(116, MAY_BE_BOOL), /* isExplicit return */ reg::packed(116, MAY_BE_BOOL), /* canContainAnyThrowable return */ - reg::packed(216, 0, 34), /* subtractCatchType $catchType */ + reg::packed(256, 0, 34), /* subtractCatchType $catchType */ reg::packed(116, 0, 117), /* subtractCatchType return */ }; using Sig = reg::Sig; @@ -87,10 +89,10 @@ inline constexpr sigtab::Sig createExplicit = { { 145 /* createExplicit */, 4, 5 inline constexpr sigtab::Sig createImplicit = { { 165 /* createImplicit */, 2, 10, 3, 13, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; inline constexpr sigtab::Sig getScope = { { 180 /* getScope */, 0, 14, 0, 14, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getType = { { 189 /* getType */, 0, 15, 0, 15, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getNode = { { 197 /* getNode */, 0, 16, 0, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isExplicit = { { 205 /* isExplicit */, 0, 16, 0, 16, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canContainAnyThrowable = { { 81 /* canContainAnyThrowable */, 0, 17, 0, 17, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig subtractCatchType = { { 226 /* subtractCatchType */, 1, 18, 1, 19, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getNode = { { 237 /* getNode */, 0, 16, 0, 16, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isExplicit = { { 245 /* isExplicit */, 0, 17, 0, 17, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canContainAnyThrowable = { { 81 /* canContainAnyThrowable */, 0, 18, 0, 18, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig subtractCatchType = { { 266 /* subtractCatchType */, 1, 19, 1, 20, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::ThrowPoint diff --git a/turbo-ext/src/generated/TraitUseHandler.h b/turbo-ext/src/generated/TraitUseHandler.h index 019d5242977..8fc29a52136 100644 --- a/turbo-ext/src/generated/TraitUseHandler.h +++ b/turbo-ext/src/generated/TraitUseHandler.h @@ -70,11 +70,12 @@ inline constexpr char strings[] = "node\0" /* 588 */ "classScope\0" /* 593 */ "processTraitUse\0" /* 604 */ - "traitReflection\0" /* 620 */ - "PHPStan\\Reflection\\ClassReflection\0" /* 636 */ - "adaptations\0" /* 671 */ - "dependencies\0" /* 683 */ - "processNodesForTraitUse"; /* 696 */ + "PhpParser\\Node\0" /* 620 */ + "traitReflection\0" /* 635 */ + "PHPStan\\Reflection\\ClassReflection\0" /* 651 */ + "adaptations\0" /* 686 */ + "dependencies\0" /* 698 */ + "processNodesForTraitUse"; /* 711 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 19), /* __construct $reflectionProvider */ reg::packed(57, 0, 68), /* __construct $fileHelper */ @@ -100,13 +101,13 @@ inline constexpr reg::PackedArg args[] = { reg::packed(403, MAY_BE_CALLABLE), /* processTraitUse $nodeCallback */ reg::packed(254, MAY_BE_NULL, 540), /* processTraitUse return */ reg::packed(264, 0, 282), /* processNodesForTraitUse $nodeScopeResolver */ - reg::packed(588, 0), /* processNodesForTraitUse $node */ - reg::packed(620, 0, 636), /* processNodesForTraitUse $traitReflection */ + reg::packed(588, MAY_BE_NULL | MAY_BE_BOOL | MAY_BE_LONG | MAY_BE_DOUBLE | MAY_BE_STRING | MAY_BE_ARRAY, 620), /* processNodesForTraitUse $node */ + reg::packed(635, 0, 651), /* processNodesForTraitUse $traitReflection */ reg::packed(317, 0, 323), /* processNodesForTraitUse $scope */ reg::packed(354, 0, 362), /* processNodesForTraitUse $storage */ - reg::packed(671, MAY_BE_ARRAY), /* processNodesForTraitUse $adaptations */ + reg::packed(686, MAY_BE_ARRAY), /* processNodesForTraitUse $adaptations */ reg::packed(403, MAY_BE_CALLABLE), /* processNodesForTraitUse $nodeCallback */ - reg::packed(683, MAY_BE_ARRAY, reg::NoString, true, false), /* processNodesForTraitUse $dependencies */ + reg::packed(698, MAY_BE_ARRAY, reg::NoString, true, false), /* processNodesForTraitUse $dependencies */ reg::packed(254, MAY_BE_VOID), /* processNodesForTraitUse return */ }; using Sig = reg::Sig; @@ -119,7 +120,7 @@ inline constexpr sigtab::Sig supports = { { 255 /* supports */, 1, 5, 1, 6, ZEND inline constexpr sigtab::Sig processStmt = { { 499 /* processStmt */, 6, 7, 6, 13, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig getDependencies = { { 572 /* getDependencies */, 2, 14, 2, 16, ZEND_ACC_PRIVATE } }; inline constexpr sigtab::Sig processTraitUse = { { 604 /* processTraitUse */, 5, 17, 5, 22, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig processNodesForTraitUse = { { 696 /* processNodesForTraitUse */, 8, 23, 8, 31, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processNodesForTraitUse = { { 711 /* processNodesForTraitUse */, 8, 23, 8, 31, ZEND_ACC_PRIVATE } }; } // namespace sig } // namespace ptdecl::TraitUseHandler diff --git a/turbo-ext/src/generated/UnresolvedTemplateArgumentType.h b/turbo-ext/src/generated/UnresolvedTemplateArgumentType.h index f0bd703bc06..7f29d8d1d68 100644 --- a/turbo-ext/src/generated/UnresolvedTemplateArgumentType.h +++ b/turbo-ext/src/generated/UnresolvedTemplateArgumentType.h @@ -92,168 +92,169 @@ inline constexpr char strings[] = "toPhpDocNode\0" /* 837 */ "position\0" /* 850 */ "PHPStan\\Type\\NativeTypePosition\0" /* 859 */ - "toNativePhpTypeNode\0" /* 891 */ - "getReferencedClasses\0" /* 911 */ - "getObjectClassNames\0" /* 932 */ - "getObjectClassReflections\0" /* 952 */ - "getClassStringType\0" /* 978 */ - "getClassStringObjectType\0" /* 997 */ - "getObjectTypeOrClassStringObjectType\0" /* 1022 */ - "isObject\0" /* 1059 */ - "isEnum\0" /* 1068 */ - "getArrays\0" /* 1075 */ - "getConstantArrays\0" /* 1085 */ - "getConstantStrings\0" /* 1103 */ - "canAccessProperties\0" /* 1122 */ - "propertyName\0" /* 1142 */ - "hasProperty\0" /* 1155 */ - "scope\0" /* 1167 */ - "PHPStan\\Reflection\\ClassMemberAccessAnswerer\0" /* 1173 */ - "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 1218 */ - "getProperty\0" /* 1264 */ - "PHPStan\\Reflection\\Type\\UnresolvedPropertyPrototypeReflection\0" /* 1276 */ - "getUnresolvedPropertyPrototype\0" /* 1338 */ - "hasInstanceProperty\0" /* 1369 */ - "getInstanceProperty\0" /* 1389 */ - "getUnresolvedInstancePropertyPrototype\0" /* 1409 */ - "hasStaticProperty\0" /* 1448 */ - "getStaticProperty\0" /* 1466 */ - "getUnresolvedStaticPropertyPrototype\0" /* 1484 */ - "canCallMethods\0" /* 1521 */ - "methodName\0" /* 1536 */ - "hasMethod\0" /* 1547 */ - "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 1557 */ - "getMethod\0" /* 1601 */ - "PHPStan\\Reflection\\Type\\UnresolvedMethodPrototypeReflection\0" /* 1611 */ - "getUnresolvedMethodPrototype\0" /* 1671 */ - "canAccessConstants\0" /* 1700 */ - "constantName\0" /* 1719 */ - "hasConstant\0" /* 1732 */ - "PHPStan\\Reflection\\ClassConstantReflection\0" /* 1744 */ - "getConstant\0" /* 1787 */ - "isIterable\0" /* 1799 */ - "isIterableAtLeastOnce\0" /* 1810 */ - "getArraySize\0" /* 1832 */ - "getIterableKeyType\0" /* 1845 */ - "getFirstIterableKeyType\0" /* 1864 */ - "getLastIterableKeyType\0" /* 1888 */ - "getIterableValueType\0" /* 1911 */ - "getFirstIterableValueType\0" /* 1932 */ - "getLastIterableValueType\0" /* 1958 */ - "isArray\0" /* 1983 */ - "isConstantArray\0" /* 1991 */ - "isOversizedArray\0" /* 2007 */ - "isList\0" /* 2024 */ - "isOffsetAccessible\0" /* 2031 */ - "isOffsetAccessLegal\0" /* 2050 */ - "offsetType\0" /* 2070 */ - "hasOffsetValueType\0" /* 2081 */ - "getOffsetValueType\0" /* 2100 */ - "valueType\0" /* 2119 */ - "unionValues\0" /* 2129 */ - "true\0" /* 2141 */ - "setOffsetValueType\0" /* 2146 */ - "setExistingOffsetValueType\0" /* 2165 */ - "unsetOffset\0" /* 2192 */ - "filterValueType\0" /* 2204 */ - "strict\0" /* 2220 */ - "getKeysArrayFiltered\0" /* 2227 */ - "getKeysArray\0" /* 2248 */ - "getValuesArray\0" /* 2261 */ - "lengthType\0" /* 2276 */ - "preserveKeys\0" /* 2287 */ - "chunkArray\0" /* 2300 */ - "fillKeysArray\0" /* 2311 */ - "flipArray\0" /* 2325 */ - "otherArraysType\0" /* 2335 */ - "intersectKeyArray\0" /* 2351 */ - "popArray\0" /* 2369 */ - "reverseArray\0" /* 2378 */ - "needleType\0" /* 2391 */ - "null\0" /* 2402 */ - "searchArray\0" /* 2407 */ - "shiftArray\0" /* 2419 */ - "shuffleArray\0" /* 2430 */ - "sliceArray\0" /* 2443 */ - "replacementType\0" /* 2454 */ - "spliceArray\0" /* 2470 */ - "sizeType\0" /* 2482 */ - "truncateListToSize\0" /* 2491 */ - "makeListMaybe\0" /* 2510 */ - "mapValueType\0" /* 2524 */ - "mapKeyType\0" /* 2537 */ - "makeAllArrayKeysOptional\0" /* 2548 */ - "case\0" /* 2573 */ - "changeKeyCaseArray\0" /* 2578 */ - "filterArrayRemovingFalsey\0" /* 2597 */ - "getEnumCases\0" /* 2623 */ - "PHPStan\\Type\\Enum\\EnumCaseObjectType\0" /* 2636 */ - "getEnumCaseObject\0" /* 2673 */ - "getFiniteTypes\0" /* 2691 */ - "exponent\0" /* 2706 */ - "arithmeticPower\0" /* 2715 */ - "isCallable\0" /* 2731 */ - "getCallableParametersAcceptors\0" /* 2742 */ - "isCloneable\0" /* 2773 */ - "PHPStan\\Type\\BooleanType\0" /* 2785 */ - "toBoolean\0" /* 2810 */ - "toNumber\0" /* 2820 */ - "PHPStan\\Type\\ValueSet\0" /* 2829 */ - "toValueSet\0" /* 2851 */ - "toBitwiseNotType\0" /* 2862 */ - "toGetClassResultType\0" /* 2879 */ - "reflectionProvider\0" /* 2900 */ - "PHPStan\\Reflection\\ReflectionProvider\0" /* 2919 */ - "toClassConstantType\0" /* 2957 */ - "PHPStan\\Type\\ClassNameToObjectTypeResult\0" /* 2977 */ - "toObjectTypeForInstanceofCheck\0" /* 3018 */ - "objectOrClassType\0" /* 3049 */ - "allowString\0" /* 3067 */ - "allowSameClass\0" /* 3079 */ - "toObjectTypeForIsACheck\0" /* 3094 */ - "toInteger\0" /* 3118 */ - "toFloat\0" /* 3128 */ - "toString\0" /* 3136 */ - "toArray\0" /* 3145 */ - "toArrayKey\0" /* 3153 */ - "isSmallerThan\0" /* 3164 */ - "isSmallerThanOrEqual\0" /* 3178 */ - "isConstantValue\0" /* 3199 */ - "isConstantScalarValue\0" /* 3215 */ - "getConstantScalarTypes\0" /* 3237 */ - "getConstantScalarValues\0" /* 3260 */ - "isNull\0" /* 3284 */ - "isTrue\0" /* 3291 */ - "isFalse\0" /* 3298 */ - "isBoolean\0" /* 3306 */ - "isFloat\0" /* 3316 */ - "isInteger\0" /* 3324 */ - "isString\0" /* 3334 */ - "isNumericString\0" /* 3343 */ - "isDecimalIntegerString\0" /* 3359 */ - "isNonEmptyString\0" /* 3382 */ - "isNonFalsyString\0" /* 3399 */ - "isLiteralString\0" /* 3416 */ - "isLowercaseString\0" /* 3432 */ - "isUppercaseString\0" /* 3450 */ - "isClassString\0" /* 3468 */ - "isVoid\0" /* 3482 */ - "isScalar\0" /* 3489 */ - "looseCompare\0" /* 3498 */ - "getSmallerType\0" /* 3511 */ - "getSmallerOrEqualType\0" /* 3526 */ - "getGreaterType\0" /* 3548 */ - "getGreaterOrEqualType\0" /* 3563 */ - "ancestorClassName\0" /* 3585 */ - "templateTypeName\0" /* 3603 */ - "getTemplateType\0" /* 3620 */ - "receivedType\0" /* 3636 */ - "PHPStan\\Type\\Generic\\TemplateTypeMap\0" /* 3649 */ - "inferTemplateTypes\0" /* 3686 */ - "positionVariance\0" /* 3705 */ - "PHPStan\\Type\\Generic\\TemplateTypeVariance\0" /* 3722 */ - "getReferencedTemplateTypes\0" /* 3764 */ - "toAbsoluteNumber"; /* 3791 */ + "PhpParser\\Node\\Identifier|PhpParser\\Node\\Name|PhpParser\\Node\\ComplexType\0" /* 891 */ + "toNativePhpTypeNode\0" /* 964 */ + "getReferencedClasses\0" /* 984 */ + "getObjectClassNames\0" /* 1005 */ + "getObjectClassReflections\0" /* 1025 */ + "getClassStringType\0" /* 1051 */ + "getClassStringObjectType\0" /* 1070 */ + "getObjectTypeOrClassStringObjectType\0" /* 1095 */ + "isObject\0" /* 1132 */ + "isEnum\0" /* 1141 */ + "getArrays\0" /* 1148 */ + "getConstantArrays\0" /* 1158 */ + "getConstantStrings\0" /* 1176 */ + "canAccessProperties\0" /* 1195 */ + "propertyName\0" /* 1215 */ + "hasProperty\0" /* 1228 */ + "scope\0" /* 1240 */ + "PHPStan\\Reflection\\ClassMemberAccessAnswerer\0" /* 1246 */ + "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 1291 */ + "getProperty\0" /* 1337 */ + "PHPStan\\Reflection\\Type\\UnresolvedPropertyPrototypeReflection\0" /* 1349 */ + "getUnresolvedPropertyPrototype\0" /* 1411 */ + "hasInstanceProperty\0" /* 1442 */ + "getInstanceProperty\0" /* 1462 */ + "getUnresolvedInstancePropertyPrototype\0" /* 1482 */ + "hasStaticProperty\0" /* 1521 */ + "getStaticProperty\0" /* 1539 */ + "getUnresolvedStaticPropertyPrototype\0" /* 1557 */ + "canCallMethods\0" /* 1594 */ + "methodName\0" /* 1609 */ + "hasMethod\0" /* 1620 */ + "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 1630 */ + "getMethod\0" /* 1674 */ + "PHPStan\\Reflection\\Type\\UnresolvedMethodPrototypeReflection\0" /* 1684 */ + "getUnresolvedMethodPrototype\0" /* 1744 */ + "canAccessConstants\0" /* 1773 */ + "constantName\0" /* 1792 */ + "hasConstant\0" /* 1805 */ + "PHPStan\\Reflection\\ClassConstantReflection\0" /* 1817 */ + "getConstant\0" /* 1860 */ + "isIterable\0" /* 1872 */ + "isIterableAtLeastOnce\0" /* 1883 */ + "getArraySize\0" /* 1905 */ + "getIterableKeyType\0" /* 1918 */ + "getFirstIterableKeyType\0" /* 1937 */ + "getLastIterableKeyType\0" /* 1961 */ + "getIterableValueType\0" /* 1984 */ + "getFirstIterableValueType\0" /* 2005 */ + "getLastIterableValueType\0" /* 2031 */ + "isArray\0" /* 2056 */ + "isConstantArray\0" /* 2064 */ + "isOversizedArray\0" /* 2080 */ + "isList\0" /* 2097 */ + "isOffsetAccessible\0" /* 2104 */ + "isOffsetAccessLegal\0" /* 2123 */ + "offsetType\0" /* 2143 */ + "hasOffsetValueType\0" /* 2154 */ + "getOffsetValueType\0" /* 2173 */ + "valueType\0" /* 2192 */ + "unionValues\0" /* 2202 */ + "true\0" /* 2214 */ + "setOffsetValueType\0" /* 2219 */ + "setExistingOffsetValueType\0" /* 2238 */ + "unsetOffset\0" /* 2265 */ + "filterValueType\0" /* 2277 */ + "strict\0" /* 2293 */ + "getKeysArrayFiltered\0" /* 2300 */ + "getKeysArray\0" /* 2321 */ + "getValuesArray\0" /* 2334 */ + "lengthType\0" /* 2349 */ + "preserveKeys\0" /* 2360 */ + "chunkArray\0" /* 2373 */ + "fillKeysArray\0" /* 2384 */ + "flipArray\0" /* 2398 */ + "otherArraysType\0" /* 2408 */ + "intersectKeyArray\0" /* 2424 */ + "popArray\0" /* 2442 */ + "reverseArray\0" /* 2451 */ + "needleType\0" /* 2464 */ + "null\0" /* 2475 */ + "searchArray\0" /* 2480 */ + "shiftArray\0" /* 2492 */ + "shuffleArray\0" /* 2503 */ + "sliceArray\0" /* 2516 */ + "replacementType\0" /* 2527 */ + "spliceArray\0" /* 2543 */ + "sizeType\0" /* 2555 */ + "truncateListToSize\0" /* 2564 */ + "makeListMaybe\0" /* 2583 */ + "mapValueType\0" /* 2597 */ + "mapKeyType\0" /* 2610 */ + "makeAllArrayKeysOptional\0" /* 2621 */ + "case\0" /* 2646 */ + "changeKeyCaseArray\0" /* 2651 */ + "filterArrayRemovingFalsey\0" /* 2670 */ + "getEnumCases\0" /* 2696 */ + "PHPStan\\Type\\Enum\\EnumCaseObjectType\0" /* 2709 */ + "getEnumCaseObject\0" /* 2746 */ + "getFiniteTypes\0" /* 2764 */ + "exponent\0" /* 2779 */ + "arithmeticPower\0" /* 2788 */ + "isCallable\0" /* 2804 */ + "getCallableParametersAcceptors\0" /* 2815 */ + "isCloneable\0" /* 2846 */ + "PHPStan\\Type\\BooleanType\0" /* 2858 */ + "toBoolean\0" /* 2883 */ + "toNumber\0" /* 2893 */ + "PHPStan\\Type\\ValueSet\0" /* 2902 */ + "toValueSet\0" /* 2924 */ + "toBitwiseNotType\0" /* 2935 */ + "toGetClassResultType\0" /* 2952 */ + "reflectionProvider\0" /* 2973 */ + "PHPStan\\Reflection\\ReflectionProvider\0" /* 2992 */ + "toClassConstantType\0" /* 3030 */ + "PHPStan\\Type\\ClassNameToObjectTypeResult\0" /* 3050 */ + "toObjectTypeForInstanceofCheck\0" /* 3091 */ + "objectOrClassType\0" /* 3122 */ + "allowString\0" /* 3140 */ + "allowSameClass\0" /* 3152 */ + "toObjectTypeForIsACheck\0" /* 3167 */ + "toInteger\0" /* 3191 */ + "toFloat\0" /* 3201 */ + "toString\0" /* 3209 */ + "toArray\0" /* 3218 */ + "toArrayKey\0" /* 3226 */ + "isSmallerThan\0" /* 3237 */ + "isSmallerThanOrEqual\0" /* 3251 */ + "isConstantValue\0" /* 3272 */ + "isConstantScalarValue\0" /* 3288 */ + "getConstantScalarTypes\0" /* 3310 */ + "getConstantScalarValues\0" /* 3333 */ + "isNull\0" /* 3357 */ + "isTrue\0" /* 3364 */ + "isFalse\0" /* 3371 */ + "isBoolean\0" /* 3379 */ + "isFloat\0" /* 3389 */ + "isInteger\0" /* 3397 */ + "isString\0" /* 3407 */ + "isNumericString\0" /* 3416 */ + "isDecimalIntegerString\0" /* 3432 */ + "isNonEmptyString\0" /* 3455 */ + "isNonFalsyString\0" /* 3472 */ + "isLiteralString\0" /* 3489 */ + "isLowercaseString\0" /* 3505 */ + "isUppercaseString\0" /* 3523 */ + "isClassString\0" /* 3541 */ + "isVoid\0" /* 3555 */ + "isScalar\0" /* 3562 */ + "looseCompare\0" /* 3571 */ + "getSmallerType\0" /* 3584 */ + "getSmallerOrEqualType\0" /* 3599 */ + "getGreaterType\0" /* 3621 */ + "getGreaterOrEqualType\0" /* 3636 */ + "ancestorClassName\0" /* 3658 */ + "templateTypeName\0" /* 3676 */ + "getTemplateType\0" /* 3693 */ + "receivedType\0" /* 3709 */ + "PHPStan\\Type\\Generic\\TemplateTypeMap\0" /* 3722 */ + "inferTemplateTypes\0" /* 3759 */ + "positionVariance\0" /* 3778 */ + "PHPStan\\Type\\Generic\\TemplateTypeVariance\0" /* 3795 */ + "getReferencedTemplateTypes\0" /* 3837 */ + "toAbsoluteNumber"; /* 3864 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 5), /* __construct $site */ reg::packed(25, 0, 38), /* __construct $templateType */ @@ -309,6 +310,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(114, MAY_BE_BOOL), /* hasTemplateOrLateResolvableType return */ reg::packed(114, 0, 798), /* toPhpDocNode return */ reg::packed(850, 0, 859), /* toNativePhpTypeNode $position */ + reg::packed(114, MAY_BE_NULL, 891), /* toNativePhpTypeNode return */ reg::packed(114, MAY_BE_ARRAY), /* getReferencedClasses return */ reg::packed(114, MAY_BE_ARRAY), /* getObjectClassNames return */ reg::packed(114, MAY_BE_ARRAY), /* getObjectClassReflections return */ @@ -321,44 +323,44 @@ inline constexpr reg::PackedArg args[] = { reg::packed(114, MAY_BE_ARRAY), /* getConstantArrays return */ reg::packed(114, MAY_BE_ARRAY), /* getConstantStrings return */ reg::packed(114, 0, 570), /* canAccessProperties return */ - reg::packed(1142, MAY_BE_STRING), /* hasProperty $propertyName */ + reg::packed(1215, MAY_BE_STRING), /* hasProperty $propertyName */ reg::packed(114, 0, 570), /* hasProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getProperty $propertyName */ - reg::packed(1167, 0, 1173), /* getProperty $scope */ - reg::packed(114, 0, 1218), /* getProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getUnresolvedPropertyPrototype $propertyName */ - reg::packed(1167, 0, 1173), /* getUnresolvedPropertyPrototype $scope */ - reg::packed(114, 0, 1276), /* getUnresolvedPropertyPrototype return */ - reg::packed(1142, MAY_BE_STRING), /* hasInstanceProperty $propertyName */ + reg::packed(1215, MAY_BE_STRING), /* getProperty $propertyName */ + reg::packed(1240, 0, 1246), /* getProperty $scope */ + reg::packed(114, 0, 1291), /* getProperty return */ + reg::packed(1215, MAY_BE_STRING), /* getUnresolvedPropertyPrototype $propertyName */ + reg::packed(1240, 0, 1246), /* getUnresolvedPropertyPrototype $scope */ + reg::packed(114, 0, 1349), /* getUnresolvedPropertyPrototype return */ + reg::packed(1215, MAY_BE_STRING), /* hasInstanceProperty $propertyName */ reg::packed(114, 0, 570), /* hasInstanceProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getInstanceProperty $propertyName */ - reg::packed(1167, 0, 1173), /* getInstanceProperty $scope */ - reg::packed(114, 0, 1218), /* getInstanceProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getUnresolvedInstancePropertyPrototype $propertyName */ - reg::packed(1167, 0, 1173), /* getUnresolvedInstancePropertyPrototype $scope */ - reg::packed(114, 0, 1276), /* getUnresolvedInstancePropertyPrototype return */ - reg::packed(1142, MAY_BE_STRING), /* hasStaticProperty $propertyName */ + reg::packed(1215, MAY_BE_STRING), /* getInstanceProperty $propertyName */ + reg::packed(1240, 0, 1246), /* getInstanceProperty $scope */ + reg::packed(114, 0, 1291), /* getInstanceProperty return */ + reg::packed(1215, MAY_BE_STRING), /* getUnresolvedInstancePropertyPrototype $propertyName */ + reg::packed(1240, 0, 1246), /* getUnresolvedInstancePropertyPrototype $scope */ + reg::packed(114, 0, 1349), /* getUnresolvedInstancePropertyPrototype return */ + reg::packed(1215, MAY_BE_STRING), /* hasStaticProperty $propertyName */ reg::packed(114, 0, 570), /* hasStaticProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getStaticProperty $propertyName */ - reg::packed(1167, 0, 1173), /* getStaticProperty $scope */ - reg::packed(114, 0, 1218), /* getStaticProperty return */ - reg::packed(1142, MAY_BE_STRING), /* getUnresolvedStaticPropertyPrototype $propertyName */ - reg::packed(1167, 0, 1173), /* getUnresolvedStaticPropertyPrototype $scope */ - reg::packed(114, 0, 1276), /* getUnresolvedStaticPropertyPrototype return */ + reg::packed(1215, MAY_BE_STRING), /* getStaticProperty $propertyName */ + reg::packed(1240, 0, 1246), /* getStaticProperty $scope */ + reg::packed(114, 0, 1291), /* getStaticProperty return */ + reg::packed(1215, MAY_BE_STRING), /* getUnresolvedStaticPropertyPrototype $propertyName */ + reg::packed(1240, 0, 1246), /* getUnresolvedStaticPropertyPrototype $scope */ + reg::packed(114, 0, 1349), /* getUnresolvedStaticPropertyPrototype return */ reg::packed(114, 0, 570), /* canCallMethods return */ - reg::packed(1536, MAY_BE_STRING), /* hasMethod $methodName */ + reg::packed(1609, MAY_BE_STRING), /* hasMethod $methodName */ reg::packed(114, 0, 570), /* hasMethod return */ - reg::packed(1536, MAY_BE_STRING), /* getMethod $methodName */ - reg::packed(1167, 0, 1173), /* getMethod $scope */ - reg::packed(114, 0, 1557), /* getMethod return */ - reg::packed(1536, MAY_BE_STRING), /* getUnresolvedMethodPrototype $methodName */ - reg::packed(1167, 0, 1173), /* getUnresolvedMethodPrototype $scope */ - reg::packed(114, 0, 1611), /* getUnresolvedMethodPrototype return */ + reg::packed(1609, MAY_BE_STRING), /* getMethod $methodName */ + reg::packed(1240, 0, 1246), /* getMethod $scope */ + reg::packed(114, 0, 1630), /* getMethod return */ + reg::packed(1609, MAY_BE_STRING), /* getUnresolvedMethodPrototype $methodName */ + reg::packed(1240, 0, 1246), /* getUnresolvedMethodPrototype $scope */ + reg::packed(114, 0, 1684), /* getUnresolvedMethodPrototype return */ reg::packed(114, 0, 570), /* canAccessConstants return */ - reg::packed(1719, MAY_BE_STRING), /* hasConstant $constantName */ + reg::packed(1792, MAY_BE_STRING), /* hasConstant $constantName */ reg::packed(114, 0, 570), /* hasConstant return */ - reg::packed(1719, MAY_BE_STRING), /* getConstant $constantName */ - reg::packed(114, 0, 1744), /* getConstant return */ + reg::packed(1792, MAY_BE_STRING), /* getConstant $constantName */ + reg::packed(114, 0, 1817), /* getConstant return */ reg::packed(114, 0, 570), /* isIterable return */ reg::packed(114, 0, 570), /* isIterableAtLeastOnce return */ reg::packed(114, 0, 84), /* getArraySize return */ @@ -374,49 +376,49 @@ inline constexpr reg::PackedArg args[] = { reg::packed(114, 0, 570), /* isList return */ reg::packed(114, 0, 570), /* isOffsetAccessible return */ reg::packed(114, 0, 570), /* isOffsetAccessLegal return */ - reg::packed(2070, 0, 84), /* hasOffsetValueType $offsetType */ + reg::packed(2143, 0, 84), /* hasOffsetValueType $offsetType */ reg::packed(114, 0, 570), /* hasOffsetValueType return */ - reg::packed(2070, 0, 84), /* getOffsetValueType $offsetType */ + reg::packed(2143, 0, 84), /* getOffsetValueType $offsetType */ reg::packed(114, 0, 84), /* getOffsetValueType return */ - reg::packed(2070, MAY_BE_NULL, 84), /* setOffsetValueType $offsetType */ - reg::packed(2119, 0, 84), /* setOffsetValueType $valueType */ - reg::packed(2129, MAY_BE_BOOL, reg::NoString, false, false, 2141), /* setOffsetValueType $unionValues */ + reg::packed(2143, MAY_BE_NULL, 84), /* setOffsetValueType $offsetType */ + reg::packed(2192, 0, 84), /* setOffsetValueType $valueType */ + reg::packed(2202, MAY_BE_BOOL, reg::NoString, false, false, 2214), /* setOffsetValueType $unionValues */ reg::packed(114, 0, 84), /* setOffsetValueType return */ - reg::packed(2070, 0, 84), /* setExistingOffsetValueType $offsetType */ - reg::packed(2119, 0, 84), /* setExistingOffsetValueType $valueType */ + reg::packed(2143, 0, 84), /* setExistingOffsetValueType $offsetType */ + reg::packed(2192, 0, 84), /* setExistingOffsetValueType $valueType */ reg::packed(114, 0, 84), /* setExistingOffsetValueType return */ - reg::packed(2070, 0, 84), /* unsetOffset $offsetType */ + reg::packed(2143, 0, 84), /* unsetOffset $offsetType */ reg::packed(114, 0, 84), /* unsetOffset return */ - reg::packed(2204, 0, 84), /* getKeysArrayFiltered $filterValueType */ - reg::packed(2220, 0, 570), /* getKeysArrayFiltered $strict */ + reg::packed(2277, 0, 84), /* getKeysArrayFiltered $filterValueType */ + reg::packed(2293, 0, 570), /* getKeysArrayFiltered $strict */ reg::packed(114, 0, 84), /* getKeysArrayFiltered return */ reg::packed(114, 0, 84), /* getKeysArray return */ reg::packed(114, 0, 84), /* getValuesArray return */ - reg::packed(2276, 0, 84), /* chunkArray $lengthType */ - reg::packed(2287, 0, 570), /* chunkArray $preserveKeys */ + reg::packed(2349, 0, 84), /* chunkArray $lengthType */ + reg::packed(2360, 0, 570), /* chunkArray $preserveKeys */ reg::packed(114, 0, 84), /* chunkArray return */ - reg::packed(2119, 0, 84), /* fillKeysArray $valueType */ + reg::packed(2192, 0, 84), /* fillKeysArray $valueType */ reg::packed(114, 0, 84), /* fillKeysArray return */ reg::packed(114, 0, 84), /* flipArray return */ - reg::packed(2335, 0, 84), /* intersectKeyArray $otherArraysType */ + reg::packed(2408, 0, 84), /* intersectKeyArray $otherArraysType */ reg::packed(114, 0, 84), /* intersectKeyArray return */ reg::packed(114, 0, 84), /* popArray return */ - reg::packed(2287, 0, 570), /* reverseArray $preserveKeys */ + reg::packed(2360, 0, 570), /* reverseArray $preserveKeys */ reg::packed(114, 0, 84), /* reverseArray return */ - reg::packed(2391, 0, 84), /* searchArray $needleType */ - reg::packed(2220, MAY_BE_NULL, 570, false, false, 2402), /* searchArray $strict */ + reg::packed(2464, 0, 84), /* searchArray $needleType */ + reg::packed(2293, MAY_BE_NULL, 570, false, false, 2475), /* searchArray $strict */ reg::packed(114, 0, 84), /* searchArray return */ reg::packed(114, 0, 84), /* shiftArray return */ reg::packed(114, 0, 84), /* shuffleArray return */ - reg::packed(2070, 0, 84), /* sliceArray $offsetType */ - reg::packed(2276, 0, 84), /* sliceArray $lengthType */ - reg::packed(2287, 0, 570), /* sliceArray $preserveKeys */ + reg::packed(2143, 0, 84), /* sliceArray $offsetType */ + reg::packed(2349, 0, 84), /* sliceArray $lengthType */ + reg::packed(2360, 0, 570), /* sliceArray $preserveKeys */ reg::packed(114, 0, 84), /* sliceArray return */ - reg::packed(2070, 0, 84), /* spliceArray $offsetType */ - reg::packed(2276, 0, 84), /* spliceArray $lengthType */ - reg::packed(2454, 0, 84), /* spliceArray $replacementType */ + reg::packed(2143, 0, 84), /* spliceArray $offsetType */ + reg::packed(2349, 0, 84), /* spliceArray $lengthType */ + reg::packed(2527, 0, 84), /* spliceArray $replacementType */ reg::packed(114, 0, 84), /* spliceArray return */ - reg::packed(2482, 0, 84), /* truncateListToSize $sizeType */ + reg::packed(2555, 0, 84), /* truncateListToSize $sizeType */ reg::packed(114, 0, 84), /* truncateListToSize return */ reg::packed(114, 0, 84), /* makeListMaybe return */ reg::packed(626, MAY_BE_CALLABLE), /* mapValueType $cb */ @@ -424,31 +426,31 @@ inline constexpr reg::PackedArg args[] = { reg::packed(626, MAY_BE_CALLABLE), /* mapKeyType $cb */ reg::packed(114, 0, 84), /* mapKeyType return */ reg::packed(114, 0, 84), /* makeAllArrayKeysOptional return */ - reg::packed(2573, MAY_BE_NULL | MAY_BE_LONG), /* changeKeyCaseArray $case */ + reg::packed(2646, MAY_BE_NULL | MAY_BE_LONG), /* changeKeyCaseArray $case */ reg::packed(114, 0, 84), /* changeKeyCaseArray return */ reg::packed(114, 0, 84), /* filterArrayRemovingFalsey return */ reg::packed(114, MAY_BE_ARRAY), /* getEnumCases return */ - reg::packed(114, MAY_BE_NULL, 2636), /* getEnumCaseObject return */ + reg::packed(114, MAY_BE_NULL, 2709), /* getEnumCaseObject return */ reg::packed(114, MAY_BE_ARRAY), /* getFiniteTypes return */ - reg::packed(2706, 0, 84), /* arithmeticPower $exponent */ + reg::packed(2779, 0, 84), /* arithmeticPower $exponent */ reg::packed(536, 0, 547), /* arithmeticPower $phpVersion */ reg::packed(114, 0, 84), /* arithmeticPower return */ reg::packed(114, 0, 570), /* isCallable return */ - reg::packed(1167, 0, 1173), /* getCallableParametersAcceptors $scope */ + reg::packed(1240, 0, 1246), /* getCallableParametersAcceptors $scope */ reg::packed(114, MAY_BE_ARRAY), /* getCallableParametersAcceptors return */ reg::packed(114, 0, 570), /* isCloneable return */ - reg::packed(114, 0, 2785), /* toBoolean return */ + reg::packed(114, 0, 2858), /* toBoolean return */ reg::packed(114, 0, 84), /* toNumber return */ - reg::packed(114, 0, 2829), /* toValueSet return */ + reg::packed(114, 0, 2902), /* toValueSet return */ reg::packed(114, 0, 84), /* toBitwiseNotType return */ reg::packed(114, 0, 84), /* toGetClassResultType return */ - reg::packed(2900, 0, 2919), /* toClassConstantType $reflectionProvider */ + reg::packed(2973, 0, 2992), /* toClassConstantType $reflectionProvider */ reg::packed(114, 0, 84), /* toClassConstantType return */ - reg::packed(114, 0, 2977), /* toObjectTypeForInstanceofCheck return */ - reg::packed(3049, 0, 84), /* toObjectTypeForIsACheck $objectOrClassType */ - reg::packed(3067, MAY_BE_BOOL), /* toObjectTypeForIsACheck $allowString */ - reg::packed(3079, MAY_BE_BOOL), /* toObjectTypeForIsACheck $allowSameClass */ - reg::packed(114, 0, 2977), /* toObjectTypeForIsACheck return */ + reg::packed(114, 0, 3050), /* toObjectTypeForInstanceofCheck return */ + reg::packed(3122, 0, 84), /* toObjectTypeForIsACheck $objectOrClassType */ + reg::packed(3140, MAY_BE_BOOL), /* toObjectTypeForIsACheck $allowString */ + reg::packed(3152, MAY_BE_BOOL), /* toObjectTypeForIsACheck $allowSameClass */ + reg::packed(114, 0, 3050), /* toObjectTypeForIsACheck return */ reg::packed(114, 0, 84), /* toInteger return */ reg::packed(114, 0, 84), /* toFloat return */ reg::packed(114, 0, 84), /* toString return */ @@ -483,7 +485,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(114, 0, 570), /* isScalar return */ reg::packed(274, 0, 84), /* looseCompare $type */ reg::packed(536, 0, 547), /* looseCompare $phpVersion */ - reg::packed(114, 0, 2785), /* looseCompare return */ + reg::packed(114, 0, 2858), /* looseCompare return */ reg::packed(536, 0, 547), /* getSmallerType $phpVersion */ reg::packed(114, 0, 84), /* getSmallerType return */ reg::packed(536, 0, 547), /* getSmallerOrEqualType $phpVersion */ @@ -492,12 +494,12 @@ inline constexpr reg::PackedArg args[] = { reg::packed(114, 0, 84), /* getGreaterType return */ reg::packed(536, 0, 547), /* getGreaterOrEqualType $phpVersion */ reg::packed(114, 0, 84), /* getGreaterOrEqualType return */ - reg::packed(3585, MAY_BE_STRING), /* getTemplateType $ancestorClassName */ - reg::packed(3603, MAY_BE_STRING), /* getTemplateType $templateTypeName */ + reg::packed(3658, MAY_BE_STRING), /* getTemplateType $ancestorClassName */ + reg::packed(3676, MAY_BE_STRING), /* getTemplateType $templateTypeName */ reg::packed(114, 0, 84), /* getTemplateType return */ - reg::packed(3636, 0, 84), /* inferTemplateTypes $receivedType */ - reg::packed(114, 0, 3649), /* inferTemplateTypes return */ - reg::packed(3705, 0, 3722), /* getReferencedTemplateTypes $positionVariance */ + reg::packed(3709, 0, 84), /* inferTemplateTypes $receivedType */ + reg::packed(114, 0, 3722), /* inferTemplateTypes return */ + reg::packed(3778, 0, 3795), /* getReferencedTemplateTypes $positionVariance */ reg::packed(114, MAY_BE_ARRAY), /* getReferencedTemplateTypes return */ reg::packed(114, 0, 84), /* toAbsoluteNumber return */ }; @@ -533,128 +535,128 @@ inline constexpr sigtab::Sig tryRemove = { { 734 /* tryRemove */, 1, 47, 1, 48, inline constexpr sigtab::Sig toCoercedArgumentType = { { 744 /* toCoercedArgumentType */, 1, 49, 1, 50, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig hasTemplateOrLateResolvableType = { { 766 /* hasTemplateOrLateResolvableType */, 0, 51, 0, 51, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig toPhpDocNode = { { 837 /* toPhpDocNode */, 0, 52, 0, 52, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toNativePhpTypeNode = { { 891 /* toNativePhpTypeNode */, 1, 53, 1, reg::NoArg, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getReferencedClasses = { { 911 /* getReferencedClasses */, 0, 54, 0, 54, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getObjectClassNames = { { 932 /* getObjectClassNames */, 0, 55, 0, 55, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getObjectClassReflections = { { 952 /* getObjectClassReflections */, 0, 56, 0, 56, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getClassStringType = { { 978 /* getClassStringType */, 0, 57, 0, 57, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getClassStringObjectType = { { 997 /* getClassStringObjectType */, 0, 58, 0, 58, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getObjectTypeOrClassStringObjectType = { { 1022 /* getObjectTypeOrClassStringObjectType */, 0, 59, 0, 59, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isObject = { { 1059 /* isObject */, 0, 60, 0, 60, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isEnum = { { 1068 /* isEnum */, 0, 61, 0, 61, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getArrays = { { 1075 /* getArrays */, 0, 62, 0, 62, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantArrays = { { 1085 /* getConstantArrays */, 0, 63, 0, 63, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantStrings = { { 1103 /* getConstantStrings */, 0, 64, 0, 64, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessProperties = { { 1122 /* canAccessProperties */, 0, 65, 0, 65, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasProperty = { { 1155 /* hasProperty */, 1, 66, 1, 67, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getProperty = { { 1264 /* getProperty */, 2, 68, 2, 70, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnresolvedPropertyPrototype = { { 1338 /* getUnresolvedPropertyPrototype */, 2, 71, 2, 73, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasInstanceProperty = { { 1369 /* hasInstanceProperty */, 1, 74, 1, 75, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getInstanceProperty = { { 1389 /* getInstanceProperty */, 2, 76, 2, 78, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnresolvedInstancePropertyPrototype = { { 1409 /* getUnresolvedInstancePropertyPrototype */, 2, 79, 2, 81, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasStaticProperty = { { 1448 /* hasStaticProperty */, 1, 82, 1, 83, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getStaticProperty = { { 1466 /* getStaticProperty */, 2, 84, 2, 86, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnresolvedStaticPropertyPrototype = { { 1484 /* getUnresolvedStaticPropertyPrototype */, 2, 87, 2, 89, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canCallMethods = { { 1521 /* canCallMethods */, 0, 90, 0, 90, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasMethod = { { 1547 /* hasMethod */, 1, 91, 1, 92, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getMethod = { { 1601 /* getMethod */, 2, 93, 2, 95, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getUnresolvedMethodPrototype = { { 1671 /* getUnresolvedMethodPrototype */, 2, 96, 2, 98, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessConstants = { { 1700 /* canAccessConstants */, 0, 99, 0, 99, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasConstant = { { 1732 /* hasConstant */, 1, 100, 1, 101, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstant = { { 1787 /* getConstant */, 1, 102, 1, 103, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isIterable = { { 1799 /* isIterable */, 0, 104, 0, 104, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isIterableAtLeastOnce = { { 1810 /* isIterableAtLeastOnce */, 0, 105, 0, 105, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getArraySize = { { 1832 /* getArraySize */, 0, 106, 0, 106, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getIterableKeyType = { { 1845 /* getIterableKeyType */, 0, 107, 0, 107, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFirstIterableKeyType = { { 1864 /* getFirstIterableKeyType */, 0, 108, 0, 108, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getLastIterableKeyType = { { 1888 /* getLastIterableKeyType */, 0, 109, 0, 109, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getIterableValueType = { { 1911 /* getIterableValueType */, 0, 110, 0, 110, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFirstIterableValueType = { { 1932 /* getFirstIterableValueType */, 0, 111, 0, 111, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getLastIterableValueType = { { 1958 /* getLastIterableValueType */, 0, 112, 0, 112, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isArray = { { 1983 /* isArray */, 0, 113, 0, 113, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isConstantArray = { { 1991 /* isConstantArray */, 0, 114, 0, 114, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isOversizedArray = { { 2007 /* isOversizedArray */, 0, 115, 0, 115, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isList = { { 2024 /* isList */, 0, 116, 0, 116, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isOffsetAccessible = { { 2031 /* isOffsetAccessible */, 0, 117, 0, 117, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isOffsetAccessLegal = { { 2050 /* isOffsetAccessLegal */, 0, 118, 0, 118, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig hasOffsetValueType = { { 2081 /* hasOffsetValueType */, 1, 119, 1, 120, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getOffsetValueType = { { 2100 /* getOffsetValueType */, 1, 121, 1, 122, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig setOffsetValueType = { { 2146 /* setOffsetValueType */, 2, 123, 3, 126, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig setExistingOffsetValueType = { { 2165 /* setExistingOffsetValueType */, 2, 127, 2, 129, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig unsetOffset = { { 2192 /* unsetOffset */, 1, 130, 1, 131, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getKeysArrayFiltered = { { 2227 /* getKeysArrayFiltered */, 2, 132, 2, 134, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getKeysArray = { { 2248 /* getKeysArray */, 0, 135, 0, 135, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getValuesArray = { { 2261 /* getValuesArray */, 0, 136, 0, 136, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig chunkArray = { { 2300 /* chunkArray */, 2, 137, 2, 139, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig fillKeysArray = { { 2311 /* fillKeysArray */, 1, 140, 1, 141, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig flipArray = { { 2325 /* flipArray */, 0, 142, 0, 142, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig intersectKeyArray = { { 2351 /* intersectKeyArray */, 1, 143, 1, 144, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig popArray = { { 2369 /* popArray */, 0, 145, 0, 145, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig reverseArray = { { 2378 /* reverseArray */, 1, 146, 1, 147, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig searchArray = { { 2407 /* searchArray */, 1, 148, 2, 150, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig shiftArray = { { 2419 /* shiftArray */, 0, 151, 0, 151, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig shuffleArray = { { 2430 /* shuffleArray */, 0, 152, 0, 152, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig sliceArray = { { 2443 /* sliceArray */, 3, 153, 3, 156, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig spliceArray = { { 2470 /* spliceArray */, 3, 157, 3, 160, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig truncateListToSize = { { 2491 /* truncateListToSize */, 1, 161, 1, 162, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig makeListMaybe = { { 2510 /* makeListMaybe */, 0, 163, 0, 163, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mapValueType = { { 2524 /* mapValueType */, 1, 164, 1, 165, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mapKeyType = { { 2537 /* mapKeyType */, 1, 166, 1, 167, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig makeAllArrayKeysOptional = { { 2548 /* makeAllArrayKeysOptional */, 0, 168, 0, 168, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig changeKeyCaseArray = { { 2578 /* changeKeyCaseArray */, 1, 169, 1, 170, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterArrayRemovingFalsey = { { 2597 /* filterArrayRemovingFalsey */, 0, 171, 0, 171, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getEnumCases = { { 2623 /* getEnumCases */, 0, 172, 0, 172, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getEnumCaseObject = { { 2673 /* getEnumCaseObject */, 0, 173, 0, 173, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFiniteTypes = { { 2691 /* getFiniteTypes */, 0, 174, 0, 174, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig arithmeticPower = { { 2715 /* arithmeticPower */, 2, 175, 2, 177, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isCallable = { { 2731 /* isCallable */, 0, 178, 0, 178, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getCallableParametersAcceptors = { { 2742 /* getCallableParametersAcceptors */, 1, 179, 1, 180, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isCloneable = { { 2773 /* isCloneable */, 0, 181, 0, 181, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toBoolean = { { 2810 /* toBoolean */, 0, 182, 0, 182, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toNumber = { { 2820 /* toNumber */, 0, 183, 0, 183, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toValueSet = { { 2851 /* toValueSet */, 0, 184, 0, 184, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toBitwiseNotType = { { 2862 /* toBitwiseNotType */, 0, 185, 0, 185, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toGetClassResultType = { { 2879 /* toGetClassResultType */, 0, 186, 0, 186, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toClassConstantType = { { 2957 /* toClassConstantType */, 1, 187, 1, 188, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toObjectTypeForInstanceofCheck = { { 3018 /* toObjectTypeForInstanceofCheck */, 0, 189, 0, 189, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toObjectTypeForIsACheck = { { 3094 /* toObjectTypeForIsACheck */, 3, 190, 3, 193, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toInteger = { { 3118 /* toInteger */, 0, 194, 0, 194, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toFloat = { { 3128 /* toFloat */, 0, 195, 0, 195, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toString = { { 3136 /* toString */, 0, 196, 0, 196, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toArray = { { 3145 /* toArray */, 0, 197, 0, 197, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toArrayKey = { { 3153 /* toArrayKey */, 0, 198, 0, 198, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isSmallerThan = { { 3164 /* isSmallerThan */, 2, 199, 2, 201, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isSmallerThanOrEqual = { { 3178 /* isSmallerThanOrEqual */, 2, 202, 2, 204, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isConstantValue = { { 3199 /* isConstantValue */, 0, 205, 0, 205, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isConstantScalarValue = { { 3215 /* isConstantScalarValue */, 0, 206, 0, 206, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantScalarTypes = { { 3237 /* getConstantScalarTypes */, 0, 207, 0, 207, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantScalarValues = { { 3260 /* getConstantScalarValues */, 0, 208, 0, 208, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isNull = { { 3284 /* isNull */, 0, 209, 0, 209, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isTrue = { { 3291 /* isTrue */, 0, 210, 0, 210, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isFalse = { { 3298 /* isFalse */, 0, 211, 0, 211, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isBoolean = { { 3306 /* isBoolean */, 0, 212, 0, 212, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isFloat = { { 3316 /* isFloat */, 0, 213, 0, 213, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInteger = { { 3324 /* isInteger */, 0, 214, 0, 214, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isString = { { 3334 /* isString */, 0, 215, 0, 215, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isNumericString = { { 3343 /* isNumericString */, 0, 216, 0, 216, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isDecimalIntegerString = { { 3359 /* isDecimalIntegerString */, 0, 217, 0, 217, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isNonEmptyString = { { 3382 /* isNonEmptyString */, 0, 218, 0, 218, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isNonFalsyString = { { 3399 /* isNonFalsyString */, 0, 219, 0, 219, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isLiteralString = { { 3416 /* isLiteralString */, 0, 220, 0, 220, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isLowercaseString = { { 3432 /* isLowercaseString */, 0, 221, 0, 221, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isUppercaseString = { { 3450 /* isUppercaseString */, 0, 222, 0, 222, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isClassString = { { 3468 /* isClassString */, 0, 223, 0, 223, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isVoid = { { 3482 /* isVoid */, 0, 224, 0, 224, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isScalar = { { 3489 /* isScalar */, 0, 225, 0, 225, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig looseCompare = { { 3498 /* looseCompare */, 2, 226, 2, 228, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getSmallerType = { { 3511 /* getSmallerType */, 1, 229, 1, 230, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getSmallerOrEqualType = { { 3526 /* getSmallerOrEqualType */, 1, 231, 1, 232, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getGreaterType = { { 3548 /* getGreaterType */, 1, 233, 1, 234, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getGreaterOrEqualType = { { 3563 /* getGreaterOrEqualType */, 1, 235, 1, 236, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getTemplateType = { { 3620 /* getTemplateType */, 2, 237, 2, 239, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig inferTemplateTypes = { { 3686 /* inferTemplateTypes */, 1, 240, 1, 241, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getReferencedTemplateTypes = { { 3764 /* getReferencedTemplateTypes */, 1, 242, 1, 243, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig toAbsoluteNumber = { { 3791 /* toAbsoluteNumber */, 0, 244, 0, 244, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toNativePhpTypeNode = { { 964 /* toNativePhpTypeNode */, 1, 53, 1, 54, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getReferencedClasses = { { 984 /* getReferencedClasses */, 0, 55, 0, 55, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getObjectClassNames = { { 1005 /* getObjectClassNames */, 0, 56, 0, 56, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getObjectClassReflections = { { 1025 /* getObjectClassReflections */, 0, 57, 0, 57, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getClassStringType = { { 1051 /* getClassStringType */, 0, 58, 0, 58, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getClassStringObjectType = { { 1070 /* getClassStringObjectType */, 0, 59, 0, 59, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getObjectTypeOrClassStringObjectType = { { 1095 /* getObjectTypeOrClassStringObjectType */, 0, 60, 0, 60, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isObject = { { 1132 /* isObject */, 0, 61, 0, 61, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isEnum = { { 1141 /* isEnum */, 0, 62, 0, 62, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getArrays = { { 1148 /* getArrays */, 0, 63, 0, 63, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantArrays = { { 1158 /* getConstantArrays */, 0, 64, 0, 64, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantStrings = { { 1176 /* getConstantStrings */, 0, 65, 0, 65, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessProperties = { { 1195 /* canAccessProperties */, 0, 66, 0, 66, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasProperty = { { 1228 /* hasProperty */, 1, 67, 1, 68, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getProperty = { { 1337 /* getProperty */, 2, 69, 2, 71, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnresolvedPropertyPrototype = { { 1411 /* getUnresolvedPropertyPrototype */, 2, 72, 2, 74, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasInstanceProperty = { { 1442 /* hasInstanceProperty */, 1, 75, 1, 76, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getInstanceProperty = { { 1462 /* getInstanceProperty */, 2, 77, 2, 79, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnresolvedInstancePropertyPrototype = { { 1482 /* getUnresolvedInstancePropertyPrototype */, 2, 80, 2, 82, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasStaticProperty = { { 1521 /* hasStaticProperty */, 1, 83, 1, 84, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getStaticProperty = { { 1539 /* getStaticProperty */, 2, 85, 2, 87, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnresolvedStaticPropertyPrototype = { { 1557 /* getUnresolvedStaticPropertyPrototype */, 2, 88, 2, 90, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canCallMethods = { { 1594 /* canCallMethods */, 0, 91, 0, 91, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasMethod = { { 1620 /* hasMethod */, 1, 92, 1, 93, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getMethod = { { 1674 /* getMethod */, 2, 94, 2, 96, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getUnresolvedMethodPrototype = { { 1744 /* getUnresolvedMethodPrototype */, 2, 97, 2, 99, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessConstants = { { 1773 /* canAccessConstants */, 0, 100, 0, 100, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasConstant = { { 1805 /* hasConstant */, 1, 101, 1, 102, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstant = { { 1860 /* getConstant */, 1, 103, 1, 104, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isIterable = { { 1872 /* isIterable */, 0, 105, 0, 105, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isIterableAtLeastOnce = { { 1883 /* isIterableAtLeastOnce */, 0, 106, 0, 106, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getArraySize = { { 1905 /* getArraySize */, 0, 107, 0, 107, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getIterableKeyType = { { 1918 /* getIterableKeyType */, 0, 108, 0, 108, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFirstIterableKeyType = { { 1937 /* getFirstIterableKeyType */, 0, 109, 0, 109, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getLastIterableKeyType = { { 1961 /* getLastIterableKeyType */, 0, 110, 0, 110, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getIterableValueType = { { 1984 /* getIterableValueType */, 0, 111, 0, 111, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFirstIterableValueType = { { 2005 /* getFirstIterableValueType */, 0, 112, 0, 112, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getLastIterableValueType = { { 2031 /* getLastIterableValueType */, 0, 113, 0, 113, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isArray = { { 2056 /* isArray */, 0, 114, 0, 114, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isConstantArray = { { 2064 /* isConstantArray */, 0, 115, 0, 115, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isOversizedArray = { { 2080 /* isOversizedArray */, 0, 116, 0, 116, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isList = { { 2097 /* isList */, 0, 117, 0, 117, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isOffsetAccessible = { { 2104 /* isOffsetAccessible */, 0, 118, 0, 118, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isOffsetAccessLegal = { { 2123 /* isOffsetAccessLegal */, 0, 119, 0, 119, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig hasOffsetValueType = { { 2154 /* hasOffsetValueType */, 1, 120, 1, 121, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getOffsetValueType = { { 2173 /* getOffsetValueType */, 1, 122, 1, 123, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig setOffsetValueType = { { 2219 /* setOffsetValueType */, 2, 124, 3, 127, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig setExistingOffsetValueType = { { 2238 /* setExistingOffsetValueType */, 2, 128, 2, 130, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig unsetOffset = { { 2265 /* unsetOffset */, 1, 131, 1, 132, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getKeysArrayFiltered = { { 2300 /* getKeysArrayFiltered */, 2, 133, 2, 135, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getKeysArray = { { 2321 /* getKeysArray */, 0, 136, 0, 136, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getValuesArray = { { 2334 /* getValuesArray */, 0, 137, 0, 137, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig chunkArray = { { 2373 /* chunkArray */, 2, 138, 2, 140, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig fillKeysArray = { { 2384 /* fillKeysArray */, 1, 141, 1, 142, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig flipArray = { { 2398 /* flipArray */, 0, 143, 0, 143, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig intersectKeyArray = { { 2424 /* intersectKeyArray */, 1, 144, 1, 145, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig popArray = { { 2442 /* popArray */, 0, 146, 0, 146, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig reverseArray = { { 2451 /* reverseArray */, 1, 147, 1, 148, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig searchArray = { { 2480 /* searchArray */, 1, 149, 2, 151, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig shiftArray = { { 2492 /* shiftArray */, 0, 152, 0, 152, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig shuffleArray = { { 2503 /* shuffleArray */, 0, 153, 0, 153, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig sliceArray = { { 2516 /* sliceArray */, 3, 154, 3, 157, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig spliceArray = { { 2543 /* spliceArray */, 3, 158, 3, 161, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig truncateListToSize = { { 2564 /* truncateListToSize */, 1, 162, 1, 163, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig makeListMaybe = { { 2583 /* makeListMaybe */, 0, 164, 0, 164, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mapValueType = { { 2597 /* mapValueType */, 1, 165, 1, 166, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mapKeyType = { { 2610 /* mapKeyType */, 1, 167, 1, 168, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig makeAllArrayKeysOptional = { { 2621 /* makeAllArrayKeysOptional */, 0, 169, 0, 169, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig changeKeyCaseArray = { { 2651 /* changeKeyCaseArray */, 1, 170, 1, 171, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterArrayRemovingFalsey = { { 2670 /* filterArrayRemovingFalsey */, 0, 172, 0, 172, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getEnumCases = { { 2696 /* getEnumCases */, 0, 173, 0, 173, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getEnumCaseObject = { { 2746 /* getEnumCaseObject */, 0, 174, 0, 174, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFiniteTypes = { { 2764 /* getFiniteTypes */, 0, 175, 0, 175, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig arithmeticPower = { { 2788 /* arithmeticPower */, 2, 176, 2, 178, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isCallable = { { 2804 /* isCallable */, 0, 179, 0, 179, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getCallableParametersAcceptors = { { 2815 /* getCallableParametersAcceptors */, 1, 180, 1, 181, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isCloneable = { { 2846 /* isCloneable */, 0, 182, 0, 182, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toBoolean = { { 2883 /* toBoolean */, 0, 183, 0, 183, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toNumber = { { 2893 /* toNumber */, 0, 184, 0, 184, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toValueSet = { { 2924 /* toValueSet */, 0, 185, 0, 185, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toBitwiseNotType = { { 2935 /* toBitwiseNotType */, 0, 186, 0, 186, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toGetClassResultType = { { 2952 /* toGetClassResultType */, 0, 187, 0, 187, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toClassConstantType = { { 3030 /* toClassConstantType */, 1, 188, 1, 189, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toObjectTypeForInstanceofCheck = { { 3091 /* toObjectTypeForInstanceofCheck */, 0, 190, 0, 190, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toObjectTypeForIsACheck = { { 3167 /* toObjectTypeForIsACheck */, 3, 191, 3, 194, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toInteger = { { 3191 /* toInteger */, 0, 195, 0, 195, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toFloat = { { 3201 /* toFloat */, 0, 196, 0, 196, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toString = { { 3209 /* toString */, 0, 197, 0, 197, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toArray = { { 3218 /* toArray */, 0, 198, 0, 198, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toArrayKey = { { 3226 /* toArrayKey */, 0, 199, 0, 199, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isSmallerThan = { { 3237 /* isSmallerThan */, 2, 200, 2, 202, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isSmallerThanOrEqual = { { 3251 /* isSmallerThanOrEqual */, 2, 203, 2, 205, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isConstantValue = { { 3272 /* isConstantValue */, 0, 206, 0, 206, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isConstantScalarValue = { { 3288 /* isConstantScalarValue */, 0, 207, 0, 207, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantScalarTypes = { { 3310 /* getConstantScalarTypes */, 0, 208, 0, 208, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantScalarValues = { { 3333 /* getConstantScalarValues */, 0, 209, 0, 209, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isNull = { { 3357 /* isNull */, 0, 210, 0, 210, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isTrue = { { 3364 /* isTrue */, 0, 211, 0, 211, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isFalse = { { 3371 /* isFalse */, 0, 212, 0, 212, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isBoolean = { { 3379 /* isBoolean */, 0, 213, 0, 213, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isFloat = { { 3389 /* isFloat */, 0, 214, 0, 214, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInteger = { { 3397 /* isInteger */, 0, 215, 0, 215, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isString = { { 3407 /* isString */, 0, 216, 0, 216, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isNumericString = { { 3416 /* isNumericString */, 0, 217, 0, 217, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isDecimalIntegerString = { { 3432 /* isDecimalIntegerString */, 0, 218, 0, 218, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isNonEmptyString = { { 3455 /* isNonEmptyString */, 0, 219, 0, 219, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isNonFalsyString = { { 3472 /* isNonFalsyString */, 0, 220, 0, 220, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isLiteralString = { { 3489 /* isLiteralString */, 0, 221, 0, 221, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isLowercaseString = { { 3505 /* isLowercaseString */, 0, 222, 0, 222, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isUppercaseString = { { 3523 /* isUppercaseString */, 0, 223, 0, 223, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isClassString = { { 3541 /* isClassString */, 0, 224, 0, 224, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isVoid = { { 3555 /* isVoid */, 0, 225, 0, 225, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isScalar = { { 3562 /* isScalar */, 0, 226, 0, 226, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig looseCompare = { { 3571 /* looseCompare */, 2, 227, 2, 229, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getSmallerType = { { 3584 /* getSmallerType */, 1, 230, 1, 231, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getSmallerOrEqualType = { { 3599 /* getSmallerOrEqualType */, 1, 232, 1, 233, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getGreaterType = { { 3621 /* getGreaterType */, 1, 234, 1, 235, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getGreaterOrEqualType = { { 3636 /* getGreaterOrEqualType */, 1, 236, 1, 237, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getTemplateType = { { 3693 /* getTemplateType */, 2, 238, 2, 240, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig inferTemplateTypes = { { 3759 /* inferTemplateTypes */, 1, 241, 1, 242, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getReferencedTemplateTypes = { { 3837 /* getReferencedTemplateTypes */, 1, 243, 1, 244, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig toAbsoluteNumber = { { 3864 /* toAbsoluteNumber */, 0, 245, 0, 245, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::UnresolvedTemplateArgumentType diff --git a/turbo-ext/src/generated/VariableFlow.h b/turbo-ext/src/generated/VariableFlow.h index 4cdd50de57f..ec8c261405f 100644 --- a/turbo-ext/src/generated/VariableFlow.h +++ b/turbo-ext/src/generated/VariableFlow.h @@ -98,7 +98,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(132, MAY_BE_STRING), /* read $name */ reg::packed(137, MAY_BE_NULL | MAY_BE_LONG, reg::NoString, false, false, 146), /* read $targetId */ reg::packed(151, MAY_BE_BOOL, reg::NoString, false, false, 161), /* read $container */ - reg::packed(167, 0, reg::NoString, false, false, 146), /* read $offset */ + reg::packed(167, MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING, reg::NoString, false, false, 146), /* read $offset */ reg::packed(53, MAY_BE_NULL, 23), /* read return */ reg::packed(179, MAY_BE_NULL, 23), /* conditional $condition */ reg::packed(189, MAY_BE_NULL, 23), /* conditional $if */ diff --git a/turbo-ext/src/generated/VariableLivenessResolver.h b/turbo-ext/src/generated/VariableLivenessResolver.h index 421254b07fd..b6abcd23de7 100644 --- a/turbo-ext/src/generated/VariableLivenessResolver.h +++ b/turbo-ext/src/generated/VariableLivenessResolver.h @@ -137,7 +137,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(262, MAY_BE_NULL, 202), /* passBindingProbes $write */ reg::packed(268, MAY_BE_BOOL, reg::NoString, false, false, 276), /* passBindingProbes $discard */ reg::packed(84, MAY_BE_ARRAY), /* passBindingProbes return */ - reg::packed(300, 0), /* offsetKey $offset */ + reg::packed(300, MAY_BE_LONG | MAY_BE_STRING), /* offsetKey $offset */ reg::packed(84, MAY_BE_STRING), /* offsetKey return */ reg::packed(84, MAY_BE_VOID), /* compileAccesses return */ reg::packed(257, MAY_BE_STRING), /* compileOverwrites $name */ diff --git a/turbo-ext/src/generated/VariableWriteOffset.h b/turbo-ext/src/generated/VariableWriteOffset.h index 2fae6436392..9ee036a12d4 100644 --- a/turbo-ext/src/generated/VariableWriteOffset.h +++ b/turbo-ext/src/generated/VariableWriteOffset.h @@ -24,16 +24,18 @@ namespace sigtab { inline constexpr char strings[] = "dimType\0" /* 0 */ "PHPStan\\Type\\Type\0" /* 8 */ - "fromType"; /* 26 */ + "\0" /* 26 */ + "fromType"; /* 27 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 8), /* fromType $dimType */ + reg::packed(26, MAY_BE_NULL | MAY_BE_LONG | MAY_BE_STRING), /* fromType return */ }; using Sig = reg::Sig; } // namespace sigtab /* the signatures of the methods the class declares itself (a used trait's are in the trait's header) */ namespace sig { -inline constexpr sigtab::Sig fromType = { { 26 /* fromType */, 1, 0, 1, reg::NoArg, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig fromType = { { 27 /* fromType */, 1, 0, 1, 1, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; } // namespace sig } // namespace ptdecl::VariableWriteOffset From bf9769b118177a9591017be5666825fb7af496be Mon Sep 17 00:00:00 2001 From: "ondrej@mirtes.cz" Date: Mon, 9 Nov 2026 07:06:06 +0000 Subject: [PATCH 3/4] Keep the BC promise and the PHP 7.4 downgrade in MissingNativeTypeRule Parameters of non-private methods in @api classes or tagged @api keep their PHPDoc types, as do non-private properties of @api classes. Standalone null, true, false, never and DNF types are not added because build/downgrade.php cannot lower them for PHP 7.4-8.1. Amp-Thread-ID: https://ampcode.com/threads/T-01a1bed4-966e-7640-a834-06bba746e1f1 --- build/PHPStan/Build/MissingNativeTypeRule.php | 59 +++++++++- .../Build/MissingNativeTypeRuleTest.php | 28 +++++ .../Build/data/missing-native-type.php | 106 ++++++++++++++++++ .../Build/data/missing-native-type.php.fixed | 98 ++++++++++++++++ 4 files changed, 286 insertions(+), 5 deletions(-) diff --git a/build/PHPStan/Build/MissingNativeTypeRule.php b/build/PHPStan/Build/MissingNativeTypeRule.php index 44b3027e01b..c44217060f9 100644 --- a/build/PHPStan/Build/MissingNativeTypeRule.php +++ b/build/PHPStan/Build/MissingNativeTypeRule.php @@ -42,6 +42,7 @@ use function implode; use function in_array; use function sprintf; +use function str_contains; use function str_starts_with; use function strtolower; use function trim; @@ -132,13 +133,20 @@ private function processFunctionLike( $ancestorMethods = $classReflection !== null ? $this->getAncestorMethods($classReflection, $functionNode->name->toString()) : []; + // the backward compatibility promise covers what callers pass, a native type would reject what the PHPDoc did not allow + $areParametersApi = !($functionNode instanceof Node\Stmt\ClassMethod && $functionNode->isPrivate()) + && ( + str_contains($functionNode->getDocComment()?->getText() ?? '', '@api') + || ($classReflection !== null && $lowercasedName !== '__construct' && self::isApi($classReflection)) + ); + /** @var array $paramTypeNodes */ $paramTypeNodes = []; $sameParamNames = []; $descriptions = []; $parameters = $function->getParameters(); foreach ($functionNode->params as $i => $paramNode) { - if ($paramNode->type !== null || $paramNode->byRef || !isset($parameters[$i])) { + if ($paramNode->type !== null || $paramNode->byRef || $areParametersApi || !isset($parameters[$i])) { // the type of a parameter passed by reference describes the variable after the call too continue; } @@ -148,7 +156,7 @@ private function processFunctionLike( // a promoted parameter declares a property too $position = $paramNode->isPromoted() ? NativeTypePosition::property($this->phpVersion) : NativeTypePosition::parameter($this->phpVersion); $typeNode = $type->toNativePhpTypeNode($position); - if ($typeNode === null) { + if ($typeNode === null || !self::isDowngradable($typeNode)) { continue; } @@ -190,7 +198,7 @@ private function processFunctionLike( $returnTypeNode = $returnType->toNativePhpTypeNode(NativeTypePosition::returnType($this->phpVersion)); if ($returnTypeNode !== null) { $nativeReturnType = ParserNodeTypeToPHPStanType::resolve($returnTypeNode, $classReflection); - if (!$nativeReturnType->isSuperTypeOf($returnType)->yes() || !self::isCovariant($nativeReturnType, $ancestorMethods)) { + if (!self::isDowngradable($returnTypeNode) || !$nativeReturnType->isSuperTypeOf($returnType)->yes() || !self::isCovariant($nativeReturnType, $ancestorMethods)) { $returnTypeNode = null; } else { $descriptions[] = sprintf('return type %s', self::printTypeNode($returnTypeNode)); @@ -271,7 +279,7 @@ private function processProperty(ClassPropertyNode $node, Scope $scope): array } $typeNode = $type->toNativePhpTypeNode(NativeTypePosition::property($this->phpVersion)); - if ($typeNode === null) { + if ($typeNode === null || !self::isDowngradable($typeNode)) { return []; } @@ -348,7 +356,7 @@ private function removePhpDocTags(Node $node, callable $shouldRemove): void */ private function canDeclarePropertyType(ClassReflection $classReflection, string $propertyName, bool $isPrivate): bool { - if (!$isPrivate && !self::isFinal($classReflection)) { + if (!$isPrivate && (!self::isFinal($classReflection) || self::isApi($classReflection))) { return false; } @@ -445,6 +453,47 @@ private static function isFinal(ClassReflection $classReflection): bool * Whether the PHPDoc type says nothing more than the native type. An explicit `mixed[]` says more than `array`: * they accept the same values, but only the former has a value type. */ + /** + * build/downgrade.php lowers mixed, static, unions and pure intersections for PHP 7.4, + * but not standalone null, true, false, never or DNF types + */ + private static function isDowngradable(Identifier|Name|ComplexType $node): bool + { + if ($node instanceof Node\NullableType) { + $node = $node->type; + } + + if ($node instanceof Identifier) { + return !in_array($node->toLowerString(), ['null', 'true', 'false', 'never'], true); + } + + if ($node instanceof Node\UnionType) { + foreach ($node->types as $member) { + if ($member instanceof Node\IntersectionType) { + return false; + } + } + } + + return true; + } + + private static function isApi(ClassReflection $classReflection): bool + { + $phpDoc = $classReflection->getResolvedPhpDoc(); + if ($phpDoc === null) { + return false; + } + + foreach ($phpDoc->getPhpDocNodes() as $phpDocNode) { + if (count($phpDocNode->getTagsByName('@api')) > 0) { + return true; + } + } + + return false; + } + private function isSameType(Type $nativeType, Type $phpDocType): bool { return $nativeType->isSuperTypeOf($phpDocType)->yes() diff --git a/tests/PHPStan/Build/MissingNativeTypeRuleTest.php b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php index 818c112c420..9b74941a1f2 100644 --- a/tests/PHPStan/Build/MissingNativeTypeRuleTest.php +++ b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php @@ -146,6 +146,34 @@ public function testRule(): void 'Method MissingNativeType\ExplicitMixedValueType::doFoo() is missing native types: array $a, return type array.', 327, ], + [ + 'Method MissingNativeType\\ApiClass::__construct() is missing native types: int $a, int $b.', + 343, + ], + [ + 'Method MissingNativeType\\ApiClass::doFoo() is missing native types: return type int.', + 351, + ], + [ + 'Property MissingNativeType\\ApiClass::$private is missing native type int.', + 360, + ], + [ + 'Method MissingNativeType\\ApiMethod::notApi() is missing native types: int $a.', + 376, + ], + [ + 'Method MissingNativeType\\NotDowngradable::params() is missing native types: int $b.', + 390, + ], + [ + 'Method MissingNativeType\\NotDowngradable::returnsUnion() is missing native types: return type string|false.', + 419, + ], + [ + 'Method MissingNativeType\\ApiClassPrivateMethod::doFoo() is missing native types: int $a.', + 434, + ], ]); } diff --git a/tests/PHPStan/Build/data/missing-native-type.php b/tests/PHPStan/Build/data/missing-native-type.php index 829b6bf3e97..e2713189b27 100644 --- a/tests/PHPStan/Build/data/missing-native-type.php +++ b/tests/PHPStan/Build/data/missing-native-type.php @@ -330,3 +330,109 @@ public function doFoo($a) } } + +/** @api */ +final class ApiClass +{ + + /** + * @param int $a + * @param int $b + * @param int $c + */ + public function __construct($a, private $b, public $c = 1) + { + } + + /** + * @param int $a + * @return int + */ + public function doFoo($a) + { + return $a; + } + + /** @var int */ + public $public = 1; + + /** @var int */ + private $private = 1; + +} + +final class ApiMethod +{ + + /** + * @api + * @param int $a + */ + public function api($a): void + { + } + + /** @param int $a */ + public function notApi($a): void + { + } + +} + +final class NotDowngradable +{ + + /** + * @param true $a + * @param int $b + * @param (Countable&\Traversable)|null $c + */ + public function params($a, $b, $c): void + { + } + + /** @return null */ + public function returnsNull() + { + return null; + } + + /** @return false */ + public function returnsFalse() + { + return false; + } + + /** @return true|null */ + public function returnsNullableTrue() + { + return true; + } + + /** @return never */ + public function returnsNever() + { + throw new \Exception(); + } + + /** @return string|false */ + public function returnsUnion() + { + return false; + } + + /** @var true */ + private $true = true; + +} + +/** @api */ +final class ApiClassPrivateMethod +{ + + /** @param int $a */ + private function doFoo($a): void + { + } + +} diff --git a/tests/PHPStan/Build/data/missing-native-type.php.fixed b/tests/PHPStan/Build/data/missing-native-type.php.fixed index c7a3428829f..d761ca3a6ae 100644 --- a/tests/PHPStan/Build/data/missing-native-type.php.fixed +++ b/tests/PHPStan/Build/data/missing-native-type.php.fixed @@ -294,3 +294,101 @@ final class ExplicitMixedValueType } } + +/** @api */ +final class ApiClass +{ + + /** + * @param int $c + */ + public function __construct(int $a, private int $b, public $c = 1) + { + } + + /** + * @param int $a + */ + public function doFoo($a): int + { + return $a; + } + + /** @var int */ + public $public = 1; + + private int $private = 1; + +} + +final class ApiMethod +{ + + /** + * @api + * @param int $a + */ + public function api($a): void + { + } + + public function notApi(int $a): void + { + } + +} + +final class NotDowngradable +{ + + /** + * @param true $a + * @param (Countable&\Traversable)|null $c + */ + public function params($a, int $b, $c): void + { + } + + /** @return null */ + public function returnsNull() + { + return null; + } + + /** @return false */ + public function returnsFalse() + { + return false; + } + + /** @return true|null */ + public function returnsNullableTrue() + { + return true; + } + + /** @return never */ + public function returnsNever() + { + throw new \Exception(); + } + + public function returnsUnion(): string|false + { + return false; + } + + /** @var true */ + private $true = true; + +} + +/** @api */ +final class ApiClassPrivateMethod +{ + + private function doFoo(int $a): void + { + } + +} From 9205dad9349e25ca083f8927cc302e22b69600da Mon Sep 17 00:00:00 2001 From: "ondrej@mirtes.cz" Date: Mon, 9 Nov 2026 07:06:06 +0000 Subject: [PATCH 4/4] Remove native types the BC promise and the PHP 7.4 downgrade do not allow Amp-Thread-ID: https://ampcode.com/threads/T-01a1bed4-966e-7640-a834-06bba746e1f1 --- src/Analyser/MutatingScope.php | 6 +- src/Analyser/Scope.php | 8 +- src/Collectors/CollectorWithPaths.php | 2 +- src/Node/PropertyHookStatementNode.php | 5 +- .../SourceLocator/CachingVisitor.php | 5 +- src/Testing/TypeInferenceTestCase.php | 3 +- src/Turbo/ForkedChild.php | 3 +- src/Type/ConstantTypeHelper.php | 5 +- src/Type/IntegerRangeType.php | 16 +- turbo-ext/src/IntegerRangeType.cpp | 8 +- turbo-ext/src/generated/ConstantTypeHelper.h | 2 +- turbo-ext/src/generated/ForkedChild.h | 7 +- turbo-ext/src/generated/IntegerRangeType.h | 8 +- turbo-ext/src/generated/MutatingScope.h | 849 +++++++++--------- 14 files changed, 474 insertions(+), 453 deletions(-) diff --git a/src/Analyser/MutatingScope.php b/src/Analyser/MutatingScope.php index aca57a7708c..8d323aa65ac 100644 --- a/src/Analyser/MutatingScope.php +++ b/src/Analyser/MutatingScope.php @@ -1690,8 +1690,9 @@ public function resolveTypeByName(Name $name): TypeWithClassName /** * @api + * @param mixed $value */ - public function getTypeFromValue(mixed $value): Type + public function getTypeFromValue($value): Type { return ConstantTypeHelper::getTypeFromValue($value); } @@ -2765,8 +2766,9 @@ public function isParameterValueNullable(Node\Param $parameter): bool /** * @api + * @param Node\Name|Node\Identifier|Node\ComplexType|null $type */ - public function getFunctionType(Name|Identifier|ComplexType|null $type, bool $isNullable, bool $isVariadic): Type + public function getFunctionType($type, bool $isNullable, bool $isVariadic): Type { if ($isVariadic) { if (!$this->getPhpVersion()->supportsNamedArguments()->no()) { diff --git a/src/Analyser/Scope.php b/src/Analyser/Scope.php index f8c07cdf3c1..dfe3b864ce9 100644 --- a/src/Analyser/Scope.php +++ b/src/Analyser/Scope.php @@ -197,8 +197,10 @@ public function resolveTypeByName(Name $name): TypeWithClassName; * Converts runtime PHP values to their corresponding constant types: * integers become ConstantIntegerType, strings become ConstantStringType, * arrays become ConstantArrayType (if small enough), etc. + * + * @param mixed $value */ - public function getTypeFromValue(mixed $value): Type; + public function getTypeFromValue($value): Type; /** * Returns whether an expression has a tracked type in this scope. @@ -274,8 +276,10 @@ public function isParameterValueNullable(Param $parameter): bool; * Handles named types, identifier types (int, string, etc.), union types, * intersection types, and nullable types. The $isNullable flag adds null * to the type, and $isVariadic wraps the type in an array. + * + * @param Node\Name|Node\Identifier|Node\ComplexType|null $type */ - public function getFunctionType(Name|Node\Identifier|Node\ComplexType|null $type, bool $isNullable, bool $isVariadic): Type; + public function getFunctionType($type, bool $isNullable, bool $isVariadic): Type; /** * Returns whether the given expression is currently being assigned to. diff --git a/src/Collectors/CollectorWithPaths.php b/src/Collectors/CollectorWithPaths.php index 65ee1a57d9e..48ca89d7a0f 100644 --- a/src/Collectors/CollectorWithPaths.php +++ b/src/Collectors/CollectorWithPaths.php @@ -32,6 +32,6 @@ interface CollectorWithPaths extends Collector * @param callable(string): string $transformPath * @return TValue */ - public static function transformCollectedDataPaths(mixed $data, callable $transformPath); + public static function transformCollectedDataPaths($data, callable $transformPath); } diff --git a/src/Node/PropertyHookStatementNode.php b/src/Node/PropertyHookStatementNode.php index 55c0cfd4387..72340cb17da 100644 --- a/src/Node/PropertyHookStatementNode.php +++ b/src/Node/PropertyHookStatementNode.php @@ -28,7 +28,10 @@ public function __construct(PropertyHook $propertyHook) parent::__construct($propertyHook->getAttributes()); } - public function getReturnType(): null + /** + * @return null + */ + public function getReturnType() { return null; } diff --git a/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php b/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php index 81dea56f6b6..70b6bb71bb7 100644 --- a/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php +++ b/src/Reflection/BetterReflection/SourceLocator/CachingVisitor.php @@ -120,8 +120,11 @@ public function enterNode(Node $node): ?int return null; } + /** + * @return null + */ #[Override] - public function leaveNode(Node $node): null + public function leaveNode(Node $node) { if (!$node instanceof Namespace_) { return null; diff --git a/src/Testing/TypeInferenceTestCase.php b/src/Testing/TypeInferenceTestCase.php index 6728ab0d9ef..071bb4bb190 100644 --- a/src/Testing/TypeInferenceTestCase.php +++ b/src/Testing/TypeInferenceTestCase.php @@ -97,11 +97,12 @@ public static function processFile( /** * @api + * @param mixed ...$args */ public function assertFileAsserts( string $assertType, string $file, - mixed ...$args, + ...$args, ): void { if ($assertType === 'type') { diff --git a/src/Turbo/ForkedChild.php b/src/Turbo/ForkedChild.php index b0da4f97d70..d7b86e9e696 100644 --- a/src/Turbo/ForkedChild.php +++ b/src/Turbo/ForkedChild.php @@ -19,9 +19,10 @@ final class ForkedChild * inherited - one waiting for threads the child never had wedges there. * Register it as the child's last shutdown function. * + * @return never * @throws TurboNotActiveException */ - public static function exitImmediately(): never + public static function exitImmediately() { throw new TurboNotActiveException(); } diff --git a/src/Type/ConstantTypeHelper.php b/src/Type/ConstantTypeHelper.php index ad0143cc7d3..04cb39180c0 100644 --- a/src/Type/ConstantTypeHelper.php +++ b/src/Type/ConstantTypeHelper.php @@ -31,7 +31,10 @@ final class ConstantTypeHelper { - public static function getTypeFromValue(mixed $value): Type + /** + * @param mixed $value + */ + public static function getTypeFromValue($value): Type { if (is_int($value)) { return new ConstantIntegerType($value); diff --git a/src/Type/IntegerRangeType.php b/src/Type/IntegerRangeType.php index a55c900659c..2c2dda52198 100644 --- a/src/Type/IntegerRangeType.php +++ b/src/Type/IntegerRangeType.php @@ -90,8 +90,10 @@ protected static function isDisjoint(?int $minA, ?int $maxA, ?int $minB, ?int $m /** * Return the range of integers smaller than the given value + * + * @param int|float $value */ - public static function createAllSmallerThan(int|float $value): Type + public static function createAllSmallerThan($value): Type { if (is_int($value)) { return self::fromInterval(null, $value, -1); @@ -113,8 +115,10 @@ public static function createAllSmallerThan(int|float $value): Type /** * Return the range of integers smaller than or equal to the given value + * + * @param int|float $value */ - public static function createAllSmallerThanOrEqualTo(int|float $value): Type + public static function createAllSmallerThanOrEqualTo($value): Type { if (is_int($value)) { return self::fromInterval(null, $value); @@ -133,8 +137,10 @@ public static function createAllSmallerThanOrEqualTo(int|float $value): Type /** * Return the range of integers greater than the given value + * + * @param int|float $value */ - public static function createAllGreaterThan(int|float $value): Type + public static function createAllGreaterThan($value): Type { if (is_int($value)) { return self::fromInterval($value, null, 1); @@ -153,8 +159,10 @@ public static function createAllGreaterThan(int|float $value): Type /** * Return the range of integers greater than or equal to the given value + * + * @param int|float $value */ - public static function createAllGreaterThanOrEqualTo(int|float $value): Type + public static function createAllGreaterThanOrEqualTo($value): Type { if (is_int($value)) { return self::fromInterval($value, null); diff --git a/turbo-ext/src/IntegerRangeType.cpp b/turbo-ext/src/IntegerRangeType.cpp index 5fe51a1a738..98308b819af 100644 --- a/turbo-ext/src/IntegerRangeType.cpp +++ b/turbo-ext/src/IntegerRangeType.cpp @@ -1308,14 +1308,12 @@ static NullableLong pt_nullable_long_arg(zend_long value, bool isNull) return isNull ? NullableLong::null() : NullableLong::of(value); } -/* the createAll*() family: one int|float $value, rejected like the twin's - * declaration rejects anything else under strict_types (zp has no number kind) */ +/* the createAll*() family: one untyped $value */ static void pt_irt_create_all(INTERNAL_FUNCTION_PARAMETERS, zv::Val (*factory)(zval *)) { zval *value; - ZEND_PARSE_PARAMETERS_START(1, 1) - Z_PARAM_NUMBER(value) - ZEND_PARSE_PARAMETERS_END(); + if (!zp::parse(execute_data, value)) RETURN_THROWS(); + ZVAL_DEREF(value); PT_RETURN_VAL(factory(value)); } diff --git a/turbo-ext/src/generated/ConstantTypeHelper.h b/turbo-ext/src/generated/ConstantTypeHelper.h index b70a204bca6..6dcaae721e1 100644 --- a/turbo-ext/src/generated/ConstantTypeHelper.h +++ b/turbo-ext/src/generated/ConstantTypeHelper.h @@ -33,7 +33,7 @@ inline constexpr char strings[] = "PHPStan\\Type\\GeneralizePrecision\0" /* 91 */ "unionGeneralized"; /* 124 */ inline constexpr reg::PackedArg args[] = { - reg::packed(0, MAY_BE_ANY), /* getTypeFromValue $value */ + reg::packed(0, 0), /* getTypeFromValue $value */ reg::packed(6, 0, 7), /* getTypeFromValue return */ reg::packed(0, MAY_BE_ARRAY), /* getOversizedArrayType $value */ reg::packed(6, 0, 7), /* getOversizedArrayType return */ diff --git a/turbo-ext/src/generated/ForkedChild.h b/turbo-ext/src/generated/ForkedChild.h index 27537efa05e..79f871a2662 100644 --- a/turbo-ext/src/generated/ForkedChild.h +++ b/turbo-ext/src/generated/ForkedChild.h @@ -22,17 +22,16 @@ inline void declareProperties(reg::Class &cls) /* the string and parameter tables the signatures below index into (see reg::Sig) */ namespace sigtab { inline constexpr char strings[] = - "\0" /* 0 */ - "exitImmediately"; /* 1 */ + "exitImmediately"; /* 0 */ inline constexpr reg::PackedArg args[] = { - reg::packed(0, MAY_BE_NEVER), /* exitImmediately return */ + reg::packed(0, 0), /* placeholder: C++ has no empty arrays */ }; using Sig = reg::Sig; } // namespace sigtab /* the signatures of the methods the class declares itself (a used trait's are in the trait's header) */ namespace sig { -inline constexpr sigtab::Sig exitImmediately = { { 1 /* exitImmediately */, 0, 0, 0, 0, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig exitImmediately = { { 0 /* exitImmediately */, 0, 0, 0, reg::NoArg, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; } // namespace sig } // namespace ptdecl::ForkedChild diff --git a/turbo-ext/src/generated/IntegerRangeType.h b/turbo-ext/src/generated/IntegerRangeType.h index a07c2483f78..1ce54ffa3aa 100644 --- a/turbo-ext/src/generated/IntegerRangeType.h +++ b/turbo-ext/src/generated/IntegerRangeType.h @@ -122,13 +122,13 @@ inline constexpr reg::PackedArg args[] = { reg::packed(75, MAY_BE_NULL | MAY_BE_LONG), /* isDisjoint $maxB */ reg::packed(80, MAY_BE_BOOL, reg::NoString, false, false, 99), /* isDisjoint $touchingIsDisjoint */ reg::packed(28, MAY_BE_BOOL), /* isDisjoint return */ - reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllSmallerThan $value */ + reg::packed(115, 0), /* createAllSmallerThan $value */ reg::packed(28, 0, 29), /* createAllSmallerThan return */ - reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllSmallerThanOrEqualTo $value */ + reg::packed(115, 0), /* createAllSmallerThanOrEqualTo $value */ reg::packed(28, 0, 29), /* createAllSmallerThanOrEqualTo return */ - reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllGreaterThan $value */ + reg::packed(115, 0), /* createAllGreaterThan $value */ reg::packed(28, 0, 29), /* createAllGreaterThan return */ - reg::packed(115, MAY_BE_LONG | MAY_BE_DOUBLE), /* createAllGreaterThanOrEqualTo $value */ + reg::packed(115, 0), /* createAllGreaterThanOrEqualTo $value */ reg::packed(28, 0, 29), /* createAllGreaterThanOrEqualTo return */ reg::packed(28, 0, 223), /* toNumberSet return */ reg::packed(28, MAY_BE_NULL | MAY_BE_LONG), /* getMin return */ diff --git a/turbo-ext/src/generated/MutatingScope.h b/turbo-ext/src/generated/MutatingScope.h index 15c298cca92..7dbab050fea 100644 --- a/turbo-ext/src/generated/MutatingScope.h +++ b/turbo-ext/src/generated/MutatingScope.h @@ -306,200 +306,199 @@ inline constexpr char strings[] = "enterArrowFunctionWithoutReflection\0" /* 4898 */ "PhpParser\\Node\\Param\0" /* 4934 */ "isParameterValueNullable\0" /* 4955 */ - "PhpParser\\Node\\Name|PhpParser\\Node\\Identifier|PhpParser\\Node\\ComplexType\0" /* 4980 */ - "isNullable\0" /* 5053 */ - "isVariadic\0" /* 5064 */ - "getFunctionType\0" /* 5075 */ - "index\0" /* 5091 */ - "getCallableParameterType\0" /* 5097 */ - "startIndex\0" /* 5122 */ - "buildVariadicArrayTypeFromCallableParameters\0" /* 5133 */ - "nativeType\0" /* 5178 */ - "inferredType\0" /* 5189 */ - "intersectButNotNever\0" /* 5202 */ - "PhpParser\\Node\\Expr\\Match_\0" /* 5223 */ - "condType\0" /* 5250 */ - "condNativeType\0" /* 5259 */ - "enterMatch\0" /* 5274 */ - "iteratee\0" /* 5285 */ - "iterateeType\0" /* 5294 */ - "nativeIterateeType\0" /* 5307 */ - "valueName\0" /* 5326 */ - "keyName\0" /* 5336 */ - "valueByRef\0" /* 5344 */ - "enterForeach\0" /* 5355 */ - "enterForeachKey\0" /* 5368 */ - "catchType\0" /* 5384 */ - "enterCatchType\0" /* 5394 */ - "isPlainWrite\0" /* 5409 */ - "enterExpressionAssign\0" /* 5422 */ - "exitExpressionAssign\0" /* 5444 */ - "isInExpressionAssign\0" /* 5465 */ - "isInWriteExpressionAssign\0" /* 5486 */ - "setAllowedUndefinedExpression\0" /* 5512 */ - "unsetAllowedUndefinedExpression\0" /* 5542 */ - "isUndefinedExpressionAllowed\0" /* 5574 */ - "certainty\0" /* 5603 */ - "intertwinedPropagatedFrom\0" /* 5613 */ - "assignVariable\0" /* 5639 */ - "overwriteExpression\0" /* 5654 */ - "scope\0" /* 5674 */ - "rootType\0" /* 5680 */ - "assignedExpr\0" /* 5689 */ - "rootVariableName\0" /* 5702 */ - "native\0" /* 5719 */ - "resolveIntertwinedAssignedType\0" /* 5726 */ - "dimFetch\0" /* 5757 */ - "PhpParser\\Node\\Expr\\ArrayDimFetch\0" /* 5766 */ - "isDimFetchPathReachable\0" /* 5800 */ - "unsetExpression\0" /* 5824 */ - "getStateType\0" /* 5840 */ - "getScopeStateType\0" /* 5853 */ - "getScopeStateNativeType\0" /* 5871 */ - "resolveScopeStateType\0" /* 5895 */ - "specifyExpressionType\0" /* 5917 */ - "openSpecificationScope\0" /* 5939 */ - "isSpecifyExpressionTypeNoop\0" /* 5962 */ - "specifyExpressionTypeInPlace\0" /* 5990 */ - "assignExpression\0" /* 6019 */ - "fetchedOnType\0" /* 6036 */ - "assignInitializedProperty\0" /* 6050 */ - "expressionToInvalidate\0" /* 6076 */ - "requireMoreCharacters\0" /* 6099 */ - "invalidatingClass\0" /* 6121 */ - "keepPropertyFetches\0" /* 6139 */ - "invalidateExpression\0" /* 6159 */ - "isPrivatePropertyOfDifferentClass\0" /* 6180 */ - "invalidateMethodsOnExpression\0" /* 6214 */ - "setExpressionCertaintyKeepingType\0" /* 6244 */ - "isComplexUnionType\0" /* 6278 */ - "addTypeToExpression\0" /* 6297 */ - "typeToRemove\0" /* 6317 */ - "removeTypeFromExpression\0" /* 6330 */ - "filterByTruthyValue\0" /* 6355 */ - "filterByFalseyValue\0" /* 6375 */ - "specifiedTypes\0" /* 6395 */ - "applySpecifiedTypes\0" /* 6410 */ - "specifiedExpressions\0" /* 6430 */ - "processConditionalExpressionsAfterSpecifying\0" /* 6451 */ - "getConditionalExpressions\0" /* 6496 */ - "conditionalExpressionHolders\0" /* 6522 */ - "addConditionalExpressions\0" /* 6551 */ - "exitFirstLevelStatements\0" /* 6577 */ - "isInFirstLevelStatement\0" /* 6602 */ - "otherScope\0" /* 6626 */ - "preserveVacuousConditionals\0" /* 6637 */ - "mergeWith\0" /* 6665 */ - "ours\0" /* 6675 */ - "theirs\0" /* 6680 */ - "collectAbsorbedClosures\0" /* 6687 */ - "mergeWithVariableState\0" /* 6711 */ - "differingExpressionKeys\0" /* 6734 */ - "mergedExpressionTypes\0" /* 6758 */ - "findMergedCallCandidates\0" /* 6780 */ - "candidates\0" /* 6805 */ - "mergedNativeTypes\0" /* 6816 */ - "findUninformativeMergedCalls\0" /* 6834 */ - "ourExpressionTypes\0" /* 6863 */ - "theirExpressionTypes\0" /* 6882 */ - "withoutPreciseClassConstantFetches\0" /* 6903 */ - "currentConditionalExpressions\0" /* 6938 */ - "sourceConditionalExpressions\0" /* 6968 */ - "otherExpressionTypes\0" /* 6997 */ - "preserveVacuousConditionalExpressions\0" /* 7018 */ - "ourConditionalExpressions\0" /* 7056 */ - "theirConditionalExpressions\0" /* 7082 */ - "mergeSameGuardConditionalExpressions\0" /* 7110 */ - "newConditionalExpressions\0" /* 7147 */ - "existingConditionalExpressions\0" /* 7173 */ - "mergeConditionalExpressions\0" /* 7204 */ - "calledMethodScope\0" /* 7232 */ - "mergeInitializedProperties\0" /* 7250 */ - "finallyScope\0" /* 7277 */ - "originalFinallyScope\0" /* 7290 */ - "processFinallyScope\0" /* 7311 */ - "ourVariableTypeHolders\0" /* 7331 */ - "finallyVariableTypeHolders\0" /* 7354 */ - "originalVariableTypeHolders\0" /* 7381 */ - "processFinallyScopeVariableTypeHolders\0" /* 7409 */ - "closureScope\0" /* 7448 */ - "prevScope\0" /* 7461 */ - "byRefUses\0" /* 7471 */ - "processClosureScope\0" /* 7481 */ - "finalScope\0" /* 7501 */ - "processAlwaysIterableForeachScopeWithoutPollute\0" /* 7512 */ - "writableVariableNames\0" /* 7560 */ - "generalizeWith\0" /* 7582 */ - "generalizeWithVariableState\0" /* 7597 */ - "variableTypeHolders\0" /* 7625 */ - "otherVariableTypeHolders\0" /* 7645 */ - "generalizeVariableTypeHolders\0" /* 7670 */ - "flattenUnionForGeneralization\0" /* 7700 */ - "a\0" /* 7730 */ - "b\0" /* 7732 */ - "depth\0" /* 7734 */ - "generalizeType\0" /* 7740 */ - "getArrayDepth\0" /* 7755 */ - "equals\0" /* 7769 */ - "otherConditionalExpressions\0" /* 7776 */ - "compareConditionalExpressions\0" /* 7804 */ - "compareVariableTypeHolders\0" /* 7834 */ - "propertyReflection\0" /* 7861 */ - "PHPStan\\Reflection\\PropertyReflection\0" /* 7880 */ - "canAccessProperty\0" /* 7918 */ - "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7936 */ - "canReadProperty\0" /* 7982 */ - "canWriteProperty\0" /* 7998 */ - "methodReflection\0" /* 8015 */ - "PHPStan\\Reflection\\MethodReflection\0" /* 8032 */ - "canCallMethod\0" /* 8068 */ - "constantReflection\0" /* 8082 */ - "PHPStan\\Reflection\\ClassConstantReflection\0" /* 8101 */ - "canAccessConstant\0" /* 8144 */ - "classMemberReflection\0" /* 8162 */ - "PHPStan\\Reflection\\ClassMemberReflection\0" /* 8184 */ - "canAccessClassMember\0" /* 8225 */ - "debug\0" /* 8246 */ - "typeWithMethod\0" /* 8252 */ - "methodName\0" /* 8267 */ - "filterTypeWithMethod\0" /* 8278 */ - "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8299 */ - "getMethodReflection\0" /* 8343 */ - "getNakedMethod\0" /* 8363 */ - "typeWithProperty\0" /* 8378 */ - "getPropertyReflection\0" /* 8395 */ - "getInstancePropertyReflection\0" /* 8417 */ - "getStaticPropertyReflection\0" /* 8447 */ - "typeWithConstant\0" /* 8475 */ - "constantName\0" /* 8492 */ - "getConstantReflection\0" /* 8505 */ - "constantType\0" /* 8527 */ - "getConstantExplicitTypeFromConfig\0" /* 8540 */ - "getConstantTypes\0" /* 8574 */ - "getGlobalConstantType\0" /* 8591 */ - "nameString\0" /* 8613 */ - "createGlobalConstantFetches\0" /* 8624 */ - "getNativeConstantTypes\0" /* 8652 */ - "getIterableKeyType\0" /* 8675 */ - "getIterableValueType\0" /* 8694 */ - "PHPStan\\Php\\PhpVersions\0" /* 8715 */ - "getPhpVersion\0" /* 8739 */ - "getConfiguredPhpVersionRange\0" /* 8753 */ - "isOverallPhpVersionRange\0" /* 8782 */ - "PhpParser\\Node\0" /* 8807 */ - "invokeNodeCallback\0" /* 8822 */ - "collectorType\0" /* 8841 */ - "data\0" /* 8855 */ - "emitCollectedData\0" /* 8860 */ - "extensionClass\0" /* 8878 */ - "trackValueDependency\0" /* 8893 */ - "file\0" /* 8914 */ - "trackFileDependency\0" /* 8919 */ - "directory\0" /* 8939 */ - "pattern\0" /* 8949 */ - "'*'\0" /* 8957 */ - "trackDirectoryDependency\0" /* 8961 */ - "trackClassDependency"; /* 8986 */ + "isNullable\0" /* 4980 */ + "isVariadic\0" /* 4991 */ + "getFunctionType\0" /* 5002 */ + "index\0" /* 5018 */ + "getCallableParameterType\0" /* 5024 */ + "startIndex\0" /* 5049 */ + "buildVariadicArrayTypeFromCallableParameters\0" /* 5060 */ + "nativeType\0" /* 5105 */ + "inferredType\0" /* 5116 */ + "intersectButNotNever\0" /* 5129 */ + "PhpParser\\Node\\Expr\\Match_\0" /* 5150 */ + "condType\0" /* 5177 */ + "condNativeType\0" /* 5186 */ + "enterMatch\0" /* 5201 */ + "iteratee\0" /* 5212 */ + "iterateeType\0" /* 5221 */ + "nativeIterateeType\0" /* 5234 */ + "valueName\0" /* 5253 */ + "keyName\0" /* 5263 */ + "valueByRef\0" /* 5271 */ + "enterForeach\0" /* 5282 */ + "enterForeachKey\0" /* 5295 */ + "catchType\0" /* 5311 */ + "enterCatchType\0" /* 5321 */ + "isPlainWrite\0" /* 5336 */ + "enterExpressionAssign\0" /* 5349 */ + "exitExpressionAssign\0" /* 5371 */ + "isInExpressionAssign\0" /* 5392 */ + "isInWriteExpressionAssign\0" /* 5413 */ + "setAllowedUndefinedExpression\0" /* 5439 */ + "unsetAllowedUndefinedExpression\0" /* 5469 */ + "isUndefinedExpressionAllowed\0" /* 5501 */ + "certainty\0" /* 5530 */ + "intertwinedPropagatedFrom\0" /* 5540 */ + "assignVariable\0" /* 5566 */ + "overwriteExpression\0" /* 5581 */ + "scope\0" /* 5601 */ + "rootType\0" /* 5607 */ + "assignedExpr\0" /* 5616 */ + "rootVariableName\0" /* 5629 */ + "native\0" /* 5646 */ + "resolveIntertwinedAssignedType\0" /* 5653 */ + "dimFetch\0" /* 5684 */ + "PhpParser\\Node\\Expr\\ArrayDimFetch\0" /* 5693 */ + "isDimFetchPathReachable\0" /* 5727 */ + "unsetExpression\0" /* 5751 */ + "getStateType\0" /* 5767 */ + "getScopeStateType\0" /* 5780 */ + "getScopeStateNativeType\0" /* 5798 */ + "resolveScopeStateType\0" /* 5822 */ + "specifyExpressionType\0" /* 5844 */ + "openSpecificationScope\0" /* 5866 */ + "isSpecifyExpressionTypeNoop\0" /* 5889 */ + "specifyExpressionTypeInPlace\0" /* 5917 */ + "assignExpression\0" /* 5946 */ + "fetchedOnType\0" /* 5963 */ + "assignInitializedProperty\0" /* 5977 */ + "expressionToInvalidate\0" /* 6003 */ + "requireMoreCharacters\0" /* 6026 */ + "invalidatingClass\0" /* 6048 */ + "keepPropertyFetches\0" /* 6066 */ + "invalidateExpression\0" /* 6086 */ + "isPrivatePropertyOfDifferentClass\0" /* 6107 */ + "invalidateMethodsOnExpression\0" /* 6141 */ + "setExpressionCertaintyKeepingType\0" /* 6171 */ + "isComplexUnionType\0" /* 6205 */ + "addTypeToExpression\0" /* 6224 */ + "typeToRemove\0" /* 6244 */ + "removeTypeFromExpression\0" /* 6257 */ + "filterByTruthyValue\0" /* 6282 */ + "filterByFalseyValue\0" /* 6302 */ + "specifiedTypes\0" /* 6322 */ + "applySpecifiedTypes\0" /* 6337 */ + "specifiedExpressions\0" /* 6357 */ + "processConditionalExpressionsAfterSpecifying\0" /* 6378 */ + "getConditionalExpressions\0" /* 6423 */ + "conditionalExpressionHolders\0" /* 6449 */ + "addConditionalExpressions\0" /* 6478 */ + "exitFirstLevelStatements\0" /* 6504 */ + "isInFirstLevelStatement\0" /* 6529 */ + "otherScope\0" /* 6553 */ + "preserveVacuousConditionals\0" /* 6564 */ + "mergeWith\0" /* 6592 */ + "ours\0" /* 6602 */ + "theirs\0" /* 6607 */ + "collectAbsorbedClosures\0" /* 6614 */ + "mergeWithVariableState\0" /* 6638 */ + "differingExpressionKeys\0" /* 6661 */ + "mergedExpressionTypes\0" /* 6685 */ + "findMergedCallCandidates\0" /* 6707 */ + "candidates\0" /* 6732 */ + "mergedNativeTypes\0" /* 6743 */ + "findUninformativeMergedCalls\0" /* 6761 */ + "ourExpressionTypes\0" /* 6790 */ + "theirExpressionTypes\0" /* 6809 */ + "withoutPreciseClassConstantFetches\0" /* 6830 */ + "currentConditionalExpressions\0" /* 6865 */ + "sourceConditionalExpressions\0" /* 6895 */ + "otherExpressionTypes\0" /* 6924 */ + "preserveVacuousConditionalExpressions\0" /* 6945 */ + "ourConditionalExpressions\0" /* 6983 */ + "theirConditionalExpressions\0" /* 7009 */ + "mergeSameGuardConditionalExpressions\0" /* 7037 */ + "newConditionalExpressions\0" /* 7074 */ + "existingConditionalExpressions\0" /* 7100 */ + "mergeConditionalExpressions\0" /* 7131 */ + "calledMethodScope\0" /* 7159 */ + "mergeInitializedProperties\0" /* 7177 */ + "finallyScope\0" /* 7204 */ + "originalFinallyScope\0" /* 7217 */ + "processFinallyScope\0" /* 7238 */ + "ourVariableTypeHolders\0" /* 7258 */ + "finallyVariableTypeHolders\0" /* 7281 */ + "originalVariableTypeHolders\0" /* 7308 */ + "processFinallyScopeVariableTypeHolders\0" /* 7336 */ + "closureScope\0" /* 7375 */ + "prevScope\0" /* 7388 */ + "byRefUses\0" /* 7398 */ + "processClosureScope\0" /* 7408 */ + "finalScope\0" /* 7428 */ + "processAlwaysIterableForeachScopeWithoutPollute\0" /* 7439 */ + "writableVariableNames\0" /* 7487 */ + "generalizeWith\0" /* 7509 */ + "generalizeWithVariableState\0" /* 7524 */ + "variableTypeHolders\0" /* 7552 */ + "otherVariableTypeHolders\0" /* 7572 */ + "generalizeVariableTypeHolders\0" /* 7597 */ + "flattenUnionForGeneralization\0" /* 7627 */ + "a\0" /* 7657 */ + "b\0" /* 7659 */ + "depth\0" /* 7661 */ + "generalizeType\0" /* 7667 */ + "getArrayDepth\0" /* 7682 */ + "equals\0" /* 7696 */ + "otherConditionalExpressions\0" /* 7703 */ + "compareConditionalExpressions\0" /* 7731 */ + "compareVariableTypeHolders\0" /* 7761 */ + "propertyReflection\0" /* 7788 */ + "PHPStan\\Reflection\\PropertyReflection\0" /* 7807 */ + "canAccessProperty\0" /* 7845 */ + "PHPStan\\Reflection\\ExtendedPropertyReflection\0" /* 7863 */ + "canReadProperty\0" /* 7909 */ + "canWriteProperty\0" /* 7925 */ + "methodReflection\0" /* 7942 */ + "PHPStan\\Reflection\\MethodReflection\0" /* 7959 */ + "canCallMethod\0" /* 7995 */ + "constantReflection\0" /* 8009 */ + "PHPStan\\Reflection\\ClassConstantReflection\0" /* 8028 */ + "canAccessConstant\0" /* 8071 */ + "classMemberReflection\0" /* 8089 */ + "PHPStan\\Reflection\\ClassMemberReflection\0" /* 8111 */ + "canAccessClassMember\0" /* 8152 */ + "debug\0" /* 8173 */ + "typeWithMethod\0" /* 8179 */ + "methodName\0" /* 8194 */ + "filterTypeWithMethod\0" /* 8205 */ + "PHPStan\\Reflection\\ExtendedMethodReflection\0" /* 8226 */ + "getMethodReflection\0" /* 8270 */ + "getNakedMethod\0" /* 8290 */ + "typeWithProperty\0" /* 8305 */ + "getPropertyReflection\0" /* 8322 */ + "getInstancePropertyReflection\0" /* 8344 */ + "getStaticPropertyReflection\0" /* 8374 */ + "typeWithConstant\0" /* 8402 */ + "constantName\0" /* 8419 */ + "getConstantReflection\0" /* 8432 */ + "constantType\0" /* 8454 */ + "getConstantExplicitTypeFromConfig\0" /* 8467 */ + "getConstantTypes\0" /* 8501 */ + "getGlobalConstantType\0" /* 8518 */ + "nameString\0" /* 8540 */ + "createGlobalConstantFetches\0" /* 8551 */ + "getNativeConstantTypes\0" /* 8579 */ + "getIterableKeyType\0" /* 8602 */ + "getIterableValueType\0" /* 8621 */ + "PHPStan\\Php\\PhpVersions\0" /* 8642 */ + "getPhpVersion\0" /* 8666 */ + "getConfiguredPhpVersionRange\0" /* 8680 */ + "isOverallPhpVersionRange\0" /* 8709 */ + "PhpParser\\Node\0" /* 8734 */ + "invokeNodeCallback\0" /* 8749 */ + "collectorType\0" /* 8768 */ + "data\0" /* 8782 */ + "emitCollectedData\0" /* 8787 */ + "extensionClass\0" /* 8805 */ + "trackValueDependency\0" /* 8820 */ + "file\0" /* 8841 */ + "trackFileDependency\0" /* 8846 */ + "directory\0" /* 8866 */ + "pattern\0" /* 8876 */ + "'*'\0" /* 8884 */ + "trackDirectoryDependency\0" /* 8888 */ + "trackClassDependency"; /* 8913 */ inline constexpr reg::PackedArg args[] = { reg::packed(0, 0, 9), /* __construct $services */ reg::packed(40, 0, 53), /* __construct $scopeFactory */ @@ -639,7 +638,7 @@ inline constexpr reg::PackedArg args[] = { reg::packed(738, MAY_BE_STRING), /* resolveName return */ reg::packed(1520, 0, 1525), /* resolveTypeByName $name */ reg::packed(738, 0, 2751), /* resolveTypeByName return */ - reg::packed(2800, MAY_BE_ANY), /* getTypeFromValue $value */ + reg::packed(2800, 0), /* getTypeFromValue $value */ reg::packed(738, 0, 1424), /* getTypeFromValue return */ reg::packed(1707, 0, 1712), /* hasExpressionType $node */ reg::packed(738, 0, 1387), /* hasExpressionType return */ @@ -761,43 +760,43 @@ inline constexpr reg::PackedArg args[] = { reg::packed(738, 0, 523), /* enterArrowFunctionWithoutReflection return */ reg::packed(2951, 0, 4934), /* isParameterValueNullable $parameter */ reg::packed(738, MAY_BE_BOOL), /* isParameterValueNullable return */ - reg::packed(3948, MAY_BE_NULL, 4980), /* getFunctionType $type */ - reg::packed(5053, MAY_BE_BOOL), /* getFunctionType $isNullable */ - reg::packed(5064, MAY_BE_BOOL), /* getFunctionType $isVariadic */ + reg::packed(3948, 0), /* getFunctionType $type */ + reg::packed(4980, MAY_BE_BOOL), /* getFunctionType $isNullable */ + reg::packed(4991, MAY_BE_BOOL), /* getFunctionType $isVariadic */ reg::packed(738, 0, 1424), /* getFunctionType return */ reg::packed(2951, 0, 4934), /* getCallableParameterType $parameter */ reg::packed(4618, MAY_BE_ARRAY), /* getCallableParameterType $callableParameters */ - reg::packed(5091, MAY_BE_LONG), /* getCallableParameterType $index */ + reg::packed(5018, MAY_BE_LONG), /* getCallableParameterType $index */ reg::packed(738, 0, 1424), /* getCallableParameterType return */ reg::packed(4618, MAY_BE_ARRAY), /* buildVariadicArrayTypeFromCallableParameters $callableParameters */ - reg::packed(5122, MAY_BE_LONG), /* buildVariadicArrayTypeFromCallableParameters $startIndex */ + reg::packed(5049, MAY_BE_LONG), /* buildVariadicArrayTypeFromCallableParameters $startIndex */ reg::packed(738, 0, 1424), /* buildVariadicArrayTypeFromCallableParameters return */ - reg::packed(5178, 0, 1424), /* intersectButNotNever $nativeType */ - reg::packed(5189, 0, 1424), /* intersectButNotNever $inferredType */ + reg::packed(5105, 0, 1424), /* intersectButNotNever $nativeType */ + reg::packed(5116, 0, 1424), /* intersectButNotNever $inferredType */ reg::packed(738, 0, 1424), /* intersectButNotNever return */ - reg::packed(966, 0, 5223), /* enterMatch $expr */ - reg::packed(5250, 0, 1424), /* enterMatch $condType */ - reg::packed(5259, 0, 1424), /* enterMatch $condNativeType */ + reg::packed(966, 0, 5150), /* enterMatch $expr */ + reg::packed(5177, 0, 1424), /* enterMatch $condType */ + reg::packed(5186, 0, 1424), /* enterMatch $condNativeType */ reg::packed(738, 0, 523), /* enterMatch return */ reg::packed(4441, 0, 523), /* enterForeach $originalScope */ - reg::packed(5285, 0, 1712), /* enterForeach $iteratee */ - reg::packed(5294, 0, 1424), /* enterForeach $iterateeType */ - reg::packed(5307, 0, 1424), /* enterForeach $nativeIterateeType */ - reg::packed(5326, MAY_BE_STRING), /* enterForeach $valueName */ - reg::packed(5336, MAY_BE_NULL | MAY_BE_STRING), /* enterForeach $keyName */ - reg::packed(5344, MAY_BE_BOOL), /* enterForeach $valueByRef */ + reg::packed(5212, 0, 1712), /* enterForeach $iteratee */ + reg::packed(5221, 0, 1424), /* enterForeach $iterateeType */ + reg::packed(5234, 0, 1424), /* enterForeach $nativeIterateeType */ + reg::packed(5253, MAY_BE_STRING), /* enterForeach $valueName */ + reg::packed(5263, MAY_BE_NULL | MAY_BE_STRING), /* enterForeach $keyName */ + reg::packed(5271, MAY_BE_BOOL), /* enterForeach $valueByRef */ reg::packed(738, 0, 523), /* enterForeach return */ reg::packed(4441, 0, 523), /* enterForeachKey $originalScope */ - reg::packed(5285, 0, 1712), /* enterForeachKey $iteratee */ - reg::packed(5294, 0, 1424), /* enterForeachKey $iterateeType */ - reg::packed(5307, 0, 1424), /* enterForeachKey $nativeIterateeType */ - reg::packed(5336, MAY_BE_STRING), /* enterForeachKey $keyName */ + reg::packed(5212, 0, 1712), /* enterForeachKey $iteratee */ + reg::packed(5221, 0, 1424), /* enterForeachKey $iterateeType */ + reg::packed(5234, 0, 1424), /* enterForeachKey $nativeIterateeType */ + reg::packed(5263, MAY_BE_STRING), /* enterForeachKey $keyName */ reg::packed(738, 0, 523), /* enterForeachKey return */ - reg::packed(5384, 0, 1424), /* enterCatchType $catchType */ + reg::packed(5311, 0, 1424), /* enterCatchType $catchType */ reg::packed(1374, MAY_BE_NULL | MAY_BE_STRING), /* enterCatchType $variableName */ reg::packed(738, 0, 523), /* enterCatchType return */ reg::packed(966, 0, 1712), /* enterExpressionAssign $expr */ - reg::packed(5409, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterExpressionAssign $isPlainWrite */ + reg::packed(5336, MAY_BE_BOOL, reg::NoString, false, false, 402), /* enterExpressionAssign $isPlainWrite */ reg::packed(738, 0, 523), /* enterExpressionAssign return */ reg::packed(966, 0, 1712), /* exitExpressionAssign $expr */ reg::packed(738, 0, 523), /* exitExpressionAssign return */ @@ -813,22 +812,22 @@ inline constexpr reg::PackedArg args[] = { reg::packed(738, MAY_BE_BOOL), /* isUndefinedExpressionAllowed return */ reg::packed(1374, MAY_BE_STRING), /* assignVariable $variableName */ reg::packed(3948, 0, 1424), /* assignVariable $type */ - reg::packed(5178, 0, 1424), /* assignVariable $nativeType */ - reg::packed(5603, 0, 1387), /* assignVariable $certainty */ - reg::packed(5613, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* assignVariable $intertwinedPropagatedFrom */ + reg::packed(5105, 0, 1424), /* assignVariable $nativeType */ + reg::packed(5530, 0, 1387), /* assignVariable $certainty */ + reg::packed(5540, MAY_BE_ARRAY, reg::NoString, false, false, 253), /* assignVariable $intertwinedPropagatedFrom */ reg::packed(738, 0, 523), /* assignVariable return */ reg::packed(966, 0, 1712), /* overwriteExpression $expr */ reg::packed(3948, 0, 1424), /* overwriteExpression $type */ - reg::packed(5178, 0, 1424), /* overwriteExpression $nativeType */ + reg::packed(5105, 0, 1424), /* overwriteExpression $nativeType */ reg::packed(738, 0, 523), /* overwriteExpression return */ - reg::packed(5674, 0, 523), /* resolveIntertwinedAssignedType $scope */ - reg::packed(5680, 0, 1424), /* resolveIntertwinedAssignedType $rootType */ - reg::packed(5689, 0, 1712), /* resolveIntertwinedAssignedType $assignedExpr */ - reg::packed(5702, MAY_BE_STRING), /* resolveIntertwinedAssignedType $rootVariableName */ - reg::packed(5719, MAY_BE_BOOL), /* resolveIntertwinedAssignedType $native */ + reg::packed(5601, 0, 523), /* resolveIntertwinedAssignedType $scope */ + reg::packed(5607, 0, 1424), /* resolveIntertwinedAssignedType $rootType */ + reg::packed(5616, 0, 1712), /* resolveIntertwinedAssignedType $assignedExpr */ + reg::packed(5629, MAY_BE_STRING), /* resolveIntertwinedAssignedType $rootVariableName */ + reg::packed(5646, MAY_BE_BOOL), /* resolveIntertwinedAssignedType $native */ reg::packed(738, 0, 1424), /* resolveIntertwinedAssignedType return */ - reg::packed(5674, 0, 523), /* isDimFetchPathReachable $scope */ - reg::packed(5757, 0, 5766), /* isDimFetchPathReachable $dimFetch */ + reg::packed(5601, 0, 523), /* isDimFetchPathReachable $scope */ + reg::packed(5684, 0, 5693), /* isDimFetchPathReachable $dimFetch */ reg::packed(738, MAY_BE_BOOL), /* isDimFetchPathReachable return */ reg::packed(966, 0, 1712), /* unsetExpression $expr */ reg::packed(738, 0, 523), /* unsetExpression return */ @@ -839,12 +838,12 @@ inline constexpr reg::PackedArg args[] = { reg::packed(966, 0, 1712), /* getScopeStateNativeType $expr */ reg::packed(738, 0, 1424), /* getScopeStateNativeType return */ reg::packed(966, 0, 1712), /* resolveScopeStateType $expr */ - reg::packed(5719, MAY_BE_BOOL), /* resolveScopeStateType $native */ + reg::packed(5646, MAY_BE_BOOL), /* resolveScopeStateType $native */ reg::packed(738, 0, 1424), /* resolveScopeStateType return */ reg::packed(966, 0, 1712), /* specifyExpressionType $expr */ reg::packed(3948, 0, 1424), /* specifyExpressionType $type */ - reg::packed(5178, 0, 1424), /* specifyExpressionType $nativeType */ - reg::packed(5603, 0, 1387), /* specifyExpressionType $certainty */ + reg::packed(5105, 0, 1424), /* specifyExpressionType $nativeType */ + reg::packed(5530, 0, 1387), /* specifyExpressionType $certainty */ reg::packed(738, 0, 523), /* specifyExpressionType return */ reg::packed(738, 0, 523), /* openSpecificationScope return */ reg::packed(966, 0, 1712), /* isSpecifyExpressionTypeNoop $expr */ @@ -852,28 +851,28 @@ inline constexpr reg::PackedArg args[] = { reg::packed(738, MAY_BE_BOOL), /* isSpecifyExpressionTypeNoop return */ reg::packed(966, 0, 1712), /* specifyExpressionTypeInPlace $expr */ reg::packed(3948, 0, 1424), /* specifyExpressionTypeInPlace $type */ - reg::packed(5178, 0, 1424), /* specifyExpressionTypeInPlace $nativeType */ - reg::packed(5603, 0, 1387), /* specifyExpressionTypeInPlace $certainty */ + reg::packed(5105, 0, 1424), /* specifyExpressionTypeInPlace $nativeType */ + reg::packed(5530, 0, 1387), /* specifyExpressionTypeInPlace $certainty */ reg::packed(738, MAY_BE_VOID), /* specifyExpressionTypeInPlace return */ reg::packed(966, 0, 1712), /* assignExpression $expr */ reg::packed(3948, 0, 1424), /* assignExpression $type */ - reg::packed(5178, 0, 1424), /* assignExpression $nativeType */ + reg::packed(5105, 0, 1424), /* assignExpression $nativeType */ reg::packed(738, 0, 523), /* assignExpression return */ - reg::packed(6036, 0, 1424), /* assignInitializedProperty $fetchedOnType */ + reg::packed(5963, 0, 1424), /* assignInitializedProperty $fetchedOnType */ reg::packed(3802, MAY_BE_STRING), /* assignInitializedProperty $propertyName */ reg::packed(738, 0, 523), /* assignInitializedProperty return */ - reg::packed(6076, 0, 1712), /* invalidateExpression $expressionToInvalidate */ - reg::packed(6099, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $requireMoreCharacters */ - reg::packed(6121, MAY_BE_NULL, 1065, false, false, 222), /* invalidateExpression $invalidatingClass */ - reg::packed(6139, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $keepPropertyFetches */ + reg::packed(6003, 0, 1712), /* invalidateExpression $expressionToInvalidate */ + reg::packed(6026, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $requireMoreCharacters */ + reg::packed(6048, MAY_BE_NULL, 1065, false, false, 222), /* invalidateExpression $invalidatingClass */ + reg::packed(6066, MAY_BE_BOOL, reg::NoString, false, false, 148), /* invalidateExpression $keepPropertyFetches */ reg::packed(738, 0, 523), /* invalidateExpression return */ reg::packed(966, 0, 1712), /* isPrivatePropertyOfDifferentClass $expr */ - reg::packed(6121, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */ + reg::packed(6048, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */ reg::packed(738, MAY_BE_BOOL), /* isPrivatePropertyOfDifferentClass return */ - reg::packed(6076, 0, 1712), /* invalidateMethodsOnExpression $expressionToInvalidate */ + reg::packed(6003, 0, 1712), /* invalidateMethodsOnExpression $expressionToInvalidate */ reg::packed(738, 0, 523), /* invalidateMethodsOnExpression return */ reg::packed(966, 0, 1712), /* setExpressionCertaintyKeepingType $expr */ - reg::packed(5603, 0, 1387), /* setExpressionCertaintyKeepingType $certainty */ + reg::packed(5530, 0, 1387), /* setExpressionCertaintyKeepingType $certainty */ reg::packed(738, 0, 523), /* setExpressionCertaintyKeepingType return */ reg::packed(3948, 0, 1424), /* isComplexUnionType $type */ reg::packed(738, MAY_BE_BOOL), /* isComplexUnionType return */ @@ -881,158 +880,158 @@ inline constexpr reg::PackedArg args[] = { reg::packed(3948, 0, 1424), /* addTypeToExpression $type */ reg::packed(738, 0, 523), /* addTypeToExpression return */ reg::packed(966, 0, 1712), /* removeTypeFromExpression $expr */ - reg::packed(6317, 0, 1424), /* removeTypeFromExpression $typeToRemove */ + reg::packed(6244, 0, 1424), /* removeTypeFromExpression $typeToRemove */ reg::packed(738, 0, 523), /* removeTypeFromExpression return */ reg::packed(966, 0, 1712), /* filterByTruthyValue $expr */ reg::packed(738, 0, 523), /* filterByTruthyValue return */ reg::packed(966, 0, 1712), /* filterByFalseyValue $expr */ reg::packed(738, 0, 523), /* filterByFalseyValue return */ - reg::packed(6395, 0, 2035), /* applySpecifiedTypes $specifiedTypes */ + reg::packed(6322, 0, 2035), /* applySpecifiedTypes $specifiedTypes */ reg::packed(738, 0, 523), /* applySpecifiedTypes return */ - reg::packed(6430, MAY_BE_ARRAY), /* processConditionalExpressionsAfterSpecifying $specifiedExpressions */ + reg::packed(6357, MAY_BE_ARRAY), /* processConditionalExpressionsAfterSpecifying $specifiedExpressions */ reg::packed(738, 0, 523), /* processConditionalExpressionsAfterSpecifying return */ reg::packed(738, MAY_BE_ARRAY), /* getConditionalExpressions return */ reg::packed(1883, MAY_BE_STRING), /* addConditionalExpressions $exprString */ - reg::packed(6522, MAY_BE_ARRAY), /* addConditionalExpressions $conditionalExpressionHolders */ + reg::packed(6449, MAY_BE_ARRAY), /* addConditionalExpressions $conditionalExpressionHolders */ reg::packed(738, 0, 523), /* addConditionalExpressions return */ reg::packed(738, 0, 523), /* exitFirstLevelStatements return */ reg::packed(738, MAY_BE_BOOL), /* isInFirstLevelStatement return */ - reg::packed(6626, MAY_BE_NULL, 523), /* mergeWith $otherScope */ - reg::packed(6637, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWith $preserveVacuousConditionals */ + reg::packed(6553, MAY_BE_NULL, 523), /* mergeWith $otherScope */ + reg::packed(6564, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWith $preserveVacuousConditionals */ reg::packed(738, 0, 523), /* mergeWith return */ - reg::packed(6675, 0, 523), /* collectAbsorbedClosures $ours */ - reg::packed(6680, 0, 523), /* collectAbsorbedClosures $theirs */ + reg::packed(6602, 0, 523), /* collectAbsorbedClosures $ours */ + reg::packed(6607, 0, 523), /* collectAbsorbedClosures $theirs */ reg::packed(738, MAY_BE_NULL, 672), /* collectAbsorbedClosures return */ - reg::packed(6626, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */ - reg::packed(6637, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWithVariableState $preserveVacuousConditionals */ + reg::packed(6553, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */ + reg::packed(6564, MAY_BE_BOOL, reg::NoString, false, false, 148), /* mergeWithVariableState $preserveVacuousConditionals */ reg::packed(738, 0, 523), /* mergeWithVariableState return */ - reg::packed(6734, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */ - reg::packed(6758, MAY_BE_ARRAY), /* findMergedCallCandidates $mergedExpressionTypes */ + reg::packed(6661, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */ + reg::packed(6685, MAY_BE_ARRAY), /* findMergedCallCandidates $mergedExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* findMergedCallCandidates return */ - reg::packed(6805, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */ - reg::packed(6816, MAY_BE_ARRAY), /* findUninformativeMergedCalls $mergedNativeTypes */ + reg::packed(6732, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */ + reg::packed(6743, MAY_BE_ARRAY), /* findUninformativeMergedCalls $mergedNativeTypes */ reg::packed(738, MAY_BE_ARRAY), /* findUninformativeMergedCalls return */ - reg::packed(6734, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */ - reg::packed(6863, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */ - reg::packed(6882, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */ + reg::packed(6661, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */ + reg::packed(6790, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */ + reg::packed(6809, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $theirExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches return */ - reg::packed(6938, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */ - reg::packed(6968, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */ - reg::packed(6997, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */ + reg::packed(6865, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */ + reg::packed(6895, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */ + reg::packed(6924, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $otherExpressionTypes */ reg::packed(738, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions return */ - reg::packed(6938, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */ - reg::packed(7056, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */ - reg::packed(7082, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */ + reg::packed(6865, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */ + reg::packed(6983, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */ + reg::packed(7009, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $theirConditionalExpressions */ reg::packed(738, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions return */ - reg::packed(7147, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */ - reg::packed(7173, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */ + reg::packed(7074, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */ + reg::packed(7100, MAY_BE_ARRAY), /* mergeConditionalExpressions $existingConditionalExpressions */ reg::packed(738, MAY_BE_ARRAY), /* mergeConditionalExpressions return */ - reg::packed(7232, 0, 523), /* mergeInitializedProperties $calledMethodScope */ + reg::packed(7159, 0, 523), /* mergeInitializedProperties $calledMethodScope */ reg::packed(738, 0, 523), /* mergeInitializedProperties return */ - reg::packed(7277, 0, 523), /* processFinallyScope $finallyScope */ - reg::packed(7290, 0, 523), /* processFinallyScope $originalFinallyScope */ + reg::packed(7204, 0, 523), /* processFinallyScope $finallyScope */ + reg::packed(7217, 0, 523), /* processFinallyScope $originalFinallyScope */ reg::packed(738, 0, 523), /* processFinallyScope return */ - reg::packed(7331, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */ - reg::packed(7354, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */ - reg::packed(7381, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */ + reg::packed(7258, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $ourVariableTypeHolders */ + reg::packed(7281, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $finallyVariableTypeHolders */ + reg::packed(7308, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders $originalVariableTypeHolders */ reg::packed(738, MAY_BE_ARRAY), /* processFinallyScopeVariableTypeHolders return */ - reg::packed(7448, 0, 523), /* processClosureScope $closureScope */ - reg::packed(7461, MAY_BE_NULL, 523), /* processClosureScope $prevScope */ - reg::packed(7471, MAY_BE_ARRAY), /* processClosureScope $byRefUses */ + reg::packed(7375, 0, 523), /* processClosureScope $closureScope */ + reg::packed(7388, MAY_BE_NULL, 523), /* processClosureScope $prevScope */ + reg::packed(7398, MAY_BE_ARRAY), /* processClosureScope $byRefUses */ reg::packed(738, 0, 523), /* processClosureScope return */ - reg::packed(7501, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */ + reg::packed(7428, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */ reg::packed(738, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute return */ - reg::packed(6626, 0, 523), /* generalizeWith $otherScope */ - reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */ + reg::packed(6553, 0, 523), /* generalizeWith $otherScope */ + reg::packed(7487, MAY_BE_NULL | MAY_BE_ARRAY, reg::NoString, false, false, 222), /* generalizeWith $writableVariableNames */ reg::packed(738, 0, 523), /* generalizeWith return */ - reg::packed(6626, 0, 523), /* generalizeWithVariableState $otherScope */ - reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */ + reg::packed(6553, 0, 523), /* generalizeWithVariableState $otherScope */ + reg::packed(7487, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeWithVariableState $writableVariableNames */ reg::packed(738, 0, 523), /* generalizeWithVariableState return */ - reg::packed(7625, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */ - reg::packed(7645, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */ - reg::packed(7560, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */ + reg::packed(7552, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $variableTypeHolders */ + reg::packed(7572, MAY_BE_ARRAY), /* generalizeVariableTypeHolders $otherVariableTypeHolders */ + reg::packed(7487, MAY_BE_NULL | MAY_BE_ARRAY), /* generalizeVariableTypeHolders $writableVariableNames */ reg::packed(738, MAY_BE_ARRAY), /* generalizeVariableTypeHolders return */ reg::packed(3948, 0, 1424), /* flattenUnionForGeneralization $type */ reg::packed(738, MAY_BE_ARRAY), /* flattenUnionForGeneralization return */ - reg::packed(7730, 0, 1424), /* generalizeType $a */ - reg::packed(7732, 0, 1424), /* generalizeType $b */ - reg::packed(7734, MAY_BE_LONG), /* generalizeType $depth */ + reg::packed(7657, 0, 1424), /* generalizeType $a */ + reg::packed(7659, 0, 1424), /* generalizeType $b */ + reg::packed(7661, MAY_BE_LONG), /* generalizeType $depth */ reg::packed(738, 0, 1424), /* generalizeType return */ reg::packed(3948, 0, 1424), /* getArrayDepth $type */ reg::packed(738, MAY_BE_LONG), /* getArrayDepth return */ - reg::packed(6626, 0, 523), /* equals $otherScope */ + reg::packed(6553, 0, 523), /* equals $otherScope */ reg::packed(738, MAY_BE_BOOL), /* equals return */ reg::packed(278, MAY_BE_ARRAY), /* compareConditionalExpressions $conditionalExpressions */ - reg::packed(7776, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */ + reg::packed(7703, MAY_BE_ARRAY), /* compareConditionalExpressions $otherConditionalExpressions */ reg::packed(738, MAY_BE_BOOL), /* compareConditionalExpressions return */ - reg::packed(7625, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */ - reg::packed(7645, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */ + reg::packed(7552, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */ + reg::packed(7572, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */ reg::packed(738, MAY_BE_BOOL), /* compareVariableTypeHolders return */ - reg::packed(7861, 0, 7880), /* canAccessProperty $propertyReflection */ + reg::packed(7788, 0, 7807), /* canAccessProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessProperty return */ - reg::packed(7861, 0, 7936), /* canReadProperty $propertyReflection */ + reg::packed(7788, 0, 7863), /* canReadProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canReadProperty return */ - reg::packed(7861, 0, 7936), /* canWriteProperty $propertyReflection */ + reg::packed(7788, 0, 7863), /* canWriteProperty $propertyReflection */ reg::packed(738, MAY_BE_BOOL), /* canWriteProperty return */ - reg::packed(8015, 0, 8032), /* canCallMethod $methodReflection */ + reg::packed(7942, 0, 7959), /* canCallMethod $methodReflection */ reg::packed(738, MAY_BE_BOOL), /* canCallMethod return */ - reg::packed(8082, 0, 8101), /* canAccessConstant $constantReflection */ + reg::packed(8009, 0, 8028), /* canAccessConstant $constantReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessConstant return */ - reg::packed(8162, 0, 8184), /* canAccessClassMember $classMemberReflection */ + reg::packed(8089, 0, 8111), /* canAccessClassMember $classMemberReflection */ reg::packed(738, MAY_BE_BOOL), /* canAccessClassMember return */ reg::packed(738, MAY_BE_ARRAY), /* debug return */ - reg::packed(8252, 0, 1424), /* filterTypeWithMethod $typeWithMethod */ - reg::packed(8267, MAY_BE_STRING), /* filterTypeWithMethod $methodName */ + reg::packed(8179, 0, 1424), /* filterTypeWithMethod $typeWithMethod */ + reg::packed(8194, MAY_BE_STRING), /* filterTypeWithMethod $methodName */ reg::packed(738, MAY_BE_NULL, 1424), /* filterTypeWithMethod return */ - reg::packed(8252, 0, 1424), /* getMethodReflection $typeWithMethod */ - reg::packed(8267, MAY_BE_STRING), /* getMethodReflection $methodName */ - reg::packed(738, MAY_BE_NULL, 8299), /* getMethodReflection return */ - reg::packed(8252, 0, 1424), /* getNakedMethod $typeWithMethod */ - reg::packed(8267, MAY_BE_STRING), /* getNakedMethod $methodName */ - reg::packed(738, MAY_BE_NULL, 8299), /* getNakedMethod return */ - reg::packed(8378, 0, 1424), /* getPropertyReflection $typeWithProperty */ + reg::packed(8179, 0, 1424), /* getMethodReflection $typeWithMethod */ + reg::packed(8194, MAY_BE_STRING), /* getMethodReflection $methodName */ + reg::packed(738, MAY_BE_NULL, 8226), /* getMethodReflection return */ + reg::packed(8179, 0, 1424), /* getNakedMethod $typeWithMethod */ + reg::packed(8194, MAY_BE_STRING), /* getNakedMethod $methodName */ + reg::packed(738, MAY_BE_NULL, 8226), /* getNakedMethod return */ + reg::packed(8305, 0, 1424), /* getPropertyReflection $typeWithProperty */ reg::packed(3802, MAY_BE_STRING), /* getPropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7936), /* getPropertyReflection return */ - reg::packed(8378, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */ + reg::packed(738, MAY_BE_NULL, 7863), /* getPropertyReflection return */ + reg::packed(8305, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */ reg::packed(3802, MAY_BE_STRING), /* getInstancePropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7936), /* getInstancePropertyReflection return */ - reg::packed(8378, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */ + reg::packed(738, MAY_BE_NULL, 7863), /* getInstancePropertyReflection return */ + reg::packed(8305, 0, 1424), /* getStaticPropertyReflection $typeWithProperty */ reg::packed(3802, MAY_BE_STRING), /* getStaticPropertyReflection $propertyName */ - reg::packed(738, MAY_BE_NULL, 7936), /* getStaticPropertyReflection return */ - reg::packed(8475, 0, 1424), /* getConstantReflection $typeWithConstant */ - reg::packed(8492, MAY_BE_STRING), /* getConstantReflection $constantName */ - reg::packed(738, MAY_BE_NULL, 8101), /* getConstantReflection return */ - reg::packed(8492, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */ - reg::packed(8527, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */ + reg::packed(738, MAY_BE_NULL, 7863), /* getStaticPropertyReflection return */ + reg::packed(8402, 0, 1424), /* getConstantReflection $typeWithConstant */ + reg::packed(8419, MAY_BE_STRING), /* getConstantReflection $constantName */ + reg::packed(738, MAY_BE_NULL, 8028), /* getConstantReflection return */ + reg::packed(8419, MAY_BE_STRING), /* getConstantExplicitTypeFromConfig $constantName */ + reg::packed(8454, 0, 1424), /* getConstantExplicitTypeFromConfig $constantType */ reg::packed(738, 0, 1424), /* getConstantExplicitTypeFromConfig return */ reg::packed(738, MAY_BE_ARRAY), /* getConstantTypes return */ reg::packed(1520, 0, 1525), /* getGlobalConstantType $name */ reg::packed(738, MAY_BE_NULL, 1424), /* getGlobalConstantType return */ reg::packed(1520, 0, 1525), /* createGlobalConstantFetches $name */ - reg::packed(8613, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */ + reg::packed(8540, MAY_BE_STRING), /* createGlobalConstantFetches $nameString */ reg::packed(227, MAY_BE_NULL | MAY_BE_STRING), /* createGlobalConstantFetches $namespace */ reg::packed(738, MAY_BE_ARRAY), /* createGlobalConstantFetches return */ reg::packed(738, MAY_BE_ARRAY), /* getNativeConstantTypes return */ - reg::packed(5285, 0, 1424), /* getIterableKeyType $iteratee */ + reg::packed(5212, 0, 1424), /* getIterableKeyType $iteratee */ reg::packed(738, 0, 1424), /* getIterableKeyType return */ - reg::packed(5285, 0, 1424), /* getIterableValueType $iteratee */ + reg::packed(5212, 0, 1424), /* getIterableValueType $iteratee */ reg::packed(738, 0, 1424), /* getIterableValueType return */ - reg::packed(738, 0, 8715), /* getPhpVersion return */ + reg::packed(738, 0, 8642), /* getPhpVersion return */ reg::packed(738, MAY_BE_NULL, 1424), /* getConfiguredPhpVersionRange return */ reg::packed(3948, 0, 1424), /* isOverallPhpVersionRange $type */ reg::packed(738, MAY_BE_BOOL), /* isOverallPhpVersionRange return */ - reg::packed(1707, 0, 8807), /* invokeNodeCallback $node */ + reg::packed(1707, 0, 8734), /* invokeNodeCallback $node */ reg::packed(738, MAY_BE_VOID), /* invokeNodeCallback return */ - reg::packed(8841, MAY_BE_STRING), /* emitCollectedData $collectorType */ - reg::packed(8855, MAY_BE_ANY), /* emitCollectedData $data */ + reg::packed(8768, MAY_BE_STRING), /* emitCollectedData $collectorType */ + reg::packed(8782, MAY_BE_ANY), /* emitCollectedData $data */ reg::packed(738, MAY_BE_VOID), /* emitCollectedData return */ - reg::packed(8878, MAY_BE_STRING), /* trackValueDependency $extensionClass */ + reg::packed(8805, MAY_BE_STRING), /* trackValueDependency $extensionClass */ reg::packed(2540, MAY_BE_STRING), /* trackValueDependency $key */ reg::packed(738, MAY_BE_VOID), /* trackValueDependency return */ - reg::packed(8914, MAY_BE_STRING), /* trackFileDependency $file */ + reg::packed(8841, MAY_BE_STRING), /* trackFileDependency $file */ reg::packed(738, MAY_BE_VOID), /* trackFileDependency return */ - reg::packed(8939, MAY_BE_STRING), /* trackDirectoryDependency $directory */ - reg::packed(8949, MAY_BE_STRING, reg::NoString, false, false, 8957), /* trackDirectoryDependency $pattern */ + reg::packed(8866, MAY_BE_STRING), /* trackDirectoryDependency $directory */ + reg::packed(8876, MAY_BE_STRING, reg::NoString, false, false, 8884), /* trackDirectoryDependency $pattern */ reg::packed(738, MAY_BE_VOID), /* trackDirectoryDependency return */ reg::packed(3051, MAY_BE_STRING), /* trackClassDependency $className */ reg::packed(738, MAY_BE_VOID), /* trackClassDependency return */ @@ -1145,104 +1144,104 @@ inline constexpr sigtab::Sig invalidateStaticExpressions = { { 4803 /* invalidat inline constexpr sigtab::Sig enterArrowFunction = { { 4879 /* enterArrowFunction */, 2, 250, 3, 253, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig enterArrowFunctionWithoutReflection = { { 4898 /* enterArrowFunctionWithoutReflection */, 3, 254, 3, 257, ZEND_ACC_PUBLIC } }; inline constexpr sigtab::Sig isParameterValueNullable = { { 4955 /* isParameterValueNullable */, 1, 258, 1, 259, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getFunctionType = { { 5075 /* getFunctionType */, 3, 260, 3, 263, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getCallableParameterType = { { 5097 /* getCallableParameterType */, 3, 264, 3, 267, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig buildVariadicArrayTypeFromCallableParameters = { { 5133 /* buildVariadicArrayTypeFromCallableParameters */, 2, 268, 2, 270, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig intersectButNotNever = { { 5202 /* intersectButNotNever */, 2, 271, 2, 273, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig enterMatch = { { 5274 /* enterMatch */, 3, 274, 3, 277, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterForeach = { { 5355 /* enterForeach */, 7, 278, 7, 285, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterForeachKey = { { 5368 /* enterForeachKey */, 5, 286, 5, 291, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterCatchType = { { 5394 /* enterCatchType */, 2, 292, 2, 294, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig enterExpressionAssign = { { 5422 /* enterExpressionAssign */, 1, 295, 2, 297, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig exitExpressionAssign = { { 5444 /* exitExpressionAssign */, 1, 298, 1, 299, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInExpressionAssign = { { 5465 /* isInExpressionAssign */, 1, 300, 1, 301, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInWriteExpressionAssign = { { 5486 /* isInWriteExpressionAssign */, 1, 302, 1, 303, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig setAllowedUndefinedExpression = { { 5512 /* setAllowedUndefinedExpression */, 1, 304, 1, 305, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig unsetAllowedUndefinedExpression = { { 5542 /* unsetAllowedUndefinedExpression */, 1, 306, 1, 307, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isUndefinedExpressionAllowed = { { 5574 /* isUndefinedExpressionAllowed */, 1, 308, 1, 309, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig assignVariable = { { 5639 /* assignVariable */, 4, 310, 5, 315, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig overwriteExpression = { { 5654 /* overwriteExpression */, 3, 316, 3, 319, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveIntertwinedAssignedType = { { 5726 /* resolveIntertwinedAssignedType */, 5, 320, 5, 325, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isDimFetchPathReachable = { { 5800 /* isDimFetchPathReachable */, 2, 326, 2, 328, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig unsetExpression = { { 5824 /* unsetExpression */, 1, 329, 1, 330, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getStateType = { { 5840 /* getStateType */, 1, 331, 1, 332, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getScopeStateType = { { 5853 /* getScopeStateType */, 1, 333, 1, 334, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getScopeStateNativeType = { { 5871 /* getScopeStateNativeType */, 1, 335, 1, 336, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig resolveScopeStateType = { { 5895 /* resolveScopeStateType */, 2, 337, 2, 339, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig specifyExpressionType = { { 5917 /* specifyExpressionType */, 4, 340, 4, 344, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig openSpecificationScope = { { 5939 /* openSpecificationScope */, 0, 345, 0, 345, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isSpecifyExpressionTypeNoop = { { 5962 /* isSpecifyExpressionTypeNoop */, 2, 346, 2, 348, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig specifyExpressionTypeInPlace = { { 5990 /* specifyExpressionTypeInPlace */, 4, 349, 4, 353, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig assignExpression = { { 6019 /* assignExpression */, 3, 354, 3, 357, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig assignInitializedProperty = { { 6050 /* assignInitializedProperty */, 2, 358, 2, 360, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig invalidateExpression = { { 6159 /* invalidateExpression */, 1, 361, 4, 365, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isPrivatePropertyOfDifferentClass = { { 6180 /* isPrivatePropertyOfDifferentClass */, 2, 366, 2, 368, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig invalidateMethodsOnExpression = { { 6214 /* invalidateMethodsOnExpression */, 1, 369, 1, 370, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig setExpressionCertaintyKeepingType = { { 6244 /* setExpressionCertaintyKeepingType */, 2, 371, 2, 373, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isComplexUnionType = { { 6278 /* isComplexUnionType */, 1, 374, 1, 375, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig addTypeToExpression = { { 6297 /* addTypeToExpression */, 2, 376, 2, 378, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig removeTypeFromExpression = { { 6330 /* removeTypeFromExpression */, 2, 379, 2, 381, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterByTruthyValue = { { 6355 /* filterByTruthyValue */, 1, 382, 1, 383, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterByFalseyValue = { { 6375 /* filterByFalseyValue */, 1, 384, 1, 385, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig applySpecifiedTypes = { { 6410 /* applySpecifiedTypes */, 1, 386, 1, 387, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processConditionalExpressionsAfterSpecifying = { { 6451 /* processConditionalExpressionsAfterSpecifying */, 1, 388, 1, 389, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getConditionalExpressions = { { 6496 /* getConditionalExpressions */, 0, 390, 0, 390, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig addConditionalExpressions = { { 6551 /* addConditionalExpressions */, 2, 391, 2, 393, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig exitFirstLevelStatements = { { 6577 /* exitFirstLevelStatements */, 0, 394, 0, 394, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig isInFirstLevelStatement = { { 6602 /* isInFirstLevelStatement */, 0, 395, 0, 395, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig mergeWith = { { 6665 /* mergeWith */, 1, 396, 2, 398, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig collectAbsorbedClosures = { { 6687 /* collectAbsorbedClosures */, 2, 399, 2, 401, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeWithVariableState = { { 6711 /* mergeWithVariableState */, 1, 402, 2, 404, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig findMergedCallCandidates = { { 6780 /* findMergedCallCandidates */, 2, 405, 2, 407, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig findUninformativeMergedCalls = { { 6834 /* findUninformativeMergedCalls */, 2, 408, 2, 410, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6903 /* withoutPreciseClassConstantFetches */, 3, 411, 3, 414, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 7018 /* preserveVacuousConditionalExpressions */, 3, 415, 3, 418, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 7110 /* mergeSameGuardConditionalExpressions */, 3, 419, 3, 422, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeConditionalExpressions = { { 7204 /* mergeConditionalExpressions */, 2, 423, 2, 425, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig mergeInitializedProperties = { { 7250 /* mergeInitializedProperties */, 1, 426, 1, 427, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processFinallyScope = { { 7311 /* processFinallyScope */, 2, 428, 2, 430, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7409 /* processFinallyScopeVariableTypeHolders */, 3, 431, 3, 434, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig processClosureScope = { { 7481 /* processClosureScope */, 3, 435, 3, 438, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7512 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 439, 1, 440, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig generalizeWith = { { 7582 /* generalizeWith */, 1, 441, 2, 443, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig generalizeWithVariableState = { { 7597 /* generalizeWithVariableState */, 2, 444, 2, 446, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7670 /* generalizeVariableTypeHolders */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7700 /* flattenUnionForGeneralization */, 1, 451, 1, 452, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig generalizeType = { { 7740 /* generalizeType */, 3, 453, 3, 456, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getArrayDepth = { { 7755 /* getArrayDepth */, 1, 457, 1, 458, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig equals = { { 7769 /* equals */, 1, 459, 1, 460, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig compareConditionalExpressions = { { 7804 /* compareConditionalExpressions */, 2, 461, 2, 463, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7834 /* compareVariableTypeHolders */, 2, 464, 2, 466, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig canAccessProperty = { { 7918 /* canAccessProperty */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canReadProperty = { { 7982 /* canReadProperty */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canWriteProperty = { { 7998 /* canWriteProperty */, 1, 471, 1, 472, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canCallMethod = { { 8068 /* canCallMethod */, 1, 473, 1, 474, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessConstant = { { 8144 /* canAccessConstant */, 1, 475, 1, 476, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig canAccessClassMember = { { 8225 /* canAccessClassMember */, 1, 477, 1, 478, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig debug = { { 8246 /* debug */, 0, 479, 0, 479, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig filterTypeWithMethod = { { 8278 /* filterTypeWithMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getMethodReflection = { { 8343 /* getMethodReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getNakedMethod = { { 8363 /* getNakedMethod */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPropertyReflection = { { 8395 /* getPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8417 /* getInstancePropertyReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8447 /* getStaticPropertyReflection */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantReflection = { { 8505 /* getConstantReflection */, 2, 498, 2, 500, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8540 /* getConstantExplicitTypeFromConfig */, 2, 501, 2, 503, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConstantTypes = { { 8574 /* getConstantTypes */, 0, 504, 0, 504, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getGlobalConstantType = { { 8591 /* getGlobalConstantType */, 1, 505, 1, 506, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8624 /* createGlobalConstantFetches */, 3, 507, 3, 510, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; -inline constexpr sigtab::Sig getNativeConstantTypes = { { 8652 /* getNativeConstantTypes */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig getIterableKeyType = { { 8675 /* getIterableKeyType */, 1, 512, 1, 513, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getIterableValueType = { { 8694 /* getIterableValueType */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getPhpVersion = { { 8739 /* getPhpVersion */, 0, 516, 0, 516, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8753 /* getConfiguredPhpVersionRange */, 0, 517, 0, 517, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8782 /* isOverallPhpVersionRange */, 1, 518, 1, 519, ZEND_ACC_PRIVATE } }; -inline constexpr sigtab::Sig invokeNodeCallback = { { 8822 /* invokeNodeCallback */, 1, 520, 1, 521, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig emitCollectedData = { { 8860 /* emitCollectedData */, 2, 522, 2, 524, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackValueDependency = { { 8893 /* trackValueDependency */, 2, 525, 2, 527, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackFileDependency = { { 8919 /* trackFileDependency */, 1, 528, 1, 529, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackDirectoryDependency = { { 8961 /* trackDirectoryDependency */, 1, 530, 2, 532, ZEND_ACC_PUBLIC } }; -inline constexpr sigtab::Sig trackClassDependency = { { 8986 /* trackClassDependency */, 1, 533, 1, 534, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getFunctionType = { { 5002 /* getFunctionType */, 3, 260, 3, 263, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getCallableParameterType = { { 5024 /* getCallableParameterType */, 3, 264, 3, 267, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig buildVariadicArrayTypeFromCallableParameters = { { 5060 /* buildVariadicArrayTypeFromCallableParameters */, 2, 268, 2, 270, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig intersectButNotNever = { { 5129 /* intersectButNotNever */, 2, 271, 2, 273, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig enterMatch = { { 5201 /* enterMatch */, 3, 274, 3, 277, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterForeach = { { 5282 /* enterForeach */, 7, 278, 7, 285, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterForeachKey = { { 5295 /* enterForeachKey */, 5, 286, 5, 291, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterCatchType = { { 5321 /* enterCatchType */, 2, 292, 2, 294, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig enterExpressionAssign = { { 5349 /* enterExpressionAssign */, 1, 295, 2, 297, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig exitExpressionAssign = { { 5371 /* exitExpressionAssign */, 1, 298, 1, 299, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInExpressionAssign = { { 5392 /* isInExpressionAssign */, 1, 300, 1, 301, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInWriteExpressionAssign = { { 5413 /* isInWriteExpressionAssign */, 1, 302, 1, 303, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig setAllowedUndefinedExpression = { { 5439 /* setAllowedUndefinedExpression */, 1, 304, 1, 305, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig unsetAllowedUndefinedExpression = { { 5469 /* unsetAllowedUndefinedExpression */, 1, 306, 1, 307, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isUndefinedExpressionAllowed = { { 5501 /* isUndefinedExpressionAllowed */, 1, 308, 1, 309, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig assignVariable = { { 5566 /* assignVariable */, 4, 310, 5, 315, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig overwriteExpression = { { 5581 /* overwriteExpression */, 3, 316, 3, 319, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveIntertwinedAssignedType = { { 5653 /* resolveIntertwinedAssignedType */, 5, 320, 5, 325, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isDimFetchPathReachable = { { 5727 /* isDimFetchPathReachable */, 2, 326, 2, 328, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig unsetExpression = { { 5751 /* unsetExpression */, 1, 329, 1, 330, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getStateType = { { 5767 /* getStateType */, 1, 331, 1, 332, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getScopeStateType = { { 5780 /* getScopeStateType */, 1, 333, 1, 334, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getScopeStateNativeType = { { 5798 /* getScopeStateNativeType */, 1, 335, 1, 336, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig resolveScopeStateType = { { 5822 /* resolveScopeStateType */, 2, 337, 2, 339, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig specifyExpressionType = { { 5844 /* specifyExpressionType */, 4, 340, 4, 344, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig openSpecificationScope = { { 5866 /* openSpecificationScope */, 0, 345, 0, 345, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isSpecifyExpressionTypeNoop = { { 5889 /* isSpecifyExpressionTypeNoop */, 2, 346, 2, 348, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig specifyExpressionTypeInPlace = { { 5917 /* specifyExpressionTypeInPlace */, 4, 349, 4, 353, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig assignExpression = { { 5946 /* assignExpression */, 3, 354, 3, 357, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig assignInitializedProperty = { { 5977 /* assignInitializedProperty */, 2, 358, 2, 360, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig invalidateExpression = { { 6086 /* invalidateExpression */, 1, 361, 4, 365, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isPrivatePropertyOfDifferentClass = { { 6107 /* isPrivatePropertyOfDifferentClass */, 2, 366, 2, 368, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig invalidateMethodsOnExpression = { { 6141 /* invalidateMethodsOnExpression */, 1, 369, 1, 370, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig setExpressionCertaintyKeepingType = { { 6171 /* setExpressionCertaintyKeepingType */, 2, 371, 2, 373, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isComplexUnionType = { { 6205 /* isComplexUnionType */, 1, 374, 1, 375, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig addTypeToExpression = { { 6224 /* addTypeToExpression */, 2, 376, 2, 378, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig removeTypeFromExpression = { { 6257 /* removeTypeFromExpression */, 2, 379, 2, 381, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterByTruthyValue = { { 6282 /* filterByTruthyValue */, 1, 382, 1, 383, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterByFalseyValue = { { 6302 /* filterByFalseyValue */, 1, 384, 1, 385, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig applySpecifiedTypes = { { 6337 /* applySpecifiedTypes */, 1, 386, 1, 387, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processConditionalExpressionsAfterSpecifying = { { 6378 /* processConditionalExpressionsAfterSpecifying */, 1, 388, 1, 389, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getConditionalExpressions = { { 6423 /* getConditionalExpressions */, 0, 390, 0, 390, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig addConditionalExpressions = { { 6478 /* addConditionalExpressions */, 2, 391, 2, 393, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig exitFirstLevelStatements = { { 6504 /* exitFirstLevelStatements */, 0, 394, 0, 394, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig isInFirstLevelStatement = { { 6529 /* isInFirstLevelStatement */, 0, 395, 0, 395, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig mergeWith = { { 6592 /* mergeWith */, 1, 396, 2, 398, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig collectAbsorbedClosures = { { 6614 /* collectAbsorbedClosures */, 2, 399, 2, 401, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeWithVariableState = { { 6638 /* mergeWithVariableState */, 1, 402, 2, 404, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig findMergedCallCandidates = { { 6707 /* findMergedCallCandidates */, 2, 405, 2, 407, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig findUninformativeMergedCalls = { { 6761 /* findUninformativeMergedCalls */, 2, 408, 2, 410, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig withoutPreciseClassConstantFetches = { { 6830 /* withoutPreciseClassConstantFetches */, 3, 411, 3, 414, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig preserveVacuousConditionalExpressions = { { 6945 /* preserveVacuousConditionalExpressions */, 3, 415, 3, 418, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeSameGuardConditionalExpressions = { { 7037 /* mergeSameGuardConditionalExpressions */, 3, 419, 3, 422, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeConditionalExpressions = { { 7131 /* mergeConditionalExpressions */, 2, 423, 2, 425, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig mergeInitializedProperties = { { 7177 /* mergeInitializedProperties */, 1, 426, 1, 427, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processFinallyScope = { { 7238 /* processFinallyScope */, 2, 428, 2, 430, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processFinallyScopeVariableTypeHolders = { { 7336 /* processFinallyScopeVariableTypeHolders */, 3, 431, 3, 434, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig processClosureScope = { { 7408 /* processClosureScope */, 3, 435, 3, 438, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig processAlwaysIterableForeachScopeWithoutPollute = { { 7439 /* processAlwaysIterableForeachScopeWithoutPollute */, 1, 439, 1, 440, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig generalizeWith = { { 7509 /* generalizeWith */, 1, 441, 2, 443, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig generalizeWithVariableState = { { 7524 /* generalizeWithVariableState */, 2, 444, 2, 446, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig generalizeVariableTypeHolders = { { 7597 /* generalizeVariableTypeHolders */, 3, 447, 3, 450, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig flattenUnionForGeneralization = { { 7627 /* flattenUnionForGeneralization */, 1, 451, 1, 452, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig generalizeType = { { 7667 /* generalizeType */, 3, 453, 3, 456, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getArrayDepth = { { 7682 /* getArrayDepth */, 1, 457, 1, 458, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig equals = { { 7696 /* equals */, 1, 459, 1, 460, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig compareConditionalExpressions = { { 7731 /* compareConditionalExpressions */, 2, 461, 2, 463, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig compareVariableTypeHolders = { { 7761 /* compareVariableTypeHolders */, 2, 464, 2, 466, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig canAccessProperty = { { 7845 /* canAccessProperty */, 1, 467, 1, 468, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canReadProperty = { { 7909 /* canReadProperty */, 1, 469, 1, 470, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canWriteProperty = { { 7925 /* canWriteProperty */, 1, 471, 1, 472, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canCallMethod = { { 7995 /* canCallMethod */, 1, 473, 1, 474, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessConstant = { { 8071 /* canAccessConstant */, 1, 475, 1, 476, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig canAccessClassMember = { { 8152 /* canAccessClassMember */, 1, 477, 1, 478, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig debug = { { 8173 /* debug */, 0, 479, 0, 479, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig filterTypeWithMethod = { { 8205 /* filterTypeWithMethod */, 2, 480, 2, 482, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getMethodReflection = { { 8270 /* getMethodReflection */, 2, 483, 2, 485, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getNakedMethod = { { 8290 /* getNakedMethod */, 2, 486, 2, 488, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPropertyReflection = { { 8322 /* getPropertyReflection */, 2, 489, 2, 491, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getInstancePropertyReflection = { { 8344 /* getInstancePropertyReflection */, 2, 492, 2, 494, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getStaticPropertyReflection = { { 8374 /* getStaticPropertyReflection */, 2, 495, 2, 497, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantReflection = { { 8432 /* getConstantReflection */, 2, 498, 2, 500, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantExplicitTypeFromConfig = { { 8467 /* getConstantExplicitTypeFromConfig */, 2, 501, 2, 503, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConstantTypes = { { 8501 /* getConstantTypes */, 0, 504, 0, 504, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getGlobalConstantType = { { 8518 /* getGlobalConstantType */, 1, 505, 1, 506, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig createGlobalConstantFetches = { { 8551 /* createGlobalConstantFetches */, 3, 507, 3, 510, ZEND_ACC_PRIVATE | ZEND_ACC_STATIC } }; +inline constexpr sigtab::Sig getNativeConstantTypes = { { 8579 /* getNativeConstantTypes */, 0, 511, 0, 511, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig getIterableKeyType = { { 8602 /* getIterableKeyType */, 1, 512, 1, 513, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getIterableValueType = { { 8621 /* getIterableValueType */, 1, 514, 1, 515, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getPhpVersion = { { 8666 /* getPhpVersion */, 0, 516, 0, 516, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig getConfiguredPhpVersionRange = { { 8680 /* getConfiguredPhpVersionRange */, 0, 517, 0, 517, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig isOverallPhpVersionRange = { { 8709 /* isOverallPhpVersionRange */, 1, 518, 1, 519, ZEND_ACC_PRIVATE } }; +inline constexpr sigtab::Sig invokeNodeCallback = { { 8749 /* invokeNodeCallback */, 1, 520, 1, 521, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig emitCollectedData = { { 8787 /* emitCollectedData */, 2, 522, 2, 524, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackValueDependency = { { 8820 /* trackValueDependency */, 2, 525, 2, 527, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackFileDependency = { { 8846 /* trackFileDependency */, 1, 528, 1, 529, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackDirectoryDependency = { { 8888 /* trackDirectoryDependency */, 1, 530, 2, 532, ZEND_ACC_PUBLIC } }; +inline constexpr sigtab::Sig trackClassDependency = { { 8913 /* trackClassDependency */, 1, 533, 1, 534, ZEND_ACC_PUBLIC } }; } // namespace sig } // namespace ptdecl::MutatingScope