rename Property to VariableInfo, few method name changes

src/Builder/Class_/ClassPropertyCollector.php

@@ -5,7 +5,7 @@ namespace Rector\Builder\Class_;
 final class ClassPropertyCollector
 {
     /**
-     * @var Property[][]
+     * @var VariableInfo[][]
      */
     private $classProperties = [];
 
@@ -14,11 +14,11 @@ final class ClassPropertyCollector
      */
     public function addPropertyForClass(string $class, array $propertyTypes, string $propertyName): void
     {
-        $this->classProperties[$class][] = Property::createFromNameAndTypes($propertyName, $propertyTypes);
+        $this->classProperties[$class][] = VariableInfo::createFromNameAndTypes($propertyName, $propertyTypes);
     }
 
     /**
-     * @return Property[]
+     * @return VariableInfo[]
      */
     public function getPropertiesForClass(string $class): array
     {

src/Builder/Class_/VariableInfo.php

@@ -2,7 +2,7 @@
 
 namespace Rector\Builder\Class_;
 
-final class Property
+final class VariableInfo
 {
     /**
      * @var string
@@ -24,11 +24,11 @@ final class Property
     }
 
     /**
-     * @param string[] $propertyTypes
+     * @param string[] $types
      */
-    public static function createFromNameAndTypes(string $propertyName, array $propertyTypes): self
+    public static function createFromNameAndTypes(string $name, array $types): self
     {
-        return new self($propertyName, $propertyTypes);
+        return new self($name, $types);
     }
 
     public function getName(): string

src/Builder/ConstructorMethodBuilder.php

@@ -10,7 +10,7 @@ use PhpParser\Node\Expr\Assign;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
-use Rector\Builder\Class_\Property;
+use Rector\Builder\Class_\VariableInfo;
 use Rector\Node\NodeFactory;
 
 final class ConstructorMethodBuilder
@@ -37,15 +37,15 @@ final class ConstructorMethodBuilder
         $this->nodeFactory = $nodeFactory;
     }
 
-    /**
+    public function addPropertyWithExpression(
-     * @todo optimize with the other method
+        Class_ $classNode,
-     */
+        VariableInfo $argument,
-    public function addPropertyWithExpression(Class_ $classNode, Property $argument, Expr $exprNode, Property $assignProperty): void
+        Expr $exprNode,
-    {
+        VariableInfo $assignProperty
-        $constructorMethod = $classNode->getMethod('__construct') ?: null;
+    ): void {
-
         $propertyAssignNode = $this->nodeFactory->createPropertyAssignmentWithExpr($assignProperty->getName(), $exprNode);
 
+        $constructorMethod = $classNode->getMethod('__construct') ?: null;
         /** @var ClassMethod $constructorMethod */
         if ($constructorMethod) {
             // has parameter already?
@@ -63,21 +63,15 @@ final class ConstructorMethodBuilder
             return;
         }
 
-        /** @var Method $constructorMethod */
+        $constructorMethod = $this->createMethodWithPropertyAndAssign('__construct', $argument, $propertyAssignNode);
-        $constructorMethod = $this->builderFactory->method('__construct')
-            ->makePublic()
-            ->addParam($this->createParameter($argument->getTypes(), $argument->getName()))
-            ->addStmts([$propertyAssignNode]);
-
         $this->statementGlue->addAsFirstMethod($classNode, $constructorMethod->getNode());
     }
 
-    public function addPropertyAssignToClass(Class_ $classNode, Property $property): void
+    public function addPropertyAssignToClass(Class_ $classNode, VariableInfo $property): void
     {
-        $constructorMethod = $classNode->getMethod('__construct') ?: null;
-
         $propertyAssignNode = $this->nodeFactory->createPropertyAssignment($property->getName());
 
+        $constructorMethod = $classNode->getMethod('__construct') ?: null;
         /** @var ClassMethod $constructorMethod */
         if ($constructorMethod) {
             // has parameter already?
@@ -95,8 +89,7 @@ final class ConstructorMethodBuilder
             return;
         }
 
-        $constructorMethod = $this->createMethodsWithArgumentsAndAssign('__construct', $property, $propertyAssignNode);
+        $constructorMethod = $this->createMethodWithPropertyAndAssign('__construct', $property, $propertyAssignNode);
-
         $this->statementGlue->addAsFirstMethod($classNode, $constructorMethod->getNode());
     }
 
@@ -107,17 +100,17 @@ final class ConstructorMethodBuilder
     {
         $paramBuild = $this->builderFactory->param($propertyName);
         foreach ($propertyTypes as $propertyType) {
-            $paramBuild->setTypeHint($this->nodeFactory->createTypeNamespace($propertyType));
+            $paramBuild->setTypeHint($this->nodeFactory->createTypeName($propertyType));
         }
 
         return $paramBuild;
     }
 
-    private function createMethodsWithArgumentsAndAssign(string $name, Property $property, Expression $expressionNode): Method
+    private function createMethodWithPropertyAndAssign(string $name, VariableInfo $variable, Expression $expressionNode): Method
     {
         return $this->builderFactory->method($name)
             ->makePublic()
-            ->addParam($this->createParameter($property->getTypes(), $property->getName()))
+            ->addParam($this->createParameter($variable->getTypes(), $variable->getName()))
             ->addStmts([$expressionNode]);
     }
 }

src/Builder/PropertyBuilder.php

@@ -6,7 +6,7 @@ use PhpParser\BuilderFactory;
 use PhpParser\Comment\Doc;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Property as PhpParserProperty;
-use Rector\Builder\Class_\Property;
+use Rector\Builder\Class_\VariableInfo;
 use Rector\Naming\PropertyNaming;
 
 final class PropertyBuilder
@@ -27,7 +27,7 @@ final class PropertyBuilder
         $this->statementGlue = $statementGlue;
     }
 
-    public function addPropertyToClass(Class_ $classNode, Property $property): void
+    public function addPropertyToClass(Class_ $classNode, VariableInfo $property): void
     {
         if ($this->doesPropertyAlreadyExist($classNode, $property)) {
             return;
@@ -38,7 +38,7 @@ final class PropertyBuilder
         $this->statementGlue->addAsFirstMethod($classNode, $propertyNode);
     }
 
-    private function buildPrivatePropertyNode(Property $property): PhpParserProperty
+    private function buildPrivatePropertyNode(VariableInfo $property): PhpParserProperty
     {
         $docComment = $this->createDocWithVarAnnotation($property->getTypes());
 
@@ -59,7 +59,7 @@ final class PropertyBuilder
             . PHP_EOL . ' */');
     }
 
-    private function doesPropertyAlreadyExist(Class_ $classNode, Property $property): bool
+    private function doesPropertyAlreadyExist(Class_ $classNode, VariableInfo $property): bool
     {
         foreach ($classNode->stmts as $inClassNode) {
             if (! $inClassNode instanceof PhpParserProperty) {

src/Node/NodeFactory.php

@@ -222,7 +222,7 @@ final class NodeFactory
         return new StaticCall(new Name($class), new Identifier($method), $arguments);
     }
 
-    public function createTypeNamespace(string $name): Name
+    public function createTypeName(string $name): Name
     {
         if (PropertyNaming::isPhpReservedType($name)) {
             return new Name($name);

src/Rector/Architecture/RepositoryAsService/RemoveParentDoctrineRepositoryRector.php

@@ -7,7 +7,7 @@ use PhpParser\Node;
 use PhpParser\Node\Expr\MethodCall;
 use PhpParser\Node\Expr\Variable;
 use PhpParser\Node\Stmt\Class_;
-use Rector\Builder\Class_\Property;
+use Rector\Builder\Class_\VariableInfo;
 use Rector\Builder\ConstructorMethodBuilder;
 use Rector\Builder\PropertyBuilder;
 use Rector\Node\Attribute;
@@ -59,13 +59,13 @@ final class RemoveParentDoctrineRepositoryRector extends AbstractRector
         $node->extends = null;
 
         // add $repository property
-        $property = Property::createFromNameAndTypes('repository', ['Doctrine\ORM\EntityRepository']);
+        $parameterInfo = VariableInfo::createFromNameAndTypes('repository', ['Doctrine\ORM\EntityRepository']);
-        $this->propertyBuilder->addPropertyToClass($node, $property);
+        $this->propertyBuilder->addPropertyToClass($node, $parameterInfo);
 
         // add repository to constuctor
         $methodCall = new MethodCall(new Variable('entityManager'), 'getRepository');
-        $argument = Property::createFromNameAndTypes('entityManager', ['Doctrine\ORM\EntityManager']);
+        $propertyInfo = VariableInfo::createFromNameAndTypes('entityManager', ['Doctrine\ORM\EntityManager']);
-        $this->constructorMethodBuilder->addPropertyWithExpression($node, $argument, $methodCall, $property);
+        $this->constructorMethodBuilder->addPropertyWithExpression($node, $propertyInfo, $methodCall, $parameterInfo);
 
         return $node;
     }