[Naming] Add Closure and Function_ on RenameParamToMatchTypeRector (#…

…2042) * [Naming] Add Closure and Function_ on RenameParamToMatchTypeRector * [ci-review] Rector Rectify * [ci-review] Rector Rectify * [ci-review] Rector Rectify * [ci-review] Rector Rectify * rename method name * [ci-review] Rector Rectify * [ci-review] Rector Rectify Co-authored-by: GitHub Action <action@github.com>
rectorphp · Apr 10, 2022 · 76894e5 · 76894e5
1 parent 9b46906
commit 76894e5
Show file tree

Hide file tree

Showing 12 changed files with 105 additions and 34 deletions.
diff --git a/packages/NodeTypeResolver/PHPStan/Scope/PHPStanNodeScopeResolver.php b/packages/NodeTypeResolver/PHPStan/Scope/PHPStanNodeScopeResolver.php
@@ -73,13 +73,13 @@ public function processNodes(array $stmts, SmartFileInfo $smartFileInfo): array
         $scope = $this->scopeFactory->createFromFile($smartFileInfo);
 
         // skip chain method calls, performance issue: https://github.com/phpstan/phpstan/issues/254
-        $nodeCallback = function (Node $node, MutatingScope $scope) use (&$nodeCallback): void {
+        $nodeCallback = function (Node $node, MutatingScope $mutatingScope) use (&$nodeCallback): void {
             if ($node instanceof Trait_) {
                 $traitName = $this->resolveClassName($node);
 
                 $traitReflectionClass = $this->reflectionProvider->getClass($traitName);
 
-                $traitScope = clone $scope;
+                $traitScope = clone $mutatingScope;
 
                 $scopeContext = $this->privatesAccessor->getPrivatePropertyOfClass(
                     $traitScope,
@@ -109,17 +109,17 @@ public function processNodes(array $stmts, SmartFileInfo $smartFileInfo): array
             // the class reflection is resolved AFTER entering to class node
             // so we need to get it from the first after this one
             if ($node instanceof Class_ || $node instanceof Interface_) {
-                /** @var MutatingScope $scope */
-                $scope = $this->resolveClassOrInterfaceScope($node, $scope);
+                /** @var MutatingScope $mutatingScope */
+                $mutatingScope = $this->resolveClassOrInterfaceScope($node, $mutatingScope);
             }
 
             // special case for unreachable nodes
             if ($node instanceof UnreachableStatementNode) {
                 $originalNode = $node->getOriginalStatement();
                 $originalNode->setAttribute(AttributeKey::IS_UNREACHABLE, true);
-                $originalNode->setAttribute(AttributeKey::SCOPE, $scope);
+                $originalNode->setAttribute(AttributeKey::SCOPE, $mutatingScope);
             } else {
-                $node->setAttribute(AttributeKey::SCOPE, $scope);
+                $node->setAttribute(AttributeKey::SCOPE, $mutatingScope);
             }
         };
 

diff --git a/packages/NodeTypeResolver/PhpDoc/NodeAnalyzer/DocBlockNamespaceRenamer.php b/packages/NodeTypeResolver/PhpDoc/NodeAnalyzer/DocBlockNamespaceRenamer.php
@@ -39,13 +39,13 @@ public function renameFullyQualifiedNamespace(
         $phpDocNodeTraverser->traverseWithCallable(
             $phpDocInfo->getPhpDocNode(),
             '',
-            function (DocNode $subNode) use ($oldToNewNamespaces): ?DocNode {
-                if (! $subNode instanceof IdentifierTypeNode) {
+            function (DocNode $docNode) use ($oldToNewNamespaces): ?DocNode {
+                if (! $docNode instanceof IdentifierTypeNode) {
                     return null;
                 }
 
-                $name = $subNode->name;
-                $trimmedName = ltrim($subNode->name, '\\');
+                $name = $docNode->name;
+                $trimmedName = ltrim($docNode->name, '\\');
 
                 if ($name === $trimmedName) {
                     return null;

diff --git a/packages/PostRector/Collector/NodesToRemoveCollector.php b/packages/PostRector/Collector/NodesToRemoveCollector.php
@@ -119,19 +119,19 @@ private function isUsedInArg(Node $node, Node $parentNode): bool
 
         $paramVariable = $node->var;
         if ($paramVariable instanceof Variable) {
-            return (bool) $this->betterNodeFinder->findFirst((array) $parentNode->stmts, function (Node $variable) use (
+            return (bool) $this->betterNodeFinder->findFirst((array) $parentNode->stmts, function (Node $node) use (
                 $paramVariable
             ): bool {
-                if (! $this->nodeComparator->areNodesEqual($variable, $paramVariable)) {
+                if (! $this->nodeComparator->areNodesEqual($node, $paramVariable)) {
                     return false;
                 }
 
-                $hasArgParent = (bool) $this->betterNodeFinder->findParentType($variable, Arg::class);
+                $hasArgParent = (bool) $this->betterNodeFinder->findParentType($node, Arg::class);
                 if (! $hasArgParent) {
                     return false;
                 }
 
-                return ! (bool) $this->betterNodeFinder->findParentType($variable, StaticCall::class);
+                return ! (bool) $this->betterNodeFinder->findParentType($node, StaticCall::class);
             });
         }
 

diff --git a/...tests/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/callback_use.php.inc b/...tests/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/callback_use.php.inc
@@ -32,8 +32,8 @@ class CallbackUse
 {
     public function run(ClassMethod $classMethod, array $items)
     {
-        array_walk($classMethod->stmts, function (Node $stmt) use ($classMethod) {
-            return $stmt + $classMethod;
+        array_walk($classMethod->stmts, function (Node $node) use ($classMethod) {
+            return $node + $classMethod;
         });
 
         function someFunction($node)

diff --git a/...tests/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/closure_only.php.inc b/...tests/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/closure_only.php.inc
@@ -0,0 +1,27 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Naming\Rector\ClassMethod\RenameParamToMatchTypeRector\Fixture;
+
+use Rector\Config\RectorConfig;
+
+return static function (RectorConfig $containerConfigurator): void {
+
+};
+
+?>
+-----
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\Naming\Rector\ClassMethod\RenameParamToMatchTypeRector\Fixture;
+
+use Rector\Config\RectorConfig;
+
+return static function (RectorConfig $rectorConfig): void {
+
+};
+
+?>
diff --git a/...ng/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/function_calllback_use.php.inc b/...ng/Rector/ClassMethod/RenameParamToMatchTypeRector/Fixture/function_calllback_use.php.inc
@@ -0,0 +1,33 @@
+<?php
+
+namespace Rector\Tests\Naming\Rector\ClassMethod\RenameParamToMatchTypeRector\Fixture;
+
+function FunctionCallbackUse(ClassMethod $node, array $items)
+{
+    array_walk($node->stmts, function (Node $stmt) use ($node) {
+        return $stmt + $node;
+    });
+
+    function someFunction($node)
+    {
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Naming\Rector\ClassMethod\RenameParamToMatchTypeRector\Fixture;
+
+function FunctionCallbackUse(ClassMethod $classMethod, array $items)
+{
+    array_walk($classMethod->stmts, function (Node $node) use ($classMethod) {
+        return $node + $classMethod;
+    });
+
+    function someFunction($node)
+    {
+    }
+}
+
+?>
diff --git a/rules/CodingStyle/Rector/Class_/AddArrayDefaultToArrayPropertyRector.php b/rules/CodingStyle/Rector/Class_/AddArrayDefaultToArrayPropertyRector.php
@@ -140,18 +140,18 @@ private function collectPropertyNamesWithMissingDefaultArray(Class_ $class): arr
      */
     private function completeDefaultArrayToPropertyNames(Class_ $class, array $propertyNames): void
     {
-        $this->traverseNodesWithCallable($class, function (Node $class) use ($propertyNames): ?PropertyProperty {
-            if (! $class instanceof PropertyProperty) {
+        $this->traverseNodesWithCallable($class, function (Node $node) use ($propertyNames): ?PropertyProperty {
+            if (! $node instanceof PropertyProperty) {
                 return null;
             }
 
-            if (! $this->isNames($class, $propertyNames)) {
+            if (! $this->isNames($node, $propertyNames)) {
                 return null;
             }
 
-            $class->default = new Array_();
+            $node->default = new Array_();
 
-            return $class;
+            return $node;
         });
     }
 

diff --git a/rules/Naming/Guard/BreakingVariableRenameGuard.php b/rules/Naming/Guard/BreakingVariableRenameGuard.php
@@ -88,7 +88,7 @@ public function shouldSkipVariable(
     public function shouldSkipParam(
         string $currentName,
         string $expectedName,
-        ClassMethod $classMethod,
+        ClassMethod|Function_|Closure $classMethod,
         Param $param
     ): bool {
         // is the suffix? → also accepted
@@ -106,7 +106,7 @@ public function shouldSkipParam(
             return true;
         }
 
-        if ($this->overridenExistingNamesResolver->hasNameInClassMethodForParam($expectedName, $classMethod)) {
+        if ($this->overridenExistingNamesResolver->hasNameInFunctionLikeForParam($expectedName, $classMethod)) {
             return true;
         }
 

diff --git a/rules/Naming/Naming/ConflictingNameResolver.php b/rules/Naming/Naming/ConflictingNameResolver.php
@@ -32,7 +32,7 @@ public function __construct(
     /**
      * @return string[]
      */
-    public function resolveConflictingVariableNamesForParam(ClassMethod $classMethod): array
+    public function resolveConflictingVariableNamesForParam(ClassMethod|Function_|Closure $classMethod): array
     {
         $expectedNames = [];
         foreach ($classMethod->params as $param) {

diff --git a/rules/Naming/Naming/OverridenExistingNamesResolver.php b/rules/Naming/Naming/OverridenExistingNamesResolver.php
@@ -35,8 +35,10 @@ public function hasNameInClassMethodForNew(
         return in_array($variableName, $overridenVariableNames, true);
     }
 
-    public function hasNameInClassMethodForParam(string $expectedName, ClassMethod $classMethod): bool
-    {
+    public function hasNameInFunctionLikeForParam(
+        string $expectedName,
+        ClassMethod|Function_|Closure $classMethod
+    ): bool {
         /** @var Assign[] $assigns */
         $assigns = $this->betterNodeFinder->findInstanceOf((array) $classMethod->stmts, Assign::class);
 

diff --git a/rules/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector.php b/rules/Naming/Rector/ClassMethod/RenameParamToMatchTypeRector.php
@@ -5,8 +5,10 @@
 namespace Rector\Naming\Rector\ClassMethod;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr\Closure;
 use PhpParser\Node\Param;
 use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Function_;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\ValueObject\MethodName;
 use Rector\Naming\ExpectedNameResolver\MatchParamTypeExpectedNameResolver;
@@ -66,11 +68,11 @@ public function run(Apple $apple)
      */
     public function getNodeTypes(): array
     {
-        return [ClassMethod::class];
+        return [ClassMethod::class, Function_::class, Closure::class];
     }
 
     /**
-     * @param ClassMethod $node
+     * @param ClassMethod|Function_|Closure $node
      */
     public function refactor(Node $node): ?Node
     {
@@ -107,15 +109,22 @@ public function refactor(Node $node): ?Node
         return $node;
     }
 
-    private function shouldSkipParam(Param $param, string $expectedName, ClassMethod $classMethod): bool
-    {
+    private function shouldSkipParam(
+        Param $param,
+        string $expectedName,
+        ClassMethod|Function_|Closure $classMethod
+    ): bool {
         /** @var string $paramName */
         $paramName = $this->getName($param);
 
         if ($this->breakingVariableRenameGuard->shouldSkipParam($paramName, $expectedName, $classMethod, $param)) {
             return true;
         }
 
+        if (! $classMethod instanceof ClassMethod) {
+            return false;
+        }
+
         // promoted property
         if (! $this->isName($classMethod, MethodName::CONSTRUCT)) {
             return false;

diff --git a/src/NodeAnalyzer/VariableAnalyzer.php b/src/NodeAnalyzer/VariableAnalyzer.php
@@ -28,18 +28,18 @@ public function isStaticOrGlobal(Variable $variable): bool
             return true;
         }
 
-        return (bool) $this->betterNodeFinder->findFirstPreviousOfNode($variable, function (Node $n) use (
+        return (bool) $this->betterNodeFinder->findFirstPreviousOfNode($variable, function (Node $node) use (
             $variable
         ): bool {
-            if (! in_array($n::class, [Static_::class, Global_::class], true)) {
+            if (! in_array($node::class, [Static_::class, Global_::class], true)) {
                 return false;
             }
 
             /**
-             * @var Static_|Global_ $n
+             * @var Static_|Global_ $node
              * @var StaticVar[]|Variable[] $vars
              */
-            $vars = $n->vars;
+            $vars = $node->vars;
             foreach ($vars as $var) {
                 $staticVarVariable = $var instanceof StaticVar
                     ? $var->var