Rework

Author: VincentLanglet

src/Type/Php/IsAFunctionTypeSpecifyingExtension.php

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

src/Type/Php/IsAFunctionTypeSpecifyingHelper.php

@@ -16,6 +16,7 @@
 use PHPStan\Type\UnionType;
 use function array_unique;
 use function array_values;
+use function in_array;
 
 #[AutowiredService]
 final class IsAFunctionTypeSpecifyingHelper
@@ -26,7 +27,7 @@ public function determineType(
 		Type $classType,
 		bool $allowString,
 		bool $allowSameClass,
-	): Type
+	): ?Type
 	{
 		$objectOrClassTypeClassNames = $objectOrClassType->getObjectClassNames();
 		if ($allowString) {
@@ -36,20 +37,35 @@ public function determineType(
 			$objectOrClassTypeClassNames = array_values(array_unique($objectOrClassTypeClassNames));
 		}
 
-		return TypeTraverser::map(
+		$isUncertain = $classType->getConstantStrings() === [];
+
+		$resultType = TypeTraverser::map(
 			$classType,
-			static function (Type $type, callable $traverse) use ($objectOrClassType, $objectOrClassTypeClassNames, $allowString, $allowSameClass): Type {
+			static function (Type $type, callable $traverse) use ($objectOrClassType, $objectOrClassTypeClassNames, $allowString, $allowSameClass, &$isUncertain): Type {
 				if ($type instanceof UnionType || $type instanceof IntersectionType) {
 					return $traverse($type);
 				}
 				if ($type instanceof ConstantStringType) {
-					if (!$allowSameClass && $objectOrClassTypeClassNames === [$type->getValue()]) {
+					if (!$allowSameClass) {
 						// For objectType we cannot be sure since 'Foo' is used for both
 						// - the Foo class
 						// - a child of foo class
-						if ($objectOrClassType->isString()->yes()) {
+						if (
+							$objectOrClassTypeClassNames === [$type->getValue()]
+							&& $objectOrClassType->isString()->yes()
+						) {
 							return new NeverType();
 						}
+
+						if (
+							// For object, as soon as the exact same type is provided
+							// in the list we cannot be sure of the result
+							in_array($type->getValue(), $objectOrClassTypeClassNames, true)
+							// This also occurs for generic class string
+							|| ($allowString && $objectOrClassTypeClassNames === [] && $objectOrClassType->isSuperTypeOf($type)->yes()))
+						{
+							$isUncertain = true;
+						}
 					}
 					if ($allowString) {
 						return TypeCombinator::union(
@@ -80,6 +96,13 @@ static function (Type $type, callable $traverse) use ($objectOrClassType, $objec
 				return new ObjectWithoutClassType();
 			},
 		);
+
+		// prevent false-positives
+		if ($isUncertain && $resultType->isSuperTypeOf($objectOrClassType)->yes()) {
+			return null;
+		}
+
+		return $resultType;
 	}
 
 }

src/Type/Php/IsSubclassOfFunctionTypeSpecifyingExtension.php

@@ -45,15 +45,8 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		$allowStringType = isset($node->getArgs()[2]) ? $scope->getType($node->getArgs()[2]->value) : new ConstantBooleanType(true);
 		$allowString = !$allowStringType->equals(new ConstantBooleanType(false));
 
-		// prevent false-positives in IsAFunctionTypeSpecifyingHelper
-		if ($objectOrClassType instanceof GenericClassStringType && $classType instanceof GenericClassStringType) {
-			return new SpecifiedTypes([], []);
-		}
-
 		$resultType = $this->isAFunctionTypeSpecifyingHelper->determineType($objectOrClassType, $classType, $allowString, false);
-
-		// prevent false-positives in IsAFunctionTypeSpecifyingHelper
-		if ($resultType->isSuperTypeOf($objectOrClassType)->yes()) {
+		if (null === $resultType) {
 			return new SpecifiedTypes([], []);
 		}
 

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -389,10 +389,10 @@ 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\\\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,
@@ -409,7 +409,17 @@ public function testBug6305b(): void
 	public function testBug13713(): void
 	{
 		$this->treatPhpDocTypesAsCertain = true;
-		$this->analyse([__DIR__ . '/data/bug-13713.php'], []);
+		$this->analyse([__DIR__ . '/data/bug-13713.php'], [
+			[
+				"Call to function is_subclass_of() with arguments Bug13713\\test, 'stdClass' and false will always evaluate to true.",
+				12,
+			],
+			[
+				"Call to function is_subclass_of() with arguments class-string<Bug13713\\test>, 'stdClass' and true will always evaluate to true.",
+				25,
+				'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%</>.',
+			],
+		]);
 	}
 
 	public function testBug6698(): void

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

@@ -4,11 +4,25 @@
 
 namespace Bug13713;
 
-function debug(object $test): void {
-	if ($test instanceof \stdClass) {
-		echo var_export(\is_subclass_of($test, \stdClass::class, false), true) . \PHP_EOL;
+function debug(object $object): void {
+	if ($object instanceof \stdClass) {
+		echo var_export(\is_subclass_of($object, \stdClass::class, false), true) . \PHP_EOL;
+	}
+	if ($object instanceof test) {
+		echo var_export(\is_subclass_of($object, \stdClass::class, false), true) . \PHP_EOL;
 	}
 }
 
 class test extends \stdClass {}
 debug(new test);
+
+/**
+ * @param class-string<\stdClass> $stdClass
+ * @param class-string<test> 	  $test
+ */
+function debugWithClass(string $stdClass, string $test): void {
+	echo var_export(\is_subclass_of($stdClass, \stdClass::class, true), true) . \PHP_EOL;
+	echo var_export(\is_subclass_of($test, \stdClass::class, true), true) . \PHP_EOL;
+}
+
+debugWithClass(test::class, test::class);

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

@@ -9,27 +9,15 @@ 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';
-	}
 }