Fix template type resolution for spread of associative arrays

- When spreading an associative constant array into a function/method call,
  ParametersAcceptorSelector::selectFromArgs() now expands string-keyed
  constant arrays into individual named type entries instead of collapsing
  them into a single getIterableValueType() call
- This allows GenericParametersAcceptorResolver to correctly map argument
  types to parameters by name, preventing template types from being
  incorrectly inferred from default values
- Added regression tests for both function calls and class constructors

Closes phpstan/phpstan#12363

Author: github-actions[bot]

src/Reflection/ParametersAcceptorSelector.php

@@ -516,7 +516,36 @@ public static function selectFromArgs(
 			}
 			if ($originalArg->unpack) {
 				$unpack = true;
-				$types[$index] = $type->getIterableValueType();
+				$constantArrays = $type->getConstantArrays();
+				$expanded = false;
+				if (count($constantArrays) > 0) {
+					$allStringKeys = true;
+					foreach ($constantArrays as $constantArray) {
+						foreach ($constantArray->getKeyTypes() as $keyType) {
+							if (!$keyType->isString()->yes()) {
+								$allStringKeys = false;
+								break 2;
+							}
+						}
+					}
+					if ($allStringKeys) {
+						foreach ($constantArrays as $constantArray) {
+							foreach ($constantArray->getKeyTypes() as $j => $keyType) {
+								$keyName = $keyType->getValue();
+								if (!isset($types[$keyName])) {
+									$types[$keyName] = $constantArray->getValueTypes()[$j];
+								} else {
+									$types[$keyName] = TypeCombinator::union($types[$keyName], $constantArray->getValueTypes()[$j]);
+								}
+							}
+						}
+						$hasName = true;
+						$expanded = true;
+					}
+				}
+				if (!$expanded) {
+					$types[$index] = $type->getIterableValueType();
+				}
 			} else {
 				$types[$index] = $type;
 			}

tests/PHPStan/Rules/Classes/InstantiationRuleTest.php

@@ -579,6 +579,11 @@ public function testBug13440(): void
 		$this->analyse([__DIR__ . '/data/bug-13440.php'], []);
 	}
 
+	public function testBug12363(): void
+	{
+		$this->analyse([__DIR__ . '/../Methods/data/bug-12363.php'], []);
+	}
+
 	public function testNewStaticWithConsistentConstructor(): void
 	{
 		$this->analyse([__DIR__ . '/data/instantiation-new-static-consistent-constructor.php'], [

tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php

@@ -2735,4 +2735,9 @@ public function testBug10559(): void
 		$this->analyse([__DIR__ . '/data/bug-10559.php'], []);
 	}
 
+	public function testBug12363(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-12363.php'], []);
+	}
+
 }

tests/PHPStan/Rules/Functions/data/bug-12363.php

@@ -0,0 +1,26 @@
+<?php // lint >= 8.0
+
+declare(strict_types = 1);
+
+namespace Bug12363;
+
+/**
+ * @template Y of 'a'|'b'
+ * @param Y $y
+ */
+function f(int $x, string $y = 'a'): void {}
+
+// Spreading associative array with required + optional template param
+f(...['x' => 5, 'y' => 'b']);
+
+// Without spread - should also work
+f(5, 'b');
+
+/**
+ * @template Y of 'a'|'b'
+ * @param Y $y
+ */
+function g(string $y = 'a'): void {}
+
+// Without preceding required arg - already works
+g(...['y' => 'b']);

tests/PHPStan/Rules/Methods/data/bug-12363.php

@@ -0,0 +1,22 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace Bug12363Methods;
+
+/**
+ * @template Y of 'a'|'b'
+ */
+class A
+{
+	/**
+	 * @param Y $y
+	 */
+	public function __construct(
+		public readonly int $x,
+		public readonly string $y = 'a',
+	) {
+	}
+}
+
+$a = new A(...['x' => 5, 'y' => 'b']);