Avoid false error on is_subclass_of

Author: VincentLanglet

src/Type/Php/IsAFunctionTypeSpecifyingHelper.php

@@ -38,13 +38,18 @@ public function determineType(
 
 		return TypeTraverser::map(
 			$classType,
-			static function (Type $type, callable $traverse) use ($objectOrClassTypeClassNames, $allowString, $allowSameClass): Type {
+			static function (Type $type, callable $traverse) use ($objectOrClassType, $objectOrClassTypeClassNames, $allowString, $allowSameClass): Type {
 				if ($type instanceof UnionType || $type instanceof IntersectionType) {
 					return $traverse($type);
 				}
 				if ($type instanceof ConstantStringType) {
 					if (!$allowSameClass && $objectOrClassTypeClassNames === [$type->getValue()]) {
-						return new NeverType();
+						// For objectType we cannot be sure since 'Foo' is used for both
+						// - the Foo class
+						// - a child of foo class
+						if ($objectOrClassType->isString()->yes()) {
+							return new NeverType();
+						}
 					}
 					if ($allowString) {
 						return TypeCombinator::union(

src/Type/Php/IsSubclassOfFunctionTypeSpecifyingExtension.php

@@ -53,7 +53,7 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		$resultType = $this->isAFunctionTypeSpecifyingHelper->determineType($objectOrClassType, $classType, $allowString, false);
 
 		// prevent false-positives in IsAFunctionTypeSpecifyingHelper
-		if ($classType->getConstantStrings() === [] && $resultType->isSuperTypeOf($objectOrClassType)->yes()) {
+		if ($resultType->isSuperTypeOf($objectOrClassType)->yes()) {
 			return new SpecifiedTypes([], []);
 		}
 

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

@@ -15,5 +15,5 @@ class B extends A {}
 }
 
 if (is_subclass_of($b, B::class)) {
-	assertType('*NEVER*', $b);
+	assertType('Bug6305Types\B', $b); // Could be NEVER
 }

tests/PHPStan/Analyser/nsrt/is-subclass-of.php

@@ -4,7 +4,7 @@
 
 function (Bar $a, Bar $b, Bar $c, Bar $d) {
 	if (is_subclass_of($a, Bar::class)) {
-		\PHPStan\Testing\assertType('*NEVER*', $a);
+		\PHPStan\Testing\assertType('IsSubclassOf\Bar', $a); // Can still be a Bar child
 	}
 
 	if (is_subclass_of($b, Foo::class)) {

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -389,17 +389,29 @@ public function testBug6305(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
 		$this->analyse([__DIR__ . '/data/bug-6305.php'], [
-			[
-				'Call to function is_subclass_of() with Bug6305\B and \'Bug6305\\\A\' will always evaluate to true.',
-				11,
-			],
-			[
-				'Call to function is_subclass_of() with Bug6305\B and \'Bug6305\\\B\' will always evaluate to false.',
-				14,
-			],
+			// [
+			//	'Call to function is_subclass_of() with Bug6305\B and \'Bug6305\\\A\' will always evaluate to true.',
+			//	11,
+			// ],
+			// [
+			//	'Call to function is_subclass_of() with Bug6305\B and \'Bug6305\\\B\' will always evaluate to false.',
+			//	14,
+			// ],
 		]);
 	}
 
+	public function testBug6305b(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-6305b.php'], []);
+	}
+
+	public function testBug13713(): void
+	{
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-13713.php'], []);
+	}
+
 	public function testBug6698(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;

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

@@ -0,0 +1,14 @@
+<?php
+
+declare(strict_types = 1);
+
+namespace Bug13713;
+
+function debug(object $test): void {
+	if ($test instanceof \stdClass) {
+		echo var_export(\is_subclass_of($test, \stdClass::class, false), true) . \PHP_EOL;
+	}
+}
+
+class test extends \stdClass {}
+debug(new test);

tests/PHPStan/Rules/Comparison/data/bug-6305b.php

@@ -0,0 +1,35 @@
+<?php
+
+namespace Bug6305b;
+
+class A {}
+
+class B extends A {}
+
+$b = mt_rand(0, 1) === 0 ? new B() : new A();
+
+if (is_subclass_of($b, A::class)) {
+	if (is_subclass_of($b, A::class)) {
+		echo 'x';
+	}
+}
+
+if (is_subclass_of($b, B::class)) {
+	if (is_subclass_of($b, B::class)) {
+		echo 'y';
+	}
+}
+
+$b = mt_rand(0, 1) === 0 ? A::class : B::class;
+
+if (is_subclass_of($b, A::class)) {
+	if (is_subclass_of($b, A::class)) {
+		echo 'x';
+	}
+}
+
+if (is_subclass_of($b, B::class)) {
+	if (is_subclass_of($b, B::class)) {
+		echo 'y';
+	}
+}