Seed the arrow function type cache from the handler's single body walk

processArrowFunctionNode() now returns ProcessArrowFunctionResult: the walked
arrow scope plus the throw points, impure points (merged in getClosureType()
order) and invalidate expressions its type needs, gathered during the single
body walk. ArrowFunctionHandler seeds the per-node type cache with both
flavours built from the walk - unlike a closure, an arrow function's native
return type genuinely differs from its phpdoc one, so the native slot gets its
own build reading the walked body's native types. Arrow functions now
participate in the cache read: the flavour- and parameter-aware key answers
each ask from its own seeded slot.

Both seeding paths (this one and the closure one) are gated on the storage
having no parked fibers: a parked fiber may still append to the walk's
gathered data - the invalidate expressions of a write like $this->prop[] = ...
arrive only when the fiber flushes - so a seeded entry could be incomplete.
When anything is parked, the lazy ask keeps re-walking with the fibers
flushed, as before.

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01DaBZjgksga4c5s6Q9FniY7

Author: ondrejmirtes

src/Analyser/ExprHandler/ArrowFunctionHandler.php

@@ -41,7 +41,9 @@ public function supports(Expr $expr): bool
 
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
-		$result = $nodeScopeResolver->processArrowFunctionNode($stmt, $expr, $scope, $storage, $nodeCallback, null);
+		$arrowFunctionResult = $nodeScopeResolver->processArrowFunctionNode($stmt, $expr, $scope, $storage, $nodeCallback, null);
+		$this->closureTypeResolver->seedCacheFromArrowFunctionWalk($scope, $expr, $arrowFunctionResult, $storage);
+		$result = $arrowFunctionResult->getExpressionResult();
 
 		return $this->expressionResultFactory->create(
 			$result->getScope(),

src/Analyser/ExprHandler/ClosureHandler.php

@@ -42,7 +42,7 @@ public function supports(Expr $expr): bool
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult
 	{
 		$processClosureResult = $nodeScopeResolver->processClosureNode($stmt, $expr, $scope, $storage, $nodeCallback, $context, null);
-		$this->closureTypeResolver->seedCacheFromClosureWalk($scope, $expr, $processClosureResult);
+		$this->closureTypeResolver->seedCacheFromClosureWalk($scope, $expr, $processClosureResult, $storage);
 
 		return $this->expressionResultFactory->create(
 			$processClosureResult->applyByRefUseScope($processClosureResult->getScope()),

src/Analyser/ExprHandler/Helper/ClosureTypeResolver.php

@@ -14,6 +14,7 @@
 use PHPStan\Analyser\InternalThrowPoint;
 use PHPStan\Analyser\MutatingScope;
 use PHPStan\Analyser\NodeScopeResolver;
+use PHPStan\Analyser\ProcessArrowFunctionResult;
 use PHPStan\Analyser\ProcessClosureResult;
 use PHPStan\Analyser\Scope;
 use PHPStan\Analyser\StatementContext;
@@ -87,7 +88,7 @@ public function getClosureType(
 
 		$cachedTypes = $expr->getAttribute('phpstanCachedTypes', []);
 		$cacheKey = $this->closureContextCacheKey($scope, $expr, $callableParameters, $parameters);
-		if (!$expr instanceof ArrowFunction && array_key_exists($cacheKey, $cachedTypes)) {
+		if (array_key_exists($cacheKey, $cachedTypes)) {
 			return $this->createClosureTypeFromCache($expr, $parameters, $isVariadic, $cachedTypes[$cacheKey]);
 		}
 		if (self::$resolveClosureTypeDepth >= 2) {
@@ -322,8 +323,18 @@ public function buildClosureTypeForArrowFunction(
 	 * slot is seeded with the same build, keyed exactly as the
 	 * promoted-scope ask computes its key.
 	 */
-	public function seedCacheFromClosureWalk(MutatingScope $scope, Node\Expr\Closure $expr, ProcessClosureResult $processClosureResult): void
+	public function seedCacheFromClosureWalk(MutatingScope $scope, Node\Expr\Closure $expr, ProcessClosureResult $processClosureResult, ExpressionResultStorage $storage): void
 	{
+		// a parked fiber may still append to the walk's gathered data - the
+		// invalidate expressions of a write like $this->prop[] = ... arrive
+		// only when the fiber flushes (see the invalidate-expressions note in
+		// NodeScopeResolver::processArgs()). Seed only when nothing is parked,
+		// so a seeded entry is never incomplete; otherwise the lazy ask keeps
+		// re-walking with the fibers flushed, as before.
+		if ($storage->pendingFibers !== []) {
+			return;
+		}
+
 		// for array_map() callbacks and immediately invoked closures this
 		// delegates to a getClosureType() walk with the call-site parameter
 		// types; either way the phpdoc build lands in the cache under the
@@ -352,6 +363,39 @@ public function seedCacheFromClosureWalk(MutatingScope $scope, Node\Expr\Closure
 		$expr->setAttribute('phpstanCachedTypes', $cachedTypes);
 	}
 
+	/**
+	 * Arrow-function counterpart of seedCacheFromClosureWalk() (see
+	 * ArrowFunctionHandler::processExpr()). Unlike a closure, an arrow
+	 * function's native return type genuinely differs from its phpdoc one,
+	 * so the native-flavour slot is seeded with its own build reading the
+	 * walked body's native types.
+	 */
+	public function seedCacheFromArrowFunctionWalk(MutatingScope $scope, ArrowFunction $expr, ProcessArrowFunctionResult $arrowFunctionResult, ExpressionResultStorage $storage): void
+	{
+		// see the parked-fiber note in seedCacheFromClosureWalk()
+		if ($storage->pendingFibers !== []) {
+			return;
+		}
+
+		$this->buildClosureTypeForArrowFunction(
+			$scope,
+			$expr,
+			$arrowFunctionResult->getArrowFunctionScope(),
+			$arrowFunctionResult->getClosureTypeThrowPoints(),
+			$arrowFunctionResult->getClosureTypeImpurePoints(),
+			$arrowFunctionResult->getInvalidateExpressions(),
+		);
+		$this->buildClosureTypeForArrowFunction(
+			$scope,
+			$expr,
+			$arrowFunctionResult->getArrowFunctionScope(),
+			$arrowFunctionResult->getClosureTypeThrowPoints(),
+			$arrowFunctionResult->getClosureTypeImpurePoints(),
+			$arrowFunctionResult->getInvalidateExpressions(),
+			true,
+		);
+	}
+
 	/**
 	 * The cache key of everything this closure's type can depend on: the
 	 * enclosing scope plus the parameter types the caller feeds in -

src/Analyser/NodeScopeResolver.php

@@ -3198,7 +3198,7 @@ public function processArrowFunctionNode(
 		callable $nodeCallback,
 		?Type $passedToType,
 		?Type $nativePassedToType = null,
-	): ExpressionResult
+	): ProcessArrowFunctionResult
 	{
 		foreach ($expr->params as $param) {
 			$this->processParamNode($stmt, $param, $scope, $storage, $nodeCallback);
@@ -3216,9 +3216,49 @@ public function processArrowFunctionNode(
 			throw new ShouldNotHappenException();
 		}
 		$this->callNodeCallback($nodeCallback, new InArrowFunctionNode($arrowFunctionType, $expr), $arrowFunctionScope, $storage);
-		$exprResult = $this->processExprNode($stmt, $expr->expr, $arrowFunctionScope, $storage, $nodeCallback, ExpressionContext::createTopLevel());
 
-		return $this->expressionResultFactory->create($scope, beforeScope: $scope, expr: $expr, hasYield: false, isAlwaysTerminating: $exprResult->isAlwaysTerminating(), throwPoints: $exprResult->getThrowPoints(), impurePoints: $exprResult->getImpurePoints());
+		// Gather the property-assign impure points and invalidate expressions the
+		// arrow function type needs (mirroring ClosureTypeResolver::getClosureType()),
+		// on top of the regular rule node callback, so the single body walk here
+		// feeds ClosureTypeResolver::buildClosureTypeForArrowFunction().
+		$arrowFunctionImpurePoints = [];
+		$invalidateExpressions = [];
+		$arrowFunctionStmtsCallback = new GatheringNodeCallback(static function (Node $node, Scope $innerScope) use ($arrowFunctionScope, &$arrowFunctionImpurePoints, &$invalidateExpressions): void {
+			if ($innerScope->getAnonymousFunctionReflection() !== $arrowFunctionScope->getAnonymousFunctionReflection()) {
+				return;
+			}
+
+			if ($node instanceof InvalidateExprNode) {
+				$invalidateExpressions[] = $node;
+				return;
+			}
+
+			if (!$node instanceof PropertyAssignNode) {
+				return;
+			}
+
+			$arrowFunctionImpurePoints[] = new ImpurePoint(
+				$innerScope,
+				$node,
+				'propertyAssign',
+				'property assignment',
+				true,
+			);
+			$invalidateExpressions[] = new InvalidateExprNode($node->getPropertyFetch());
+		}, $nodeCallback);
+
+		$exprResult = $this->processExprNode($stmt, $expr->expr, $arrowFunctionScope, $storage, $arrowFunctionStmtsCallback, ExpressionContext::createTopLevel());
+
+		$closureTypeThrowPoints = array_map(static fn (InternalThrowPoint $throwPoint) => $throwPoint->toPublic(), $exprResult->getThrowPoints());
+		$closureTypeImpurePoints = array_merge($arrowFunctionImpurePoints, $exprResult->getImpurePoints());
+
+		return new ProcessArrowFunctionResult(
+			$this->expressionResultFactory->create($scope, beforeScope: $scope, expr: $expr, hasYield: false, isAlwaysTerminating: $exprResult->isAlwaysTerminating(), throwPoints: $exprResult->getThrowPoints(), impurePoints: $exprResult->getImpurePoints()),
+			$arrowFunctionScope,
+			$closureTypeThrowPoints,
+			$closureTypeImpurePoints,
+			$invalidateExpressions,
+		);
 	}
 
 	/**
@@ -3918,7 +3958,7 @@ public function processArgs(
 				}
 
 				$this->callNodeCallbackWithExpression($nodeCallback, $arg->value, $scopeToPass, $storage, $context);
-				$arrowFunctionResult = $this->processArrowFunctionNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $parameterType, $parameterNativeType);
+				$arrowFunctionResult = $this->processArrowFunctionNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $parameterType, $parameterNativeType)->getExpressionResult();
 				if ($this->callCallbackImmediately($parameter, $parameterType, $calleeReflection)) {
 					$throwPoints = array_merge($throwPoints, array_map(static fn (InternalThrowPoint $throwPoint) => $throwPoint->isExplicit() ? InternalThrowPoint::createExplicit($scope, $throwPoint->getType(), $arg->value, $throwPoint->canContainAnyThrowable()) : InternalThrowPoint::createImplicit($scope, $arg->value), $arrowFunctionResult->getThrowPoints()));
 					$impurePoints = array_merge($impurePoints, $arrowFunctionResult->getImpurePoints());

src/Analyser/ProcessArrowFunctionResult.php

@@ -0,0 +1,59 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Node\InvalidateExprNode;
+
+final class ProcessArrowFunctionResult
+{
+
+	/**
+	 * @param ThrowPoint[] $closureTypeThrowPoints public throw points for building the arrow function type
+	 * @param ImpurePoint[] $closureTypeImpurePoints already merged in getClosureType() order (property-assign impure points first, then expression result impure points)
+	 * @param InvalidateExprNode[] $invalidateExpressions
+	 */
+	public function __construct(
+		private ExpressionResult $expressionResult,
+		private MutatingScope $arrowFunctionScope,
+		private array $closureTypeThrowPoints,
+		private array $closureTypeImpurePoints,
+		private array $invalidateExpressions,
+	)
+	{
+	}
+
+	public function getExpressionResult(): ExpressionResult
+	{
+		return $this->expressionResult;
+	}
+
+	public function getArrowFunctionScope(): MutatingScope
+	{
+		return $this->arrowFunctionScope;
+	}
+
+	/**
+	 * @return ThrowPoint[]
+	 */
+	public function getClosureTypeThrowPoints(): array
+	{
+		return $this->closureTypeThrowPoints;
+	}
+
+	/**
+	 * @return ImpurePoint[]
+	 */
+	public function getClosureTypeImpurePoints(): array
+	{
+		return $this->closureTypeImpurePoints;
+	}
+
+	/**
+	 * @return InvalidateExprNode[]
+	 */
+	public function getInvalidateExpressions(): array
+	{
+		return $this->invalidateExpressions;
+	}
+
+}