Generalize unsealed ConstantArrayType instead of returning it unchanged

`generalize()` early-returned `$this` when `count($keyTypes) === 0`,
which is correct for actually empty sealed arrays but wrong for a
CAT with no explicit keys but real unsealed extras
(`array{...<int, 'foo'>}` — type-checked construction; the builder
normally collapses this shape to `ArrayType`, but it can still
appear through `recreate()` paths). The constant values inside the
unsealed slot survived `generalize()` untouched.

Two fixes, mirroring each other:

1. Only early-return for "no explicit keys *and* not unsealed".
   When the CAT carries real extras, proceed through the normal
   path so the unsealed key/value are generalized through
   `getIterableKeyType()` / `getIterableValueType()`.

2. Switch the `NonEmptyArrayType` gate from
   `keyTypesCount > optionalKeysCount` to `isIterableAtLeastOnce()->yes()`.
   The old gate was a proxy for "the array is definitely non-empty"
   that only looked at explicit keys; for "no explicit keys + real
   extras" it would incorrectly require the accessory. The
   `isIterableAtLeastOnce()` answer is what we actually want — and
   for sealed shapes it matches the previous gate exactly.

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

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -2250,7 +2250,8 @@ public function toFloat(): Type
 
 	public function generalize(GeneralizePrecision $precision): Type
 	{
-		if (count($this->keyTypes) === 0) {
+		// No explicit keys and no real extras — actually empty, return as-is.
+		if (count($this->keyTypes) === 0 && !$this->isUnsealed()->yes()) {
 			return $this;
 		}
 
@@ -2275,7 +2276,14 @@ public function generalize(GeneralizePrecision $precision): Type
 
 				$accessoryTypes[] = new HasOffsetValueType($keyType, $this->valueTypes[$i]->generalize($precision));
 			}
-		} elseif ($keyTypesCount > $optionalKeysCount) {
+		} elseif ($this->isIterableAtLeastOnce()->yes()) {
+			// Previously gated on `keyTypesCount > optionalKeysCount`,
+			// which mishandles "no explicit keys + real unsealed
+			// extras" (`isIterableAtLeastOnce()` answers `Maybe` —
+			// extras might be empty — and correctly skips
+			// `NonEmptyArrayType`). The new gate also covers the
+			// usual sealed-with-required-keys case, so behaviour for
+			// existing CAT shapes is unchanged.
 			$accessoryTypes[] = new NonEmptyArrayType();
 		}
 

tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php

@@ -1932,7 +1932,17 @@ public static function dataGeneralize(): iterable
 		yield 'unsealed only, lessSpecific' => [
 			new ConstantArrayType([], [], unsealed: [new IntegerType(), new ConstantStringType('foo')]),
 			GeneralizePrecision::lessSpecific(),
-			"array{...<int, 'foo'>}",
+			// No explicit keys but real unsealed extras — generalize
+			// has to broaden the unsealed value (`'foo'` → `string`)
+			// and degrade to a plain `ArrayType`. The size is uncertain
+			// (zero-or-more extras), so no `NonEmptyArrayType`.
+			'array<int, string>',
+		];
+
+		yield 'unsealed only with non-falsy-string key, moreSpecific' => [
+			new ConstantArrayType([], [], unsealed: [new IntegerType(), new ConstantStringType('foo')]),
+			GeneralizePrecision::moreSpecific(),
+			'array<int, literal-string&lowercase-string&non-falsy-string>',
 		];
 
 		yield 'unsealed with explicit key, lessSpecific' => [