Narrow a class-string with call-site variance by its class name

A class name compared with a class-string of its own generic class now
takes the type arguments and the call-site variance of that class-string as
they are written: `X::class` read against `class-string<X<*>>` is `X<*>`.
So `$class !== X::class` narrows `class-string<X<*>>|class-string<Y<*>>` to
`class-string<Y<*>>`. Before, a class-string with call-site variance left
the class name bare, which is only maybe an `X<*>`, and nothing narrowed.

A subclass still stays bare when the class-string has call-site variance.

Author: miguelmeloninnatial

src/Type/Generic/GenericObjectType.php

@@ -462,19 +462,32 @@ public function changeSubtractedType(?Type $subtractedType): Type
 	 * Gives $subclass, a class written without type arguments, the ones
 	 * $supertype implies for it through the class's `@extends` and
 	 * `@implements` tags: Some with Option<int> is Some<int>, Err with
-	 * Result<int, string> is Err<string>.
+	 * Result<int, string> is Err<string>. The class of $supertype itself
+	 * takes its arguments and call-site variance as written: X with X<*> is
+	 * X<*>.
 	 *
 	 * Returns $subclass unchanged unless $supertype is a generic object type
-	 * without call-site variance, $subclass is a generic subtype of its class,
-	 * and $supertype determines every type argument of $subclass - an explicit
-	 * argument would claim more than is known.
+	 * and $subclass is its class or a generic subtype of it. A subtype also
+	 * stays unchanged when $supertype has call-site variance or does not
+	 * determine every type argument of the subtype - an explicit argument
+	 * would claim more than is known.
 	 */
 	public static function specializeSubclass(Type $supertype, Type $subclass): Type
 	{
 		if (!$supertype instanceof self || get_class($subclass) !== ObjectType::class) {
 			return $subclass;
 		}
 
+		if ($subclass->getClassName() === $supertype->getClassName()) {
+			return new self(
+				$supertype->getClassName(),
+				$supertype->types,
+				$subclass->getSubtractedType(),
+				null,
+				$supertype->variances,
+			);
+		}
+
 		foreach ($supertype->variances as $variance) {
 			if (!$variance->invariant()) {
 				return $subclass;

tests/PHPStan/Analyser/nsrt/bug-15266.php

@@ -0,0 +1,50 @@
+<?php declare(strict_types=1);
+
+namespace Bug15266;
+
+use function PHPStan\Testing\assertType;
+
+/** @template T = mixed */
+final class X {}
+
+/** @template T = mixed */
+final class Y {}
+
+/**
+ * @param class-string<X<int>> | class-string<Y<int>> $class
+ * @return class-string<X<int>> | class-string<Y<int>>
+ */
+function parametrized(string $class): string
+{
+	if ($class !== X::class) {
+		assertType('class-string<Bug15266\Y<int>>', $class);
+	}
+
+	return $class;
+}
+
+/**
+ * @param class-string<X<*>> | class-string<Y<*>> $class
+ * @return class-string<X<*>> | class-string<Y<*>>
+ */
+function star(string $class): string
+{
+	if ($class !== X::class) {
+		assertType('class-string<Bug15266\Y<*>>', $class);
+	}
+
+	return $class;
+}
+
+/**
+ * @param class-string<X> | class-string<Y> $class
+ * @return class-string<X> | class-string<Y>
+ */
+function raw(string $class): string
+{
+	if ($class !== X::class) {
+		assertType('class-string<Bug15266\Y>', $class);
+	}
+
+	return $class;
+}