move property adding to PostRector

packages/post-rector/src/Collector/PropertyToAddCollector.php

@@ -0,0 +1,98 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PostRector\Collector;
+
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassConst;
+use PHPStan\Type\Type;
+use Rector\NodeNameResolver\NodeNameResolver;
+use Rector\PostRector\Contract\Collector\NodeCollectorInterface;
+
+final class PropertyToAddCollector implements NodeCollectorInterface
+{
+    /**
+     * @var Type[][]|null[][]
+     */
+    private $propertiesByClass = [];
+
+    /**
+     * @var ClassConst[][]
+     */
+    private $constantsByClass = [];
+
+    /**
+     * @var Type[][]|null[][]
+     */
+    private $propertiesWithoutConstructorByClass = [];
+
+    /**
+     * @var NodeNameResolver
+     */
+    private $nodeNameResolver;
+
+    public function __construct(NodeNameResolver $nodeNameResolver)
+    {
+        $this->nodeNameResolver = $nodeNameResolver;
+    }
+
+    public function isActive(): bool
+    {
+        if (count($this->propertiesByClass) > 0) {
+            return true;
+        }
+
+        if (count($this->propertiesWithoutConstructorByClass) > 0) {
+            return true;
+        }
+
+        return count($this->constantsByClass) > 0;
+    }
+
+    public function addPropertyToClass(string $propertyName, ?Type $propertyType, Class_ $class): void
+    {
+        $this->propertiesByClass[spl_object_hash($class)][$propertyName] = $propertyType;
+    }
+
+    public function addConstantToClass(Class_ $class, ClassConst $classConst): void
+    {
+        $constantName = $this->nodeNameResolver->getName($classConst);
+        $this->constantsByClass[spl_object_hash($class)][$constantName] = $classConst;
+    }
+
+    public function addPropertyWithoutConstructorToClass(
+        string $propertyName,
+        ?Type $propertyType,
+        Class_ $classNode
+    ): void {
+        $this->propertiesWithoutConstructorByClass[spl_object_hash($classNode)][$propertyName] = $propertyType;
+    }
+
+    /**
+     * @var ClassConst[]
+     */
+    public function getConstantsByClass(Class_ $class): array
+    {
+        $classHash = spl_object_hash($class);
+        return $this->constantsByClass[$classHash] ?? [];
+    }
+
+    /**
+     * @var Type[]|null[]
+     */
+    public function getPropertiesByClass(Class_ $class): array
+    {
+        $classHash = spl_object_hash($class);
+        return $this->propertiesByClass[$classHash] ?? [];
+    }
+
+    /**
+     * @var Type[]|null[]
+     */
+    public function getPropertiesWithoutConstructorByClass(Class_ $class): array
+    {
+        $classHash = spl_object_hash($class);
+        return $this->propertiesWithoutConstructorByClass[$classHash] ?? [];
+    }
+}

packages/post-rector/src/Rector/AbstractRector/NodeCommandersTrait.php

@@ -14,10 +14,10 @@
 use Rector\ChangesReporting\Collector\RectorChangeCollector;
 use Rector\Core\PhpParser\Node\Commander\NodeAddingCommander;
 use Rector\Core\PhpParser\Node\Commander\NodeReplacingCommander;
-use Rector\Core\PhpParser\Node\Commander\PropertyAddingCommander;
 use Rector\PHPStan\Type\AliasedObjectType;
 use Rector\PHPStan\Type\FullyQualifiedObjectType;
 use Rector\PostRector\Collector\NodesToRemoveCollector;
+use Rector\PostRector\Collector\PropertyToAddCollector;
 use Rector\PostRector\Collector\UseNodesToAddCollector;
 
 /**
@@ -42,9 +42,9 @@ trait NodeCommandersTrait
     private $nodeAddingCommander;
 
     /**
-     * @var PropertyAddingCommander
+     * @var PropertyToAddCollector
      */
-    private $propertyAddingCommander;
+    private $propertyToAddCollector;
 
     /**
      * @var NodeReplacingCommander
@@ -62,14 +62,14 @@ trait NodeCommandersTrait
     public function autowireNodeCommandersTrait(
         NodesToRemoveCollector $nodesToRemoveCollector,
         NodeAddingCommander $nodeAddingCommander,
-        PropertyAddingCommander $propertyAddingCommander,
+        PropertyToAddCollector $propertyToAddCollector,
         UseNodesToAddCollector $useNodesToAddCollector,
         NodeReplacingCommander $nodeReplacingCommander,
         RectorChangeCollector $rectorChangeCollector
     ): void {
         $this->nodesToRemoveCollector = $nodesToRemoveCollector;
         $this->nodeAddingCommander = $nodeAddingCommander;
-        $this->propertyAddingCommander = $propertyAddingCommander;
+        $this->propertyToAddCollector = $propertyToAddCollector;
         $this->useNodesToAddCollector = $useNodesToAddCollector;
         $this->nodeReplacingCommander = $nodeReplacingCommander;
         $this->rectorChangeCollector = $rectorChangeCollector;
@@ -101,13 +101,13 @@ protected function addNodeBeforeNode(Node $newNode, Node $positionNode): void
 
     protected function addPropertyToClass(Class_ $class, ?Type $propertyType, string $propertyName): void
     {
-        $this->propertyAddingCommander->addPropertyToClass($propertyName, $propertyType, $class);
+        $this->propertyToAddCollector->addPropertyToClass($propertyName, $propertyType, $class);
         $this->rectorChangeCollector->notifyNodeFileInfo($class);
     }
 
     protected function addConstantToClass(Class_ $class, ClassConst $classConst): void
     {
-        $this->propertyAddingCommander->addConstantToClass($class, $classConst);
+        $this->propertyToAddCollector->addConstantToClass($class, $classConst);
         $this->rectorChangeCollector->notifyNodeFileInfo($class);
     }
 
@@ -116,8 +116,7 @@ protected function addPropertyWithoutConstructorToClass(
         ?Type $propertyType,
         string $propertyName
     ): void {
-        $this->propertyAddingCommander->addPropertyWithoutConstructorToClass($propertyName, $propertyType, $classNode);
-
+        $this->propertyToAddCollector->addPropertyWithoutConstructorToClass($propertyName, $propertyType, $classNode);
         $this->rectorChangeCollector->notifyNodeFileInfo($classNode);
     }
 

packages/post-rector/src/Rector/PropertyAddingPostRector.php

@@ -0,0 +1,95 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\PostRector\Rector;
+
+use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
+use Rector\Core\PhpParser\Node\Manipulator\ClassDependencyManipulator;
+use Rector\Core\PhpParser\Node\Manipulator\ClassInsertManipulator;
+use Rector\Core\RectorDefinition\RectorDefinition;
+use Rector\PostRector\Collector\PropertyToAddCollector;
+
+/**
+ * Adds new private properties to class + to constructor
+ */
+final class PropertyAddingPostRector extends AbstractPostRector
+{
+    /**
+     * @var ClassDependencyManipulator
+     */
+    private $classDependencyManipulator;
+
+    /**
+     * @var ClassInsertManipulator
+     */
+    private $classInsertManipulator;
+
+    /**
+     * @var PropertyToAddCollector
+     */
+    private $propertyToAddCollector;
+
+    public function __construct(
+        ClassDependencyManipulator $classDependencyManipulator,
+        ClassInsertManipulator $classInsertManipulator,
+        PropertyToAddCollector $propertyToAddCollector
+    ) {
+        $this->classDependencyManipulator = $classDependencyManipulator;
+        $this->classInsertManipulator = $classInsertManipulator;
+        $this->propertyToAddCollector = $propertyToAddCollector;
+    }
+
+    public function getPriority(): int
+    {
+        return 900;
+    }
+
+    public function refactor(Node $node): ?Node
+    {
+        if (! $node instanceof Class_ || $node->isAnonymous()) {
+            return null;
+        }
+
+        $this->addConstants($node);
+        $this->addProperties($node);
+        $this->addPropertiesWithoutConstructor($node);
+
+        return $node;
+    }
+
+    public function getDefinition(): RectorDefinition
+    {
+        return new RectorDefinition('Post Rector that adds properties');
+    }
+
+    private function addConstants(Class_ $class): void
+    {
+        $constants = $this->propertyToAddCollector->getConstantsByClass($class);
+
+        foreach ($constants as $constantName => $nodeConst) {
+            $this->classInsertManipulator->addConstantToClass($class, $constantName, $nodeConst);
+        }
+    }
+
+    private function addProperties(Class_ $class): void
+    {
+        $properties = $this->propertyToAddCollector->getPropertiesByClass($class);
+
+        foreach ($properties as $propertyName => $propertyType) {
+            $this->classDependencyManipulator->addConstructorDependency($class, $propertyName, $propertyType);
+        }
+    }
+
+    private function addPropertiesWithoutConstructor(Class_ $class): void
+    {
+        $propertiesWithoutConstructor = $this->propertyToAddCollector->getPropertiesWithoutConstructorByClass(
+            $class
+        );
+
+        foreach ($propertiesWithoutConstructor as $propertyName => $propertyType) {
+            $this->classInsertManipulator->addPropertyToClass($class, $propertyName, $propertyType);
+        }
+    }
+}