Enable usage of ReflectionClass::isSubclassOf() with invariant @template T

Author: ondrejmirtes

phpstan-baseline.neon

@@ -1593,12 +1593,6 @@ parameters:
 			count: 2
 			path: src/Type/Php/RangeFunctionReturnTypeExtension.php
 
-		-
-			message: '#^Doing instanceof PHPStan\\Type\\Constant\\ConstantStringType is error\-prone and deprecated\. Use Type\:\:getConstantStrings\(\) instead\.$#'
-			identifier: phpstanApi.instanceofType
-			count: 1
-			path: src/Type/Php/ReflectionClassIsSubclassOfTypeSpecifyingExtension.php
-
 		-
 			message: '#^Doing instanceof PHPStan\\Type\\Constant\\ConstantStringType is error\-prone and deprecated\. Use Type\:\:getConstantStrings\(\) instead\.$#'
 			identifier: phpstanApi.instanceofType

src/Type/Php/ReflectionClassIsSubclassOfTypeSpecifyingExtension.php

@@ -9,10 +9,9 @@
 use PHPStan\Analyser\TypeSpecifierAwareExtension;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\MethodReflection;
-use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\Generic\GenericObjectType;
 use PHPStan\Type\MethodTypeSpecifyingExtension;
-use PHPStan\Type\ObjectType;
+use PHPStan\Type\ObjectWithoutClassType;
 use ReflectionClass;
 
 final class ReflectionClassIsSubclassOfTypeSpecifyingExtension implements MethodTypeSpecifyingExtension, TypeSpecifierAwareExtension
@@ -34,24 +33,47 @@ public function isMethodSupported(MethodReflection $methodReflection, MethodCall
 	{
 		return $methodReflection->getName() === 'isSubclassOf'
 			&& isset($node->getArgs()[0])
-			&& $context->true();
+			&& !$context->null();
 	}
 
 	public function specifyTypes(MethodReflection $methodReflection, MethodCall $node, Scope $scope, TypeSpecifierContext $context): SpecifiedTypes
 	{
+		$calledOnType = $scope->getType($node->var);
+		$reflectionType = $calledOnType->getTemplateType(ReflectionClass::class, 'T');
+		if (!(new ObjectWithoutClassType())->isSuperTypeOf($reflectionType)->yes()) {
+			return new SpecifiedTypes();
+		}
+
 		$valueType = $scope->getType($node->getArgs()[0]->value);
-		if (!$valueType instanceof ConstantStringType) {
-			return new SpecifiedTypes([], []);
+		$objectType = $valueType->getClassStringObjectType();
+		$narrowingType = new GenericObjectType(ReflectionClass::class, [$objectType]);
+
+		if (!$reflectionType->isSuperTypeOf($objectType)->yes()) {
+			// cause "always false" error
+			return $this->typeSpecifier->create(
+				$node->var,
+				$narrowingType,
+				$context,
+				$scope,
+			);
+		}
+
+		if ($objectType->isSuperTypeOf($reflectionType)->yes()) {
+			// cause "always true" error
+			return $this->typeSpecifier->create(
+				$node->var,
+				$narrowingType,
+				$context,
+				$scope,
+			);
 		}
 
 		return $this->typeSpecifier->create(
 			$node->var,
-			new GenericObjectType(ReflectionClass::class, [
-				new ObjectType($valueType->getValue()),
-			]),
+			$narrowingType,
 			$context,
 			$scope,
-		);
+		)->setAlwaysOverwriteTypes();
 	}
 
 }

tests/PHPStan/Analyser/nsrt/bug-12473-types.php

@@ -0,0 +1,48 @@
+<?php // lint >= 8.4
+
+namespace Bug12473Types;
+
+use ReflectionClass;
+use function PHPStan\Testing\assertType;
+
+class Picture
+{
+}
+
+class PictureUser extends Picture
+{
+}
+
+class PictureProduct extends Picture
+{
+}
+
+/**
+ * @param class-string $a
+ */
+function doFoo(string $a): void
+{
+	$r = new ReflectionClass($a);
+	assertType('ReflectionClass<object>', $r);
+	if ($r->isSubclassOf(Picture::class)) {
+		assertType('ReflectionClass<Bug12473Types\\Picture>', $r);
+	} else {
+		assertType('ReflectionClass<object>', $r);
+	}
+	assertType('ReflectionClass<Bug12473Types\Picture>|ReflectionClass<object>', $r);
+}
+
+/**
+ * @param class-string<Picture> $a
+ */
+function doFoo2(string $a): void
+{
+	$r = new ReflectionClass($a);
+	assertType('ReflectionClass<Bug12473Types\\Picture>', $r);
+	if ($r->isSubclassOf(Picture::class)) {
+		assertType('ReflectionClass<Bug12473Types\\Picture>', $r);
+	} else {
+		assertType('*NEVER*', $r);
+	}
+	assertType('ReflectionClass<Bug12473Types\\Picture>', $r);
+}

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeMethodCallRuleTest.php

@@ -254,6 +254,29 @@ public function testReportAlwaysTrueInLastCondition(bool $reportAlwaysTrueInLast
 		$this->analyse([__DIR__ . '/data/impossible-method-report-always-true-last-condition.php'], $expectedErrors);
 	}
 
+	public function testBug12473(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$tip = 'Because the type is coming from a PHPDoc, you can turn off this check by setting <fg=cyan>treatPhpDocTypesAsCertain: false</> in your <fg=cyan>%configurationFile%</>.';
+		$this->analyse([__DIR__ . '/data/bug-12473.php'], [
+			[
+				'Call to method ReflectionClass<Bug12473\\Picture>::isSubclassOf() with \'Bug12473\\\\Picture\' will always evaluate to true.',
+				39,
+				$tip,
+			],
+			[
+				'Call to method ReflectionClass<Bug12473\\PictureUser>::isSubclassOf() with \'Bug12473\\\\PictureProduct\' will always evaluate to false.',
+				49,
+				$tip,
+			],
+			[
+				'Call to method ReflectionClass<Bug12473\\PictureUser>::isSubclassOf() with \'Bug12473\\\\PictureUser\' will always evaluate to true.',
+				59,
+				$tip,
+			],
+		]);
+	}
+
 	public static function getAdditionalConfigFiles(): array
 	{
 		return [

tests/PHPStan/Rules/Comparison/data/bug-12473.php

@@ -0,0 +1,62 @@
+<?php
+
+namespace Bug12473;
+
+use ReflectionClass;
+
+class Picture
+{
+}
+
+class PictureUser extends Picture
+{
+}
+
+class PictureProduct extends Picture
+{
+}
+
+function getPictureFqn(string $pictureType): ?string
+{
+	/** @var class-string<Picture|object> $fqn */
+	$fqn = $pictureType;
+	if ($fqn === Picture::class) {
+		return Picture::class;
+	}
+	$refl = new \ReflectionClass($fqn);
+	if (!$refl->isSubclassOf(Picture::class)) {
+		return null;
+	}
+
+	return $fqn;
+}
+
+/**
+ * @param class-string<Picture> $a
+ */
+function doFoo(string $a): void {
+	$r = new ReflectionClass($a);
+	if ($r->isSubclassOf(Picture::class)) {
+
+	}
+}
+
+/**
+ * @param class-string<PictureUser> $a
+ */
+function doFoo2(string $a): void {
+	$r = new ReflectionClass($a);
+	if ($r->isSubclassOf(PictureProduct::class)) {
+
+	}
+}
+
+/**
+ * @param class-string<PictureUser> $a
+ */
+function doFoo3(string $a): void {
+	$r = new ReflectionClass($a);
+	if ($r->isSubclassOf(PictureUser::class)) {
+
+	}
+}