[DeadCode] Keep private method called via self::class static call (#8098)

* [DeadCode] Keep private method called via self::class static call

A private method invoked through a class-string static call, e.g.
self::class::sampleClass(), is not detected by the usage analyzer and would
be wrongly removed. Keep such methods.

* [DeadCode] Add @see phpstan reference for class-string static call detection

* [DeadCode] Move phpstan @see to resolveClassStringStaticCallNames method

Author: TomasVotruba

rules-tests/DeadCode/Rector/ClassMethod/RemoveUnusedPrivateMethodRector/Fixture/keep_self_class_static_call.php.inc

@@ -0,0 +1,18 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\ClassMethod\RemoveUnusedPrivateMethodRector\Fixture;
+
+// a private method called through a class-string static call, self::class::sampleClass(),
+// is not detected by the usage analyzer - keep it
+final class KeepSelfClassStaticCall
+{
+    public function run(): object
+    {
+        return self::class::sampleClass();
+    }
+
+    private function sampleClass(): object
+    {
+        return new \stdClass();
+    }
+}

rules/DeadCode/Rector/ClassMethod/RemoveUnusedPrivateMethodRector.php

@@ -5,8 +5,11 @@
 namespace Rector\DeadCode\Rector\ClassMethod;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\Expr\MethodCall;
+use PhpParser\Node\Expr\StaticCall;
 use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Reflection\ClassReflection;
@@ -91,6 +94,10 @@ public function refactor(Node $node): ?Node
 
         $dataProviderMethodNames = $this->resolveDataProviderMethodNames($node);
 
+        // methods invoked via a class-string static call, e.g. self::class::sampleClass(),
+        // are not seen by the usage analyzer
+        $classStringCallMethodNames = $this->resolveClassStringStaticCallNames($node);
+
         foreach ($node->stmts as $classStmtKey => $classStmt) {
             if (! $classStmt instanceof ClassMethod) {
                 continue;
@@ -118,6 +125,10 @@ public function refactor(Node $node): ?Node
                 continue;
             }
 
+            if ($this->isNames($classMethod, $classStringCallMethodNames)) {
+                continue;
+            }
+
             unset($node->stmts[$classStmtKey]);
             $hasChanged = true;
         }
@@ -153,6 +164,38 @@ private function shouldSkip(ClassMethod $classMethod, ClassReflection $classRefl
         return $classReflection->hasMethod(MethodName::CALL);
     }
 
+    /**
+     * Mirrors PHPStan's UnusedPrivateMethodRule fix for class-string static calls
+     * @see https://github.com/phpstan/phpstan-src/pull/5953
+     *
+     * @return string[]
+     */
+    private function resolveClassStringStaticCallNames(Class_ $class): array
+    {
+        $methodNames = [];
+
+        /** @var StaticCall[] $staticCalls */
+        $staticCalls = $this->betterNodeFinder->findInstanceOf($class->stmts, StaticCall::class);
+        foreach ($staticCalls as $staticCall) {
+            // e.g. self::class::sampleClass() - the called class is a ::class expression
+            if (! $staticCall->class instanceof ClassConstFetch) {
+                continue;
+            }
+
+            if (! $this->isName($staticCall->class->name, 'class')) {
+                continue;
+            }
+
+            if (! $staticCall->name instanceof Identifier) {
+                continue;
+            }
+
+            $methodNames[] = $staticCall->name->toString();
+        }
+
+        return $methodNames;
+    }
+
     private function hasDynamicMethodCallOnFetchThis(ClassMethod $classMethod): bool
     {
         return (bool) $this->betterNodeFinder->findFirst(