improve is_subclass_of type checks

src/Type/Php/IsSubclassOfFunctionTypeSpecifyingExtension.php

@@ -11,6 +11,7 @@
 use PHPStan\Reflection\FunctionReflection;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
+use PHPStan\Type\Generic\GenericClassStringType;
 use function count;
 use function strtolower;
 
@@ -42,6 +43,11 @@ 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([], []);
+		}
+
 		return $this->typeSpecifier->create(
 			$node->getArgs()[0]->value,
 			$this->isAFunctionTypeSpecifyingHelper->determineType($objectOrClassType, $classType, $allowString, false),

stubs/core.stub

@@ -2,7 +2,15 @@
 
 /**
  * @param ($allow_string is false ? object : object|string) $object_or_class
- * @param class-string $class
+ * @param string $class
+ * @param bool $allow_string
+ * @return ($allow_string is false ? ($object_or_class is object ? bool : false) : bool)
+ */
+function is_subclass_of($object_or_class, string $class, $allow_string = true): bool{}
+
+/**
+ * @param ($allow_string is false ? object : object|string) $object_or_class
+ * @param string $class
  * @param bool $allow_string
  * @return ($allow_string is false ? ($object_or_class is object ? bool : false) : bool)
  */

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -535,4 +535,11 @@ public function testNonEmptySpecifiedString(): void
 		$this->analyse([__DIR__ . '/data/non-empty-string-impossible-type.php'], []);
 	}
 
+	public function testBug2755(): void
+	{
+		$this->checkAlwaysTrueCheckTypeFunctionCall = true;
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-2755.php'], []);
+	}
+
 }

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

@@ -0,0 +1,18 @@
+<?php declare(strict_types = 1);
+
+namespace Bug2755;
+
+/**
+ * @param array<class-string<object>> $interfaces
+ * @param array<class-string<object>> $classes
+ */
+function foo(array $interfaces, array $classes): void
+{
+	foreach ($interfaces as $interface) {
+		foreach ($classes as $class) {
+			if (is_subclass_of($class, $interface)) {
+
+			}
+		}
+	}
+}

tests/PHPStan/Rules/Functions/CallToFunctionParametersRuleTest.php

@@ -1001,4 +1001,42 @@ public function testBug4371(): void
 		$this->analyse([__DIR__ . '/data/bug-4371.php'], $errors);
 	}
 
+	public function testIsSubclassAllowString(): void
+	{
+		$errors = [
+			[
+				'Parameter #1 $object_or_class of function is_subclass_of expects object, string given.',
+				11,
+			],
+			[
+				'Parameter #1 $object_or_class of function is_subclass_of expects object, string given.',
+				14,
+			],
+			[
+				'Parameter #1 $object_or_class of function is_subclass_of expects object, string given.',
+				17,
+			],
+		];
+
+		if (PHP_VERSION_ID < 80000) {
+			// php 7.x had different parameter names
+			$errors = [
+				[
+					'Parameter #1 $object_or_string of function is_subclass_of expects object, string given.',
+					11,
+				],
+				[
+					'Parameter #1 $object_or_string of function is_subclass_of expects object, string given.',
+					14,
+				],
+				[
+					'Parameter #1 $object_or_string of function is_subclass_of expects object, string given.',
+					17,
+				],
+			];
+		}
+
+		$this->analyse([__DIR__ . '/data/is-subclass-allow-string.php'], $errors);
+	}
+
 }

tests/PHPStan/Rules/Functions/data/is-subclass-allow-string.php

@@ -0,0 +1,24 @@
+<?php declare(strict_types = 1);
+
+namespace IsSubclassAllowString;
+
+class A {}
+
+class B extends A {}
+
+$b = new B();
+
+if (is_subclass_of(A::class, A::class, false)) { // should error
+}
+
+if (is_subclass_of(B::class, B::class, false)) { // should error
+}
+
+if (is_subclass_of(B::class, A::class, false)) { // should error
+}
+
+if (is_subclass_of($b, A::class)) { // fine
+}
+
+if (is_subclass_of($b, B::class)) { // fine
+}