Use callCallbackImmediately() instead of hardcoded ArrayMapArgVisitor check

Instead of hardcoding ArrayMapArgVisitor in MutatingScope to determine if
a closure is immediately invoked, set the ImmediatelyInvokedClosureVisitor
attribute in NodeScopeResolver based on callCallbackImmediately(). This
relies on PHPStan's existing mechanism for determining immediate vs later
invocation, which respects @param-immediately-invoked-callable and
@param-later-invoked-callable PHPDoc tags, and defaults to immediately
invoked for function calls and later invoked for method calls.

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

Author: phpstan-bot

src/Analyser/MutatingScope.php

@@ -2155,7 +2155,6 @@ public function enterAnonymousFunctionWithoutReflection(
 
 			if (
 				$closure->getAttribute(ImmediatelyInvokedClosureVisitor::ATTRIBUTE_NAME) !== true
-				&& $closure->getAttribute(ArrayMapArgVisitor::ATTRIBUTE_NAME) === null
 				&& (
 					$expr instanceof PropertyFetch
 					|| $expr instanceof MethodCall

src/Analyser/NodeScopeResolver.php

@@ -3406,9 +3406,14 @@ public function processArgs(
 					}
 				}
 
+				$callCallbackImmediately = $this->callCallbackImmediately($parameter, $parameterType, $calleeReflection);
+				if ($callCallbackImmediately) {
+					$arg->value->setAttribute(ImmediatelyInvokedClosureVisitor::ATTRIBUTE_NAME, true);
+				}
+
 				$this->callNodeCallbackWithExpression($nodeCallback, $arg->value, $scopeToPass, $storage, $context);
 				$closureResult = $this->processClosureNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $context, $parameterType ?? null);
-				if ($this->callCallbackImmediately($parameter, $parameterType, $calleeReflection)) {
+				if ($callCallbackImmediately) {
 					$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();
@@ -3464,9 +3469,14 @@ public function processArgs(
 					}
 				}
 
+				$callCallbackImmediately = $this->callCallbackImmediately($parameter, $parameterType, $calleeReflection);
+				if ($callCallbackImmediately) {
+					$arg->value->setAttribute(ImmediatelyInvokedClosureVisitor::ATTRIBUTE_NAME, true);
+				}
+
 				$this->callNodeCallbackWithExpression($nodeCallback, $arg->value, $scopeToPass, $storage, $context);
 				$arrowFunctionResult = $this->processArrowFunctionNode($stmt, $arg->value, $scopeToPass, $storage, $nodeCallback, $parameterType ?? null);
-				if ($this->callCallbackImmediately($parameter, $parameterType, $calleeReflection)) {
+				if ($callCallbackImmediately) {
 					$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());
 					$isAlwaysTerminating = $isAlwaysTerminating || $arrowFunctionResult->isAlwaysTerminating();

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

@@ -89,4 +89,31 @@ public function doArrayMap(MethodCall $call): void
 		}
 	}
 
+	public function doGenericFunctionCall(MethodCall $call): void
+	{
+		if ($call->name instanceof Identifier) {
+			// Generic function with callable parameter - immediately invoked by default
+			usort([1], function () use ($call): int {
+				assertType('PhpParser\Node\Identifier', $call->name);
+				return 0;
+			});
+		}
+	}
+
+	public function doLaterInvokedCallable(MethodCall $call): void
+	{
+		if ($call->name instanceof Identifier) {
+			// @param-later-invoked-callable - property types should NOT be carried forward
+			laterInvoke(function () use ($call): void {
+				assertType('PhpParser\Node\Expr|PhpParser\Node\Identifier', $call->name);
+			});
+		}
+	}
+
+}
+
+/**
+ * @param-later-invoked-callable $callback
+ */
+function laterInvoke(callable $callback): void {
 }

tests/PHPStan/Rules/Arrays/DeadForeachRuleTest.php

@@ -66,6 +66,10 @@ public function testBug10345(): void
 				'Empty array passed to foreach.',
 				134,
 			],
+			[
+				'Empty array passed to foreach.',
+				152,
+			],
 		]);
 	}
 

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

@@ -134,3 +134,37 @@ public static function setItems(array $items): void
 	foreach ($container8->items as $item) {}
 	return 1;
 }, [1]);
+
+// Generic function with callable parameter - immediately invoked by default
+/**
+ * @template T
+ * @param callable(): T $callback
+ * @return T
+ */
+function invoke(callable $callback): mixed {
+	return $callback();
+}
+
+$container9 = new \stdClass();
+$container9->items = [];
+
+$result9 = invoke(function() use ($container9): int {
+	foreach ($container9->items as $item) {} // should report error - immediately invoked
+	return 1;
+});
+
+// Function with @param-later-invoked-callable - should NOT report error
+/**
+ * @param-later-invoked-callable $callback
+ */
+function invokeLater(callable $callback): void {
+	// stores callback for later
+}
+
+$container10 = new \stdClass();
+$container10->items = [];
+
+invokeLater(function() use ($container10): int {
+	foreach ($container10->items as $item) {} // should NOT report error - later invoked
+	return 1;
+});