Decide sealed array shapes with disjoint required keys before comparing values

ConstantArrayType::isSuperTypeOf() walks the keys of $this in order and
only reports that the other shape lacks a required key when it reaches
that key - after asking the other shape for the offset and comparing the
value of every key before it. Two sealed shapes where one has a required
key the other lacks share no value, and that is now decided from the key
sets first. The answer is the same No; when a value mismatch also comes
earlier in key order, the reason is now the sealed-shapes one instead of
the offset's.

hasOffsetValueType() and getOffsetValueType() also scanned every key with
isSuperTypeOf() for a constant offset the key index has no entry for,
which can only ever find nothing. A non-compound constant int or string
offset missing from the index now skips that scan.

A chain of `if ($pN !== null) { $data['kN'] = $pN; }` builds a sealed
shape under bleedingEdge, and every if-merge rechecks the growing list of
conditional holders guarded by earlier shapes of $data against the
branch's new shape (preserveVacuousConditionalExpressions()). With 90
ifs that took 1.8 s in those checks alone; each check is now a few key
lookups.

Amp-Thread-ID: https://ampcode.com/threads/T-01a1b24f-ec49-7194-bbd2-0f4a43ab9b8f

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -797,6 +797,17 @@ public function isSuperTypeOf(Type $type): IsSuperTypeOfResult
 				// $this is unsealed with no known keys — fall through to extras/unsealed-part checks below
 			}
 
+			// Two sealed shapes where one has a required key the other lacks share
+			// no value. The loops below would reach the same answer, but only after
+			// comparing the value of every key that precedes the missing one.
+			if (
+				$thisUnsealedness->no()
+				&& $typeUnsealedness->no()
+				&& ($this->hasRequiredKeyMissingIn($type) || $type->hasRequiredKeyMissingIn($this))
+			) {
+				return IsSuperTypeOfResult::createNo(lazyReasons: [fn (): string => $this->sealedArrayShapesCannotBeIntersectedReason($type)]);
+			}
+
 			$results = [];
 			foreach ($this->keyTypes as $i => $keyType) {
 				$hasOffset = $type->hasOffsetValueType($keyType);
@@ -1228,8 +1239,9 @@ private function recursiveHasOffsetValueType(Type $offsetType): TrinaryLogic
 		}
 
 		// Constant offsets against constant keys resolve by value: a hit at the
-		// indexed slot is verified before use, a miss falls through to the scan
-		// (which also covers the unsealed extras below).
+		// indexed slot is verified before use, an offset no key's value collides
+		// with skips the scan, any other miss falls through to it (the unsealed
+		// extras below are checked either way).
 		$index = $this->findVerifiedKeyIndex($offsetType);
 		if ($index !== null) {
 			if ($this->isOptionalKey($index)) {
@@ -1239,7 +1251,7 @@ private function recursiveHasOffsetValueType(Type $offsetType): TrinaryLogic
 		}
 
 		$result = TrinaryLogic::createNo();
-		foreach ($this->keyTypes as $i => $keyType) {
+		foreach ($this->isKeyIndexMiss($offsetType) ? [] : $this->keyTypes as $i => $keyType) {
 			// PHP coerces decimal-integer strings to int when used as array
 			// keys ("123" → 123), so a non-constant string offset *could* hit
 			// a constant-integer slot. Skip the upgrade when the offset is
@@ -1310,7 +1322,15 @@ public function getOffsetValueType(Type $offsetType): Type
 		$matchingValueTypes = [];
 		$all = true;
 		$maybeAll = true;
-		foreach ($this->keyTypes as $i => $keyType) {
+		$keyIndexMiss = count($this->keyTypes) > 0 && $this->isKeyIndexMiss($offsetType);
+		if ($keyIndexMiss) {
+			// What the scan below concludes for an offset no key's value
+			// collides with: every key misses it, and a constant offset cannot
+			// be a decimal-integer string hitting an integer key.
+			$all = false;
+			$maybeAll = false;
+		}
+		foreach ($keyIndexMiss ? [] : $this->keyTypes as $i => $keyType) {
 			if ($keyType->isSuperTypeOf($offsetType)->no()) {
 				$all = false;
 
@@ -3289,6 +3309,38 @@ private function findVerifiedKeyIndex(Type $offsetType): ?int
 		return $index;
 	}
 
+	/**
+	 * Whether a constant integer or string offset (already passed through
+	 * toArrayKey()) has a value no explicit key's value collides with as an
+	 * array key - then no explicit key is a supertype of it, so scanning the
+	 * keys for one is pointless. A CompoundType offset (a template, an
+	 * intersection) is left to the scan: its isSubTypeOf() may answer maybe.
+	 */
+	private function isKeyIndexMiss(Type $offsetType): bool
+	{
+		if ($offsetType instanceof CompoundType || !$offsetType->isConstantScalarValue()->yes()) {
+			return false;
+		}
+
+		$values = $offsetType->getConstantScalarValues();
+		if (count($values) !== 1 || (!is_int($values[0]) && !is_string($values[0]))) {
+			return false;
+		}
+
+		return !array_key_exists($values[0], $this->getKeyIndexMap());
+	}
+
+	private function hasRequiredKeyMissingIn(self $other): bool
+	{
+		foreach ($this->keyTypes as $i => $keyType) {
+			if (!$this->isOptionalKey($i) && $other->isKeyIndexMiss($keyType)) {
+				return true;
+			}
+		}
+
+		return false;
+	}
+
 	/**
 	 * @param ConstantIntegerType|ConstantStringType $otherKeyType
 	 */