Treat legacy-null and sealed-marker as equal in ConstantArrayType::equals()

`equals()` already documented that a null unsealed slot (legacy /
pre-bleeding-edge, `isUnsealed()` = `Maybe`) and the
`[NeverType, NeverType]` sealed marker (bleeding edge, `isUnsealed()`
= `No`) both mean "no real extras" and should compare equal. But the
implementation used `isUnsealed()->no()`, which is `false` for the
null case and `true` for the marker — so a legacy-null shape and a
marker-sealed shape of otherwise-identical structure compared
*unequal*.

This surfaced as `TypeToPhpDocNodeTest::testToPhpDocNode` failing only
under old PHPUnit (PHP < 8.2): there the data provider runs before the
test container enables bleeding edge, so the directly-constructed
expected type gets a null slot while the round-trip-parsed type
(built after bleeding edge is on) gets the marker. New PHPUnit runs
data providers after container init, so both sides got the marker and
the bug stayed hidden.

Compare on `isUnsealed()->yes()` ("has real extras") instead, so null
and marker are both treated as sealed and only genuine extras are
compared. Added a timing-independent unit test that constructs both
forms directly via `BleedingEdgeToggle`.

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

Author: ondrejmirtes

src/Type/Constant/ConstantArrayType.php

@@ -903,17 +903,21 @@ public function equals(Type $type): bool
 			return false;
 		}
 
-		// Both `unsealed === null` and `unsealed === [explicitNever, explicitNever]`
-		// mean "sealed", just from different code paths (pre-bleeding-edge vs.
-		// fresh bleeding-edge builder). Treat them as equivalent here, only
-		// comparing the actual extras when both sides have real ones.
-		$thisIsSealed = $this->isUnsealed()->no();
-		$otherIsSealed = $type->isUnsealed()->no();
-		if ($thisIsSealed !== $otherIsSealed) {
+		// Both `unsealed === null` (legacy / pre-bleeding-edge, where
+		// `isUnsealed()` answers `Maybe`) and `unsealed === [explicitNever,
+		// explicitNever]` (the fresh bleeding-edge sealed marker, where
+		// `isUnsealed()` answers `No`) mean "no real extras". Treat them as
+		// equivalent here — use `!isUnsealed()->yes()` rather than
+		// `isUnsealed()->no()`, otherwise a legacy-null shape and a
+		// marker-sealed shape compare unequal. Only compare the actual
+		// extras when both sides genuinely have them.
+		$thisHasExtras = $this->isUnsealed()->yes();
+		$otherHasExtras = $type->isUnsealed()->yes();
+		if ($thisHasExtras !== $otherHasExtras) {
 			return false;
 		}
 
-		if (!$thisIsSealed && $this->unsealed !== null && $type->unsealed !== null) {
+		if ($thisHasExtras && $this->unsealed !== null && $type->unsealed !== null) {
 			if (!$this->unsealed[0]->equals($type->unsealed[0])) {
 				return false;
 			}

tests/PHPStan/Type/Constant/ConstantArrayTypeTest.php

@@ -1549,6 +1549,32 @@ public function testHasOffsetValueType(
 		);
 	}
 
+	public function testEqualsTreatsLegacyNullAndSealedMarkerAsEqual(): void
+	{
+		$bleedingEdgeBackup = BleedingEdgeToggle::isBleedingEdge();
+
+		try {
+			// Pre-bleeding-edge construction leaves the unsealed slot null
+			// (`isUnsealed()` answers `Maybe`).
+			BleedingEdgeToggle::setBleedingEdge(false);
+			$legacyNull = new ConstantArrayType([new ConstantStringType('a')], [new IntegerType()]);
+
+			// Bleeding-edge construction seeds the `[NeverType, NeverType]`
+			// sealed marker (`isUnsealed()` answers `No`).
+			BleedingEdgeToggle::setBleedingEdge(true);
+			$sealedMarker = new ConstantArrayType([new ConstantStringType('a')], [new IntegerType()]);
+
+			// Both represent the same sealed shape, so they must compare
+			// equal in both directions — this mismatch is what made the
+			// `TypeToPhpDocNode` round-trip fail under old PHPUnit (data
+			// providers run before the container enables bleeding edge).
+			$this->assertTrue($legacyNull->equals($sealedMarker), 'legacy-null should equal sealed-marker');
+			$this->assertTrue($sealedMarker->equals($legacyNull), 'sealed-marker should equal legacy-null');
+		} finally {
+			BleedingEdgeToggle::setBleedingEdge($bleedingEdgeBackup);
+		}
+	}
+
 	public function testSealedness(): void
 	{
 		$bleedingEdgeBackup = BleedingEdgeToggle::isBleedingEdge();