Do not add HasMethodType to class-string types when the method is native

- In `MethodExistsTypeSpecifyingExtension`, when narrowing class-string
  types after `method_exists()`, use `createFuncCallSpec` instead of
  adding `HasMethodType` when all class reflections have the method
  natively.
- Previously, adding `HasMethodType` to the class-string type changed
  its representation from `GenericClassStringType` to an
  `IntersectionType`, which caused `StaticMethodCallCheck` to skip
  visibility checking via two paths: the early return at line 72-74
  for Name nodes, and the `isString()->yes()` bail-out at line 203-205
  for expression nodes.
- With this fix, the class-string type is preserved, and the normal
  visibility checking flow in `StaticMethodCallCheck` correctly reports
  calls to private/protected static methods even when guarded by
  `method_exists()`.

Closes phpstan/phpstan#14684

Author: phpstan-bot

src/Type/Php/MethodExistsTypeSpecifyingExtension.php

@@ -59,10 +59,21 @@ public function specifyTypes(
 		$objectOrStringType = $scope->getType($args[0]->value);
 		if ($objectOrStringType->isString()->yes()) {
 			if ($objectOrStringType->isClassString()->yes()) {
-				foreach ($objectOrStringType->getClassStringObjectType()->getObjectClassReflections() as $classReflection) {
+				$allNative = true;
+				$classReflections = $objectOrStringType->getClassStringObjectType()->getObjectClassReflections();
+				foreach ($classReflections as $classReflection) {
 					if ($classReflection->hasMethod($methodNameType->getValue()) && !$classReflection->hasNativeMethod($methodNameType->getValue())) {
 						return $this->createFuncCallSpec($node, $context, $scope);
 					}
+					if ($classReflection->hasNativeMethod($methodNameType->getValue())) {
+						continue;
+					}
+
+					$allNative = false;
+				}
+
+				if ($allNative && $classReflections !== []) {
+					return $this->createFuncCallSpec($node, $context, $scope);
 				}
 
 				return $this->typeSpecifier->create(

tests/PHPStan/Rules/Methods/CallStaticMethodsRuleTest.php

@@ -1033,4 +1033,40 @@ public function testBug14596(): void
 		]);
 	}
 
+	public function testBug14684(): void
+	{
+		$this->checkThisOnly = false;
+		$this->checkExplicitMixed = false;
+		$this->analyse([__DIR__ . '/data/bug-14684.php'], [
+			[
+				'Call to private static method privateFoo() of class Bug14684\X.',
+				25,
+			],
+			[
+				'Call to protected static method protectedFoo() of class Bug14684\X.',
+				29,
+			],
+			[
+				'Call to private static method privateFoo() of class Bug14684\SubX.',
+				41,
+			],
+			[
+				'Call to protected static method protectedFoo() of class Bug14684\X.',
+				45,
+			],
+			[
+				'Call to private static method privateFoo() of class Bug14684\X.',
+				52,
+			],
+			[
+				'Call to protected static method protectedFoo() of class Bug14684\X.',
+				56,
+			],
+			[
+				'Call to private static method privateFoo() of class Bug14684\SubX.',
+				60,
+			],
+		]);
+	}
+
 }

tests/PHPStan/Rules/Methods/data/bug-14684.php

@@ -0,0 +1,62 @@
+<?php declare(strict_types = 1);
+
+namespace Bug14684;
+
+class X {
+	static public function publicFoo():void {}
+
+	final static private function privateFoo():void {}
+
+	static protected function protectedFoo():void {}
+}
+
+final class SubX extends X {
+	static private function privateFoo():void {}
+}
+
+/** @param class-string<X> $row */
+function testClassStringFinalMethod(string $row): void
+{
+	if (method_exists($row, 'publicFoo')) {
+		$row::publicFoo();
+	}
+
+	if (method_exists($row, 'privateFoo')) {
+		$row::privateFoo();
+	}
+
+	if (method_exists($row, 'protectedFoo')) {
+		$row::protectedFoo();
+	}
+}
+
+/** @param class-string<SubX> $row */
+function testClassStringFinalClass(string $row): void
+{
+	if (method_exists($row, 'publicFoo')) {
+		$row::publicFoo();
+	}
+
+	if (method_exists($row, 'privateFoo')) {
+		$row::privateFoo();
+	}
+
+	if (method_exists($row, 'protectedFoo')) {
+		$row::protectedFoo();
+	}
+}
+
+function testLiteralClassCall(): void
+{
+	if (method_exists(X::class, 'privateFoo')) {
+		X::privateFoo();
+	}
+
+	if (method_exists(X::class, 'protectedFoo')) {
+		X::protectedFoo();
+	}
+
+	if (method_exists(SubX::class, 'privateFoo')) {
+		SubX::privateFoo();
+	}
+}