diff --git a/build/PHPStan/Build/MissingNativeTypeRule.php b/build/PHPStan/Build/MissingNativeTypeRule.php
new file mode 100644
index 00000000000..c44217060f9
--- /dev/null
+++ b/build/PHPStan/Build/MissingNativeTypeRule.php
@@ -0,0 +1,525 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Build;
+
+use PhpParser\Modifiers;
+use PhpParser\Node;
+use PhpParser\Node\ComplexType;
+use PhpParser\Node\Expr\ConstFetch;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Fixable\PhpDoc\PhpDocEditor;
+use PHPStan\Node\ClassPropertyNode;
+use PHPStan\Node\InClassMethodNode;
+use PHPStan\Node\InFunctionNode;
+use PHPStan\Php\PhpVersion;
+use PHPStan\PhpDocParser\Ast\Node as PhpDocAstNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocChildNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTextNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\VarTagValueNode;
+use PHPStan\Reflection\ClassReflection;
+use PHPStan\Reflection\ExtendedParametersAcceptor;
+use PHPStan\Reflection\Php\PhpFunctionFromParserNodeReflection;
+use PHPStan\Rules\IdentifierRuleError;
+use PHPStan\Rules\MissingTypehintCheck;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\ShouldNotHappenException;
+use PHPStan\TrinaryLogic;
+use PHPStan\Type\NativeTypePosition;
+use PHPStan\Type\ParserNodeTypeToPHPStanType;
+use PHPStan\Type\Type;
+use function array_filter;
+use function array_map;
+use function array_pop;
+use function array_values;
+use function count;
+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;
+
+/**
+ * Reports parameters, return types and properties without a native type
+ * when their PHPDoc type can be declared natively. The fix declares the native type
+ * and removes the PHPDoc tag when the native type says the same.
+ *
+ * A return type or a property type is added only when nothing can override it,
+ * an overriding method or property without the same native type would no longer compile.
+ * A parameter type is added only when it is contravariant with the overridden methods.
+ *
+ * @implements Rule<Node>
+ */
+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<IdentifierRuleError>
+	 */
+	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()) : [];
+
+		// 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<int, Identifier|Name|ComplexType> $paramTypeNodes */
+		$paramTypeNodes = [];
+		$sameParamNames = [];
+		$descriptions = [];
+		$parameters = $function->getParameters();
+		foreach ($functionNode->params as $i => $paramNode) {
+			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;
+			}
+
+			$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 || !self::isDowngradable($typeNode)) {
+				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 (!self::isDowngradable($returnTypeNode) || !$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<IdentifierRuleError>
+	 */
+	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 || !self::isDowngradable($typeNode)) {
+			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) || self::isApi($classReflection))) {
+			return false;
+		}
+
+		foreach ($classReflection->getParents() as $parent) {
+			if ($parent->hasNativeProperty($propertyName) && !$parent->getNativeProperty($propertyName)->isPrivate()) {
+				return false;
+			}
+		}
+
+		return true;
+	}
+
+	/**
+	 * @return list<ExtendedParametersAcceptor> 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<ExtendedParametersAcceptor> $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<ExtendedParametersAcceptor> $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.
+	 */
+	/**
+	 * 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()
+			&& $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/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..8d323aa65ac 100644
--- a/src/Analyser/MutatingScope.php
+++ b/src/Analyser/MutatingScope.php
@@ -1716,10 +1716,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];
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<array{extensionClass: string, storedKey: string, value: string, analysis: list<string>, declarations: list<string>}>
 	 */
-	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<string, array{fileHash: string, fileStat?: string, dependentFiles: list<string>, usedTraitDependentFiles?: list<string>}>
 	 */
-	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/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|null> $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<string, CacheItem> */
 	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<Collector<Node, mixed>> $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/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<T> $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/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/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<mixed>
 	 */
-	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<Rule<covariant Node>>, trait-string, string, null}|array{class-string<Rule<covariant Node>>, trait-string, string, bool, Error|array<mixed>}
 	 */
-	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<Rule<covariant Node>>, trait-string|null, string, null}|array{class-string<Rule<covariant Node>>, trait-string|null, string, bool, Error|array<mixed>}
 	 */
-	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<IdentifierRuleError>
 	 */
 	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<IdentifierRuleError>, 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<IdentifierRuleError>
 	 */
-	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<IdentifierRuleError>
 	 */
-	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/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/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/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/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/Build/MissingNativeTypeRuleTest.php b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php
new file mode 100644
index 00000000000..9b74941a1f2
--- /dev/null
+++ b/tests/PHPStan/Build/MissingNativeTypeRuleTest.php
@@ -0,0 +1,185 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Build;
+
+use PHPStan\Fixable\PhpDoc\PhpDocEditor;
+use PHPStan\Php\PhpVersion;
+use PHPStan\Rules\MissingTypehintCheck;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<MissingNativeTypeRule>
+ */
+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,
+			],
+			[
+				'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,
+			],
+		]);
+	}
+
+	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..e2713189b27
--- /dev/null
+++ b/tests/PHPStan/Build/data/missing-native-type.php
@@ -0,0 +1,438 @@
+<?php // lint >= 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<int>
+	 */
+	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<mixed>
+	 */
+	public function doFoo($a)
+	{
+		return $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
new file mode 100644
index 00000000000..d761ca3a6ae
--- /dev/null
+++ b/tests/PHPStan/Build/data/missing-native-type.php.fixed
@@ -0,0 +1,394 @@
+<?php // lint >= 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<int>
+	 */
+	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<mixed>
+	 */
+	public function doFoo(array $a): array
+	{
+		return $a;
+	}
+
+}
+
+/** @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
+	{
+	}
+
+}
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<TNodeType> */
-	private $nodeType;
-
 	/** @var (callable(TNodeType, Scope): TValue) */
 	private $processNodeCallback;
 
@@ -23,9 +20,8 @@ class UniversalCollector implements Collector
 	 * @param class-string<TNodeType> $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<TNodeType> */
-	private $nodeType;
-
 	/** @var (callable(TNodeType, Scope): list<IdentifierRuleError>) */
 	private $processNodeCallback;
 
@@ -22,9 +19,8 @@ class UniversalRule implements Rule
 	 * @param class-string<TNodeType> $nodeType
 	 * @param (callable(TNodeType, Scope): list<IdentifierRuleError>) $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<string, string> */
 			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/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<strings, args>;
 } // namespace sigtab
@@ -274,24 +276,24 @@ using Sig = reg::Sig<strings, args>;
 /* 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<strings, args>;
@@ -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/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<strings, args>;
 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<strings, args>;
@@ -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/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<strings, args>;
@@ -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<strings, args>;
 } // 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..7dbab050fea 100644
--- a/turbo-ext/src/generated/MutatingScope.h
+++ b/turbo-ext/src/generated/MutatingScope.h
@@ -213,291 +213,292 @@ 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 */
+	"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 */
@@ -643,159 +644,159 @@ inline constexpr reg::PackedArg args[] = {
 	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, 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(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(5018, 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(5049, 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(5105, 0, 1424), /* intersectButNotNever $nativeType */
+	reg::packed(5116, 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, 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(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(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(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(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(5237, 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(5262, 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 */
@@ -810,23 +811,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(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(3874, 0, 1424), /* overwriteExpression $type */
-	reg::packed(5031, 0, 1424), /* overwriteExpression $nativeType */
+	reg::packed(3948, 0, 1424), /* overwriteExpression $type */
+	reg::packed(5105, 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(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(5527, 0, 523), /* isDimFetchPathReachable $scope */
-	reg::packed(5610, 0, 5619), /* 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 */
@@ -837,202 +838,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(5646, 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(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 */
-	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(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(3874, 0, 1424), /* assignExpression $type */
-	reg::packed(5031, 0, 1424), /* assignExpression $nativeType */
+	reg::packed(3948, 0, 1424), /* assignExpression $type */
+	reg::packed(5105, 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(5963, 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(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(5974, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */
+	reg::packed(6048, 0, 1065), /* isPrivatePropertyOfDifferentClass $invalidatingClass */
 	reg::packed(738, MAY_BE_BOOL), /* isPrivatePropertyOfDifferentClass return */
-	reg::packed(5929, 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(5456, 0, 1387), /* setExpressionCertaintyKeepingType $certainty */
+	reg::packed(5530, 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(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(6248, 0, 2035), /* applySpecifiedTypes $specifiedTypes */
+	reg::packed(6322, 0, 2035), /* applySpecifiedTypes $specifiedTypes */
 	reg::packed(738, 0, 523), /* applySpecifiedTypes return */
-	reg::packed(6283, 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(6375, 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(6479, MAY_BE_NULL, 523), /* mergeWith $otherScope */
-	reg::packed(6490, 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(6528, 0, 523), /* collectAbsorbedClosures $ours */
-	reg::packed(6533, 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(6479, MAY_BE_NULL, 523), /* mergeWithVariableState $otherScope */
-	reg::packed(6490, 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(6587, MAY_BE_ARRAY), /* findMergedCallCandidates $differingExpressionKeys */
-	reg::packed(6611, 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(6658, MAY_BE_ARRAY), /* findUninformativeMergedCalls $candidates */
-	reg::packed(6669, 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(6587, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $differingExpressionKeys */
-	reg::packed(6716, MAY_BE_ARRAY), /* withoutPreciseClassConstantFetches $ourExpressionTypes */
-	reg::packed(6735, 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(6791, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $currentConditionalExpressions */
-	reg::packed(6821, MAY_BE_ARRAY), /* preserveVacuousConditionalExpressions $sourceConditionalExpressions */
-	reg::packed(6850, 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(6791, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $currentConditionalExpressions */
-	reg::packed(6909, MAY_BE_ARRAY), /* mergeSameGuardConditionalExpressions $ourConditionalExpressions */
-	reg::packed(6935, 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(7000, MAY_BE_ARRAY), /* mergeConditionalExpressions $newConditionalExpressions */
-	reg::packed(7026, 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(7085, 0, 523), /* mergeInitializedProperties $calledMethodScope */
+	reg::packed(7159, 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(7204, 0, 523), /* processFinallyScope $finallyScope */
+	reg::packed(7217, 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(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(7301, 0, 523), /* processClosureScope $closureScope */
-	reg::packed(7314, MAY_BE_NULL, 523), /* processClosureScope $prevScope */
-	reg::packed(7324, 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(7354, 0, 523), /* processAlwaysIterableForeachScopeWithoutPollute $finalScope */
+	reg::packed(7428, 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(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(6479, 0, 523), /* generalizeWithVariableState $otherScope */
-	reg::packed(7413, 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(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(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(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(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(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(6553, 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(7703, 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(7552, MAY_BE_ARRAY), /* compareVariableTypeHolders $variableTypeHolders */
+	reg::packed(7572, MAY_BE_ARRAY), /* compareVariableTypeHolders $otherVariableTypeHolders */
 	reg::packed(738, MAY_BE_BOOL), /* compareVariableTypeHolders return */
-	reg::packed(7714, 0, 7733), /* canAccessProperty $propertyReflection */
+	reg::packed(7788, 0, 7807), /* canAccessProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canAccessProperty return */
-	reg::packed(7714, 0, 7789), /* canReadProperty $propertyReflection */
+	reg::packed(7788, 0, 7863), /* canReadProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canReadProperty return */
-	reg::packed(7714, 0, 7789), /* canWriteProperty $propertyReflection */
+	reg::packed(7788, 0, 7863), /* canWriteProperty $propertyReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canWriteProperty return */
-	reg::packed(7868, 0, 7885), /* canCallMethod $methodReflection */
+	reg::packed(7942, 0, 7959), /* canCallMethod $methodReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canCallMethod return */
-	reg::packed(7935, 0, 7954), /* canAccessConstant $constantReflection */
+	reg::packed(8009, 0, 8028), /* canAccessConstant $constantReflection */
 	reg::packed(738, MAY_BE_BOOL), /* canAccessConstant return */
-	reg::packed(8015, 0, 8037), /* 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(8105, 0, 1424), /* filterTypeWithMethod $typeWithMethod */
-	reg::packed(8120, 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(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(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, 7863), /* getPropertyReflection return */
+	reg::packed(8305, 0, 1424), /* getInstancePropertyReflection $typeWithProperty */
+	reg::packed(3802, MAY_BE_STRING), /* getInstancePropertyReflection $propertyName */
+	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, 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(8466, 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(5138, 0, 1424), /* getIterableKeyType $iteratee */
+	reg::packed(5212, 0, 1424), /* getIterableKeyType $iteratee */
 	reg::packed(738, 0, 1424), /* getIterableKeyType return */
-	reg::packed(5138, 0, 1424), /* getIterableValueType $iteratee */
+	reg::packed(5212, 0, 1424), /* getIterableValueType $iteratee */
 	reg::packed(738, 0, 1424), /* getIterableValueType return */
-	reg::packed(738, 0, 8568), /* getPhpVersion return */
+	reg::packed(738, 0, 8642), /* 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, 8734), /* 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(8768, MAY_BE_STRING), /* emitCollectedData $collectorType */
+	reg::packed(8782, MAY_BE_ANY), /* emitCollectedData $data */
 	reg::packed(738, MAY_BE_VOID), /* emitCollectedData return */
-	reg::packed(8731, 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(8767, MAY_BE_STRING), /* trackFileDependency $file */
+	reg::packed(8841, 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(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(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<strings, args>;
@@ -1113,134 +1114,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 = { { 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
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<strings, args>;
@@ -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<strings, args>;
@@ -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<strings, args>;
 } // 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