Infer precise array shape unions in array unpacking

conf/bleedingEdge.neon

@@ -1,6 +1,7 @@
 parameters:
 	featureToggles:
 		bleedingEdge: true
+		preciseArrayShapeUnpacking: true
 		checkNonStringableDynamicAccess: true
 		checkParameterCastableToNumberFunctions: true
 		skipCheckGenericClasses!: []

conf/config.neon

@@ -26,6 +26,7 @@ parameters:
 			throwTypeCovariance: false
 	featureToggles:
 		bleedingEdge: false
+		preciseArrayShapeUnpacking: false
 		checkNonStringableDynamicAccess: false
 		checkParameterCastableToNumberFunctions: false
 		skipCheckGenericClasses:

conf/parametersSchema.neon

@@ -30,6 +30,7 @@ parametersSchema:
 	])
 	featureToggles: structure([
 		bleedingEdge: bool(),
+		preciseArrayShapeUnpacking: bool(),
 		checkNonStringableDynamicAccess: bool(),
 		checkParameterCastableToNumberFunctions: bool(),
 		skipCheckGenericClasses: listOf(string()),

src/DependencyInjection/ValidateIgnoredErrorsExtension.php

@@ -124,7 +124,7 @@ public function resolveTypeAlias(string $aliasName, NameScope $nameScope): ?Type
 
 						}),
 						$constantResolver,
-						new InitializerExprTypeResolver($constantResolver, $reflectionProviderProvider, new PhpVersion(PHP_VERSION_ID), new OperatorTypeSpecifyingExtensionRegistry(new DirectExtensionsCollection([])), new UnaryOperatorTypeSpecifyingExtensionRegistry(new DirectExtensionsCollection([])), new OversizedArrayBuilder(), true),
+						new InitializerExprTypeResolver($constantResolver, $reflectionProviderProvider, new PhpVersion(PHP_VERSION_ID), new OperatorTypeSpecifyingExtensionRegistry(new DirectExtensionsCollection([])), new UnaryOperatorTypeSpecifyingExtensionRegistry(new DirectExtensionsCollection([])), new OversizedArrayBuilder(), true, $builder->parameters['featureToggles']['preciseArrayShapeUnpacking']),
 						reportUnsafeArrayStringKeyCasting: null,
 					),
 				),

src/Reflection/InitializerExprTypeResolver.php

@@ -110,6 +110,7 @@
 use function dirname;
 use function floor;
 use function in_array;
+use function intdiv;
 use function intval;
 use function is_finite;
 use function is_float;
@@ -128,6 +129,7 @@ final class InitializerExprTypeResolver
 {
 
 	public const CALCULATE_SCALARS_LIMIT = 128;
+	private const CALCULATE_ARRAYS_LIMIT = 32;
 
 	/** @var array<string, true> */
 	private array $currentlyResolvingClassConstant = [];
@@ -144,6 +146,8 @@ public function __construct(
 		private OversizedArrayBuilder $oversizedArrayBuilder,
 		#[AutowiredParameter]
 		private bool $usePathConstantsAsConstantString,
+		#[AutowiredParameter(ref: '%featureToggles.preciseArrayShapeUnpacking%')]
+		private bool $preciseArrayShapeUnpacking,
 	)
 	{
 	}
@@ -642,11 +646,99 @@ public function getArrayType(Expr\Array_ $expr, callable $getTypeCallback): Type
 			return $this->oversizedArrayBuilder->build($expr, $getTypeCallback);
 		}
 
+		$valueTypes = [];
+		$keyTypes = [];
+		if ($this->preciseArrayShapeUnpacking) {
+			$constantArrayVariantsByItemIndex = [];
+			$constantArraysCombinationsCount = 1;
+			$hasConstantArrayUnion = false;
+			$canResolveConstantArraysPrecisely = true;
+			foreach ($expr->items as $itemIndex => $arrayItem) {
+				$valueType = $getTypeCallback($arrayItem->value);
+				$valueTypes[$itemIndex] = $valueType;
+
+				if (!$arrayItem->unpack) {
+					$keyTypes[$itemIndex] = $arrayItem->key !== null
+						? $getTypeCallback($arrayItem->key)
+						: null;
+					continue;
+				}
+
+				$constantArrays = $valueType->getConstantArrays();
+				$constantArraysCount = count($constantArrays);
+				$constantArrayVariantsByItemIndex[$itemIndex] = $constantArrays;
+
+				if ($constantArraysCount === 0) {
+					$canResolveConstantArraysPrecisely = false;
+					continue;
+				}
+
+				if ($constantArraysCount > 1) {
+					$hasConstantArrayUnion = true;
+				}
+
+				if ($constantArraysCount > self::CALCULATE_ARRAYS_LIMIT
+					|| $constantArraysCombinationsCount > intdiv(self::CALCULATE_ARRAYS_LIMIT, $constantArraysCount)
+				) {
+					$canResolveConstantArraysPrecisely = false;
+					continue;
+				}
+
+				$constantArraysCombinationsCount *= $constantArraysCount;
+			}
+
+			if ($hasConstantArrayUnion && $canResolveConstantArraysPrecisely) {
+				$arrayBuilders = [ConstantArrayTypeBuilder::createEmpty()];
+				$keepStringKeys = $this->phpVersion->supportsArrayUnpackingWithStringKeys();
+
+				foreach ($expr->items as $itemIndex => $arrayItem) {
+					if (!$arrayItem->unpack) {
+						foreach ($arrayBuilders as $arrayBuilder) {
+							$arrayBuilder->setOffsetValueType(
+								$keyTypes[$itemIndex],
+								$valueTypes[$itemIndex],
+							);
+						}
+
+						continue;
+					}
+
+					$newArrayBuilders = [];
+
+					foreach ($arrayBuilders as $arrayBuilder) {
+						foreach ($constantArrayVariantsByItemIndex[$itemIndex] as $constantArray) {
+							$newArrayBuilder = clone $arrayBuilder;
+
+							foreach ($constantArray->getKeyTypes() as $j => $keyType) {
+								$newArrayBuilder->setOffsetValueType(
+									$keepStringKeys && $keyType->isString()->yes() ? $keyType : null,
+									$constantArray->getValueTypes()[$j],
+									$constantArray->isOptionalKey($j),
+								);
+							}
+
+							$newArrayBuilders[] = $newArrayBuilder;
+						}
+					}
+
+					$arrayBuilders = $newArrayBuilders;
+				}
+
+				$arrayTypes = [];
+
+				foreach ($arrayBuilders as $arrayBuilder) {
+					$arrayTypes[] = $arrayBuilder->getArray();
+				}
+
+				return TypeCombinator::union(...$arrayTypes);
+			}
+		}
+
 		$arrayBuilder = ConstantArrayTypeBuilder::createEmpty();
 		$isList = null;
 		$hasOffsetValueTypes = [];
-		foreach ($expr->items as $arrayItem) {
-			$valueType = $getTypeCallback($arrayItem->value);
+		foreach ($expr->items as $itemIndex => $arrayItem) {
+			$valueType = $valueTypes[$itemIndex] ?? $getTypeCallback($arrayItem->value);
 			if ($arrayItem->unpack) {
 				$constantArrays = $valueType->getConstantArrays();
 				if (count($constantArrays) > 0) {
@@ -739,7 +831,9 @@ public function getArrayType(Expr\Array_ $expr, callable $getTypeCallback): Type
 				}
 			} else {
 				$arrayBuilder->setOffsetValueType(
-					$arrayItem->key !== null ? $getTypeCallback($arrayItem->key) : null,
+					array_key_exists($itemIndex, $keyTypes)
+						? $keyTypes[$itemIndex]
+						: ($arrayItem->key !== null ? $getTypeCallback($arrayItem->key) : null),
 					$valueType,
 				);
 			}

src/Testing/PHPStanTestCase.php

@@ -106,6 +106,7 @@ public static function createScopeFactory(ReflectionProvider $reflectionProvider
 			$container->getByType(UnaryOperatorTypeSpecifyingExtensionRegistry::class),
 			new OversizedArrayBuilder(),
 			$container->getParameter('usePathConstantsAsConstantString'),
+			$container->getParameter('featureToggles')['preciseArrayShapeUnpacking'],
 		);
 
 		return new ScopeFactory(

tests/PHPStan/Analyser/PreciseArrayShapeUnpackingLegacyTest.php

@@ -0,0 +1,29 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+final class PreciseArrayShapeUnpackingLegacyTest extends TypeInferenceTestCase
+{
+
+	public static function dataFileAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/precise-array-shape-unpacking-legacy.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataFileAsserts')]
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+}

tests/PHPStan/Analyser/PreciseArrayShapeUnpackingTest.php

@@ -0,0 +1,36 @@
+<?php declare(strict_types = 1);
+
+namespace PHPStan\Analyser;
+
+use PHPStan\Testing\TypeInferenceTestCase;
+use PHPUnit\Framework\Attributes\DataProvider;
+
+final class PreciseArrayShapeUnpackingTest extends TypeInferenceTestCase
+{
+
+	public static function dataFileAsserts(): iterable
+	{
+		yield from self::gatherAssertTypes(__DIR__ . '/data/precise-array-shape-unpacking.php');
+	}
+
+	/**
+	 * @param mixed ...$args
+	 */
+	#[DataProvider('dataFileAsserts')]
+	public function testFileAsserts(
+		string $assertType,
+		string $file,
+		...$args,
+	): void
+	{
+		$this->assertFileAsserts($assertType, $file, ...$args);
+	}
+
+	public static function getAdditionalConfigFiles(): array
+	{
+		return [
+			__DIR__ . '/../../../conf/bleedingEdge.neon',
+		];
+	}
+
+}

tests/PHPStan/Analyser/data/precise-array-shape-unpacking-legacy.php

@@ -0,0 +1,15 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace PreciseArrayShapeUnpackingLegacy;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @param array{a: 1}|array{b: 2} $input
+ */
+function test(array $input): void
+{
+	assertType('array{a?: 1, b?: 2}', [...$input]);
+}