UnusedPrivateMethodRule - fix detection with [$this, 'method']

src/Analyser/NodeScopeResolver.php

@@ -615,6 +615,10 @@ private function processStmtNode(
 					}
 					return;
 				}
+				if ($node instanceof Array_ && count($node->items) === 2) {
+					$methodCalls[] = new \PHPStan\Node\Method\MethodCall($node, $scope);
+					return;
+				}
 				if ($node instanceof Expr\ClassConstFetch) {
 					$constantFetches[] = new ClassConstantFetch($node, $scope);
 					return;

src/Node/ClassPropertiesNode.php

@@ -2,6 +2,7 @@
 
 namespace PHPStan\Node;
 
+use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
@@ -185,6 +186,9 @@ private function getMethodsCalledFromConstructor(
 		$originalCount = count($methods);
 		foreach ($methodCalls as $methodCall) {
 			$methodCallNode = $methodCall->getNode();
+			if ($methodCallNode instanceof Array_) {
+				continue;
+			}
 			if (!$methodCallNode->name instanceof Identifier) {
 				continue;
 			}

src/Node/Method/MethodCall.php

@@ -2,19 +2,20 @@
 
 namespace PHPStan\Node\Method;
 
+use PhpParser\Node\Expr\Array_;
 use PhpParser\Node\Expr\StaticCall;
 use PHPStan\Analyser\Scope;
 
 class MethodCall
 {
 
-	/** @var \PhpParser\Node\Expr\MethodCall|StaticCall */
+	/** @var \PhpParser\Node\Expr\MethodCall|StaticCall|Array_ */
 	private $node;
 
 	private Scope $scope;
 
 	/**
-	 * @param \PhpParser\Node\Expr\MethodCall|StaticCall$node
+	 * @param \PhpParser\Node\Expr\MethodCall|StaticCall|Array_ $node
 	 * @param Scope $scope
 	 */
 	public function __construct($node, Scope $scope)
@@ -24,7 +25,7 @@ public function __construct($node, Scope $scope)
 	}
 
 	/**
-	 * @return \PhpParser\Node\Expr\MethodCall|StaticCall
+	 * @return \PhpParser\Node\Expr\MethodCall|StaticCall|Array_
 	 */
 	public function getNode()
 	{

src/Rules/DeadCode/UnusedPrivateMethodRule.php

@@ -9,6 +9,7 @@
 use PHPStan\Reflection\MethodReflection;
 use PHPStan\Rules\Rule;
 use PHPStan\Rules\RuleErrorBuilder;
+use PHPStan\Type\Constant\ConstantArrayType;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\ObjectType;
 
@@ -49,8 +50,13 @@ public function processNode(Node $node, Scope $scope): array
 			$methods[$method->name->toString()] = $method;
 		}
 
+		$arrayCalls = [];
 		foreach ($node->getMethodCalls() as $methodCall) {
 			$methodCallNode = $methodCall->getNode();
+			if ($methodCallNode instanceof Node\Expr\Array_) {
+				$arrayCalls[] = $methodCall;
+				continue;
+			}
 			if (!$methodCallNode->name instanceof Identifier) {
 				continue;
 			}
@@ -80,6 +86,43 @@ public function processNode(Node $node, Scope $scope): array
 			unset($methods[$methodName]);
 		}
 
+		if (count($methods) > 0) {
+			foreach ($arrayCalls as $arrayCall) {
+				/** @var Node\Expr\Array_ $array */
+				$array = $arrayCall->getNode();
+				$arrayScope = $arrayCall->getScope();
+				$arrayType = $scope->getType($array);
+				if (!$arrayType instanceof ConstantArrayType) {
+					continue;
+				}
+				$typeAndMethod = $arrayType->findTypeAndMethodName();
+				if ($typeAndMethod === null) {
+					continue;
+				}
+				if ($typeAndMethod->isUnknown()) {
+					return [];
+				}
+				if (!$typeAndMethod->getCertainty()->yes()) {
+					return [];
+				}
+				$calledOnType = $typeAndMethod->getType();
+				if ($classType->isSuperTypeOf($calledOnType)->no()) {
+					continue;
+				}
+				if ($calledOnType instanceof MixedType) {
+					continue;
+				}
+				$inMethod = $arrayScope->getFunction();
+				if (!$inMethod instanceof MethodReflection) {
+					continue;
+				}
+				if ($inMethod->getName() === $typeAndMethod->getMethod()) {
+					continue;
+				}
+				unset($methods[$typeAndMethod->getMethod()]);
+			}
+		}
+
 		$errors = [];
 		foreach ($methods as $methodName => $methodNode) {
 			$errors[] = RuleErrorBuilder::message(sprintf('Class %s has an unused method %s().', $classReflection->getDisplayName(), $methodName))->line($methodNode->getLine())->build();

src/Type/Constant/ConstantArrayType.php

@@ -332,7 +332,7 @@ public function getCallableParametersAcceptors(ClassMemberAccessAnswerer $scope)
 		return $method->getVariants();
 	}
 
-	private function findTypeAndMethodName(): ?ConstantArrayTypeAndMethod
+	public function findTypeAndMethodName(): ?ConstantArrayTypeAndMethod
 	{
 		if (count($this->keyTypes) !== 2) {
 			return null;

tests/PHPStan/Rules/DeadCode/UnusedPrivateMethodRuleTest.php

@@ -31,6 +31,10 @@ public function testRule(): void
 				'Class UnusedPrivateMethod\Foo has an unused method unusedStaticMethod().',
 				44,
 			],
+			[
+				'Class UnusedPrivateMethod\Bar has an unused method doBaz().',
+				59,
+			],
 		]);
 	}
 

tests/PHPStan/Rules/DeadCode/data/unused-private-method.php

@@ -47,3 +47,41 @@ private static function unusedStaticMethod()
 	}
 
 }
+
+class Bar
+{
+
+	private function doFoo()
+	{
+
+	}
+
+	private function doBaz()
+	{
+		$cb = [$this, 'doBaz'];
+		$cb();
+	}
+
+	public function doBar()
+	{
+		$cb = [$this, 'doFoo'];
+		$cb();
+	}
+
+}
+
+class Baz
+{
+
+	private function doFoo()
+	{
+
+	}
+
+	public function doBar(string $name)
+	{
+		$cb = [$this, $name];
+		$cb();
+	}
+
+}