Preserve property fetch types in immediately invoked closures

When a closure is immediately invoked (IIFE or callback passed to
functions like array_map), property fetch types should be carried
forward into the closure scope since the closure runs before
properties can be modified.

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

Author: phpstan-bot

src/Analyser/MutatingScope.php

@@ -36,6 +36,7 @@
 use PHPStan\Node\Printer\ExprPrinter;
 use PHPStan\Node\VirtualNode;
 use PHPStan\Parser\ArrayMapArgVisitor;
+use PHPStan\Parser\ImmediatelyInvokedClosureVisitor;
 use PHPStan\Parser\Parser;
 use PHPStan\Php\PhpVersion;
 use PHPStan\Php\PhpVersionFactory;
@@ -2088,7 +2089,12 @@ public function enterAnonymousFunctionWithoutReflection(
 				|| $expr instanceof Expr\StaticPropertyFetch
 				|| $expr instanceof Expr\StaticCall
 			) {
-				continue;
+				if (
+					$closure->getAttribute(ImmediatelyInvokedClosureVisitor::ATTRIBUTE_NAME) !== true
+					&& $closure->getAttribute(NodeScopeResolver::IMMEDIATELY_CALLED_CALLBACK_ATTRIBUTE_NAME) !== true
+				) {
+					continue;
+				}
 			}
 
 			$expressionTypes[$exprString] = $typeHolder;

src/Analyser/NodeScopeResolver.php

@@ -187,6 +187,8 @@ class NodeScopeResolver
 	private const LOOP_SCOPE_ITERATIONS = 3;
 	private const GENERALIZE_AFTER_ITERATION = 1;
 
+	public const IMMEDIATELY_CALLED_CALLBACK_ATTRIBUTE_NAME = 'isImmediatelyCalledCallback';
+
 	/** @var array<string, true> filePath(string) => bool(true) */
 	private array $analysedFiles = [];
 
@@ -3332,8 +3334,12 @@ public function processArgs(
 				}
 
 				$this->callNodeCallbackWithExpression($nodeCallback, $arg->value, $scopeToPass, $storage, $context);
+				$callImmediately = $this->callCallbackImmediately($parameter, $parameterType, $calleeReflection);
+				if ($callImmediately) {
+					$arg->value->setAttribute(self::IMMEDIATELY_CALLED_CALLBACK_ATTRIBUTE_NAME, true);
+				}
 				$closureResult = $this->processClosureNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $context, $parameterType ?? null);
-				if ($this->callCallbackImmediately($parameter, $parameterType, $calleeReflection)) {
+				if ($callImmediately) {
 					$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), $closureResult->getThrowPoints()));
 					$impurePoints = array_merge($impurePoints, $closureResult->getImpurePoints());
 					$isAlwaysTerminating = $isAlwaysTerminating || $closureResult->isAlwaysTerminating();

tests/PHPStan/Analyser/nsrt/specified-types-closure-use.php

@@ -34,6 +34,24 @@ function () use ($call, &$a): void {
 		}
 	}
 
+	public function doImmediatelyInvoked(MethodCall $call): void
+	{
+		if ($call->name instanceof Identifier) {
+			array_map(function () use ($call): void {
+				assertType('PhpParser\Node\Identifier', $call->name);
+			}, [1]);
+		}
+	}
+
+	public function doIife(MethodCall $call): void
+	{
+		if ($call->name instanceof Identifier) {
+			(function () use ($call): void {
+				assertType('PhpParser\Node\Identifier', $call->name);
+			})();
+		}
+	}
+
 	public function doBaz(array $arr, string $key): void
 	{
 		$arr[$key] = 'test';

tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php

@@ -62,7 +62,20 @@ public function testBug8056(): void
 
 	public function testBug10345(): void
 	{
-		$this->analyse([__DIR__ . '/data/bug-10345.php'], []);
+		$this->analyse([__DIR__ . '/data/bug-10345.php'], [
+			[
+				'Empty array passed to foreach.',
+				153,
+			],
+			[
+				'Empty array passed to foreach.',
+				170,
+			],
+			[
+				'Empty array passed to foreach.',
+				185,
+			],
+		]);
 	}
 
 }

tests/PHPStan/Rules/Arrays/data/bug-10345.php

@@ -139,3 +139,50 @@ public static function setItems(array $items): void
 
 	$a6 = $func6();
 }
+
+// Immediately invoked closure should keep the type
+$container7 = new \stdClass();
+$container7->items = [];
+
+assertType('stdClass', $container7);
+assertType('array{}', $container7->items);
+$result7 = array_map(
+	function() use ($container7): int {
+		assertType('stdClass', $container7);
+		assertType('array{}', $container7->items);
+		foreach ($container7->items as $item) {
+		}
+		return 1;
+	},
+	[1, 2, 3],
+);
+
+// Immediately invoked closure with declared property should also keep the type
+$container8 = new Foo();
+$container8->items = [];
+
+assertType('Bug10345\Foo', $container8);
+assertType('array{}', $container8->items);
+$result8 = array_map(
+	function() use ($container8): int {
+		assertType('Bug10345\Foo', $container8);
+		assertType('array{}', $container8->items);
+		foreach ($container8->items as $item) {}
+		return 1;
+	},
+	[1, 2, 3],
+);
+
+// IIFE should keep the type
+$container9 = new \stdClass();
+$container9->items = [];
+
+assertType('stdClass', $container9);
+assertType('array{}', $container9->items);
+$result9 = (function() use ($container9): int {
+	assertType('stdClass', $container9);
+	assertType('array{}', $container9->items);
+	foreach ($container9->items as $item) {
+	}
+	return 1;
+})();