Generalize an inferred template type by what a conditional branch knows about it

In the else branch of `(TNewKey is \UnitEnum ? array-key : TNewKey)` with
TNewKey of array-key|\UnitEnum, the branch knows TNewKey is an array-key. Since
the branches hold NarrowedSubjectType references, the resolver traversed into
them and generalized the inferred type against the subject's own bound, which
is not scalar, so a literal key such as 'foo' became string. 2.2.14 kept 'foo'.

The resolver now resolves the subject inside a NarrowedSubjectType without
generalizing it, and generalizes the narrowed result against the reference, whose
bound is the narrowed one. A template type in the target stays generalized, as
the condition sees it: otherwise `(T is U ? T : int)` narrowed 'foo' & 'bar' to
never.

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

Author: SanderMuller

src/Reflection/ResolvedFunctionVariantWithOriginal.php

@@ -230,7 +230,23 @@ private function resolveResolvableTemplateTypes(Type $type, TemplateTypeVariance
 	{
 		$references = $type->getReferencedTemplateTypes($positionVariance);
 
-		$objectCb = function (Type $type, callable $traverse) use ($references): Type {
+		$resolve = function (Type $type, callable $traverse, ?string $keepInferredName) use ($references, &$resolve): Type {
+			if (
+				$type instanceof NarrowedSubjectType
+				&& $keepInferredName === null
+				&& !$type->isArgument()
+				&& $type->getScope()->getFunctionName() !== null
+			) {
+				// generalize what the branch knows about the subject, not the subject: in the
+				// else branch of `(T is \UnitEnum ? array-key : T)` with T of array-key|\UnitEnum,
+				// T is a scalar and an inferred 'foo' stays 'foo'. Only the subject is taken as
+				// inferred - a template type in the target is generalized as the condition sees it.
+				$subjectName = $type->getName();
+				$resolved = TypeTraverser::map($type, static fn (Type $type, callable $traverse): Type => $resolve($type, $traverse, $subjectName));
+
+				return TemplateTypeHelper::generalizeInferredTemplateType($type, $resolved);
+			}
+
 			if (
 				$type instanceof TemplateType
 				&& !$type instanceof NarrowedSubjectType
@@ -242,7 +258,10 @@ private function resolveResolvableTemplateTypes(Type $type, TemplateTypeVariance
 					return $traverse($type);
 				}
 
-				$newType = TemplateTypeHelper::generalizeInferredTemplateType($type, $newType);
+				if ($type->getName() !== $keepInferredName) {
+					$newType = TemplateTypeHelper::generalizeInferredTemplateType($type, $newType);
+				}
+
 				$variance = TemplateTypeVariance::createInvariant();
 				foreach ($references as $reference) {
 					// this uses identity to distinguish between different occurrences of the same template type
@@ -271,6 +290,7 @@ private function resolveResolvableTemplateTypes(Type $type, TemplateTypeVariance
 
 			return $traverse($type);
 		};
+		$objectCb = static fn (Type $type, callable $traverse): Type => $resolve($type, $traverse, null);
 
 		return TypeTraverser::map($type, function (Type $type, callable $traverse) use ($references, $objectCb): Type {
 			if ($type instanceof GenericObjectType || $type instanceof GenericStaticType) {

tests/PHPStan/Analyser/nsrt/narrowed-subject-inferred-literal.php

@@ -0,0 +1,90 @@
+<?php // lint >= 8.1
+
+declare(strict_types = 1);
+
+namespace NarrowedSubjectInferredLiteral;
+
+use function PHPStan\Testing\assertType;
+
+class User
+{
+
+}
+
+enum Digit: int
+{
+
+	case One = 1;
+
+}
+
+/**
+ * @template TKey of array-key
+ * @template TValue
+ */
+class Collection
+{
+
+	/**
+	 * @template TNewKey of array-key|\UnitEnum
+	 *
+	 * @param  (callable(TValue, TKey): TNewKey)|array<mixed>|string  $keyBy
+	 * @return static<($keyBy is (array|string) ? array-key : (TNewKey is \UnitEnum ? array-key : TNewKey)), TValue>
+	 */
+	public function keyBy($keyBy)
+	{
+		throw new \Exception();
+	}
+
+	/**
+	 * @template TNewKey of array-key|\UnitEnum
+	 *
+	 * @param  callable(TValue, TKey): TNewKey  $keyBy
+	 * @return static<(TNewKey is \UnitEnum ? array-key : TNewKey), TValue>
+	 */
+	public function keyByCallback($keyBy)
+	{
+		throw new \Exception();
+	}
+
+}
+
+/**
+ * @template T of array-key
+ * @template U of array-key
+ * @param T $a
+ * @param U $b
+ * @return Collection<(T is U ? T : int), int>
+ */
+function templateTarget($a, $b)
+{
+	throw new \Exception();
+}
+
+/**
+ * @template T of array-key
+ * @template U of array-key
+ * @param T $a
+ * @param U $b
+ * @return Collection<(T is not U ? int : T), int>
+ */
+function negatedTemplateTarget($a, $b)
+{
+	throw new \Exception();
+}
+
+/** @param Collection<int, User> $collection */
+function test(Collection $collection): void
+{
+	assertType("NarrowedSubjectInferredLiteral\\Collection<'foo', NarrowedSubjectInferredLiteral\\User>", $collection->keyBy(fn ($user) => 'foo'));
+	assertType('NarrowedSubjectInferredLiteral\\Collection<0, NarrowedSubjectInferredLiteral\\User>', $collection->keyBy(static fn ($user): int => 0));
+	assertType('NarrowedSubjectInferredLiteral\\Collection<(int|string), NarrowedSubjectInferredLiteral\\User>', $collection->keyBy('name'));
+	assertType('NarrowedSubjectInferredLiteral\\Collection<(int|string), NarrowedSubjectInferredLiteral\\User>', $collection->keyBy(static fn ($user) => Digit::One));
+
+	assertType("NarrowedSubjectInferredLiteral\\Collection<'foo', NarrowedSubjectInferredLiteral\\User>", $collection->keyByCallback(fn ($user) => 'foo'));
+	assertType('NarrowedSubjectInferredLiteral\\Collection<(int|string), NarrowedSubjectInferredLiteral\\User>', $collection->keyByCallback(static fn ($user) => Digit::One));
+
+	// the condition compares the generalized T and U, the branch keeps the inferred T
+	assertType("NarrowedSubjectInferredLiteral\\Collection<'foo', int>", templateTarget('foo', 'bar'));
+	assertType("NarrowedSubjectInferredLiteral\\Collection<'foo', int>", negatedTemplateTarget('foo', 'bar'));
+}