Avoid 2^N getAllArrays() expansion in ConstantArrayType::getFiniteTypes()

Process keys incrementally instead of generating all power-set variants
upfront via `getAllArrays()`. For each key, fork partial
`ConstantArrayTypeBuilder` instances for optional keys and finite value
variants, bailing early when the count exceeds `CALCULATE_SCALARS_LIMIT`.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -4,7 +4,6 @@
 
 use Nette\Utils\Strings;
 use PHPStan\Analyser\OutOfClassScope;
-use PHPStan\Internal\CombinationsHelper;
 use PHPStan\Php\PhpVersion;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprIntegerNode;
 use PHPStan\PhpDocParser\Ast\ConstExpr\ConstExprStringNode;
@@ -1997,38 +1996,43 @@ public static function isValidIdentifier(string $value): bool
 
 	public function getFiniteTypes(): array
 	{
-		$arraysArraysForCombinations = [];
-		$count = 0;
-		foreach ($this->getAllArrays() as $array) {
-			$values = $array->getValueTypes();
-			$arraysForCombinations = [];
-			$combinationCount = 1;
-			foreach ($values as $valueType) {
-				$finiteTypes = $valueType->getFiniteTypes();
-				if ($finiteTypes === []) {
-					return [];
+		$limit = InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT;
+
+		// Build finite array types incrementally, processing one key at a time.
+		// For optional keys, fork each partial result into with/without variants.
+		// This avoids generating 2^N ConstantArrayType objects via getAllArrays().
+		/** @var list<ConstantArrayTypeBuilder> $partials */
+		$partials = [ConstantArrayTypeBuilder::createEmpty()];
+
+		foreach ($this->keyTypes as $i => $keyType) {
+			$finiteValueTypes = $this->valueTypes[$i]->getFiniteTypes();
+			if ($finiteValueTypes === []) {
+				return [];
+			}
+
+			$isOptional = $this->isOptionalKey($i);
+			$newPartials = [];
+
+			foreach ($partials as $partial) {
+				if ($isOptional) {
+					$newPartials[] = clone $partial;
+				}
+				foreach ($finiteValueTypes as $finiteValueType) {
+					$newPartial = clone $partial;
+					$newPartial->setOffsetValueType($keyType, $finiteValueType);
+					$newPartials[] = $newPartial;
 				}
-				$arraysForCombinations[] = $finiteTypes;
-				$combinationCount *= count($finiteTypes);
 			}
-			$arraysArraysForCombinations[] = $arraysForCombinations;
-			$count += $combinationCount;
-		}
 
-		if ($count > InitializerExprTypeResolver::CALCULATE_SCALARS_LIMIT) {
-			return [];
+			$partials = $newPartials;
+			if (count($partials) > $limit) {
+				return [];
+			}
 		}
 
 		$finiteTypes = [];
-		foreach ($arraysArraysForCombinations as $arraysForCombinations) {
-			$combinations = CombinationsHelper::combinations($arraysForCombinations);
-			foreach ($combinations as $combination) {
-				$builder = ConstantArrayTypeBuilder::createEmpty();
-				foreach ($combination as $i => $v) {
-					$builder->setOffsetValueType($this->keyTypes[$i], $v);
-				}
-				$finiteTypes[] = $builder->getArray();
-			}
+		foreach ($partials as $partial) {
+			$finiteTypes[] = $partial->getArray();
 		}
 
 		return $finiteTypes;

tests/bench/data/finite-types-optional-keys-blowup.php

@@ -0,0 +1,23 @@
+<?php declare(strict_types = 1);
+
+namespace BenchFiniteTypesOptionalKeysBlowup;
+
+/**
+ * Regression test for getFiniteTypes() calling getAllArrays() on arrays with many optional keys.
+ * getAllArrays() generates 2^N ConstantArrayType objects for N optional keys.
+ * The fix processes keys incrementally, bailing early when partial count exceeds the limit.
+ *
+ * @param array{
+ *     a?: 'x', b?: 'x', c?: 'x', d?: 'x', e?: 'x',
+ *     f?: 'x', g?: 'x', h?: 'x', i?: 'x', j?: 'x',
+ *     k?: 'x', l?: 'x', m?: 'x', n?: 'x', o?: 'x',
+ *     p?: 'x', q?: 'x', r?: 'x'
+ * } $data
+ * @param array{a?: 'x', b?: 'x', c?: 'x', d?: 'x', e?: 'x', f?: 'x', g?: 'x', h?: 'x', i?: 'x', j?: 'x', k?: 'x', l?: 'x', m?: 'x', n?: 'x', o?: 'x', p?: 'x', q?: 'x', r?: 'x'} $other
+ */
+function testFinite(array $data, array $other): void
+{
+	if ($data === $other) {
+		echo 'same';
+	}
+}