Gather the VariableWritesNode of each method in ClassStatementsGatherer

ClassMethodsNode now carries the VariableWritesNode of each method body
together with the scope inside the method, so rules listening to it can
combine parameter usage with the method calls gathered in the class.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: 2 people

src/Analyser/StmtHandler/ClassLikeHandler.php

@@ -144,7 +144,7 @@ public function processStmt(
 		// declaration is visited during an enclosing body's observation pass.
 		$bodyResult = $nodeScopeResolver->processStmtNodesInternal($stmt, $classLikeStatements, $classScope, $storage, $classStatementsGatherer, StatementContext::createTopLevel());
 		$nodeScopeResolver->callNodeCallback($nodeCallback, new ClassPropertiesNode($stmt, $this->readWritePropertiesExtensions, $classStatementsGatherer->getProperties(), $classStatementsGatherer->getPropertyUsages(), $classStatementsGatherer->getMethodCalls(), $classStatementsGatherer->getReturnStatementsNodes(), $classStatementsGatherer->getPropertyAssigns(), $classReflection), $classScope, $storage);
-		$nodeScopeResolver->callNodeCallback($nodeCallback, new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection), $classScope, $storage);
+		$nodeScopeResolver->callNodeCallback($nodeCallback, new ClassMethodsNode($stmt, $classStatementsGatherer->getMethods(), $classStatementsGatherer->getMethodCalls(), $classReflection, $classStatementsGatherer->getMethodVariableWrites()), $classScope, $storage);
 		$nodeScopeResolver->callNodeCallback($nodeCallback, new ClassConstantsNode($stmt, $classStatementsGatherer->getConstants(), $classStatementsGatherer->getConstantFetches(), $classReflection), $classScope, $storage);
 		$classReflection->evictPrivateSymbols();
 		$this->calledMethodProcessor->clearCalledMethodResults();

src/Node/ClassMethodsNode.php

@@ -6,6 +6,7 @@
 use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\NodeAbstract;
 use PHPStan\Node\Method\MethodCall;
+use PHPStan\Node\Method\MethodVariableWrites;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Turbo\ReferencedByTurboExtension;
 
@@ -19,8 +20,9 @@ final class ClassMethodsNode extends NodeAbstract implements VirtualNode
 	/**
 	 * @param ClassMethod[] $methods
 	 * @param array<int, MethodCall> $methodCalls
+	 * @param list<MethodVariableWrites> $methodVariableWrites
 	 */
-	public function __construct(private ClassLike $class, private array $methods, private array $methodCalls, private ClassReflection $classReflection)
+	public function __construct(private ClassLike $class, private array $methods, private array $methodCalls, private ClassReflection $classReflection, private array $methodVariableWrites = [])
 	{
 		parent::__construct($class->getAttributes());
 	}
@@ -46,6 +48,16 @@ public function getMethodCalls(): array
 		return $this->methodCalls;
 	}
 
+	/**
+	 * The VariableWritesNode of each method body, with the scope inside the method.
+	 *
+	 * @return list<MethodVariableWrites>
+	 */
+	public function getMethodVariableWrites(): array
+	{
+		return $this->methodVariableWrites;
+	}
+
 	#[Override]
 	public function getType(): string
 	{

src/Node/ClassStatementsGatherer.php

@@ -15,6 +15,7 @@
 use PHPStan\Node\Constant\ClassConstantFetch;
 use PHPStan\Node\Expr\SetExistingOffsetValueTypeExpr;
 use PHPStan\Node\Expr\SetOffsetValueTypeExpr;
+use PHPStan\Node\Method\MethodVariableWrites;
 use PHPStan\Node\Printer\ExprPrinter;
 use PHPStan\Node\Property\PropertyAssign;
 use PHPStan\Node\Property\PropertyRead;
@@ -51,6 +52,9 @@ final class ClassStatementsGatherer
 	/** @var \PHPStan\Node\Method\MethodCall[] */
 	private array $methodCalls = [];
 
+	/** @var list<MethodVariableWrites> */
+	private array $methodVariableWrites = [];
+
 	/** @var array<int, PropertyWrite|PropertyRead> */
 	private array $propertyUsages = [];
 
@@ -101,6 +105,14 @@ public function getMethodCalls(): array
 		return $this->methodCalls;
 	}
 
+	/**
+	 * @return list<MethodVariableWrites>
+	 */
+	public function getMethodVariableWrites(): array
+	{
+		return $this->methodVariableWrites;
+	}
+
 	/**
 	 * @return array<int, PropertyWrite|PropertyRead>
 	 */
@@ -191,6 +203,10 @@ private function gatherNodes(Node $node, Scope $scope): void
 			$this->returnStatementNodes[strtolower($node->getMethodName())] = $node;
 			return;
 		}
+		if ($node instanceof VariableWritesNode && $node->getFunctionLike() instanceof Node\Stmt\ClassMethod) {
+			$this->methodVariableWrites[] = new MethodVariableWrites($node, $scope);
+			return;
+		}
 		if (
 			$node instanceof Expr\FuncCall
 			&& $node->name instanceof Node\Name

src/Node/Method/MethodVariableWrites.php

@@ -0,0 +1,33 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Node\Method;
+
+use PHPStan\Analyser\Scope;
+use PHPStan\Node\VariableWritesNode;
+use PHPStan\Turbo\ReferencedByTurboExtension;
+
+/**
+ * @api
+ */
+#[ReferencedByTurboExtension(key: 'gatheredMethodVariableWrites')]
+final class MethodVariableWrites
+{
+
+	public function __construct(
+		private VariableWritesNode $node,
+		private Scope $scope,
+	)
+	{
+	}
+
+	public function getNode(): VariableWritesNode
+	{
+		return $this->node;
+	}
+
+	public function getScope(): Scope
+	{
+		return $this->scope;
+	}
+
+}

turbo-ext/src/ClassLikeHandler.cpp

@@ -374,8 +374,9 @@ class ClassLikeHandler
 		{
 			zv::Val methods = pt_class_statements_gatherer_get(classStatementsGatherer.raw(), PT_CSG_LIST_METHODS);
 			zv::Val methodCalls = pt_class_statements_gatherer_get(classStatementsGatherer.raw(), PT_CSG_LIST_METHOD_CALLS);
-			zv::Args nodeArgv{stmt, methods.raw(), methodCalls.raw(), classReflection.raw()};
-			zv::Val classMethodsNode = pt_type_new(PT_CLASS_CLASS_METHODS_NODE, 4, nodeArgv);
+			zv::Val methodVariableWrites = pt_class_statements_gatherer_get(classStatementsGatherer.raw(), PT_CSG_LIST_METHOD_VARIABLE_WRITES);
+			zv::Args nodeArgv{stmt, methods.raw(), methodCalls.raw(), classReflection.raw(), methodVariableWrites.raw()};
+			zv::Val classMethodsNode = pt_type_new(PT_CLASS_CLASS_METHODS_NODE, 5, nodeArgv);
 			if (UNEXPECTED(classMethodsNode.isUndef())) return zv::Val();
 			if (UNEXPECTED(!pt_node_scope_resolver_call_node_callback(nodeScopeResolver, nodeCallback, classMethodsNode.raw(), classScope.raw(), storage))) return zv::Val();
 		}

turbo-ext/src/ClassStatementsGatherer.cpp

@@ -6,19 +6,19 @@
  * ClassLikeHandler hands one to the walk of a class body as its node
  * callback: every node of the class reaches __invoke(), which forwards the
  * pair to the wrapped callback (the rule and collector dispatch, PHP) and
- * then gathers the properties, methods, method calls, property usages,
- * constants, constant fetches, return statements and property assigns the
- * Class*Node emissions after the walk carry. The gathering asks the scope
- * through MutatingScope's and ScopeContext's direct entries and the class
- * reflections through ClassReflection's, so the scope and reflection calls
- * made from here (~2.7M per self-analysis) stay native; anything a subclass
- * may override or a PHP twin answers goes by name. The collected value
- * objects are the PHP classes, built through the class map; the PHPStan
- * node classes read here are final with plain getters, so their slots are
- * read directly.
+ * then gathers the properties, methods, method calls, method variable
+ * writes, property usages, constants, constant fetches, return statements
+ * and property assigns the Class*Node emissions after the walk carry. The
+ * gathering asks the scope through MutatingScope's and ScopeContext's direct
+ * entries and the class reflections through ClassReflection's, so the scope
+ * and reflection calls made from here (~2.7M per self-analysis) stay native;
+ * anything a subclass may override or a PHP twin answers goes by name. The
+ * collected value objects are the PHP classes, built through the class map;
+ * the PHPStan node classes read here are final with plain getters, so their
+ * slots are read directly.
  *
  * State is the twin's properties in declaration order: the untyped
- * $nodeCallback, the eight collected arrays, then the promoted
+ * $nodeCallback, the nine collected arrays, then the promoted
  * $classReflection.
  */
 
@@ -91,6 +91,7 @@ static NodeProp pt_csg_param_hooks = PT_NODE_PROP(PT_CLASS_PARAM, "hooks");
 static NodeProp pt_csg_param_var = PT_NODE_PROP(PT_CLASS_PARAM, "var");
 static NodeProp pt_csg_arg_value = PT_NODE_PROP(PT_CLASS_ARG, "value");
 static NodeProp pt_csg_gathered_class_method_node = PT_NODE_PROP(PT_CLASS_GATHERED_CLASS_METHOD, "node");
+static NodeProp pt_csg_variable_writes_function_like = PT_NODE_PROP(PT_CLASS_VARIABLE_WRITES_NODE, "functionLike");
 
 /* Mirrors PHPStan\Node\ClassStatementsGatherer. State lives in the PHP
  * object's slots. */
@@ -294,6 +295,9 @@ class ClassStatementsGatherer
 		}
 		if (callableOriginal != NULL) return pushNodeScope(slots::methodCalls, PT_CLASS_GATHERED_METHOD_CALL, callableOriginal, scope);
 		if (isInstanceOf(node, PT_CLASS_METHOD_RETURN_STATEMENTS_NODE)) return addReturnStatementsNode(node, &nodeZv);
+		if (isInstanceOf(node, PT_CLASS_VARIABLE_WRITES_NODE) && pt_csg_variable_writes_function_like.objectOf(node, PT_CLASS_CLASS_METHOD_STMT) != NULL) {
+			return pushNodeScope(slots::methodVariableWrites, PT_CLASS_GATHERED_METHOD_VARIABLE_WRITES, &nodeZv, scope);
+		}
 		if (isInstanceOf(node, PT_CLASS_FUNC_CALL)) {
 			zend_object *callee = pt_csg_func_call_name.objectOf(node, PT_CLASS_NAME);
 			zend_string *calleeName = callee != NULL ? visitors::nameString(callee, pt_csg_name_name) : NULL;
@@ -596,7 +600,7 @@ zv::Val pt_class_statements_gatherer_new(zval *classReflection, zval *nodeCallba
 
 zv::Val pt_class_statements_gatherer_get(zval *gatherer, pt_class_statements_gatherer_list list)
 {
-	static const uint32_t listSlots[] = { slots::properties, slots::methods, slots::methodCalls, slots::propertyUsages, slots::constants, slots::constantFetches, slots::returnStatementNodes, slots::propertyAssigns };
+	static const uint32_t listSlots[] = { slots::properties, slots::methods, slots::methodCalls, slots::methodVariableWrites, slots::propertyUsages, slots::constants, slots::constantFetches, slots::returnStatementNodes, slots::propertyAssigns };
 	return zv::Val::copyOf(zv::Ref(OBJ_PROP_NUM(Z_OBJ_P(gatherer), listSlots[list])));
 }
 
@@ -608,12 +612,13 @@ PT_MINIT_REGISTRATION(pt_register_class_statements_gatherer)
 {
 	reg::Class cls("PHPStan\\Node\\ClassStatementsGatherer");
 	ptdecl::ClassStatementsGatherer::declareClass(cls);
-	/* the slots PT_CSG_PROP_*: the nine class-body properties first, the
+	/* the slots PT_CSG_PROP_*: the ten class-body properties first, the
 	 * promoted constructor property after them */
 	cls.privateNullProperty("nodeCallback");
 	cls.privateTypedArrayPropertyDefaultEmpty("properties");
 	cls.privateTypedArrayPropertyDefaultEmpty("methods");
 	cls.privateTypedArrayPropertyDefaultEmpty("methodCalls");
+	cls.privateTypedArrayPropertyDefaultEmpty("methodVariableWrites");
 	cls.privateTypedArrayPropertyDefaultEmpty("propertyUsages");
 	cls.privateTypedArrayPropertyDefaultEmpty("constants");
 	cls.privateTypedArrayPropertyDefaultEmpty("constantFetches");
@@ -644,6 +649,10 @@ PT_MINIT_REGISTRATION(pt_register_class_statements_gatherer)
 		ZEND_PARSE_PARAMETERS_NONE();
 		RETURN_COPY(OBJ_PROP_NUM(Z_OBJ_P(ZEND_THIS), slots::methodCalls));
 	});
+	cls.method(sigs::getMethodVariableWrites, [](INTERNAL_FUNCTION_PARAMETERS) {
+		ZEND_PARSE_PARAMETERS_NONE();
+		RETURN_COPY(OBJ_PROP_NUM(Z_OBJ_P(ZEND_THIS), slots::methodVariableWrites));
+	});
 	cls.method(sigs::getPropertyUsages, [](INTERNAL_FUNCTION_PARAMETERS) {
 		ZEND_PARSE_PARAMETERS_NONE();
 		RETURN_COPY(OBJ_PROP_NUM(Z_OBJ_P(ZEND_THIS), slots::propertyUsages));

turbo-ext/src/generated/ClassStatementsGatherer.h

@@ -14,12 +14,13 @@ inline constexpr uint32_t nodeCallback = 0;
 inline constexpr uint32_t properties = 1;
 inline constexpr uint32_t methods = 2;
 inline constexpr uint32_t methodCalls = 3;
-inline constexpr uint32_t propertyUsages = 4;
-inline constexpr uint32_t constants = 5;
-inline constexpr uint32_t constantFetches = 6;
-inline constexpr uint32_t returnStatementNodes = 7;
-inline constexpr uint32_t propertyAssigns = 8;
-inline constexpr uint32_t classReflection = 9;
+inline constexpr uint32_t methodVariableWrites = 4;
+inline constexpr uint32_t propertyUsages = 5;
+inline constexpr uint32_t constants = 6;
+inline constexpr uint32_t constantFetches = 7;
+inline constexpr uint32_t returnStatementNodes = 8;
+inline constexpr uint32_t propertyAssigns = 9;
+inline constexpr uint32_t classReflection = 10;
 } // namespace slot
 
 inline void declareClass(reg::Class &cls)
@@ -34,6 +35,7 @@ inline void declareProperties(reg::Class &cls)
 	cls.property("properties", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
 	cls.property("methods", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
 	cls.property("methodCalls", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
+	cls.property("methodVariableWrites", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
 	cls.property("propertyUsages", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
 	cls.property("constants", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
 	cls.property("constantFetches", ZEND_ACC_PRIVATE, reg::PropertyKind::TypedEmptyArray, MAY_BE_ARRAY);
@@ -53,49 +55,51 @@ inline constexpr char strings[] =
 	"getProperties\0" /* 77 */
 	"getMethods\0" /* 91 */
 	"getMethodCalls\0" /* 102 */
-	"getPropertyUsages\0" /* 117 */
-	"getConstants\0" /* 135 */
-	"getConstantFetches\0" /* 148 */
-	"getReturnStatementsNodes\0" /* 167 */
-	"getPropertyAssigns\0" /* 192 */
-	"node\0" /* 211 */
-	"PhpParser\\Node\0" /* 216 */
-	"scope\0" /* 231 */
-	"PHPStan\\Analyser\\Scope\0" /* 237 */
-	"__invoke\0" /* 260 */
-	"gatherNodes\0" /* 269 */
-	"PhpParser\\Node\\Expr\\FuncCall\0" /* 281 */
-	"tryToApplyPropertyReads\0" /* 310 */
-	"PhpParser\\Node\\Expr\\Variable\0" /* 334 */
-	"tryToApplyPromotedParameterRead\0" /* 363 */
-	"ancestorConstructorCall\0" /* 395 */
-	"PhpParser\\Node\\Expr\\StaticCall\0" /* 419 */
-	"tryToApplyPropertyWritesFromAncestorConstructor"; /* 450 */
+	"getMethodVariableWrites\0" /* 117 */
+	"getPropertyUsages\0" /* 141 */
+	"getConstants\0" /* 159 */
+	"getConstantFetches\0" /* 172 */
+	"getReturnStatementsNodes\0" /* 191 */
+	"getPropertyAssigns\0" /* 216 */
+	"node\0" /* 235 */
+	"PhpParser\\Node\0" /* 240 */
+	"scope\0" /* 255 */
+	"PHPStan\\Analyser\\Scope\0" /* 261 */
+	"__invoke\0" /* 284 */
+	"gatherNodes\0" /* 293 */
+	"PhpParser\\Node\\Expr\\FuncCall\0" /* 305 */
+	"tryToApplyPropertyReads\0" /* 334 */
+	"PhpParser\\Node\\Expr\\Variable\0" /* 358 */
+	"tryToApplyPromotedParameterRead\0" /* 387 */
+	"ancestorConstructorCall\0" /* 419 */
+	"PhpParser\\Node\\Expr\\StaticCall\0" /* 443 */
+	"tryToApplyPropertyWritesFromAncestorConstructor"; /* 474 */
 inline constexpr reg::PackedArg args[] = {
 	reg::packed(0, 0, 16), /* __construct $classReflection */
 	reg::packed(51, MAY_BE_CALLABLE), /* __construct $nodeCallback */
 	reg::packed(76, MAY_BE_ARRAY), /* getProperties return */
 	reg::packed(76, MAY_BE_ARRAY), /* getMethods return */
 	reg::packed(76, MAY_BE_ARRAY), /* getMethodCalls return */
+	reg::packed(76, MAY_BE_ARRAY), /* getMethodVariableWrites return */
 	reg::packed(76, MAY_BE_ARRAY), /* getPropertyUsages return */
 	reg::packed(76, MAY_BE_ARRAY), /* getConstants return */
 	reg::packed(76, MAY_BE_ARRAY), /* getConstantFetches return */
 	reg::packed(76, MAY_BE_ARRAY), /* getReturnStatementsNodes return */
 	reg::packed(76, MAY_BE_ARRAY), /* getPropertyAssigns return */
-	reg::packed(211, 0, 216), /* __invoke $node */
-	reg::packed(231, 0, 237), /* __invoke $scope */
+	reg::packed(235, 0, 240), /* __invoke $node */
+	reg::packed(255, 0, 261), /* __invoke $scope */
 	reg::packed(76, MAY_BE_VOID), /* __invoke return */
-	reg::packed(211, 0, 216), /* gatherNodes $node */
-	reg::packed(231, 0, 237), /* gatherNodes $scope */
+	reg::packed(235, 0, 240), /* gatherNodes $node */
+	reg::packed(255, 0, 261), /* gatherNodes $scope */
 	reg::packed(76, MAY_BE_VOID), /* gatherNodes return */
-	reg::packed(211, 0, 281), /* tryToApplyPropertyReads $node */
-	reg::packed(231, 0, 237), /* tryToApplyPropertyReads $scope */
+	reg::packed(235, 0, 305), /* tryToApplyPropertyReads $node */
+	reg::packed(255, 0, 261), /* tryToApplyPropertyReads $scope */
 	reg::packed(76, MAY_BE_VOID), /* tryToApplyPropertyReads return */
-	reg::packed(211, 0, 334), /* tryToApplyPromotedParameterRead $node */
-	reg::packed(231, 0, 237), /* tryToApplyPromotedParameterRead $scope */
+	reg::packed(235, 0, 358), /* tryToApplyPromotedParameterRead $node */
+	reg::packed(255, 0, 261), /* tryToApplyPromotedParameterRead $scope */
 	reg::packed(76, MAY_BE_VOID), /* tryToApplyPromotedParameterRead return */
-	reg::packed(395, 0, 419), /* tryToApplyPropertyWritesFromAncestorConstructor $ancestorConstructorCall */
-	reg::packed(231, 0, 237), /* tryToApplyPropertyWritesFromAncestorConstructor $scope */
+	reg::packed(419, 0, 443), /* tryToApplyPropertyWritesFromAncestorConstructor $ancestorConstructorCall */
+	reg::packed(255, 0, 261), /* tryToApplyPropertyWritesFromAncestorConstructor $scope */
 	reg::packed(76, MAY_BE_VOID), /* tryToApplyPropertyWritesFromAncestorConstructor return */
 };
 using Sig = reg::Sig<strings, args>;
@@ -107,16 +111,17 @@ inline constexpr sigtab::Sig __construct = { { 64 /* __construct */, 2, 0, 2, re
 inline constexpr sigtab::Sig getProperties = { { 77 /* getProperties */, 0, 2, 0, 2, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig getMethods = { { 91 /* getMethods */, 0, 3, 0, 3, ZEND_ACC_PUBLIC } };
 inline constexpr sigtab::Sig getMethodCalls = { { 102 /* getMethodCalls */, 0, 4, 0, 4, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getPropertyUsages = { { 117 /* getPropertyUsages */, 0, 5, 0, 5, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConstants = { { 135 /* getConstants */, 0, 6, 0, 6, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getConstantFetches = { { 148 /* getConstantFetches */, 0, 7, 0, 7, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getReturnStatementsNodes = { { 167 /* getReturnStatementsNodes */, 0, 8, 0, 8, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig getPropertyAssigns = { { 192 /* getPropertyAssigns */, 0, 9, 0, 9, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig __invoke = { { 260 /* __invoke */, 2, 10, 2, 12, ZEND_ACC_PUBLIC } };
-inline constexpr sigtab::Sig gatherNodes = { { 269 /* gatherNodes */, 2, 13, 2, 15, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig tryToApplyPropertyReads = { { 310 /* tryToApplyPropertyReads */, 2, 16, 2, 18, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig tryToApplyPromotedParameterRead = { { 363 /* tryToApplyPromotedParameterRead */, 2, 19, 2, 21, ZEND_ACC_PRIVATE } };
-inline constexpr sigtab::Sig tryToApplyPropertyWritesFromAncestorConstructor = { { 450 /* tryToApplyPropertyWritesFromAncestorConstructor */, 2, 22, 2, 24, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig getMethodVariableWrites = { { 117 /* getMethodVariableWrites */, 0, 5, 0, 5, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getPropertyUsages = { { 141 /* getPropertyUsages */, 0, 6, 0, 6, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConstants = { { 159 /* getConstants */, 0, 7, 0, 7, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getConstantFetches = { { 172 /* getConstantFetches */, 0, 8, 0, 8, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getReturnStatementsNodes = { { 191 /* getReturnStatementsNodes */, 0, 9, 0, 9, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig getPropertyAssigns = { { 216 /* getPropertyAssigns */, 0, 10, 0, 10, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig __invoke = { { 284 /* __invoke */, 2, 11, 2, 13, ZEND_ACC_PUBLIC } };
+inline constexpr sigtab::Sig gatherNodes = { { 293 /* gatherNodes */, 2, 14, 2, 16, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig tryToApplyPropertyReads = { { 334 /* tryToApplyPropertyReads */, 2, 17, 2, 19, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig tryToApplyPromotedParameterRead = { { 387 /* tryToApplyPromotedParameterRead */, 2, 20, 2, 22, ZEND_ACC_PRIVATE } };
+inline constexpr sigtab::Sig tryToApplyPropertyWritesFromAncestorConstructor = { { 474 /* tryToApplyPropertyWritesFromAncestorConstructor */, 2, 23, 2, 25, ZEND_ACC_PRIVATE } };
 } // namespace sig
 
 } // namespace ptdecl::ClassStatementsGatherer