support 'HasMethodType' on StaticCall

src/Rules/Methods/StaticMethodCallCheck.php

@@ -109,6 +109,11 @@ public function check(
 
 				$classType = $scope->resolveTypeByName($class);
 			} else {
+				$classStringType = $scope->getType(new Expr\ClassConstFetch($class, 'class'));
+				if ($classStringType->hasMethod($methodName)->yes()) {
+					return [[], null];
+				}
+
 				if (!$this->reflectionProvider->hasClass($className)) {
 					if ($scope->isInClassExists($className)) {
 						return [[], null];

src/Type/Constant/ConstantStringType.php

@@ -64,6 +64,14 @@ public function getValue(): string
 		return $this->value;
 	}
 
+	public function hasMethod(string $methodName): TrinaryLogic
+	{
+		if ($this->isClassString()) {
+			return TrinaryLogic::createMaybe();
+		}
+		return TrinaryLogic::createNo();
+	}
+
 	public function isClassString(): bool
 	{
 		if ($this->isClassString) {

src/Type/Php/MethodExistsTypeSpecifyingExtension.php

@@ -14,7 +14,6 @@
 use PHPStan\Type\Constant\ConstantStringType;
 use PHPStan\Type\FunctionTypeSpecifyingExtension;
 use PHPStan\Type\IntersectionType;
-use PHPStan\Type\ObjectType;
 use PHPStan\Type\ObjectWithoutClassType;
 use PHPStan\Type\UnionType;
 use function count;
@@ -47,15 +46,26 @@ public function specifyTypes(
 		TypeSpecifierContext $context,
 	): SpecifiedTypes
 	{
+		$methodNameType = $scope->getType($node->getArgs()[1]->value);
+		if (!$methodNameType instanceof ConstantStringType) {
+			return new SpecifiedTypes([], []);
+		}
+
 		$objectType = $scope->getType($node->getArgs()[0]->value);
-		if (!$objectType instanceof ObjectType) {
-			if ($objectType->isString()->yes()) {
-				return new SpecifiedTypes([], []);
+		if ($objectType->isString()->yes()) {
+			if ($objectType instanceof ConstantStringType && $objectType->isClassString()) {
+				return $this->typeSpecifier->create(
+					$node->getArgs()[0]->value,
+					new IntersectionType([
+						$objectType,
+						new HasMethodType($methodNameType->getValue()),
+					]),
+					$context,
+					false,
+					$scope,
+				);
 			}
-		}
 
-		$methodNameType = $scope->getType($node->getArgs()[1]->value);
-		if (!$methodNameType instanceof ConstantStringType) {
 			return new SpecifiedTypes([], []);
 		}
 

tests/PHPStan/Analyser/NodeScopeResolverTest.php

@@ -1124,6 +1124,7 @@ public function dataFileAsserts(): iterable
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/bug-8272.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/../Rules/Comparison/data/bug-8277.php');
 		yield from $this->gatherAssertTypes(__DIR__ . '/data/strtr.php');
+		yield from $this->gatherAssertTypes(__DIR__ . '/data/static-has-method.php');
 	}
 
 	/**

tests/PHPStan/Analyser/data/static-has-method.php

@@ -0,0 +1,21 @@
+<?php declare(strict_types = 1);
+
+namespace StaticHasMethod;
+
+use function PHPStan\Testing\assertType;
+
+class rex_var {}
+
+class HelloWorld
+{
+	public function sayHello(): void
+	{
+		if (!method_exists(rex_var::class, 'varsIterator')) {
+			return;
+		}
+		assertType("'StaticHasMethod\\\\rex_var'&hasMethod(varsIterator)", rex_var::class);
+
+		$it = rex_var::varsIterator();
+	}
+}
+

tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php

@@ -531,4 +531,20 @@ public function testBug7489(): void
 		$this->analyse([__DIR__ . '/data/bug-7489.php'], []);
 	}
 
+	public function testHasMethodStaticCall(): void
+	{
+		$this->checkThisOnly = false;
+		$this->checkExplicitMixed = false;
+		$this->analyse([__DIR__ . '/data/static-has-method.php'], [
+			[
+				'Call to an undefined static method StaticHasMethodCall\rex_var::doesNotExist().',
+				38,
+			],
+			[
+				'Call to an undefined static method StaticHasMethodCall\rex_var::doesNotExist().',
+				48,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Methods/data/static-has-method.php

@@ -0,0 +1,51 @@
+<?php declare(strict_types = 1);
+
+namespace StaticHasMethodCall;
+
+class rex_var {
+	public static function aMethod() {}
+}
+
+class HelloWorld
+{
+	public function sayHello(): void
+	{
+		if (!method_exists(rex_var::class, 'doesNotExist')) {
+			return;
+		}
+
+		// should not error
+		$it = rex_var::doesNotExist();
+	}
+
+	public function sayHello2(): void
+	{
+		if (!method_exists(rex_var::class, 'doesNotExist')) {
+			return;
+		}
+
+		// should not error
+		$it = rex_var::aMethod();
+	}
+
+	public function sayHello3(): void
+	{
+		if (!method_exists(rex_var::class, 'anotherNotExistingMethod')) {
+			return;
+		}
+
+		// should error
+		$it = rex_var::doesNotExist();
+	}
+
+	public function sayHello4(): void
+	{
+		if (!method_exists(notExistentClass::class, 'doesNotExist')) {
+			return;
+		}
+
+		// should error
+		$it = rex_var::doesNotExist();
+	}
+}
+