[NodeRepository] Remove ChildReturnPopulator (#599)

rectorphp · Aug 5, 2021 · f668ee2 · f668ee2
1 parent 738cea7
commit f668ee2
Show file tree

Hide file tree

Showing 16 changed files with 118 additions and 606 deletions.
diff --git a/packages/NodeCollector/NodeCollector/NodeRepository.php b/packages/NodeCollector/NodeCollector/NodeRepository.php
@@ -5,10 +5,9 @@
 namespace Rector\NodeCollector\NodeCollector;
 
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassLike;
-use PhpParser\Node\Stmt\Trait_;
 use PHPStan\Reflection\ReflectionProvider;
-use Rector\NodeNameResolver\NodeNameResolver;
+use Rector\Core\Exception\ShouldNotHappenException;
+use Rector\Core\NodeAnalyzer\ClassAnalyzer;
 use Rector\NodeTypeResolver\Node\AttributeKey;
 
 /**
@@ -19,82 +18,60 @@
  */
 final class NodeRepository
 {
+    /**
+     * @deprecated Not reliable, as only works with so-far parsed classes
+     * @var Class_[]
+     */
+    private array $classes = [];
+
     public function __construct(
-        private NodeNameResolver $nodeNameResolver,
-        private ParsedNodeCollector $parsedNodeCollector,
+        private ClassAnalyzer $classAnalyzer,
         private ReflectionProvider $reflectionProvider,
     ) {
     }
 
-    public function hasClassChildren(Class_ $desiredClass): bool
+    public function collectClass(Class_ $class): void
     {
-        $desiredClassName = $this->nodeNameResolver->getName($desiredClass);
-        if ($desiredClassName === null) {
-            return false;
+        if ($this->classAnalyzer->isAnonymousClass($class)) {
+            return;
         }
 
-        return $this->findChildrenOfClass($desiredClassName) !== [];
-    }
-
-    /**
-     * @deprecated Use ReflectionProvider instead to resolve all the traits
-     * @return Trait_[]
-     */
-    public function findUsedTraitsInClass(ClassLike $classLike): array
-    {
-        $traits = [];
-
-        foreach ($classLike->getTraitUses() as $traitUse) {
-            foreach ($traitUse->traits as $trait) {
-                $traitName = $this->nodeNameResolver->getName($trait);
-                $foundTrait = $this->parsedNodeCollector->findTrait($traitName);
-                if ($foundTrait !== null) {
-                    $traits[] = $foundTrait;
-                }
-            }
+        $className = $class->getAttribute(AttributeKey::CLASS_NAME);
+        if ($className === null) {
+            throw new ShouldNotHappenException();
         }
 
-        return $traits;
+        $this->classes[$className] = $class;
     }
 
     /**
-     * @deprecated Use static reflection instead
-     *
-     * @param class-string $class
+     * @param class-string $className
      * @return Class_[]
+     * @deprecated Use static reflection instead
      */
-    public function findChildrenOfClass(string $class): array
+    public function findChildrenOfClass(string $className): array
     {
         $childrenClasses = [];
 
-        foreach ($this->parsedNodeCollector->getClasses() as $classNode) {
-            $currentClassName = $classNode->getAttribute(AttributeKey::CLASS_NAME);
-            if (! $this->isChildOrEqualClassLike($class, $currentClassName)) {
+        // @todo refactor to reflection
+        foreach ($this->classes as $class) {
+            $currentClassName = $class->getAttribute(AttributeKey::CLASS_NAME);
+            if ($currentClassName === null) {
                 continue;
             }
 
-            $childrenClasses[] = $classNode;
+            if (! $this->isChildOrEqualClassLike($className, $currentClassName)) {
+                continue;
+            }
+
+            $childrenClasses[] = $class;
         }
 
         return $childrenClasses;
     }
 
-    /**
-     * @deprecated Use static reflection instead
-     *
-     * @param class-string $name
-     */
-    public function findClass(string $name): ?Class_
-    {
-        return $this->parsedNodeCollector->findClass($name);
-    }
-
-    private function isChildOrEqualClassLike(string $desiredClass, ?string $currentClassName): bool
+    private function isChildOrEqualClassLike(string $desiredClass, string $currentClassName): bool
     {
-        if ($currentClassName === null) {
-            return false;
-        }
-
         if (! $this->reflectionProvider->hasClass($desiredClass)) {
             return false;
         }

diff --git a/packages/NodeCollector/NodeCollector/ParsedNodeCollector.php b/packages/NodeCollector/NodeCollector/ParsedNodeCollector.php
diff --git a/packages/NodeCollector/NodeVisitor/NodeCollectorNodeVisitor.php b/packages/NodeCollector/NodeVisitor/NodeCollectorNodeVisitor.php
@@ -5,19 +5,23 @@
 namespace Rector\NodeCollector\NodeVisitor;
 
 use PhpParser\Node;
+use PhpParser\Node\Stmt\Class_;
 use PhpParser\NodeVisitorAbstract;
-use Rector\NodeCollector\NodeCollector\ParsedNodeCollector;
+use Rector\NodeCollector\NodeCollector\NodeRepository;
 
 final class NodeCollectorNodeVisitor extends NodeVisitorAbstract
 {
     public function __construct(
-        private ParsedNodeCollector $parsedNodeCollector,
+        private NodeRepository $nodeRepository,
     ) {
     }
 
     public function enterNode(Node $node)
     {
-        $this->parsedNodeCollector->collect($node);
+        if ($node instanceof Class_) {
+            $this->nodeRepository->collectClass($node);
+        }
+
         return null;
     }
 }
diff --git a/packages/VendorLocker/NodeVendorLocker/ClassMethodParamVendorLockResolver.php b/packages/VendorLocker/NodeVendorLocker/ClassMethodParamVendorLockResolver.php
@@ -6,21 +6,18 @@
 
 use PhpParser\Node\Stmt\ClassMethod;
 use PHPStan\Analyser\Scope;
-use PHPStan\BetterReflection\Reflection\ReflectionClass;
 use PHPStan\Reflection\ClassReflection;
-use PHPStan\Reflection\ReflectionProvider;
+use Rector\FamilyTree\Reflection\FamilyRelationsAnalyzer;
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\NodeTypeResolver\Node\AttributeKey;
-use Symplify\PackageBuilder\Reflection\PrivatesAccessor;
 use Symplify\SmartFileSystem\Normalizer\PathNormalizer;
 
 final class ClassMethodParamVendorLockResolver
 {
     public function __construct(
         private NodeNameResolver $nodeNameResolver,
         private PathNormalizer $pathNormalizer,
-        private ReflectionProvider $reflectionProvider,
-        private PrivatesAccessor $privatesAccessor
+        private FamilyRelationsAnalyzer $familyRelationsAnalyzer
     ) {
     }
 
@@ -73,36 +70,9 @@ public function isVendorLocked(ClassMethod $classMethod): bool
         return false;
     }
 
-    /**
-     * @return ReflectionClass[]
-     */
-    private function findRelatedClassReflections(ClassReflection $classReflection): array
-    {
-        // @todo decouple to some reflection family finder?
-
-        /** @var ReflectionClass[] $reflectionClasses */
-        $reflectionClasses = $this->privatesAccessor->getPrivateProperty($this->reflectionProvider, 'classes');
-
-        $relatedClassReflections = [];
-        foreach ($reflectionClasses as $reflectionClass) {
-            if ($reflectionClass->getName() === $classReflection->getName()) {
-                continue;
-            }
-
-            // is related?
-            if (! $reflectionClass->isSubclassOf($classReflection->getName())) {
-                continue;
-            }
-
-            $relatedClassReflections[] = $reflectionClass;
-        }
-
-        return $relatedClassReflections;
-    }
-
     private function hasTraitMethodVendorLock(ClassReflection $classReflection, string $methodName): bool
     {
-        $relatedReflectionClasses = $this->findRelatedClassReflections($classReflection);
+        $relatedReflectionClasses = $this->familyRelationsAnalyzer->getChildrenOfClassReflection($classReflection);
 
         foreach ($relatedReflectionClasses as $relatedReflectionClass) {
             foreach ($relatedReflectionClass->getTraits() as $traitReflectionClass) {

diff --git a/...on/Rector/FunctionLike/ReturnTypeDeclarationRector/FixtureInheritance/inheritance.php.inc b/...on/Rector/FunctionLike/ReturnTypeDeclarationRector/FixtureInheritance/inheritance.php.inc