[ci-review] Rector Rectify

actions-user · actions-user · commit f5e7b205bb05 · 2025-11-18T23:39:55.000Z
diff --git a/src/PhpParser/NodeTraverser/AbstractImmutableNodeTraverser.php b/src/PhpParser/NodeTraverser/AbstractImmutableNodeTraverser.php
@@ -4,6 +4,9 @@
 
 namespace Rector\PhpParser\NodeTraverser;
 
+use LogicException;
+use PhpParser\Node\Stmt;
+use PhpParser\Node\Expr;
 use PhpParser\Node;
 use PhpParser\NodeTraverserInterface;
 use PhpParser\NodeVisitor;
@@ -65,7 +68,7 @@ public function addVisitor(NodeVisitor $visitor): void
      */
     public function removeVisitor(NodeVisitor $visitor): void
     {
-        $index = array_search($visitor, $this->visitors);
+        $index = array_search($visitor, $this->visitors, true);
         if ($index !== false) {
             array_splice($this->visitors, $index, 1, []);
         }
@@ -86,20 +89,22 @@ public function traverse(array $nodes): array
                 $nodes = $return;
             }
         }
+
         $nodes = $this->traverseArray($nodes);
         for ($i = \count($this->visitors) - 1; $i >= 0; --$i) {
             $visitor = $this->visitors[$i];
             if (null !== $return = $visitor->afterTraverse($nodes)) {
                 $nodes = $return;
             }
         }
+
         return $nodes;
     }
 
     /**
      * @return NodeVisitor[]
      */
-    abstract public function getVisitorsForNode(\PhpParser\Node $node): array;
+    abstract public function getVisitorsForNode(Node $node): array;
 
     /**
      * Recursively traverse a node.
@@ -115,11 +120,14 @@ protected function traverseNode(Node $node): void
                 if ($this->stopTraversal) {
                     break;
                 }
+
                 continue;
             }
+
             if (! $subNode instanceof Node) {
                 continue;
             }
+
             $traverseChildren = true;
             $visitorIndex = -1;
             $currentNodeVisitors = $this->getVisitorsForNode($subNode);
@@ -128,7 +136,8 @@ protected function traverseNode(Node $node): void
                 if ($return !== null) {
                     if ($return instanceof Node) {
                         $this->ensureReplacementReasonable($subNode, $return);
-                        $subNode = $node->{$name} = $return;
+                        $subNode = $return;
+                        $node->{$name} = $return;
                     } elseif ($return === NodeVisitor::DONT_TRAVERSE_CHILDREN) {
                         $traverseChildren = false;
                     } elseif ($return === NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN) {
@@ -141,35 +150,38 @@ protected function traverseNode(Node $node): void
                         $node->{$name} = null;
                         continue 2;
                     } else {
-                        throw new \LogicException('enterNode() returned invalid value of type ' . gettype($return));
+                        throw new LogicException('enterNode() returned invalid value of type ' . gettype($return));
                     }
                 }
             }
+
             if ($traverseChildren) {
                 $this->traverseNode($subNode);
                 if ($this->stopTraversal) {
                     break;
                 }
             }
+
             for (; $visitorIndex >= 0; --$visitorIndex) {
                 $visitor = $currentNodeVisitors[$visitorIndex];
                 $return = $visitor->leaveNode($subNode);
                 if ($return !== null) {
                     if ($return instanceof Node) {
                         $this->ensureReplacementReasonable($subNode, $return);
-                        $subNode = $node->{$name} = $return;
+                        $subNode = $return;
+                        $node->{$name} = $return;
                     } elseif ($return === NodeVisitor::STOP_TRAVERSAL) {
                         $this->stopTraversal = true;
                         break 2;
                     } elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {
                         $node->{$name} = null;
                         break;
                     } elseif (\is_array($return)) {
-                        throw new \LogicException(
-                            'leaveNode() may only return an array ' . 'if the parent structure is an array'
+                        throw new LogicException(
+                            'leaveNode() may only return an array if the parent structure is an array'
                         );
                     } else {
-                        throw new \LogicException('leaveNode() returned invalid value of type ' . gettype($return));
+                        throw new LogicException('leaveNode() returned invalid value of type ' . gettype($return));
                     }
                 }
             }
@@ -179,7 +191,7 @@ protected function traverseNode(Node $node): void
     /**
      * Recursively traverse array (usually of nodes).
      *
-     * @param array $nodes Array to traverse
+     * @param Node[] $nodes Array to traverse
      *
      * @return array Result of traversal (may be original array or changed one)
      */
@@ -189,10 +201,12 @@ protected function traverseArray(array $nodes): array
         foreach ($nodes as $i => $node) {
             if (! $node instanceof Node) {
                 if (\is_array($node)) {
-                    throw new \LogicException('Invalid node structure: Contains nested arrays');
+                    throw new LogicException('Invalid node structure: Contains nested arrays');
                 }
+
                 continue;
             }
+
             $traverseChildren = true;
             $visitorIndex = -1;
             $currentNodeVisitors = $this->getVisitorsForNode($node);
@@ -217,20 +231,22 @@ protected function traverseArray(array $nodes): array
                         $this->stopTraversal = true;
                         break 2;
                     } elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {
-                        throw new \LogicException(
+                        throw new LogicException(
                             'REPLACE_WITH_NULL can not be used if the parent structure is an array'
                         );
                     } else {
-                        throw new \LogicException('enterNode() returned invalid value of type ' . gettype($return));
+                        throw new LogicException('enterNode() returned invalid value of type ' . gettype($return));
                     }
                 }
             }
+
             if ($traverseChildren) {
                 $this->traverseNode($node);
                 if ($this->stopTraversal) {
                     break;
                 }
             }
+
             for (; $visitorIndex >= 0; --$visitorIndex) {
                 $visitor = $currentNodeVisitors[$visitorIndex];
                 $return = $visitor->leaveNode($node);
@@ -248,33 +264,36 @@ protected function traverseArray(array $nodes): array
                         $this->stopTraversal = true;
                         break 2;
                     } elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {
-                        throw new \LogicException(
+                        throw new LogicException(
                             'REPLACE_WITH_NULL can not be used if the parent structure is an array'
                         );
                     } else {
-                        throw new \LogicException('leaveNode() returned invalid value of type ' . gettype($return));
+                        throw new LogicException('leaveNode() returned invalid value of type ' . gettype($return));
                     }
                 }
             }
         }
-        if (! empty($doNodes)) {
-            while (list($i, $replace) = array_pop($doNodes)) {
+
+        if ($doNodes !== []) {
+            while ([$i, $replace] = array_pop($doNodes)) {
                 array_splice($nodes, $i, 1, $replace);
             }
         }
+
         return $nodes;
     }
 
     private function ensureReplacementReasonable(Node $old, Node $new): void
     {
-        if ($old instanceof Node\Stmt && $new instanceof Node\Expr) {
-            throw new \LogicException(
-                "Trying to replace statement ({$old->getType()}) " . "with expression ({$new->getType()}). Are you missing a " . 'Stmt_Expression wrapper?'
+        if ($old instanceof Stmt && $new instanceof Expr) {
+            throw new LogicException(
+                sprintf('Trying to replace statement (%s) ', $old->getType()) . sprintf('with expression (%s). Are you missing a ', $new->getType()) . 'Stmt_Expression wrapper?'
             );
         }
-        if ($old instanceof Node\Expr && $new instanceof Node\Stmt) {
-            throw new \LogicException(
-                "Trying to replace expression ({$old->getType()}) " . "with statement ({$new->getType()})"
+
+        if ($old instanceof Expr && $new instanceof Stmt) {
+            throw new LogicException(
+                sprintf('Trying to replace expression (%s) ', $old->getType()) . sprintf('with statement (%s)', $new->getType())
             );
         }
     }
diff --git a/src/PhpParser/NodeTraverser/RectorNodeTraverser.php b/src/PhpParser/NodeTraverser/RectorNodeTraverser.php
@@ -19,7 +19,7 @@ final class RectorNodeTraverser extends AbstractImmutableNodeTraverser
     private bool $areNodeVisitorsPrepared = false;
 
     /**
-     * @var array<class-string<\PhpParser\Node>, NodeVisitor[]>
+     * @var array<class-string<Node>, NodeVisitor[]>
      */
     private array $visitorsPerNodeClass = [];
 
@@ -67,11 +67,10 @@ public function getVisitorsForNode(Node $node): array
 
         if (! isset($this->visitorsPerNodeClass[$nodeClass])) {
             $this->visitorsPerNodeClass[$nodeClass] = [];
-            /** @var RectorInterface $rector */
-            foreach ($this->visitors as $rector) {
-                foreach ($rector->getNodeTypes() as $nodeType) {
+            foreach ($this->visitors as $visitor) {
+                foreach ($visitor->getNodeTypes() as $nodeType) {
                     if (is_a($nodeClass, $nodeType, true)) {
-                        $this->visitorsPerNodeClass[$nodeClass][] = $rector;
+                        $this->visitorsPerNodeClass[$nodeClass][] = $visitor;
                         continue 2;
                     }
                 }

Original file line number	Diff line number	Diff line change
`@@ -4,6 +4,9 @@`
`4`	`4`
`5`	`5`	`namespace Rector\PhpParser\NodeTraverser;`
`6`	`6`
	`7`	`+use LogicException;`
	`8`	`+use PhpParser\Node\Stmt;`
	`9`	`+use PhpParser\Node\Expr;`
`7`	`10`	`use PhpParser\Node;`
`8`	`11`	`use PhpParser\NodeTraverserInterface;`
`9`	`12`	`use PhpParser\NodeVisitor;`
`@@ -65,7 +68,7 @@ public function addVisitor(NodeVisitor $visitor): void`
`65`	`68`	`*/`
`66`	`69`	`public function removeVisitor(NodeVisitor $visitor): void`
`67`	`70`	`{`
`68`		`- $index = array_search($visitor, $this->visitors);`
	`71`	`+ $index = array_search($visitor, $this->visitors, true);`
`69`	`72`	`if ($index !== false) {`
`70`	`73`	`array_splice($this->visitors, $index, 1, []);`
`71`	`74`	`}`
`@@ -86,20 +89,22 @@ public function traverse(array $nodes): array`
`86`	`89`	`$nodes = $return;`
`87`	`90`	`}`
`88`	`91`	`}`
	`92`	`+`
`89`	`93`	`$nodes = $this->traverseArray($nodes);`
`90`	`94`	`for ($i = \count($this->visitors) - 1; $i >= 0; --$i) {`
`91`	`95`	`$visitor = $this->visitors[$i];`
`92`	`96`	`if (null !== $return = $visitor->afterTraverse($nodes)) {`
`93`	`97`	`$nodes = $return;`
`94`	`98`	`}`
`95`	`99`	`}`
	`100`	`+`
`96`	`101`	`return $nodes;`
`97`	`102`	`}`
`98`	`103`
`99`	`104`	`/**`
`100`	`105`	`* @return NodeVisitor[]`
`101`	`106`	`*/`
`102`		`- abstract public function getVisitorsForNode(\PhpParser\Node $node): array;`
	`107`	`+ abstract public function getVisitorsForNode(Node $node): array;`
`103`	`108`
`104`	`109`	`/**`
`105`	`110`	`* Recursively traverse a node.`
`@@ -115,11 +120,14 @@ protected function traverseNode(Node $node): void`
`115`	`120`	`if ($this->stopTraversal) {`
`116`	`121`	`break;`
`117`	`122`	`}`
	`123`	`+`
`118`	`124`	`continue;`
`119`	`125`	`}`
	`126`	`+`
`120`	`127`	`if (! $subNode instanceof Node) {`
`121`	`128`	`continue;`
`122`	`129`	`}`
	`130`	`+`
`123`	`131`	`$traverseChildren = true;`
`124`	`132`	`$visitorIndex = -1;`
`125`	`133`	`$currentNodeVisitors = $this->getVisitorsForNode($subNode);`
`@@ -128,7 +136,8 @@ protected function traverseNode(Node $node): void`
`128`	`136`	`if ($return !== null) {`
`129`	`137`	`if ($return instanceof Node) {`
`130`	`138`	`$this->ensureReplacementReasonable($subNode, $return);`
`131`		`- $subNode = $node->{$name} = $return;`
	`139`	`+ $subNode = $return;`
	`140`	`+ $node->{$name} = $return;`
`132`	`141`	`} elseif ($return === NodeVisitor::DONT_TRAVERSE_CHILDREN) {`
`133`	`142`	`$traverseChildren = false;`
`134`	`143`	`} elseif ($return === NodeVisitor::DONT_TRAVERSE_CURRENT_AND_CHILDREN) {`
`@@ -141,35 +150,38 @@ protected function traverseNode(Node $node): void`
`141`	`150`	`$node->{$name} = null;`
`142`	`151`	`continue 2;`
`143`	`152`	`} else {`
`144`		`- throw new \LogicException('enterNode() returned invalid value of type ' . gettype($return));`
	`153`	`+ throw new LogicException('enterNode() returned invalid value of type ' . gettype($return));`
`145`	`154`	`}`
`146`	`155`	`}`
`147`	`156`	`}`
	`157`	`+`
`148`	`158`	`if ($traverseChildren) {`
`149`	`159`	`$this->traverseNode($subNode);`
`150`	`160`	`if ($this->stopTraversal) {`
`151`	`161`	`break;`
`152`	`162`	`}`
`153`	`163`	`}`
	`164`	`+`
`154`	`165`	`for (; $visitorIndex >= 0; --$visitorIndex) {`
`155`	`166`	`$visitor = $currentNodeVisitors[$visitorIndex];`
`156`	`167`	`$return = $visitor->leaveNode($subNode);`
`157`	`168`	`if ($return !== null) {`
`158`	`169`	`if ($return instanceof Node) {`
`159`	`170`	`$this->ensureReplacementReasonable($subNode, $return);`
`160`		`- $subNode = $node->{$name} = $return;`
	`171`	`+ $subNode = $return;`
	`172`	`+ $node->{$name} = $return;`
`161`	`173`	`} elseif ($return === NodeVisitor::STOP_TRAVERSAL) {`
`162`	`174`	`$this->stopTraversal = true;`
`163`	`175`	`break 2;`
`164`	`176`	`} elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {`
`165`	`177`	`$node->{$name} = null;`
`166`	`178`	`break;`
`167`	`179`	`} elseif (\is_array($return)) {`
`168`		`- throw new \LogicException(`
`169`		`- 'leaveNode() may only return an array ' . 'if the parent structure is an array'`
	`180`	`+ throw new LogicException(`
	`181`	`+ 'leaveNode() may only return an array if the parent structure is an array'`
`170`	`182`	`);`
`171`	`183`	`} else {`
`172`		`- throw new \LogicException('leaveNode() returned invalid value of type ' . gettype($return));`
	`184`	`+ throw new LogicException('leaveNode() returned invalid value of type ' . gettype($return));`
`173`	`185`	`}`
`174`	`186`	`}`
`175`	`187`	`}`
`@@ -179,7 +191,7 @@ protected function traverseNode(Node $node): void`
`179`	`191`	`/**`
`180`	`192`	`* Recursively traverse array (usually of nodes).`
`181`	`193`	`*`
`182`		`- * @param array $nodes Array to traverse`
	`194`	`+ * @param Node[] $nodes Array to traverse`
`183`	`195`	`*`
`184`	`196`	`* @return array Result of traversal (may be original array or changed one)`
`185`	`197`	`*/`
`@@ -189,10 +201,12 @@ protected function traverseArray(array $nodes): array`
`189`	`201`	`foreach ($nodes as $i => $node) {`
`190`	`202`	`if (! $node instanceof Node) {`
`191`	`203`	`if (\is_array($node)) {`
`192`		`- throw new \LogicException('Invalid node structure: Contains nested arrays');`
	`204`	`+ throw new LogicException('Invalid node structure: Contains nested arrays');`
`193`	`205`	`}`
	`206`	`+`
`194`	`207`	`continue;`
`195`	`208`	`}`
	`209`	`+`
`196`	`210`	`$traverseChildren = true;`
`197`	`211`	`$visitorIndex = -1;`
`198`	`212`	`$currentNodeVisitors = $this->getVisitorsForNode($node);`
`@@ -217,20 +231,22 @@ protected function traverseArray(array $nodes): array`
`217`	`231`	`$this->stopTraversal = true;`
`218`	`232`	`break 2;`
`219`	`233`	`} elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {`
`220`		`- throw new \LogicException(`
	`234`	`+ throw new LogicException(`
`221`	`235`	`'REPLACE_WITH_NULL can not be used if the parent structure is an array'`
`222`	`236`	`);`
`223`	`237`	`} else {`
`224`		`- throw new \LogicException('enterNode() returned invalid value of type ' . gettype($return));`
	`238`	`+ throw new LogicException('enterNode() returned invalid value of type ' . gettype($return));`
`225`	`239`	`}`
`226`	`240`	`}`
`227`	`241`	`}`
	`242`	`+`
`228`	`243`	`if ($traverseChildren) {`
`229`	`244`	`$this->traverseNode($node);`
`230`	`245`	`if ($this->stopTraversal) {`
`231`	`246`	`break;`
`232`	`247`	`}`
`233`	`248`	`}`
	`249`	`+`
`234`	`250`	`for (; $visitorIndex >= 0; --$visitorIndex) {`
`235`	`251`	`$visitor = $currentNodeVisitors[$visitorIndex];`
`236`	`252`	`$return = $visitor->leaveNode($node);`
`@@ -248,33 +264,36 @@ protected function traverseArray(array $nodes): array`
`248`	`264`	`$this->stopTraversal = true;`
`249`	`265`	`break 2;`
`250`	`266`	`} elseif ($return === NodeVisitor::REPLACE_WITH_NULL) {`
`251`		`- throw new \LogicException(`
	`267`	`+ throw new LogicException(`
`252`	`268`	`'REPLACE_WITH_NULL can not be used if the parent structure is an array'`
`253`	`269`	`);`
`254`	`270`	`} else {`
`255`		`- throw new \LogicException('leaveNode() returned invalid value of type ' . gettype($return));`
	`271`	`+ throw new LogicException('leaveNode() returned invalid value of type ' . gettype($return));`
`256`	`272`	`}`
`257`	`273`	`}`
`258`	`274`	`}`
`259`	`275`	`}`
`260`		`- if (! empty($doNodes)) {`
`261`		`- while (list($i, $replace) = array_pop($doNodes)) {`
	`276`	`+`
	`277`	`+ if ($doNodes !== []) {`
	`278`	`+ while ([$i, $replace] = array_pop($doNodes)) {`
`262`	`279`	`array_splice($nodes, $i, 1, $replace);`
`263`	`280`	`}`
`264`	`281`	`}`
	`282`	`+`
`265`	`283`	`return $nodes;`
`266`	`284`	`}`
`267`	`285`
`268`	`286`	`private function ensureReplacementReasonable(Node $old, Node $new): void`
`269`	`287`	`{`
`270`		`- if ($old instanceof Node\Stmt && $new instanceof Node\Expr) {`
`271`		`- throw new \LogicException(`
`272`		`- "Trying to replace statement ({$old->getType()}) " . "with expression ({$new->getType()}). Are you missing a " . 'Stmt_Expression wrapper?'`
	`288`	`+ if ($old instanceof Stmt && $new instanceof Expr) {`
	`289`	`+ throw new LogicException(`
	`290`	`+ sprintf('Trying to replace statement (%s) ', $old->getType()) . sprintf('with expression (%s). Are you missing a ', $new->getType()) . 'Stmt_Expression wrapper?'`
`273`	`291`	`);`
`274`	`292`	`}`
`275`		`- if ($old instanceof Node\Expr && $new instanceof Node\Stmt) {`
`276`		`- throw new \LogicException(`
`277`		`- "Trying to replace expression ({$old->getType()}) " . "with statement ({$new->getType()})"`
	`293`	`+`
	`294`	`+ if ($old instanceof Expr && $new instanceof Stmt) {`
	`295`	`+ throw new LogicException(`
	`296`	`+ sprintf('Trying to replace expression (%s) ', $old->getType()) . sprintf('with statement (%s)', $new->getType())`
`278`	`297`	`);`
`279`	`298`	`}`
`280`	`299`	`}`