[Nette] Nette\DI\Compiler deprecations

src/Builder/StatementGlue.php

@@ -66,6 +66,18 @@ public function insertBefore(array $nodes, Node $node, int $key): array
         return $nodes;
     }
 
+    /**
+     * @param Node[] $nodes
+     * @param Node[] $newNodes
+     * @return Node[]
+     */
+    public function insertNewNodesAfter(array $nodes, array $newNodes, int $key): array
+    {
+        array_splice($nodes, $key + 1, 0, $newNodes);
+
+        return $nodes;
+    }
+
     private function addStatementToClassBeforeTypes(Class_ $classNode, Node $node, string ...$types): void
     {
         foreach ($types as $type) {

src/Rector/AbstractRector.php

@@ -3,10 +3,14 @@
 namespace Rector\Rector;
 
 use PhpParser\Node;
+use PhpParser\Node\Expr;
+use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\Nop;
 use PhpParser\NodeTraverser;
 use PhpParser\NodeVisitorAbstract;
 use Rector\Contract\Rector\RectorInterface;
+use Rector\Node\Attribute;
+use SplObjectStorage;
 
 abstract class AbstractRector extends NodeVisitorAbstract implements RectorInterface
 {
@@ -15,6 +19,28 @@ abstract class AbstractRector extends NodeVisitorAbstract implements RectorInter
      */
     protected $shouldRemoveNode = false;
 
+    /**
+     * @var SplObjectStorage|Expression[]
+     */
+    private $expressionsToPrependBefore = [];
+
+    /**
+     * @var SplObjectStorage|Expression[]
+     */
+    private $expressionsToPrependAfter = [];
+
+    /**
+     * @param Node[] $nodes
+     * @return Node[]
+     */
+    final public function beforeTraverse(array $nodes): array
+    {
+        $this->expressionsToPrependBefore = new SplObjectStorage;
+        $this->expressionsToPrependAfter = new SplObjectStorage;
+
+        return $nodes;
+    }
+
     /**
      * @return null|int|Node
      */
@@ -44,4 +70,96 @@ final public function leaveNode(Node $node)
 
         return null;
     }
+
+    /**
+     * @param Node[] $nodes
+     * @return Node[]
+     */
+    public function afterTraverse(array $nodes): array
+    {
+        return $this->prependExpressionNodes($nodes);
+    }
+
+    protected function prependNodeAfterNode(Expr $nodeToPrepend, Node $positionNode): void
+    {
+        /** @var Expression $parentNode */
+        $parentNode = $positionNode->getAttribute(Attribute::PARENT_NODE);
+
+        $expressionToPrepend = $this->resolveToExpression($nodeToPrepend);
+
+        if (isset($this->expressionsToPrependAfter[$parentNode])) {
+            $this->expressionsToPrependAfter[$parentNode] = array_merge(
+                $this->expressionsToPrependAfter[$parentNode],
+                [$expressionToPrepend]
+            );
+        } else {
+            $this->expressionsToPrependAfter[$parentNode] = [$expressionToPrepend];
+        }
+    }
+
+    protected function prependNodeBeforeNode(Expr $nodeToPrepend, Node $positionNode): void
+    {
+        /** @var Expression $parentNode */
+        $parentNode = $positionNode->getAttribute(Attribute::PARENT_NODE);
+
+        $expressionToPrepend = $this->resolveToExpression($nodeToPrepend);
+
+        if (isset($this->expressionsToPrependBefore[$parentNode])) {
+            $this->expressionsToPrependBefore[$parentNode] = array_merge(
+                $this->expressionsToPrependBefore[$parentNode],
+                [$expressionToPrepend]
+            );
+        } else {
+            $this->expressionsToPrependBefore[$parentNode] = [$expressionToPrepend];
+        }
+    }
+
+    /**
+     * Adds new nodes before or after particular Expression nodes.
+     *
+     * @param Node[] $nodes
+     * @return Node[] array
+     */
+    private function prependExpressionNodes(array $nodes): array
+    {
+        foreach ($nodes as $i => $node) {
+            if ($node instanceof Expression) {
+                $nodes = $this->prependNodesAfterAndBeforeExpression($nodes, $node, $i);
+            } elseif (isset($node->stmts)) {
+                $node->stmts = $this->prependExpressionNodes($node->stmts);
+            }
+        }
+
+        return $nodes;
+    }
+
+    /**
+     * @param Node[] $nodes
+     * @return Node[]
+     */
+    private function prependNodesAfterAndBeforeExpression(array $nodes, Node $node, int $i): array
+    {
+        if (isset($this->expressionsToPrependBefore[$node])) {
+            array_splice($nodes, $i, 0, $this->expressionsToPrependBefore[$node]);
+
+            unset($this->expressionsToPrependBefore[$node]);
+        }
+
+        if (isset($this->expressionsToPrependAfter[$node])) {
+            array_splice($nodes, $i + 1, 0, $this->expressionsToPrependAfter[$node]);
+
+            unset($this->expressionsToPrependAfter[$node]);
+        }
+
+        return $nodes;
+    }
+
+    private function resolveToExpression(Expr $exprNode): Expression
+    {
+        if ($exprNode instanceof Expression) {
+            return $exprNode;
+        }
+
+        return new Expression($exprNode);
+    }
 }

src/Rector/Contrib/Nette/DI/CompilerCompileArgumentsRector.php

@@ -0,0 +1,83 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Rector\Contrib\Nette\DI;
+
+use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\MethodCall;
+use Rector\NodeAnalyzer\MethodCallAnalyzer;
+use Rector\Rector\AbstractRector;
+
+/**
+ * Nette\DI\Compiler::compile arguments are deprecated, use Compiler::addConfig() and Compiler::setClassName().
+ *
+ * From:
+ * - $compiler->compile($config, $className);
+ *
+ * To:
+ * - $compiler->compile();
+ * - $compiler->addConfig($config);
+ * - $compiler->setClassName($className);
+ */
+final class CompilerCompileArgumentsRector extends AbstractRector
+{
+    /**
+     * @var MethodCallAnalyzer
+     */
+    private $methodCallAnalyzer;
+
+    public function __construct(MethodCallAnalyzer $methodCallAnalyzer)
+    {
+        $this->methodCallAnalyzer = $methodCallAnalyzer;
+    }
+
+    public function isCandidate(Node $node): bool
+    {
+        if (! $this->methodCallAnalyzer->isMethodCallTypeAndMethod($node, 'Nette\DI\Compiler', 'compile')) {
+            return false;
+        }
+
+        /** @var MethodCall $node */
+        return count($node->args) >= 1;
+    }
+
+    /**
+     * @param MethodCall $methodCallNode
+     */
+    public function refactor(Node $methodCallNode): ?Node
+    {
+        $oldArguments = $methodCallNode->args;
+
+        $addConfigMethodCallNode = $this->cloneMethodWithNameAndArgument(
+            $methodCallNode,
+            'addConfig',
+            $oldArguments[0]
+        );
+        $this->prependNodeAfterNode($addConfigMethodCallNode, $methodCallNode);
+
+        if (isset($oldArguments[1])) {
+            $setClassNameMethodCallNode = $this->cloneMethodWithNameAndArgument(
+                $methodCallNode,
+                'setClassName',
+                $oldArguments[1]
+            );
+            $this->prependNodeAfterNode($setClassNameMethodCallNode, $methodCallNode);
+        }
+
+        $methodCallNode->args = [];
+
+        return $methodCallNode;
+    }
+
+    private function cloneMethodWithNameAndArgument(
+        MethodCall $methodCallNode,
+        string $method,
+        Arg $argNode
+    ): MethodCall {
+        $addConfigMethodCallNode = clone $methodCallNode;
+        $addConfigMethodCallNode->name = $method;
+        $addConfigMethodCallNode->args = [$argNode];
+
+        return $addConfigMethodCallNode;
+    }
+}

src/Rector/Contrib/Nette/DI/CompilerGenerateCodeArgumentsRector.php

@@ -0,0 +1,72 @@
+<?php declare(strict_types=1);
+
+namespace Rector\Rector\Contrib\Nette\DI;
+
+use PhpParser\Node;
+use PhpParser\Node\Arg;
+use PhpParser\Node\Expr\MethodCall;
+use Rector\NodeAnalyzer\MethodCallAnalyzer;
+use Rector\Rector\AbstractRector;
+
+/**
+ * From:
+ * - $compiler->generateCode($className);
+ *
+ * To:
+ * - $compiler->setClassName($className);
+ * - $compiler->generateCode();
+ */
+final class CompilerGenerateCodeArgumentsRector extends AbstractRector
+{
+    /**
+     * @var MethodCallAnalyzer
+     */
+    private $methodCallAnalyzer;
+
+    public function __construct(MethodCallAnalyzer $methodCallAnalyzer)
+    {
+        $this->methodCallAnalyzer = $methodCallAnalyzer;
+    }
+
+    public function isCandidate(Node $node): bool
+    {
+        if (! $this->methodCallAnalyzer->isMethodCallTypeAndMethod($node, 'Nette\DI\Compiler', 'generateCode')) {
+            return false;
+        }
+
+        /** @var MethodCall $node */
+        return count($node->args) >= 1;
+    }
+
+    /**
+     * @param MethodCall $methodCallNode
+     */
+    public function refactor(Node $methodCallNode): ?Node
+    {
+        $oldArguments = $methodCallNode->args;
+
+        $setClassNameMethodCallNode = $this->cloneMethodWithNameAndArgument(
+            $methodCallNode,
+            'setClassName',
+            $oldArguments[0]
+        );
+
+        $this->prependNodeBeforeNode($setClassNameMethodCallNode, $methodCallNode);
+
+        $methodCallNode->args = [];
+
+        return $methodCallNode;
+    }
+
+    private function cloneMethodWithNameAndArgument(
+        MethodCall $methodCallNode,
+        string $method,
+        Arg $argNode
+    ): MethodCall {
+        $addConfigMethodCallNode = clone $methodCallNode;
+        $addConfigMethodCallNode->name = $method;
+        $addConfigMethodCallNode->args = [$argNode];
+
+        return $addConfigMethodCallNode;
+    }
+}

src/Rector/Dynamic/PseudoNamespaceToNamespaceRector.php

@@ -55,15 +55,6 @@ public function __construct(array $pseudoNamespacePrefixes, NodeFactory $nodeFac
         $this->statementGlue = $statementGlue;
     }
 
-    /**
-     * @param mixed[] $nodes
-     */
-    public function beforeTraverse(array $nodes): void
-    {
-        $this->newNamespace = null;
-        $this->oldToNewUseStatements = [];
-    }
-
     public function isCandidate(Node $node): bool
     {
         $name = $this->resolveNameFromNode($node);
@@ -134,6 +125,9 @@ public function afterTraverse(array $nodes): array
             }
         }
 
+        $this->newNamespace = null;
+        $this->oldToNewUseStatements = [];
+
         return $nodes;
     }
 

src/config/level/nette/nette24.yml

@@ -4,9 +4,13 @@ rectors:
     Rector\Rector\Contrib\Nette\Form\FormSetRequiredRector: ~
     Rector\Rector\Contrib\Nette\Utils\NetteObjectToSmartTraitRector: ~
     Rector\Rector\Contrib\Nette\Utils\MagicMethodRector: ~
+
+    # di
     Rector\Rector\Contrib\Nette\DI\SetEntityToStatementRector: ~
     Rector\Rector\Contrib\Nette\DI\ExpandFunctionToParametersArrayRector: ~
     Rector\Rector\Contrib\Nette\DI\ExpandFunctionToStaticExpandFunctionRector: ~
+    Rector\Rector\Contrib\Nette\DI\CompilerCompileArgumentsRector: ~
+    Rector\Rector\Contrib\Nette\DI\CompilerGenerateCodeArgumentsRector: ~
 
     Rector\Rector\MagicDisclosure\GetAndSetToMethodCallRector:
         # di

tests/Rector/Contrib/Nette/DI/CompilerCompileArgumentsRector/Correct/correct.php.inc

@@ -0,0 +1,8 @@
+<?php declare (strict_types=1);
+
+$compiler = new Nette\DI\Compiler;
+$compiler->compile();
+$compiler->addConfig($firstArg);
+$compiler->setClassName($secondArg);
+
+$someOtherValue = 5;

tests/Rector/Contrib/Nette/DI/CompilerCompileArgumentsRector/Correct/correct2.php.inc

@@ -0,0 +1,14 @@
+<?php declare (strict_types=1);
+
+class SomeClass
+{
+    public function run()
+    {
+        $compiler = new Nette\DI\Compiler;
+        $compiler->compile();
+        $compiler->addConfig($firstArg);
+        $compiler->setClassName($secondArg);
+
+        $someOtherValue = 5;
+    }
+}