[ci-review] Rector Rectify

Author: actions-user

rules/Php85/Rector/StmtsAwareInterface/NestedToPipeOperatorRector.php

@@ -4,6 +4,7 @@
 
 namespace Rector\Php85\Rector\StmtsAwareInterface;
 
+use PhpParser\Node\Expr\BinaryOp\Pipe;
 use PhpParser\Node;
 use PhpParser\Node\Arg;
 use PhpParser\Node\Expr;
@@ -90,17 +91,17 @@ public function refactor(Node $node): ?Node
         return $hasChanged ? $node : null;
     }
 
-    private function transformSequentialAssignments(StmtsAwareInterface $node): bool
+    private function transformSequentialAssignments(StmtsAwareInterface $stmtsAware): bool
     {
         $hasChanged = false;
-        $statements = $node->stmts;
+        $statements = $stmtsAware->stmts;
         $totalStatements = count($statements) - 1;
 
         for ($i = 0; $i < $totalStatements; ++$i) {
             $chain = $this->findAssignmentChain($statements, $i);
 
             if ($chain && count($chain) >= 2) {
-                $this->processAssignmentChain($node, $chain, $i);
+                $this->processAssignmentChain($stmtsAware, $chain, $i);
                 $hasChanged = true;
                 // Skip processed statements
                 $i += count($chain) - 1;
@@ -153,6 +154,7 @@ private function findAssignmentChain(array $statements, int $startIndex): ?array
                 if (! $arg->value instanceof Variable && ! $this->isSimpleValue($arg->value)) {
                     return null;
                 }
+
                 $chain[] = [
                     'stmt' => $stmt,
                     'assign' => $expr,
@@ -166,6 +168,7 @@ private function findAssignmentChain(array $statements, int $startIndex): ?array
                 if (! $arg->value instanceof Variable || $this->getName($arg->value) !== $previousVarName) {
                     break;
                 }
+
                 $chain[] = [
                     'stmt' => $stmt,
                     'assign' => $expr,
@@ -192,9 +195,8 @@ private function isSimpleValue(Expr $expr): bool
     /**
      * @param array<int, array{stmt: Stmt, assign: Expr, funcCall: Expr\FuncCall}> $chain
      */
-    private function processAssignmentChain(StmtsAwareInterface $node, array $chain, int $startIndex): void
+    private function processAssignmentChain(StmtsAwareInterface $stmtsAware, array $chain, int $startIndex): void
     {
-        $firstAssignment = $chain[0]['assign'];
         $lastAssignment = $chain[count($chain) - 1]['assign'];
 
         // Get the initial value from the first function call's argument
@@ -217,39 +219,40 @@ private function processAssignmentChain(StmtsAwareInterface $node, array $chain,
         foreach ($chain as $chainItem) {
             $funcCall = $chainItem['funcCall'];
             $placeholderCall = $this->createPlaceholderCall($funcCall);
-            $pipeExpression = new Node\Expr\BinaryOp\Pipe($pipeExpression, $placeholderCall);
+            $pipeExpression = new Pipe($pipeExpression, $placeholderCall);
         }
 
         if (! $lastAssignment instanceof Assign) {
             return;
         }
+
         // Create the final assignment
-        $finalAssignment = new Assign($lastAssignment->var, $pipeExpression);
-        $finalExpression = new Expression($finalAssignment);
+        $assign = new Assign($lastAssignment->var, $pipeExpression);
+        $finalExpression = new Expression($assign);
 
         // Replace the statements
         $endIndex = $startIndex + count($chain) - 1;
 
         // Remove all intermediate statements and replace with the final pipe expression
         for ($i = $startIndex; $i <= $endIndex; ++$i) {
             if ($i === $startIndex) {
-                $node->stmts[$i] = $finalExpression;
+                $stmtsAware->stmts[$i] = $finalExpression;
             } else {
-                unset($node->stmts[$i]);
+                unset($stmtsAware->stmts[$i]);
             }
         }
 
-        $stmts = array_values($node->stmts);
+        $stmts = array_values($stmtsAware->stmts);
 
         // Reindex the array
-        $node->stmts = $stmts;
+        $stmtsAware->stmts = $stmts;
     }
 
-    private function transformNestedCalls(StmtsAwareInterface $node): bool
+    private function transformNestedCalls(StmtsAwareInterface $stmtsAware): bool
     {
         $hasChanged = false;
 
-        foreach ($node->stmts as $stmt) {
+        foreach ($stmtsAware->stmts as $stmt) {
             if (! $stmt instanceof Expression) {
                 continue;
             }
@@ -260,14 +263,14 @@ private function transformNestedCalls(StmtsAwareInterface $node): bool
                 $assignedValue = $expr->expr;
                 $processedValue = $this->processNestedCalls($assignedValue);
 
-                if ($processedValue !== null && $processedValue !== $assignedValue) {
+                if ($processedValue instanceof Expr && $processedValue !== $assignedValue) {
                     $expr->expr = $processedValue;
                     $hasChanged = true;
                 }
             } elseif ($expr instanceof FuncCall) {
                 $processedValue = $this->processNestedCalls($expr);
 
-                if ($processedValue !== null && $processedValue !== $expr) {
+                if ($processedValue instanceof Expr && $processedValue !== $expr) {
                     $stmt->expr = $processedValue;
                     $hasChanged = true;
                 }
@@ -288,6 +291,7 @@ private function processNestedCalls(Node $node): ?Expr
             if (! $arg instanceof Arg) {
                 return null;
             }
+
             if ($arg->value instanceof FuncCall) {
                 return $this->buildPipeExpression($node, $arg->value);
             }
@@ -296,20 +300,18 @@ private function processNestedCalls(Node $node): ?Expr
         return null;
     }
 
-    private function buildPipeExpression(FuncCall $outerCall, FuncCall $innerCall): Node\Expr\BinaryOp\Pipe
+    private function buildPipeExpression(FuncCall $outerCall, FuncCall $innerCall): Pipe
     {
-        $pipe = new Node\Expr\BinaryOp\Pipe($innerCall, $this->createPlaceholderCall($outerCall));
-
-        return $pipe;
+        return new Pipe($innerCall, $this->createPlaceholderCall($outerCall));
     }
 
-    private function createPlaceholderCall(FuncCall $originalCall): FuncCall
+    private function createPlaceholderCall(FuncCall $funcCall): FuncCall
     {
         $newArgs = [];
-        foreach ($originalCall->args as $arg) {
+        foreach ($funcCall->args as $arg) {
             $newArgs[] = new VariadicPlaceholder();
         }
 
-        return new FuncCall($originalCall->name, $newArgs);
+        return new FuncCall($funcCall->name, $newArgs);
     }
 }

rules/Transform/ValueObject/ArrayDimFetchToMethodCall.php

@@ -6,16 +6,16 @@
 
 use PHPStan\Type\ObjectType;
 
-final class ArrayDimFetchToMethodCall
+final readonly class ArrayDimFetchToMethodCall
 {
     public function __construct(
-        private readonly ObjectType $objectType,
-        private readonly string $method,
+        private ObjectType $objectType,
+        private string $method,
         // Optional methods for set, exists, and unset operations
         // if null, then these operations will not be transformed
-        private readonly ?string $setMethod = null,
-        private readonly ?string $existsMethod = null,
-        private readonly ?string $unsetMethod = null,
+        private ?string $setMethod = null,
+        private ?string $existsMethod = null,
+        private ?string $unsetMethod = null,
     ) {
     }