From 6f86a58ff1dbd774629e1e6e79f7153998aecc7f Mon Sep 17 00:00:00 2001
From: phpstan-bot <79867460+phpstan-bot@users.noreply.github.com>
Date: Sat, 24 Oct 2026 20:41:15 +0000
Subject: [PATCH] Do not generalize a union of constant arrays that is no
 bigger than its largest member in `TypeCombinator::optimizeConstantArrays()`

- `optimizeConstantArrays()` generalized any union whose constant array value
  count exceeded `ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT`, even when the
  union reduced to a single shape no bigger than one of its own members. A
  declared shape with more than 256 values (nested ones included) is kept
  as-is on its own, but after `$r['opt'] ?? null` (or `isset`,
  `array_key_exists`, `empty`, `!== null`) the scope merge unions it with its
  narrowed variant, and the merged result was degraded to
  `non-empty-array<..., ...>&oversized-array`.
- The threshold is now raised to the largest per-member count of the unioned
  types (new `getConstantArrayValueTypesLimit()`), computed only once the
  total is already over the plain limit. Both callers in
  `processArrayTypes()` pass the types being unioned.
- Ported the same change to the native mirror in
  `turbo-ext/src/TypeCombinator.cpp`.
- Probed: big list shapes (fixed by the same change, test added); declared
  unions of a large shape with another shape (already generalized when they
  are declared, which is long-standing behavior and left unchanged); shapes
  with more than 256 *keys* (degraded by `ConstantArrayTypeBuilder::createFromConstantArray()`,
  an older design decision, left unchanged).
---
 src/Type/TypeCombinator.php               |  33 +-
 tests/PHPStan/Analyser/nsrt/bug-15459.php | 545 ++++++++++++++++++++++
 turbo-ext/src/TypeCombinator.cpp          |  28 +-
 3 files changed, 598 insertions(+), 8 deletions(-)
 create mode 100644 tests/PHPStan/Analyser/nsrt/bug-15459.php

diff --git a/src/Type/TypeCombinator.php b/src/Type/TypeCombinator.php
index 1c375aae070..f70f0e3961c 100644
--- a/src/Type/TypeCombinator.php
+++ b/src/Type/TypeCombinator.php
@@ -44,6 +44,7 @@
 use function get_class;
 use function implode;
 use function in_array;
+use function max;
 use function spl_object_id;
 use function sprintf;
 use function usort;
@@ -1221,7 +1222,7 @@ private static function processArrayTypes(array $arrayTypes): array
 
 			$arrayType = new ArrayType(
 				self::union(...$keyTypesForGeneralArray),
-				self::union(...self::optimizeConstantArrays($valueTypesForGeneralArray)),
+				self::union(...self::optimizeConstantArrays($valueTypesForGeneralArray, $valueTypesForGeneralArray)),
 			);
 
 			if ($templateArrayType !== null) {
@@ -1240,7 +1241,7 @@ private static function processArrayTypes(array $arrayTypes): array
 			];
 		}
 
-		$reducedArrayTypes = self::optimizeConstantArrays(self::reduceArrays($arrayTypes, true));
+		$reducedArrayTypes = self::optimizeConstantArrays(self::reduceArrays($arrayTypes, true), $arrayTypes);
 		foreach ($reducedArrayTypes as $idx => $reducedArray) {
 			$applied = $accessoryTypes;
 			if ($reducedArray->isIterableAtLeastOnce()->no()) {
@@ -1259,10 +1260,29 @@ private static function processArrayTypes(array $arrayTypes): array
 	}
 
 	/**
+	 * The count of constant array value types above which a union of the given
+	 * types gets generalized. A single type already holding more than
+	 * ARRAY_COUNT_LIMIT of them raises it - a union no bigger than one of its
+	 * members does not grow the type, generalizing it would only lose precision.
+	 *
 	 * @param Type[] $types
+	 */
+	private static function getConstantArrayValueTypesLimit(array $types): int
+	{
+		$limit = ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT;
+		foreach ($types as $type) {
+			$limit = max($limit, self::countConstantArrayValueTypes([$type]));
+		}
+
+		return $limit;
+	}
+
+	/**
+	 * @param Type[] $types
+	 * @param Type[] $unionedTypes the types whose union $types represent
 	 * @return Type[]
 	 */
-	private static function optimizeConstantArrays(array $types): array
+	private static function optimizeConstantArrays(array $types, array $unionedTypes): array
 	{
 		$constantArrayValuesCount = self::countConstantArrayValueTypes($types);
 
@@ -1270,6 +1290,11 @@ private static function optimizeConstantArrays(array $types): array
 			return $types;
 		}
 
+		$limit = self::getConstantArrayValueTypesLimit($unionedTypes);
+		if ($constantArrayValuesCount <= $limit) {
+			return $types;
+		}
+
 		// Stage 1: collapse same-key-set ConstantArrayType variants per-position
 		// before the (lossy) generalization below kicks in. Variants with the
 		// same key signature mergeWith losslessly into a single shape whose
@@ -1311,7 +1336,7 @@ private static function optimizeConstantArrays(array $types): array
 			if ($anyMerged) {
 				$types = array_values($collapsed);
 				$constantArrayValuesCount = self::countConstantArrayValueTypes($types);
-				if ($constantArrayValuesCount <= ConstantArrayTypeBuilder::ARRAY_COUNT_LIMIT) {
+				if ($constantArrayValuesCount <= $limit) {
 					return $types;
 				}
 			}
diff --git a/tests/PHPStan/Analyser/nsrt/bug-15459.php b/tests/PHPStan/Analyser/nsrt/bug-15459.php
new file mode 100644
index 00000000000..407dea28caa
--- /dev/null
+++ b/tests/PHPStan/Analyser/nsrt/bug-15459.php
@@ -0,0 +1,545 @@
+<?php declare(strict_types = 1);
+
+namespace Bug15459;
+
+use function PHPStan\Testing\assertType;
+
+/**
+ * @return array{
+ * 	k0: string,
+ * 	k1: string,
+ * 	k2: string,
+ * 	k3: string,
+ * 	k4: string,
+ * 	k5: string,
+ * 	k6: string,
+ * 	k7: string,
+ * 	k8: string,
+ * 	k9: string,
+ * 	k10: string,
+ * 	k11: string,
+ * 	k12: string,
+ * 	k13: string,
+ * 	k14: string,
+ * 	k15: string,
+ * 	k16: string,
+ * 	k17: string,
+ * 	k18: string,
+ * 	k19: string,
+ * 	k20: string,
+ * 	k21: string,
+ * 	k22: string,
+ * 	k23: string,
+ * 	k24: string,
+ * 	k25: string,
+ * 	k26: string,
+ * 	k27: string,
+ * 	k28: string,
+ * 	k29: string,
+ * 	k30: string,
+ * 	k31: string,
+ * 	k32: string,
+ * 	k33: string,
+ * 	k34: string,
+ * 	k35: string,
+ * 	k36: string,
+ * 	k37: string,
+ * 	k38: string,
+ * 	k39: string,
+ * 	k40: string,
+ * 	k41: string,
+ * 	k42: string,
+ * 	k43: string,
+ * 	k44: string,
+ * 	k45: string,
+ * 	k46: string,
+ * 	k47: string,
+ * 	k48: string,
+ * 	k49: string,
+ * 	k50: string,
+ * 	k51: string,
+ * 	k52: string,
+ * 	k53: string,
+ * 	k54: string,
+ * 	k55: string,
+ * 	k56: string,
+ * 	k57: string,
+ * 	k58: string,
+ * 	k59: string,
+ * 	k60: string,
+ * 	k61: string,
+ * 	k62: string,
+ * 	k63: string,
+ * 	k64: string,
+ * 	k65: string,
+ * 	k66: string,
+ * 	k67: string,
+ * 	k68: string,
+ * 	k69: string,
+ * 	k70: string,
+ * 	k71: string,
+ * 	k72: string,
+ * 	k73: string,
+ * 	k74: string,
+ * 	k75: string,
+ * 	k76: string,
+ * 	k77: string,
+ * 	k78: string,
+ * 	k79: string,
+ * 	k80: string,
+ * 	k81: string,
+ * 	k82: string,
+ * 	k83: string,
+ * 	k84: string,
+ * 	k85: string,
+ * 	k86: string,
+ * 	k87: string,
+ * 	k88: string,
+ * 	k89: string,
+ * 	k90: string,
+ * 	k91: string,
+ * 	k92: string,
+ * 	k93: string,
+ * 	k94: string,
+ * 	k95: string,
+ * 	k96: string,
+ * 	k97: string,
+ * 	k98: string,
+ * 	k99: string,
+ * 	k100: string,
+ * 	k101: string,
+ * 	k102: string,
+ * 	k103: string,
+ * 	k104: string,
+ * 	k105: string,
+ * 	k106: string,
+ * 	k107: string,
+ * 	k108: string,
+ * 	k109: string,
+ * 	k110: string,
+ * 	k111: string,
+ * 	k112: string,
+ * 	k113: string,
+ * 	k114: string,
+ * 	k115: string,
+ * 	k116: string,
+ * 	k117: string,
+ * 	k118: string,
+ * 	k119: string,
+ * 	k120: string,
+ * 	k121: string,
+ * 	k122: string,
+ * 	k123: string,
+ * 	k124: string,
+ * 	k125: string,
+ * 	k126: string,
+ * 	k127: string,
+ * 	k128: string,
+ * 	k129: string,
+ * 	k130: string,
+ * 	k131: string,
+ * 	k132: string,
+ * 	k133: string,
+ * 	k134: string,
+ * 	k135: string,
+ * 	k136: string,
+ * 	k137: string,
+ * 	k138: string,
+ * 	k139: string,
+ * 	k140: string,
+ * 	k141: string,
+ * 	k142: string,
+ * 	k143: string,
+ * 	k144: string,
+ * 	k145: string,
+ * 	k146: string,
+ * 	k147: string,
+ * 	k148: string,
+ * 	k149: string,
+ * 	k150: string,
+ * 	k151: string,
+ * 	k152: string,
+ * 	k153: string,
+ * 	k154: string,
+ * 	k155: string,
+ * 	k156: string,
+ * 	k157: string,
+ * 	k158: string,
+ * 	k159: string,
+ * 	k160: string,
+ * 	k161: string,
+ * 	k162: string,
+ * 	k163: string,
+ * 	k164: string,
+ * 	k165: string,
+ * 	k166: string,
+ * 	k167: string,
+ * 	k168: string,
+ * 	k169: string,
+ * 	k170: string,
+ * 	k171: string,
+ * 	k172: string,
+ * 	k173: string,
+ * 	k174: string,
+ * 	k175: string,
+ * 	k176: string,
+ * 	k177: string,
+ * 	k178: string,
+ * 	k179: string,
+ * 	k180: string,
+ * 	k181: string,
+ * 	k182: string,
+ * 	k183: string,
+ * 	k184: string,
+ * 	k185: string,
+ * 	k186: string,
+ * 	k187: string,
+ * 	k188: string,
+ * 	k189: string,
+ * 	k190: string,
+ * 	k191: string,
+ * 	k192: string,
+ * 	k193: string,
+ * 	k194: string,
+ * 	k195: string,
+ * 	k196: string,
+ * 	o0?: array{currency: string, price: float}|null,
+ * 	o1?: array{currency: string, price: float}|null,
+ * 	o2?: array{currency: string, price: float}|null,
+ * 	o3?: array{currency: string, price: float}|null,
+ * 	o4?: array{currency: string, price: float}|null,
+ * 	o5?: array{currency: string, price: float}|null,
+ * 	o6?: array{currency: string, price: float}|null,
+ * 	o7?: array{currency: string, price: float}|null,
+ * 	o8?: array{currency: string, price: float}|null,
+ * 	o9?: array{currency: string, price: float}|null,
+ * 	o10?: array{currency: string, price: float}|null,
+ * 	o11?: array{currency: string, price: float}|null,
+ * 	o12?: array{currency: string, price: float}|null,
+ * 	o13?: array{currency: string, price: float}|null,
+ * 	o14?: array{currency: string, price: float}|null,
+ * 	o15?: array{currency: string, price: float}|null,
+ * 	o16?: array{currency: string, price: float}|null,
+ * 	o17?: array{currency: string, price: float}|null,
+ * 	o18?: array{currency: string, price: float}|null,
+ * 	o19?: array{currency: string, price: float}|null,
+ * }
+ */
+function make(): array { throw new \LogicException(); }
+
+/**
+ * @return array{
+ * 	o0?: array{currency: string, price: float}|null,
+ * 	o1?: array{currency: string, price: float}|null,
+ * 	o2?: array{currency: string, price: float}|null,
+ * 	o3?: array{currency: string, price: float}|null,
+ * 	o4?: array{currency: string, price: float}|null,
+ * 	o5?: array{currency: string, price: float}|null,
+ * 	o6?: array{currency: string, price: float}|null,
+ * 	o7?: array{currency: string, price: float}|null,
+ * 	o8?: array{currency: string, price: float}|null,
+ * 	o9?: array{currency: string, price: float}|null,
+ * 	o10?: array{currency: string, price: float}|null,
+ * 	o11?: array{currency: string, price: float}|null,
+ * 	o12?: array{currency: string, price: float}|null,
+ * 	o13?: array{currency: string, price: float}|null,
+ * 	o14?: array{currency: string, price: float}|null,
+ * 	o15?: array{currency: string, price: float}|null,
+ * 	o16?: array{currency: string, price: float}|null,
+ * 	o17?: array{currency: string, price: float}|null,
+ * 	o18?: array{currency: string, price: float}|null,
+ * 	o19?: array{currency: string, price: float}|null,
+ * 	o20?: array{currency: string, price: float}|null,
+ * 	o21?: array{currency: string, price: float}|null,
+ * 	o22?: array{currency: string, price: float}|null,
+ * 	o23?: array{currency: string, price: float}|null,
+ * 	o24?: array{currency: string, price: float}|null,
+ * 	o25?: array{currency: string, price: float}|null,
+ * 	o26?: array{currency: string, price: float}|null,
+ * 	o27?: array{currency: string, price: float}|null,
+ * 	o28?: array{currency: string, price: float}|null,
+ * 	o29?: array{currency: string, price: float}|null,
+ * 	o30?: array{currency: string, price: float}|null,
+ * 	o31?: array{currency: string, price: float}|null,
+ * 	o32?: array{currency: string, price: float}|null,
+ * 	o33?: array{currency: string, price: float}|null,
+ * 	o34?: array{currency: string, price: float}|null,
+ * 	o35?: array{currency: string, price: float}|null,
+ * 	o36?: array{currency: string, price: float}|null,
+ * 	o37?: array{currency: string, price: float}|null,
+ * 	o38?: array{currency: string, price: float}|null,
+ * 	o39?: array{currency: string, price: float}|null,
+ * 	o40?: array{currency: string, price: float}|null,
+ * 	o41?: array{currency: string, price: float}|null,
+ * 	o42?: array{currency: string, price: float}|null,
+ * 	o43?: array{currency: string, price: float}|null,
+ * 	o44?: array{currency: string, price: float}|null,
+ * 	o45?: array{currency: string, price: float}|null,
+ * 	o46?: array{currency: string, price: float}|null,
+ * 	o47?: array{currency: string, price: float}|null,
+ * 	o48?: array{currency: string, price: float}|null,
+ * 	o49?: array{currency: string, price: float}|null,
+ * 	o50?: array{currency: string, price: float}|null,
+ * 	o51?: array{currency: string, price: float}|null,
+ * 	o52?: array{currency: string, price: float}|null,
+ * 	o53?: array{currency: string, price: float}|null,
+ * 	o54?: array{currency: string, price: float}|null,
+ * 	o55?: array{currency: string, price: float}|null,
+ * 	o56?: array{currency: string, price: float}|null,
+ * 	o57?: array{currency: string, price: float}|null,
+ * 	o58?: array{currency: string, price: float}|null,
+ * 	o59?: array{currency: string, price: float}|null,
+ * 	o60?: array{currency: string, price: float}|null,
+ * 	o61?: array{currency: string, price: float}|null,
+ * 	o62?: array{currency: string, price: float}|null,
+ * 	o63?: array{currency: string, price: float}|null,
+ * 	o64?: array{currency: string, price: float}|null,
+ * 	o65?: array{currency: string, price: float}|null,
+ * 	o66?: array{currency: string, price: float}|null,
+ * 	o67?: array{currency: string, price: float}|null,
+ * 	o68?: array{currency: string, price: float}|null,
+ * 	o69?: array{currency: string, price: float}|null,
+ * 	o70?: array{currency: string, price: float}|null,
+ * 	o71?: array{currency: string, price: float}|null,
+ * 	o72?: array{currency: string, price: float}|null,
+ * 	o73?: array{currency: string, price: float}|null,
+ * 	o74?: array{currency: string, price: float}|null,
+ * 	o75?: array{currency: string, price: float}|null,
+ * 	o76?: array{currency: string, price: float}|null,
+ * 	o77?: array{currency: string, price: float}|null,
+ * 	o78?: array{currency: string, price: float}|null,
+ * 	o79?: array{currency: string, price: float}|null,
+ * 	o80?: array{currency: string, price: float}|null,
+ * 	o81?: array{currency: string, price: float}|null,
+ * 	o82?: array{currency: string, price: float}|null,
+ * 	o83?: array{currency: string, price: float}|null,
+ * 	o84?: array{currency: string, price: float}|null,
+ * 	o85?: array{currency: string, price: float}|null,
+ * }
+ */
+function makeNested(): array { throw new \LogicException(); }
+
+/**
+ * @return list{
+ * 	0: string,
+ * 	1: string,
+ * 	2: string,
+ * 	3: string,
+ * 	4: string,
+ * 	5: string,
+ * 	6: string,
+ * 	7: string,
+ * 	8: string,
+ * 	9: string,
+ * 	10: string,
+ * 	11: string,
+ * 	12: string,
+ * 	13: string,
+ * 	14: string,
+ * 	15: string,
+ * 	16: string,
+ * 	17: string,
+ * 	18: string,
+ * 	19: string,
+ * 	20: string,
+ * 	21: string,
+ * 	22: string,
+ * 	23: string,
+ * 	24: string,
+ * 	25: string,
+ * 	26: string,
+ * 	27: string,
+ * 	28: string,
+ * 	29: string,
+ * 	30: string,
+ * 	31: string,
+ * 	32: string,
+ * 	33: string,
+ * 	34: string,
+ * 	35: string,
+ * 	36: string,
+ * 	37: string,
+ * 	38: string,
+ * 	39: string,
+ * 	40: string,
+ * 	41: string,
+ * 	42: string,
+ * 	43: string,
+ * 	44: string,
+ * 	45: string,
+ * 	46: string,
+ * 	47: string,
+ * 	48: string,
+ * 	49: string,
+ * 	50: string,
+ * 	51: string,
+ * 	52: string,
+ * 	53: string,
+ * 	54: string,
+ * 	55: string,
+ * 	56: string,
+ * 	57: string,
+ * 	58: string,
+ * 	59: string,
+ * 	60: string,
+ * 	61: string,
+ * 	62: string,
+ * 	63: string,
+ * 	64: string,
+ * 	65: string,
+ * 	66: string,
+ * 	67: string,
+ * 	68: string,
+ * 	69: string,
+ * 	70: string,
+ * 	71: string,
+ * 	72: string,
+ * 	73: string,
+ * 	74: string,
+ * 	75: string,
+ * 	76: string,
+ * 	77: string,
+ * 	78: string,
+ * 	79: string,
+ * 	80: string,
+ * 	81: string,
+ * 	82: string,
+ * 	83: string,
+ * 	84: string,
+ * 	85: string,
+ * 	86: string,
+ * 	87: string,
+ * 	88: string,
+ * 	89: string,
+ * 	90: string,
+ * 	91: string,
+ * 	92: string,
+ * 	93: string,
+ * 	94: string,
+ * 	95: string,
+ * 	96: string,
+ * 	97: string,
+ * 	98: string,
+ * 	99: string,
+ * 	100?: array{a: string, b: float}|null,
+ * 	101?: array{a: string, b: float}|null,
+ * 	102?: array{a: string, b: float}|null,
+ * 	103?: array{a: string, b: float}|null,
+ * 	104?: array{a: string, b: float}|null,
+ * 	105?: array{a: string, b: float}|null,
+ * 	106?: array{a: string, b: float}|null,
+ * 	107?: array{a: string, b: float}|null,
+ * 	108?: array{a: string, b: float}|null,
+ * 	109?: array{a: string, b: float}|null,
+ * 	110?: array{a: string, b: float}|null,
+ * 	111?: array{a: string, b: float}|null,
+ * 	112?: array{a: string, b: float}|null,
+ * 	113?: array{a: string, b: float}|null,
+ * 	114?: array{a: string, b: float}|null,
+ * 	115?: array{a: string, b: float}|null,
+ * 	116?: array{a: string, b: float}|null,
+ * 	117?: array{a: string, b: float}|null,
+ * 	118?: array{a: string, b: float}|null,
+ * 	119?: array{a: string, b: float}|null,
+ * 	120?: array{a: string, b: float}|null,
+ * 	121?: array{a: string, b: float}|null,
+ * 	122?: array{a: string, b: float}|null,
+ * 	123?: array{a: string, b: float}|null,
+ * 	124?: array{a: string, b: float}|null,
+ * 	125?: array{a: string, b: float}|null,
+ * 	126?: array{a: string, b: float}|null,
+ * 	127?: array{a: string, b: float}|null,
+ * 	128?: array{a: string, b: float}|null,
+ * 	129?: array{a: string, b: float}|null,
+ * 	130?: array{a: string, b: float}|null,
+ * 	131?: array{a: string, b: float}|null,
+ * 	132?: array{a: string, b: float}|null,
+ * 	133?: array{a: string, b: float}|null,
+ * 	134?: array{a: string, b: float}|null,
+ * 	135?: array{a: string, b: float}|null,
+ * 	136?: array{a: string, b: float}|null,
+ * 	137?: array{a: string, b: float}|null,
+ * 	138?: array{a: string, b: float}|null,
+ * 	139?: array{a: string, b: float}|null,
+ * 	140?: array{a: string, b: float}|null,
+ * 	141?: array{a: string, b: float}|null,
+ * 	142?: array{a: string, b: float}|null,
+ * 	143?: array{a: string, b: float}|null,
+ * 	144?: array{a: string, b: float}|null,
+ * 	145?: array{a: string, b: float}|null,
+ * 	146?: array{a: string, b: float}|null,
+ * 	147?: array{a: string, b: float}|null,
+ * 	148?: array{a: string, b: float}|null,
+ * 	149?: array{a: string, b: float}|null,
+ * 	150?: array{a: string, b: float}|null,
+ * 	151?: array{a: string, b: float}|null,
+ * 	152?: array{a: string, b: float}|null,
+ * 	153?: array{a: string, b: float}|null,
+ * 	154?: array{a: string, b: float}|null,
+ * 	155?: array{a: string, b: float}|null,
+ * 	156?: array{a: string, b: float}|null,
+ * 	157?: array{a: string, b: float}|null,
+ * 	158?: array{a: string, b: float}|null,
+ * 	159?: array{a: string, b: float}|null,
+ * }
+ */
+function makeList(): array { throw new \LogicException(); }
+
+function f(): void {
+	$r = make();
+	$a = $r['o0'] ?? null;
+	$b = $r['o1'] ?? null;
+	assertType('array{currency: string, price: float}|null', $b);
+}
+
+function nested(): void {
+	$r = makeNested();
+	$a = $r['o0'] ?? null;
+	$b = $r['o1'] ?? null;
+	assertType('array{currency: string, price: float}|null', $b);
+}
+
+function issetCheck(): void {
+	$r = make();
+	if (isset($r['o0'])) {
+		assertType('array{currency: string, price: float}', $r['o0']);
+	}
+	assertType('array{currency: string, price: float}|null', $r['o1'] ?? null);
+}
+
+function arrayKeyExists(): void {
+	$r = make();
+	if (array_key_exists('o0', $r)) {
+		assertType('array{currency: string, price: float}|null', $r['o0']);
+	}
+	assertType('array{currency: string, price: float}|null', $r['o1'] ?? null);
+}
+
+function emptyCheck(): void {
+	$r = make();
+	if (!empty($r['o0'])) {
+		assertType('array{currency: string, price: float}', $r['o0']);
+	}
+	assertType('array{currency: string, price: float}|null', $r['o1'] ?? null);
+}
+
+function notNull(): void {
+	$r = make();
+	if (($r['o0'] ?? null) !== null) {
+		assertType('array{currency: string, price: float}', $r['o0']);
+	}
+	assertType('array{currency: string, price: float}|null', $r['o1'] ?? null);
+}
+
+function ternary(): void {
+	$r = make();
+	$a = isset($r['o0']) ? $r['o0'] : null;
+	assertType('array{currency: string, price: float}|null', $r['o1'] ?? null);
+}
+
+function listShape(): void {
+	$r = makeList();
+	$a = $r[100] ?? null;
+	$b = $r[101] ?? null;
+	assertType('array{a: string, b: float}|null', $b);
+}
diff --git a/turbo-ext/src/TypeCombinator.cpp b/turbo-ext/src/TypeCombinator.cpp
index f6c1afd51e3..97b804113f6 100644
--- a/turbo-ext/src/TypeCombinator.cpp
+++ b/turbo-ext/src/TypeCombinator.cpp
@@ -2053,7 +2053,7 @@ class TypeCombinator
 			zv::Val keyType = unionOf(keyTypesForGeneralArray);
 			PT_FAIL_IF_UNDEF(keyType);
 			zv::Arr valueTypesArray = listOf(valueTypesForGeneralArray);
-			zv::Val optimizedValueTypes = optimizeConstantArrays(valueTypesArray.raw());
+			zv::Val optimizedValueTypes = optimizeConstantArrays(valueTypesArray.raw(), valueTypesArray.raw());
 			PT_FAIL_IF_UNDEF(optimizedValueTypes);
 			zv::Val valueType = unionSpread(optimizedValueTypes.raw());
 			PT_FAIL_IF_UNDEF(valueType);
@@ -2092,7 +2092,7 @@ class TypeCombinator
 		zv::Arr arrayTypesArray = listOf(arrayTypes);
 		zv::Val reduced = reduceArrays(arrayTypesArray.raw(), true);
 		PT_FAIL_IF_UNDEF(reduced);
-		zv::Val reducedArrayTypes = optimizeConstantArrays(reduced.raw());
+		zv::Val reducedArrayTypes = optimizeConstantArrays(reduced.raw(), arrayTypesArray.raw());
 		PT_FAIL_IF_UNDEF(reducedArrayTypes);
 		zv::Arr result = zv::Arr::adoptVal(std::move(reducedArrayTypes));
 		result.separate();
@@ -2297,8 +2297,24 @@ class TypeCombinator
 		traversed.intoReturnValue(return_value);
 	}
 
-	/* private static optimizeConstantArrays(Type[] $types): Type[] */
-	static zv::Val optimizeConstantArrays(zval *typesArray)
+	/* private static getConstantArrayValueTypesLimit(Type[] $types): int;
+	 * -1 = pending exception */
+	[[nodiscard]] static zend_long getConstantArrayValueTypesLimit(zval *types)
+	{
+		zend_long limit = arrayCountLimit();
+		if (UNEXPECTED(limit < 0)) return -1;
+		for (zv::ArrayEntry entry : zv::ArrRef(types)) {
+			zv::Arr single = zv::Arr::create(1);
+			single.push(zv::Ref(entry.value().raw()));
+			zend_long count = countConstantArrayValueTypes(single.raw());
+			if (UNEXPECTED(count < 0)) return -1;
+			if (count > limit) limit = count;
+		}
+		return limit;
+	}
+
+	/* private static optimizeConstantArrays(Type[] $types, Type[] $unionedTypes): Type[] */
+	static zv::Val optimizeConstantArrays(zval *typesArray, zval *unionedTypes)
 	{
 		zv::Val types = copy(typesArray);
 		zend_long limit = arrayCountLimit();
@@ -2308,6 +2324,10 @@ class TypeCombinator
 
 		if (constantArrayValuesCount <= limit) return types;
 
+		limit = getConstantArrayValueTypesLimit(unionedTypes);
+		PT_FAIL_IF_NEG(limit);
+		if (constantArrayValuesCount <= limit) return types;
+
 		/* Stage 1: collapse same-key-set ConstantArrayType variants
 		 * per-position before the (lossy) generalization below kicks in */
 		zv::Arr signatureGroups = zv::Arr::create(0);