fixup! return variadic directly

Author: TomasVotruba

rules/Php85/Rector/StmtsAwareInterface/NestedToPipeOperatorRector.php

@@ -34,7 +34,7 @@
 final class NestedToPipeOperatorRector extends AbstractRector implements MinPhpVersionInterface
 {
     public function __construct(
-        private ExprAnalyzer $exprAnalyzer
+        private readonly ExprAnalyzer $exprAnalyzer
     ) {
     }
 
@@ -164,6 +164,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,
@@ -177,6 +178,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,
@@ -196,8 +198,7 @@ private function isSimpleValue(Expr $expr): bool
             return ! $this->exprAnalyzer->isDynamicExpr($expr);
         }
 
-        return $expr instanceof Variable
-            || $expr instanceof ConstFetch
+        return $expr instanceof ConstFetch
             || $expr instanceof String_
             || $expr instanceof Float_
             || $expr instanceof Int_;
@@ -206,9 +207,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
@@ -237,33 +237,34 @@ private function processAssignmentChain(StmtsAwareInterface $node, array $chain,
         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;
             }
@@ -274,14 +275,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;
                 }
@@ -302,6 +303,7 @@ private function processNestedCalls(Node $node): ?Expr
             if (! $arg instanceof Arg) {
                 return null;
             }
+
             if ($arg->value instanceof FuncCall) {
                 return $this->buildPipeExpression($node, $arg->value);
             }
@@ -315,8 +317,8 @@ private function buildPipeExpression(FuncCall $outerCall, FuncCall $innerCall):
         return new Pipe($innerCall, $this->createPlaceholderCall($outerCall));
     }
 
-    private function createPlaceholderCall(FuncCall $originalCall): FuncCall
+    private function createPlaceholderCall(FuncCall $funcCall): FuncCall
     {
-        return new FuncCall($originalCall->name, [new VariadicPlaceholder()]);
+        return new FuncCall($funcCall->name, [new VariadicPlaceholder()]);
     }
 }

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,
     ) {
     }