Resolve generic parameter types from an array literal argument's skeleton before typing the closures nested in it

- `ArgumentsHandler::processArgs()` now pins a structural skeleton for an
  array-literal argument that holds closures, before the argument is walked,
  so the per-argument acceptor resolution can infer the callee's templates
  from the array's own keys and non-closure values instead of padding the
  whole argument with `mixed` and falling back to the templates' bounds.
- New `ArgumentsHandler::gatherArrayArgTypeSkeleton()` builds that skeleton
  without walking anything: nested array literals recurse, closures/arrow
  functions contribute `ClosureTypeResolver::getDeclaredClosureType()`, and
  every other key/value is priced from scope state, then from
  `InitializerExprTypeResolver` (literals, `::class`, constants, concatenation),
  and finally `mixed`. A `mixed` slot can never resolve a template below its
  bound, so the skeleton only ever sharpens the resolution.
- The skeleton never reaches `$gatheredTypes`; the argument's real type
  replaces it once the walk is done, so the call's return type and the
  reported argument type are unchanged.
- The same code path covers the analogous cases, each with its own assertion
  in the regression test: templates pinned by a sibling *value* of the array
  (in either order), nested array literals, `callable(T)` instead of
  `Closure(T)`, `class-string<T>` keys, variadic array parameters, named
  arguments, and methods / static methods / constructors.

Author: phpstan-bot

src/Analyser/ArgumentsHandler.php

@@ -30,6 +30,8 @@
 use PHPStan\Reflection\ExtendedMethodReflection;
 use PHPStan\Reflection\ExtendedParameterReflection;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Reflection\InitializerExprContext;
+use PHPStan\Reflection\InitializerExprTypeResolver;
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Reflection\ParameterReflection;
 use PHPStan\Reflection\ParametersAcceptor;
@@ -119,6 +121,7 @@ public function __construct(
 		private AssignHandler $assignHandler,
 		private ClosureTypeResolver $closureTypeResolver,
 		private ClosureParameterResolver $closureParameterResolver,
+		private InitializerExprTypeResolver $initializerExprTypeResolver,
 	)
 	{
 	}
@@ -235,6 +238,19 @@ public function processArgs(
 					? $this->gatherClosureArgType($parametersAcceptors, $i, $arg->value, $scope)
 					: $this->closureTypeResolver->getClosureType($scope, $arg->value, true, $storage);
 				$this->addGatheredArgType($gatheredTypes, $gatheredUnpack, $gatheredHasName, $originalArgForGather, $i, $gatheredArgTypeByIndex[$i]);
+			} elseif (
+				$argMetadataIsTypeDriven
+				&& !$arg->unpack
+				&& $arg->value instanceof Expr\Array_
+				&& $this->argConsumesResolvedParameterType($arg->value)
+			) {
+				// An array literal holding closures decides the templates of its own
+				// parameter through its keys and its non-closure values - and those
+				// very templates type the closures nested in it. Pin a SKELETON of the
+				// array (declared closure signatures, scope-known leaves, mixed for
+				// anything that needs a walk) so the per-argument resolution below sees
+				// them; the walk that follows overwrites it with the real type.
+				$gatheredArgTypeByIndex[$i] = $this->gatherArrayArgTypeSkeleton($nodeScopeResolver, $arg->value, $scope);
 			}
 
 			$argMetadataAcceptor = $metadataAcceptor;
@@ -938,6 +954,40 @@ private function gatherClosureArgType(array $parametersAcceptors, int $i, Expr $
 		return $this->closureParameterResolver->resolveCallableTypeForScope($closureExpr, $scope);
 	}
 
+	/**
+	 * A structural stand-in for an array literal argument that holds closures,
+	 * built without walking anything: a nested array literal recurses, a closure /
+	 * arrow function contributes its DECLARED signature
+	 * (ClosureTypeResolver::getDeclaredClosureType()), and every other key/value
+	 * is priced by the scope state it is already tracked as, falling back to the
+	 * constant-expression resolver (literals, ::class, constants, concatenation)
+	 * and ultimately to mixed. Widening a slot to mixed is safe: a template is
+	 * never resolved below its bound, so the skeleton can only ever sharpen the
+	 * resolution.
+	 *
+	 * Unlike gatherClosureArgType() this type never reaches $gatheredTypes: it
+	 * exists solely to resolve the parameter type the nested closures are typed
+	 * from. The argument's real type replaces it once the walk is done.
+	 */
+	private function gatherArrayArgTypeSkeleton(NodeScopeResolver $nodeScopeResolver, Expr\Array_ $expr, MutatingScope $scope): Type
+	{
+		$initializerContext = InitializerExprContext::fromScope($scope);
+		$getType = function (Expr $inner) use (&$getType, $nodeScopeResolver, $scope, $initializerContext): Type {
+			if ($inner instanceof Expr\Closure || $inner instanceof Expr\ArrowFunction) {
+				return $this->closureTypeResolver->getDeclaredClosureType($scope, $inner);
+			}
+
+			if ($inner instanceof Expr\Array_) {
+				return $this->initializerExprTypeResolver->getArrayType($inner, $getType);
+			}
+
+			return $nodeScopeResolver->findScopeStateType($inner, $scope)
+				?? $this->initializerExprTypeResolver->getType($inner, $initializerContext);
+		};
+
+		return $this->initializerExprTypeResolver->getArrayType($expr, $getType);
+	}
+
 	/**
 	 * @param array<int|string, Type> $types
 	 * @param ParametersAcceptor[] $parametersAcceptors

tests/PHPStan/Analyser/nsrt/bug-15269.php

@@ -0,0 +1,184 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug15269;
+
+use Closure;
+use stdClass;
+use function PHPStan\Testing\assertType;
+
+/**
+ * @template TColumn of string
+ * @param array<TColumn, \Closure(TColumn): string> $formatters
+ */
+function formatColumns(array $formatters): void
+{
+}
+
+formatColumns([
+	'name' => function ($column) {
+		assertType("'email'|'name'", $column);
+		return strtoupper($column);
+	},
+	'email' => fn ($column) => assertType("'email'|'name'", $column),
+]);
+
+/**
+ * @template T
+ * @param array{0: T, 1: \Closure(T): void} $a
+ */
+function siblingValue(array $a): void
+{
+}
+
+siblingValue([1, function ($x) {
+	assertType('1', $x);
+}]);
+
+/**
+ * @template T
+ * @param array{0: \Closure(T): void, 1: T} $a
+ */
+function siblingValueReversed(array $a): void
+{
+}
+
+siblingValueReversed([function ($x) {
+	assertType("'foo'", $x);
+}, 'foo']);
+
+/**
+ * @template T of string
+ * @param array<string, array<T, \Closure(T): string>> $f
+ */
+function nested(array $f): void
+{
+}
+
+nested(['group' => ['inner' => function ($x) {
+	assertType("'inner'", $x);
+	return 'z';
+}]]);
+
+/**
+ * @template T of string
+ * @param array<T, callable(T): string> $f
+ */
+function withCallable(array $f): void
+{
+}
+
+withCallable(['e' => function ($x) {
+	assertType("'e'", $x);
+	return 'z';
+}]);
+
+/**
+ * @template T of object
+ * @param array<class-string<T>, \Closure(T): void> $handlers
+ */
+function handlers(array $handlers): void
+{
+}
+
+handlers([stdClass::class => function ($o) {
+	assertType('stdClass', $o);
+}]);
+
+/**
+ * @template T of string
+ * @param array<T, \Closure(T): string> ...$f
+ */
+function variadic(array ...$f): void
+{
+}
+
+variadic(['v' => function ($x) {
+	assertType("'v'", $x);
+	return 'z';
+}]);
+
+/**
+ * @template T of string
+ * @param array<T, \Closure(T): string> $f
+ */
+function named(array $f): void
+{
+}
+
+named(f: ['n' => fn ($x) => assertType("'n'", $x)]);
+
+/**
+ * @template T of string
+ * @param array{0: T, 1: \Closure(T): void} $a
+ */
+function boundedUnknown(array $a): void
+{
+}
+
+function unknownString(): string
+{
+	return 'x';
+}
+
+// the first slot cannot be priced without a walk, so the template stays at its
+// bound instead of being widened to mixed
+boundedUnknown([unknownString(), function ($x) {
+	assertType('string', $x);
+}]);
+
+class Svc
+{
+
+	/**
+	 * @template T of string
+	 * @param array<T, \Closure(T): string> $f
+	 */
+	public function __construct(array $f)
+	{
+	}
+
+	/**
+	 * @template T of string
+	 * @param array<T, \Closure(T): string> $f
+	 */
+	public function method(array $f): void
+	{
+	}
+
+	/**
+	 * @template T of string
+	 * @param array<T, \Closure(T): string> $f
+	 */
+	public static function staticMethod(array $f): void
+	{
+	}
+
+}
+
+$svc = new Svc(['a' => function ($x) {
+	assertType("'a'", $x);
+	return 'z';
+}]);
+$svc->method(['b' => function ($x) {
+	assertType("'b'", $x);
+	return 'z';
+}]);
+Svc::staticMethod(['c' => function ($x) {
+	assertType("'c'", $x);
+	return 'z';
+}]);
+
+/**
+ * @template T
+ * @template U
+ * @param array{\Closure(T): U, T} $a
+ * @return U
+ */
+function inferReturn(array $a)
+{
+	throw new \Exception();
+}
+
+assertType("'3'", inferReturn([fn ($x) => (string) $x, 3]));