Cleanup NodeRepository (#315)

rectorphp · Jun 28, 2021 · d8a7f6c · d8a7f6c
1 parent 1a87a3d
commit d8a7f6c
Show file tree

Hide file tree

Showing 9 changed files with 36 additions and 124 deletions.
diff --git a/packages/NodeCollector/NodeCollector/NodeRepository.php b/packages/NodeCollector/NodeCollector/NodeRepository.php
@@ -4,19 +4,13 @@
 
 namespace Rector\NodeCollector\NodeCollector;
 
-use PhpParser\Node\Expr;
-use PhpParser\Node\Expr\PropertyFetch;
-use PhpParser\Node\Expr\StaticPropertyFetch;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\Interface_;
-use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\Stmt\Trait_;
 use PHPStan\Reflection\ReflectionProvider;
-use PHPStan\Type\TypeWithClassName;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
-use Rector\NodeTypeResolver\NodeTypeResolver;
 
 /**
  * This service contains all the parsed nodes. E.g. all the functions, method call, classes, static calls etc. It's
@@ -28,31 +22,17 @@ public function __construct(
         private NodeNameResolver $nodeNameResolver,
         private ParsedNodeCollector $parsedNodeCollector,
         private ReflectionProvider $reflectionProvider,
-        private NodeTypeResolver $nodeTypeResolver
     ) {
     }
 
     public function hasClassChildren(Class_ $desiredClass): bool
     {
-        $desiredClassName = $desiredClass->getAttribute(AttributeKey::CLASS_NAME);
+        $desiredClassName = $this->nodeNameResolver->getName($desiredClass);
         if ($desiredClassName === null) {
             return false;
         }
 
-        foreach ($this->parsedNodeCollector->getClasses() as $classNode) {
-            $currentClassName = $classNode->getAttribute(AttributeKey::CLASS_NAME);
-            if ($currentClassName === null) {
-                continue;
-            }
-
-            if (! $this->isChildOrEqualClassLike($desiredClassName, $currentClassName)) {
-                continue;
-            }
-
-            return true;
-        }
-
-        return false;
+        return $this->findChildrenOfClass($desiredClassName) !== [];
     }
 
     /**
@@ -85,6 +65,7 @@ public function findClassesAndInterfacesByType(string $type): array
     }
 
     /**
+     * @param class-string $class
      * @return Class_[]
      */
     public function findChildrenOfClass(string $class): array
@@ -103,40 +84,20 @@ public function findChildrenOfClass(string $class): array
         return $childrenClasses;
     }
 
+    /**
+     * @param class-string $class
+     */
     public function findInterface(string $class): ?Interface_
     {
         return $this->parsedNodeCollector->findInterface($class);
     }
 
-    public function findClass(string $name): ?Class_
-    {
-        return $this->parsedNodeCollector->findClass($name);
-    }
-
     /**
-     * @param PropertyFetch|StaticPropertyFetch $expr
+     * @param class-string $name
      */
-    public function findPropertyByPropertyFetch(Expr $expr): ?Property
+    public function findClass(string $name): ?Class_
     {
-        $propertyCaller = $expr instanceof StaticPropertyFetch ? $expr->class : $expr->var;
-
-        $propertyCallerType = $this->nodeTypeResolver->getStaticType($propertyCaller);
-        if (! $propertyCallerType instanceof TypeWithClassName) {
-            return null;
-        }
-
-        $className = $this->nodeTypeResolver->getFullyQualifiedClassName($propertyCallerType);
-        $class = $this->findClass($className);
-        if (! $class instanceof Class_) {
-            return null;
-        }
-
-        $propertyName = $this->nodeNameResolver->getName($expr->name);
-        if ($propertyName === null) {
-            return null;
-        }
-
-        return $class->getProperty($propertyName);
+        return $this->parsedNodeCollector->findClass($name);
     }
 
     public function findTrait(string $name): ?Trait_
@@ -171,6 +132,7 @@ private function isChildOrEqualClassLike(string $desiredClass, ?string $currentC
         if (! $currentClassReflection->isSubclassOf($desiredClassReflection->getName())) {
             return false;
         }
+
         return $currentClassName !== $desiredClass;
     }
 

diff --git a/rules-tests/Transform/Rector/FuncCall/FuncCallToMethodCallRector/config/configured_rule.php b/rules-tests/Transform/Rector/FuncCall/FuncCallToMethodCallRector/config/configured_rule.php
@@ -10,6 +10,7 @@
 
 return static function (ContainerConfigurator $containerConfigurator): void {
     $services = $containerConfigurator->services();
+
     $services->set(FuncCallToMethodCallRector::class)
         ->call('configure', [[
             FuncCallToMethodCallRector::FUNC_CALL_TO_CLASS_METHOD_CALL => ValueObjectInliner::inline([

diff --git a/rules/CodeQuality/Rector/Isset_/IssetOnPropertyObjectToPropertyExistsRector.php b/rules/CodeQuality/Rector/Isset_/IssetOnPropertyObjectToPropertyExistsRector.php
@@ -12,6 +12,7 @@
 use PhpParser\Node\Expr\Isset_;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Scalar\String_;
+use PhpParser\Node\Stmt\Property;
 use PHPStan\Reflection\Php\PhpPropertyReflection;
 use PHPStan\Reflection\ReflectionProvider;
 use PHPStan\Type\MixedType;

diff --git a/rules/Transform/NodeAnalyzer/FuncCallStaticCallToMethodCallAnalyzer.php b/rules/Transform/NodeAnalyzer/FuncCallStaticCallToMethodCallAnalyzer.php
@@ -44,6 +44,7 @@ public function matchTypeProvidingExpr(
             $functionLike,
             $objectType
         );
+
         if ($expr !== null) {
             if ($expr instanceof Variable) {
                 $this->addClassMethodParamForVariable($expr, $objectType, $functionLike);

diff --git a/rules/Transform/Rector/FuncCall/FuncCallToMethodCallRector.php b/rules/Transform/Rector/FuncCall/FuncCallToMethodCallRector.php
@@ -117,6 +117,7 @@ public function refactor(Node $node): ?Node
                 $classMethod,
                 $funcNameToMethodCallName->getNewObjectType()
             );
+
             return $this->nodeFactory->createMethodCall(
                 $expr,
                 $funcNameToMethodCallName->getNewMethodName(),

diff --git a/rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictTypedPropertyRector.php b/rules/TypeDeclaration/Rector/ClassMethod/ReturnTypeFromStrictTypedPropertyRector.php
@@ -122,18 +122,19 @@ private function resolveReturnPropertyType(ClassMethod $classMethod): array
                 return [];
             }
 
-            $propertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch(
+            $phpPropertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch(
                 $return->expr
             );
-            if (! $propertyReflection instanceof PhpPropertyReflection) {
+            if (! $phpPropertyReflection instanceof PhpPropertyReflection) {
                 return [];
             }
 
-            if ($propertyReflection->getNativeType() instanceof MixedType) {
+            // all property must have type declaration
+            if ($phpPropertyReflection->getNativeType() instanceof MixedType) {
                 return [];
             }
 
-            $propertyTypes[] = $propertyReflection->getNativeType();
+            $propertyTypes[] = $phpPropertyReflection->getNativeType();
         }
 
         return $propertyTypes;

diff --git a/rules/TypeDeclaration/Rector/Param/ParamTypeFromStrictTypedPropertyRector.php b/rules/TypeDeclaration/Rector/Param/ParamTypeFromStrictTypedPropertyRector.php
@@ -10,15 +10,15 @@
 use PhpParser\Node\FunctionLike;
 use PhpParser\Node\NullableType;
 use PhpParser\Node\Param;
-use PhpParser\Node\Stmt\Property;
 use PhpParser\Node\UnionType;
 use PHPStan\Analyser\Scope;
+use PHPStan\Reflection\Php\PhpPropertyReflection;
 use PHPStan\Type\MixedType;
 use PHPStan\Type\Type;
 use Rector\Core\Rector\AbstractRector;
+use Rector\Core\Reflection\ReflectionResolver;
 use Rector\Core\ValueObject\PhpVersionFeature;
 use Rector\NodeTypeResolver\Node\AttributeKey;
-use Rector\TypeDeclaration\Reflection\ReflectionTypeResolver;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -28,7 +28,7 @@
 final class ParamTypeFromStrictTypedPropertyRector extends AbstractRector
 {
     public function __construct(
-        private ReflectionTypeResolver $reflectionTypeResolver
+        private ReflectionResolver $reflectionResolver
     ) {
     }
 
@@ -127,39 +127,30 @@ public function decorateParamWithType(FunctionLike $functionLike, Param $param):
     }
 
     /**
-     * @return Node\Identifier|Node\Name|UnionType|NullableType|null
+     * @return Node\Name|UnionType|NullableType|null
      */
     private function matchPropertySingleTypeNode(PropertyFetch $propertyFetch): ?Node
     {
-        $property = $this->nodeRepository->findPropertyByPropertyFetch($propertyFetch);
-        if (! $property instanceof Property) {
-            // code from /vendor
-            $propertyFetchType = $this->reflectionTypeResolver->resolvePropertyFetchType($propertyFetch);
-            if (! $propertyFetchType instanceof Type) {
-                return null;
-            }
-
-            return $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($propertyFetchType);
+        $phpPropertyReflection = $this->reflectionResolver->resolvePropertyReflectionFromPropertyFetch($propertyFetch);
+        if (! $phpPropertyReflection instanceof PhpPropertyReflection) {
+            return null;
         }
 
-        if ($property->type === null) {
+        $propertyType = $phpPropertyReflection->getNativeType();
+
+        if ($propertyType instanceof MixedType) {
             return null;
         }
 
-        // move type to param if not union type
-        if ($property->type instanceof UnionType) {
+        if ($propertyType instanceof \PHPStan\Type\UnionType) {
             return null;
         }
 
-        if ($property->type instanceof NullableType) {
+        if ($propertyType instanceof NullableType) {
             return null;
         }
 
-        // needed to avoid reprinting original tokens bug
-        $typeNode = clone $property->type;
-        $typeNode->setAttribute(AttributeKey::ORIGINAL_NODE, null);
-
-        return $typeNode;
+        return $this->staticTypeMapper->mapPHPStanTypeToPhpParserNode($propertyType);
     }
 
     private function hasTypeChangedBeforeAssign(Assign $assign, string $paramName, Type $originalType): bool

diff --git a/rules/TypeDeclaration/Reflection/ReflectionTypeResolver.php b/rules/TypeDeclaration/Reflection/ReflectionTypeResolver.php
diff --git a/rules/TypeDeclaration/TypeInferer/SilentVoidResolver.php b/rules/TypeDeclaration/TypeInferer/SilentVoidResolver.php
@@ -8,6 +8,7 @@
 use PhpParser\Node\Expr\Yield_;
 use PhpParser\Node\FunctionLike;
 use PhpParser\Node\Stmt;
+use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\Function_;
@@ -48,7 +49,9 @@ public function hasExclusiveVoid(ClassMethod | Closure | Function_ $functionLike
             return false;
         }
 
-        if ($classLike instanceof Stmt\Class_ && $this->externalFullyQualifiedAnalyzer->hasExternalFullyQualifieds($classLike)) {
+        if ($classLike instanceof Class_ && $this->externalFullyQualifiedAnalyzer->hasExternalFullyQualifieds(
+            $classLike
+        )) {
             return false;
         }