More SA fixes

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -2178,40 +2178,43 @@ public function isKeysSupersetOf(self $otherArray): bool
 			return $this->legacyIsKeysSupersetOf($otherArray);
 		}
 
-		$keyIndexMap = $this->getKeyIndexMap();
-		$otherKeyIndexMap = $otherArray->getKeyIndexMap();
-
-		// Disjoint values at a common key prevent a lossless merge
-		$hasCommon = false;
-		foreach ($otherKeyIndexMap as $keyValue => $j) {
-			if (!array_key_exists($keyValue, $keyIndexMap)) {
-				continue;
-			}
-			$i = $keyIndexMap[$keyValue];
-			$valueType = $this->valueTypes[$i];
-			$otherValueType = $otherArray->valueTypes[$j];
-			if ($valueType->isSuperTypeOf($otherValueType)->no() && $otherValueType->isSuperTypeOf($valueType)->no()) {
-				return false;
-			}
-			$hasCommon = true;
-		}
-
 		[$thisUnsealedKey, $thisUnsealedValue] = $this->unsealed;
 		[$otherUnsealedKey, $otherUnsealedValue] = $otherArray->unsealed;
 		$thisHasExtras = !($thisUnsealedKey instanceof NeverType && $thisUnsealedKey->isExplicit());
 		$otherHasExtras = !($otherUnsealedKey instanceof NeverType && $otherUnsealedKey->isExplicit());
 
-		if ($hasCommon) {
+		$otherHasRequiredKeys = false;
+		foreach ($otherArray->keyTypes as $j => $keyType) {
+			if ($otherArray->isOptionalKey($j)) {
+				continue;
+			}
+			$otherHasRequiredKeys = true;
+			break;
+		}
+
+		// Sealed empty $other (no keys, no extras): absorbing it is lossless iff $this
+		// already accepts []. i.e., all of $this's known keys are optional. Otherwise
+		// merge would add [] as a new instance.
+		if (!$otherHasRequiredKeys && !$otherHasExtras && count($otherArray->keyTypes) === 0) {
+			foreach ($this->keyTypes as $i => $keyType) {
+				if (!$this->isOptionalKey($i)) {
+					return false;
+				}
+			}
 			return true;
 		}
 
+		// With real unsealed extras on both sides that can absorb each other's
+		// required keys, merging is acceptable regardless of which keys overlap.
 		if ($thisHasExtras && $otherHasExtras) {
 			return true;
 		}
 
-		// Mixed or both sealed, no common keys — only merge if one side's extras can
-		// absorb the other side's required keys (preserves tagged-union otherwise).
+		// Asymmetric extras: one side has real extras that can absorb the other's keys.
 		if ($thisHasExtras) {
+			if ($this->legacyIsKeysSupersetOf($otherArray)) {
+				return true;
+			}
 			foreach ($otherArray->keyTypes as $j => $keyType) {
 				if ($otherArray->isOptionalKey($j)) {
 					continue;
@@ -2227,6 +2230,9 @@ public function isKeysSupersetOf(self $otherArray): bool
 		}
 
 		if ($otherHasExtras) {
+			if ($this->legacyIsKeysSupersetOf($otherArray)) {
+				return true;
+			}
 			foreach ($this->keyTypes as $i => $keyType) {
 				if ($this->isOptionalKey($i)) {
 					continue;
@@ -2241,7 +2247,8 @@ public function isKeysSupersetOf(self $otherArray): bool
 			return true;
 		}
 
-		return false;
+		// Both sealed: fall back to the legacy key/value shape check.
+		return $this->legacyIsKeysSupersetOf($otherArray);
 	}
 
 	private function legacyIsKeysSupersetOf(self $otherArray): bool
@@ -2352,7 +2359,7 @@ public function mergeWith(self $otherArray): self
 				$j = $otherKeyIndexMap[$keyValue];
 				$otherValueType = $otherArray->valueTypes[$j];
 				$mergedValue = TypeCombinator::union($valueType, $otherValueType);
-				$optional = $this->isOptionalKey($i) && $otherArray->isOptionalKey($j);
+				$optional = $this->isOptionalKey($i) || $otherArray->isOptionalKey($j);
 
 				$keyTypes[] = $keyType;
 				$valueTypes[] = $mergedValue;

src/Type/TypeCombinator.php

@@ -1156,7 +1156,14 @@ private static function reduceArrays(array $constantArrays, bool $preserveTagged
 		}
 
 		if ($emptyArray !== null) {
-			$newArrays[] = $emptyArray;
+			if ($preserveTaggedUnions && $emptyArray instanceof ConstantArrayType) {
+				// Let the empty array participate in merging — the passes below will absorb
+				// it into any array that already accepts [] (all-optional keys, compatible
+				// unsealed extras). If no such array exists, it remains as-is in the result.
+				$arraysToProcess[] = $emptyArray;
+			} else {
+				$newArrays[] = $emptyArray;
+			}
 		}
 
 		$arraysToProcessPerKey = [];

tests/PHPStan/Analyser/nsrt/array-append-count.php

@@ -0,0 +1,32 @@
+<?php
+
+namespace ArrayAppendCount;
+
+use function PHPStan\Testing\assertType;
+
+function multipleConditionalAppends(int $a, int $b, int $c): void
+{
+	$types = ['base'];
+	if ($a > 0) {
+		$types[] = 'x';
+	} elseif ($a < 0) {
+		$types[] = 'y';
+	}
+	if ($b > 0) {
+		$types[] = 'z';
+	}
+	if ($c === 1) {
+		$types[] = 'p';
+	} elseif ($c === 2) {
+		$types[] = 'q';
+	}
+
+	// $types could have 1 (just 'base'), or 2/3/4 depending on which
+	// elseif arms fire. count should at least allow 1.
+	assertType('int<1, 4>', count($types));
+
+	if (count($types) === 1) {
+		// reachable: all three ifs miss — $types stays as ['base'].
+		assertType("array{'base'}", $types);
+	}
+}

tests/PHPStan/Analyser/nsrt/conditional-array-key-exists.php

@@ -0,0 +1,25 @@
+<?php
+
+namespace ConditionalArrayKeyExists;
+
+use function PHPStan\Testing\assertType;
+
+/** @param array<string, mixed> $options */
+function apply(array $options): void
+{
+	$range = [];
+	if (isset($options['min_range'])) {
+		$range['min'] = 1;
+	}
+	if (isset($options['max_range'])) {
+		$range['max'] = 2;
+	}
+
+	// $range can be {}, {min}, {max}, or {min, max}
+	assertType('array{min?: 1, max?: 2}', $range);
+
+	if (array_key_exists('min', $range) || array_key_exists('max', $range)) {
+		// reachable: either key could be set.
+		assertType('non-empty-array{min?: 1, max?: 2}', $range);
+	}
+}

tests/PHPStan/Type/TypeCombinatorTest.php

@@ -3102,8 +3102,8 @@ public static function dataUnion(): iterable
 				'array{a: int, ...}',
 				'array{a: string, ...}',
 			],
-			UnionType::class,
-			'array{a: int, ...}|array{a: string, ...}',
+			ConstantArrayType::class,
+			'array{a: int|string, ...}',
 		];
 
 		yield [