Answer isSubTypeOf() against a single value from the FiniteTypeSet too

`finiteTypeSetContainedIn()` only ever compared two unions, so a union of values
asked about one value still walked its members. That is the shape
`TypeCombinator::doRemove()` opens with: `$typeToRemove->isSuperTypeOf($fromType)`
lands on `UnionType::isSubTypeOf()` through the `CompoundType` delegation, once
per removal, over the whole union.

A single value is a one-member set, so the map answers it: the union is under
that value only if it has nothing else in it, and disjoint from it if the key is
missing. `FiniteTypeSet::containedInKey()` is `containedIn()` for that case, and
the helper now treats a non-union other type as the set holding just that value.

`isAcceptedBy()` shares the helper and keeps its yes-only guard. As it happens no
constant value accepts another one - not a numeric string an int, in either
direction - so the guard cannot change an answer today; it stays because that is
a fact about the current value types rather than something the map guarantees.

Measured on the reproducer from phpstan/phpstan#15004, a `1|2|...|N` parameter
narrowed by a chain of N `!==` clauses, `analyse -l 8` wall clock:

| N | before the identity map | at HEAD | with this commit |
| --- | --- | --- | --- |
| 50 | 1.30 s | 1.20 s | 1.20 s |
| 100 | 3.11 s | 2.70 s | 2.41 s |
| 200 | 15.02 s | 12.92 s | 10.42 s |
| 300 | 46.27 s | 39.57 s | 30.95 s |

This is a constant factor, not the fix that issue wants: counting calls at N=100
shows 79674 `doRemove()`s costing 0.92 s, split 0.40 s `isSubTypeOf()` and 0.47 s
`tryRemove()`, and both are O(n) per call against an O(n) chain of O(n) removals.
Keying takes the first of the two down to a lookup; the growth stays ~O(N^2.7),
which only stopping the removals themselves would change.

The reference-implementation matrix now runs `isSubTypeOf()` and `isAcceptedBy()`
over the 17x18 union/non-union pairs as well as the union pairs, and asserts that
no member attaches a reason to an answer the map now gives on its behalf.
Mutating the fix afterwards fails 399 cases (a miss answering yes), 1 (never
answering yes), 92 (dropping the completeness gate) and 36 (keying an unkeyable
other type).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: phpstan-bot

src/Type/FiniteTypeSet.php

@@ -264,6 +264,29 @@ public function containedIn(self $other): TrinaryLogic
 		return TrinaryLogic::createMaybe();
 	}
 
+	/**
+	 * containedIn() against the one-member set holding just $key.
+	 *
+	 * Yes only when this set holds nothing besides that value, no when it does not hold it
+	 * at all, maybe in between - the same three answers as containedIn(), which is what a
+	 * single value is being compared as here.
+	 *
+	 * Only keyed members are compared - call isComplete() first when the answer has to
+	 * hold for the whole union.
+	 */
+	public function containedInKey(string $key): TrinaryLogic
+	{
+		if (!$this->has($key)) {
+			return TrinaryLogic::createNo();
+		}
+
+		if (count($this->members) === 1) {
+			return TrinaryLogic::createYes();
+		}
+
+		return TrinaryLogic::createMaybe();
+	}
+
 	/**
 	 * Whether a constant string member might also be a class-string.
 	 *

src/Type/UnionType.php

@@ -394,23 +394,48 @@ public function isAcceptedBy(Type $acceptingType, bool $strictTypes): AcceptsRes
 	}
 
 	/**
-	 * Whether the other union holds every member of this one, or null when the question
-	 * cannot be settled from the identity maps alone.
+	 * Whether $otherType holds every member of this one, or null when the question cannot
+	 * be settled from the identity maps alone.
+	 *
+	 * $otherType is compared as a set of values: a union through its own map, a single
+	 * finite value as the one-member set holding it.
 	 *
 	 * $yesOnly skips the completeness requirement on the other union: a member missing from
 	 * its map only rules out the yes answer, which is all the caller is after.
 	 */
 	private function finiteTypeSetContainedIn(Type $otherType, bool $yesOnly): ?TrinaryLogic
 	{
-		if (!$otherType instanceof self || $otherType instanceof TemplateType) {
-			return null;
-		}
-
 		$finiteTypeSet = $this->getFiniteTypeSet();
 		if ($finiteTypeSet === null || !$finiteTypeSet->isComplete()) {
 			return null;
 		}
 
+		if (!$otherType instanceof self || $otherType instanceof TemplateType) {
+			// A single value covers a member iff they are the same value, and no member
+			// stands for a value it is not keyed by - so one lookup answers for every member
+			// at once. This is the shape TypeCombinator::remove() takes to ask whether
+			// removing a value empties a union of values, and the only way a non-union other
+			// type reaches this helper at all.
+			$key = FiniteTypeSet::key($otherType);
+			if ($key === null) {
+				return null;
+			}
+
+			$containment = $finiteTypeSet->containedInKey($key);
+
+			// No constant value accepts another one - not even a numeric string an int, in
+			// either direction - so today accepts() agrees with isSuperTypeOf() here and this
+			// guard never changes an answer. It is kept because that is a fact about the
+			// current value types rather than something the identity map guarantees: a value
+			// the map does not hold being accepted anyway is exactly what accepts() is
+			// allowed to do, and all isAcceptedBy() wants from the map is the yes.
+			if (!$containment->yes() && $yesOnly) {
+				return null;
+			}
+
+			return $containment;
+		}
+
 		$otherFiniteTypeSet = $otherType->getFiniteTypeSet();
 		if ($otherFiniteTypeSet === null) {
 			return null;

tests/PHPStan/Type/FiniteTypeSetTest.php

@@ -154,12 +154,22 @@ public function testAcceptsUnion(UnionType $type, UnionType $otherType): void
 		$this->assertAccepts($type, $otherType);
 	}
 
-	private function assertAccepts(UnionType $type, Type $otherType): void
+	/**
+	 * Whether the map alone settles a comparison of $type against $otherType - the whole
+	 * union is keyed, and $otherType is one value to look up in it.
+	 */
+	private static function answersFromTheMap(UnionType $type, Type $otherType): bool
 	{
 		$finiteTypeSet = $type->getFiniteTypeSet();
-		$answersPerKind = FiniteTypeSet::key($otherType) !== null
+
+		return FiniteTypeSet::key($otherType) !== null
 			&& $finiteTypeSet !== null
 			&& $finiteTypeSet->isComplete();
+	}
+
+	private function assertAccepts(UnionType $type, Type $otherType): void
+	{
+		$answersPerKind = self::answersFromTheMap($type, $otherType);
 
 		foreach ([true, false] as $strictTypes) {
 			$this->assertSame(
@@ -198,17 +208,35 @@ public function testTryRemove(UnionType $type, Type $otherType): void
 	}
 
 	#[DataProvider('dataUnionPairs')]
-	public function testIsSubTypeOf(UnionType $type, UnionType $otherType): void
+	#[DataProvider('dataUnionAndOtherType')]
+	public function testIsSubTypeOf(UnionType $type, Type $otherType): void
 	{
 		$this->assertSame(
 			self::referenceIsSubTypeOf($type, $otherType)->describe(),
 			$type->isSubTypeOf($otherType)->result->describe(),
 			sprintf('%s -> isSubTypeOf(%s)', $type->describe(VerbosityLevel::precise()), $otherType->describe(VerbosityLevel::precise())),
 		);
+
+		if (!self::answersFromTheMap($type, $otherType)) {
+			return;
+		}
+
+		// One key lookup stands in for asking every member, which is only invisible as long
+		// as none of them attaches a reason to its answer - reasons are per member.
+		foreach ($type->getTypes() as $innerType) {
+			$result = $otherType->isSuperTypeOf($innerType);
+			$this->assertSame(
+				[],
+				$result->reasons,
+				sprintf('%s -> isSuperTypeOf(%s)', $otherType->describe(VerbosityLevel::precise()), $innerType->describe(VerbosityLevel::precise())),
+			);
+			$this->assertSame([], $result->lazyReasons);
+		}
 	}
 
 	#[DataProvider('dataUnionPairs')]
-	public function testIsAcceptedBy(UnionType $type, UnionType $otherType): void
+	#[DataProvider('dataUnionAndOtherType')]
+	public function testIsAcceptedBy(UnionType $type, Type $otherType): void
 	{
 		foreach ([true, false] as $strictTypes) {
 			$this->assertSame(
@@ -484,6 +512,67 @@ public function testContainedIn(array $types, array $otherTypes, TrinaryLogic $e
 		$this->assertSame($expected->describe(), $set->containedIn($otherSet)->describe());
 	}
 
+	/**
+	 * @return Iterator<string, array{list<Type>, Type, TrinaryLogic}>
+	 */
+	public static function dataContainedInKey(): Iterator
+	{
+		// the only way a set is wholly under one value is by being that one value
+		yield 'the only member' => [[new ConstantStringType('a')], new ConstantStringType('a'), TrinaryLogic::createYes()];
+		yield 'one of two members' => [
+			[new ConstantStringType('a'), new ConstantStringType('b')],
+			new ConstantStringType('a'),
+			TrinaryLogic::createMaybe(),
+		];
+		yield 'the last of many members' => [
+			[new ConstantStringType('a'), new ConstantStringType('b'), new ConstantStringType('c')],
+			new ConstantStringType('c'),
+			TrinaryLogic::createMaybe(),
+		];
+		yield 'not held' => [
+			[new ConstantStringType('a'), new ConstantStringType('b')],
+			new ConstantStringType('z'),
+			TrinaryLogic::createNo(),
+		];
+		yield 'not held by a single-member set' => [
+			[new ConstantStringType('a')],
+			new ConstantStringType('z'),
+			TrinaryLogic::createNo(),
+		];
+		// the key carries the kind, so the same value of another kind is not held either
+		yield 'the same value of another kind' => [
+			[new ConstantIntegerType(1)],
+			new ConstantStringType('1'),
+			TrinaryLogic::createNo(),
+		];
+		yield 'one of two kinds' => [
+			[new ConstantStringType('a'), new NullType()],
+			new NullType(),
+			TrinaryLogic::createMaybe(),
+		];
+	}
+
+	/**
+	 * @param list<Type> $types
+	 */
+	#[DataProvider('dataContainedInKey')]
+	public function testContainedInKey(array $types, Type $value, TrinaryLogic $expected): void
+	{
+		$set = FiniteTypeSet::create($types);
+		$this->assertNotNull($set);
+
+		$key = FiniteTypeSet::key($value);
+		$this->assertNotNull($key);
+
+		$this->assertSame($expected->describe(), $set->containedInKey($key)->describe());
+
+		// the same answer containedIn() gives against the set of just that one value, which
+		// is what a single value is being compared as
+		$singleMemberSet = FiniteTypeSet::create([$value]);
+		$this->assertNotNull($singleMemberSet);
+		$this->assertSame($expected->describe(), $set->containedIn($singleMemberSet)->describe());
+	}
+
 	public function testUnkeyableMembersDoNotDefeatTheSet(): void
 	{
 		$set = (new UnionType([