[Php81] ArrayToFirstClassCallableRector should not skip non-public methods from owning scope (#7760)

* test: Prove ArrayToFirstClassCallableRector skips internal callbacks

If a class contains array callbacks with a non-public method, they are
not converted into first-class callables. This is due to a fix for a bug
that was specific to skipping non-public methods referenced from
*outside* the owning class - there was no previous coverage for what
should happen when a callable is referenced within a valid scope.

* fix: ArrayToFirstClassCallableRector should convert private in own scope

If an array callable is explicitly referencing `$this`, then it should
always be safe to convert it to a first-class callable even if the
method is private / protected.

This was the original behaviour of the 8.1 fixers, but it changed in
v1.1.1 following a fix for cases where a private / protected method was
being referenced from outside the owning scope.

* Apply fixture class naming changes from code review

Co-authored-by: Abdul Malik Ikhsan <[email protected]>

---------

Co-authored-by: Abdul Malik Ikhsan <[email protected]>

Author: acoulton

rules-tests/Php81/Rector/Array_/ArrayToFirstClassCallableRector/Fixture/some_class_with_own_private.php.inc

@@ -0,0 +1,35 @@
+<?php
+
+namespace Rector\Tests\Php81\Rector\Array_\FirstClassCallableRector\Fixture;
+
+final class SomeClassWithOwnPrivate
+{
+    public function run()
+    {
+        $name = [$this, 'name'];
+    }
+
+    private function name()
+    {
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php81\Rector\Array_\FirstClassCallableRector\Fixture;
+
+final class SomeClassWithOwnPrivate
+{
+    public function run()
+    {
+        $name = $this->name(...);
+    }
+
+    private function name()
+    {
+    }
+}
+
+?>

rules/Php81/Rector/Array_/ArrayToFirstClassCallableRector.php

@@ -72,6 +72,7 @@ public function name()
     }
 }
 CODE_SAMPLE
+                ,
             ),
         ]);
     }
@@ -123,7 +124,7 @@ public function refactor(Node $node): StaticCall|MethodCall|null
             if ($type instanceof FullyQualifiedObjectType && $this->isNonStaticOtherObject(
                 $type,
                 $arrayCallable,
-                $scope
+                $scope,
             )) {
                 return null;
             }
@@ -133,13 +134,9 @@ public function refactor(Node $node): StaticCall|MethodCall|null
 
         $methodName = $arrayCallable->getMethod();
         $methodCall = new MethodCall($callerExpr, $methodName, $args);
-        $classReflection = $this->reflectionResolver->resolveClassReflectionSourceObject($methodCall);
 
-        if ($classReflection instanceof ClassReflection && $classReflection->hasNativeMethod($methodName)) {
-            $method = $classReflection->getNativeMethod($methodName);
-            if (! $method->isPublic()) {
-                return null;
-            }
+        if ($this->isReferenceToNonPublicMethodOutsideOwningScope($methodCall, $methodName)) {
+            return null;
         }
 
         return $methodCall;
@@ -174,4 +171,25 @@ private function isNonStaticOtherObject(
 
         return ! $extendedMethodReflection->isPublic();
     }
+
+    private function isReferenceToNonPublicMethodOutsideOwningScope(MethodCall $methodCall, string $methodName): bool
+    {
+        if ($methodCall->var instanceof Variable && $methodCall->var->name === 'this') {
+            // If the callable is scoped to `$this` then it can be converted even if it is protected / private
+            return false;
+        }
+
+        // If the callable is scoped to another object / variable then it should only be converted if it is public
+        // https://github.com/rectorphp/rector/issues/8659
+        $classReflection = $this->reflectionResolver->resolveClassReflectionSourceObject($methodCall);
+
+        if ($classReflection instanceof ClassReflection && $classReflection->hasNativeMethod($methodName)) {
+            $method = $classReflection->getNativeMethod($methodName);
+            if (! $method->isPublic()) {
+                return true;
+            }
+        }
+
+        return false;
+    }
 }