Recognize [$obj, $method] as callable when method_exists($obj, $method) is known true in scope

- In `ArrayHandler::resolveType()`, after computing the array type, check if
  the 2-element array's `isCallable()` returns `maybe` and whether
  `method_exists(item0, item1)` is known to be `true` in the current scope
- When both conditions are met, intersect the array type with `CallableType`,
  making `isCallable()` return `yes` instead of `maybe`
- This fixes false positives from `CallCallablesRule` for patterns like:
  `method_exists($obj, $method)` followed by `[$obj, $method]()`
- Also fixes the same pattern via `is_callable([$obj, $method])` for inline
  arrays, since `IsCallableFunctionTypeSpecifyingExtension` delegates to
  `MethodExistsTypeSpecifyingExtension` which stores the `method_exists`
  result in scope
- Tested with: `$this`, class-string first element, `is_callable` inline
  array, and if/else branching patterns

Author: VincentLanglet

src/Analyser/ExprHandler/ArrayHandler.php

@@ -2,8 +2,11 @@
 
 namespace PHPStan\Analyser\ExprHandler;
 
+use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
 use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Expr\FuncCall;
+use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt;
 use PHPStan\Analyser\ExpressionContext;
 use PHPStan\Analyser\ExpressionResult;
@@ -15,8 +18,12 @@
 use PHPStan\Node\LiteralArrayItem;
 use PHPStan\Node\LiteralArrayNode;
 use PHPStan\Reflection\InitializerExprTypeResolver;
+use PHPStan\Type\CallableType;
+use PHPStan\Type\Constant\ConstantBooleanType;
 use PHPStan\Type\Type;
+use PHPStan\Type\TypeCombinator;
 use function array_merge;
+use function count;
 
 /**
  * @implements ExprHandler<Array_>
@@ -38,7 +45,25 @@ public function supports(Expr $expr): bool
 
 	public function resolveType(MutatingScope $scope, Expr $expr): Type
 	{
-		return $this->initializerExprTypeResolver->getArrayType($expr, static fn (Expr $expr): Type => $scope->getType($expr));
+		$type = $this->initializerExprTypeResolver->getArrayType($expr, static fn (Expr $expr): Type => $scope->getType($expr));
+
+		if (
+			count($expr->items) === 2
+			&& $expr->items[0]->key === null
+			&& $expr->items[1]->key === null
+			&& $type->isCallable()->maybe()
+		) {
+			$methodExistsCall = new FuncCall(
+				new FullyQualified('method_exists'),
+				[new Arg($expr->items[0]->value), new Arg($expr->items[1]->value)],
+			);
+			$methodExistsType = $scope->getType($methodExistsCall);
+			if ((new ConstantBooleanType(true))->isSuperTypeOf($methodExistsType)->yes()) {
+				$type = TypeCombinator::intersect($type, new CallableType());
+			}
+		}
+
+		return $type;
 	}
 
 	public function processExpr(NodeScopeResolver $nodeScopeResolver, Stmt $stmt, Expr $expr, MutatingScope $scope, ExpressionResultStorage $storage, callable $nodeCallback, ExpressionContext $context): ExpressionResult

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

@@ -0,0 +1,41 @@
+<?php declare(strict_types = 1);
+
+namespace Bug4510Nsrt;
+
+use function PHPStan\Testing\assertType;
+
+class Foo
+{
+	public function existingMethod(): void {}
+}
+
+function testMethodExists(string $method): void {
+	$instance = new Foo();
+	if (!method_exists($instance, $method)) {
+		return;
+	}
+
+	assertType('list{Bug4510Nsrt\Foo, string}&callable(): mixed', [$instance, $method]);
+}
+
+function testIsCallableInlineArray(string $method): void {
+	$instance = new Foo();
+	if (!is_callable([$instance, $method])) {
+		return;
+	}
+
+	assertType('list{Bug4510Nsrt\Foo, string}&callable(): mixed', [$instance, $method]);
+}
+
+function testMethodExistsWithClassString(string $method): void {
+	if (!method_exists(Foo::class, $method)) {
+		return;
+	}
+
+	assertType("list{'Bug4510Nsrt\\\\Foo', string}&callable(): mixed", [Foo::class, $method]);
+}
+
+function testNoMethodExists(string $method): void {
+	$instance = new Foo();
+	assertType('array{Bug4510Nsrt\Foo, string}', [$instance, $method]);
+}

tests/PHPStan/Rules/Functions/CallCallablesRuleTest.php

@@ -374,6 +374,11 @@ public function testBug4608(): void
 		]);
 	}
 
+	public function testBug4510(): void
+	{
+		$this->analyse([__DIR__ . '/data/bug-4510.php'], []);
+	}
+
 	public function testMaybeNotCallable(): void
 	{
 		$errors = [];

tests/PHPStan/Rules/Functions/data/bug-4510.php

@@ -0,0 +1,57 @@
+<?php declare(strict_types = 1);
+
+namespace Bug4510;
+
+class HelloWorld
+{
+	public function doSomething(string $method): void {
+		if (!method_exists($this, $method)) {
+			return;
+		}
+
+		[$this, $method]();
+	}
+}
+
+function bar(string $method): void {
+	$instance = new HelloWorld();
+	if (!method_exists($instance, $method)) {
+		return;
+	}
+
+	[$instance, $method]();
+}
+
+function baz(string $method): void {
+	$instance = new HelloWorld();
+	if (!is_callable([$instance, $method])) {
+		return;
+	}
+
+	[$instance, $method]();
+}
+
+function withClassString(string $method): void {
+	if (!method_exists(HelloWorld::class, $method)) {
+		return;
+	}
+
+	[HelloWorld::class, $method]();
+}
+
+function withDynamicMethodExistsAndVariable(string $method): void {
+	$instance = new HelloWorld();
+	$callable = [$instance, $method];
+	if (!is_callable($callable)) {
+		return;
+	}
+
+	$callable();
+}
+
+function methodExistsInElseBranch(string $method): void {
+	$instance = new HelloWorld();
+	if (method_exists($instance, $method)) {
+		[$instance, $method]();
+	}
+}