use conditional parameter for is_a() via stub

src/Rules/Comparison/ImpossibleCheckTypeFunctionCallRule.php

@@ -7,7 +7,6 @@
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
 use function sprintf;
-use function strtolower;
 
 /**
  * @implements Rule<Node\Expr\FuncCall>
@@ -35,9 +34,6 @@ public function processNode(Node $node, Scope $scope): array
 		}
 
 		$functionName = (string) $node->name;
-		if (strtolower($functionName) === 'is_a') {
-			return [];
-		}
 		$isAlways = $this->impossibleCheckTypeHelper->findSpecifiedType($scope, $node);
 		if ($isAlways === null) {
 			return [];

src/Type/Php/IsAFunctionTypeSpecifyingExtension.php

@@ -9,9 +9,12 @@
 use PHPStan\Analyser\TypeSpecifierAwareExtension;
 use PHPStan\Analyser\TypeSpecifierContext;
 use PHPStan\Reflection\FunctionReflection;
+use PHPStan\Type\ClassStringType;
 use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
+use PHPStan\Type\Generic\GenericClassStringType;
+use PHPStan\Type\MixedType;
 use function count;
 use function strtolower;
 
@@ -42,6 +45,16 @@ public function specifyTypes(FunctionReflection $functionReflection, FuncCall $n
 		$allowStringType = isset($node->getArgs()[2]) ? $scope->getType($node->getArgs()[2]->value) : new ConstantBooleanType(false);
 		$allowString = !$allowStringType->equals(new ConstantBooleanType(false));
 
+		// early exit in some cases, so we don't create false positives via IsAFunctionTypeSpecifyingHelper
+		if ($classType instanceof ClassStringType && !$classType instanceof GenericClassStringType) {
+			if ($objectOrClassType->isString()->yes() && $allowString) {
+				return new SpecifiedTypes([], []);
+			}
+			if (!$objectOrClassType->isString()->yes() && !$objectOrClassType instanceof MixedType) {
+				return new SpecifiedTypes([], []);
+			}
+		}
+
 		if (!$classType instanceof ConstantStringType && !$context->truthy()) {
 			return new SpecifiedTypes([], []);
 		}

src/Type/Php/TypeSpecifyingFunctionsDynamicReturnTypeExtension.php

@@ -42,6 +42,7 @@ public function isFunctionSupported(FunctionReflection $functionReflection): boo
 			'in_array',
 			'is_numeric',
 			'is_int',
+			'is_a',
 			'is_array',
 			'is_bool',
 			'is_callable',

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -885,6 +885,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/pr-1244.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-7144.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-7144-composer-integration.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-4371.php');
 	}
 
 	/**

tests/PHPStan/Analyser/data/bug-4371.php

@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Bug4371;
+
+use function PHPStan\Testing\assertType;
+use Exception;
+
+class HelloWorld
+{
+	/**
+	 * @param Exception $exception
+	 * @param class-string $classString
+	 */
+	public function sayHello(Exception $exception, $classString): void
+	{
+		assertType('bool', is_a($exception, $classString));
+		assertType('bool', is_a($exception, $classString, true));
+		assertType('bool', is_a($exception, $classString, false));
+
+		$exceptionClass = get_class($exception);
+		assertType('false', is_a($exceptionClass, $classString));
+		assertType('bool', is_a($exceptionClass, $classString, true));
+		assertType('false', is_a($exceptionClass, $classString, false));
+	}
+}

tests/PHPStan/Rules/Comparison/ImpossibleCheckTypeFunctionCallRuleTest.php

@@ -51,6 +51,10 @@ public function testImpossibleCheckTypeFunctionCall(): void
 					'Call to function is_int() with string will always evaluate to false.',
 					31,
 				],
+				[
+					'Call to function is_a() with arguments \'Foo\', \'Throwable\' and true will always evaluate to false.',
+					35,
+				],
 				[
 					'Call to function is_callable() with array<int> will always evaluate to false.',
 					44,
@@ -248,6 +252,10 @@ public function testImpossibleCheckTypeFunctionCallWithoutAlwaysTrue(): void
 					'Call to function is_int() with string will always evaluate to false.',
 					31,
 				],
+				[
+					'Call to function is_a() with arguments \'Foo\', \'Throwable\' and true will always evaluate to false.',
+					35,
+				],
 				[
 					'Call to function is_callable() with array<int> will always evaluate to false.',
 					44,
@@ -535,4 +543,20 @@ public function testNonEmptySpecifiedString(): void
 		$this->analyse([__DIR__ . '/data/non-empty-string-impossible-type.php'], []);
 	}
 
+	public function testBug4371(): void
+	{
+		$this->checkAlwaysTrueCheckTypeFunctionCall = true;
+		$this->treatPhpDocTypesAsCertain = true;
+		$this->analyse([__DIR__ . '/data/bug-4371.php'], [
+			[
+				"Call to function is_a() with 'Bug4371\\\\Bar' and 'Bug4371\\\\Foo' will always evaluate to false.",
+				14,
+			],
+			[
+				"Call to function is_a() with arguments 'Bug4371\\\\Bar', 'Bug4371\\\\Foo' and false will always evaluate to false.",
+				21,
+			],
+		]);
+	}
+
 }

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

@@ -0,0 +1,28 @@
+<?php
+
+namespace Bug4371;
+
+class Foo {
+}
+
+class Bar extends Foo {
+
+}
+
+class HalloWorld {
+	public function doFoo() {
+		if(is_a(Bar::class, Foo::class)) { // should be reported
+			echo "This will never be true";
+		} else {
+			echo "NO";
+		}
+	}
+	public function doBar() {
+		if(is_a(Bar::class, Foo::class, false)) { // should be reported
+			echo "This will never be true";
+		} else {
+			echo "NO";
+		}
+	}
+}
+

tests/PHPStan/Rules/Comparison/data/check-type-function-call.php

@@ -32,7 +32,7 @@ public function doFoo(
 
 		}
 		$className = 'Foo';
-		if (is_a($className, \Throwable::class, true)) { // should be fine
+		if (is_a($className, \Throwable::class, true)) { // always false
 
 		}
 		if (is_array($callable)) {
@@ -860,3 +860,21 @@ public function doFoo(int $i, array $is): void
 	}
 
 }
+
+class NonFinalSubclassMightImplementInterface {
+	/**
+	 * @param class-string<Foo> $classString
+	 */
+	public function doFoo($classString, Foo $obj): void {
+		if (is_a($classString, \Throwable::class, true)) { // should be fine
+
+		}
+
+		if (is_a($obj, \Throwable::class, true)) { // should be fine
+
+		}
+		if (is_a($obj, \Throwable::class)) { // should be fine
+
+		}
+	}
+}