[cleanup] handle stop traverse in ClassConstFetchNodeVisitor

Author: TomasVotruba

rules/Renaming/Rector/Name/RenameClassRector.php

@@ -5,16 +5,13 @@
 namespace Rector\Renaming\Rector\Name;
 
 use PhpParser\Node;
-use PhpParser\Node\Expr\ClassConstFetch;
 use PhpParser\Node\FunctionLike;
-use PhpParser\Node\Identifier;
 use PhpParser\Node\Name;
 use PhpParser\Node\Name\FullyQualified;
 use PhpParser\Node\Stmt\ClassLike;
 use PhpParser\Node\Stmt\Expression;
 use PhpParser\Node\Stmt\If_;
 use PhpParser\Node\Stmt\Property;
-use PhpParser\NodeVisitor;
 use PHPStan\Reflection\ReflectionProvider;
 use Rector\Configuration\RenamedClassesDataCollector;
 use Rector\Contract\Rector\ConfigurableRectorInterface;
@@ -80,7 +77,6 @@ function someFunction(SomeNewClass $someOldClass): SomeNewClass
     public function getNodeTypes(): array
     {
         return [
-            ClassConstFetch::class,
             // place FullyQualified before Name on purpose executed early before the Name as parent
             FullyQualified::class,
             // Name as parent of FullyQualified executed later for fallback annotation to attribute rename to Name
@@ -94,19 +90,21 @@ public function getNodeTypes(): array
     }
 
     /**
-     * @param ClassConstFetch|FunctionLike|FullyQualified|Name|ClassLike|Expression|Property|If_ $node
-     * @return null|NodeVisitor::DONT_TRAVERSE_CHILDREN|Node
+     * @param FunctionLike|FullyQualified|Name|ClassLike|Expression|Property|If_ $node
      */
-    public function refactor(Node $node): int|null|Node
+    public function refactor(Node $node): ?Node
     {
         $oldToNewClasses = $this->renamedClassesDataCollector->getOldToNewClasses();
 
         if ($oldToNewClasses === []) {
             return null;
         }
 
-        if ($node instanceof ClassConstFetch) {
-            return $this->processClassConstFetch($node, $oldToNewClasses);
+        if ($node instanceof FullyQualified && $this->shouldSkipClassConstFetchForMissingConstantName(
+            $node,
+            $oldToNewClasses
+        )) {
+            return null;
         }
 
         $scope = $node->getAttribute(AttributeKey::SCOPE);
@@ -126,18 +124,29 @@ public function configure(array $configuration): void
 
     /**
      * @param array<string, string> $oldToNewClasses
-     * @return null|NodeVisitor::DONT_TRAVERSE_CHILDREN
      */
-    private function processClassConstFetch(ClassConstFetch $classConstFetch, array $oldToNewClasses): int|null
-    {
-        if (! $classConstFetch->class instanceof FullyQualified
-            || ! $classConstFetch->name instanceof Identifier
-            || ! $this->reflectionProvider->hasClass($classConstFetch->class->toString())) {
-            return null;
+    private function shouldSkipClassConstFetchForMissingConstantName(
+        FullyQualified $fullyQualified,
+        array $oldToNewClasses
+    ): bool {
+        if (! $this->reflectionProvider->hasClass($fullyQualified->toString())) {
+            return false;
+        }
+
+        // not part of class const fetch (e.g. SomeClass::SOME_VALUE)
+        $constFetchName = $fullyQualified->getAttribute(AttributeKey::CLASS_CONST_FETCH_NAME);
+        if (! is_string($constFetchName)) {
+            return false;
         }
 
+        //        if (! $classConstFetch->class instanceof FullyQualified
+        //            || ! $classConstFetch->name instanceof Identifier
+        //            || ! $this->reflectionProvider->hasClass($classConstFetch->class->toString())) {
+        //            return null;
+        //        }
+
         foreach ($oldToNewClasses as $oldClass => $newClass) {
-            if (! $this->isName($classConstFetch->class, $oldClass)) {
+            if (! $this->isName($fullyQualified, $oldClass)) {
                 continue;
             }
 
@@ -146,20 +155,20 @@ private function processClassConstFetch(ClassConstFetch $classConstFetch, array
             }
 
             $classReflection = $this->reflectionProvider->getClass($newClass);
-            if (! $classReflection->isInterface()) {
-                continue;
-            }
+            //            if (! $classReflection->isInterface()) {
+            //                continue;
+            //            }
 
             $oldClassReflection = $this->reflectionProvider->getClass($oldClass);
 
-            if ($oldClassReflection->hasConstant($classConstFetch->name->toString())
-                && ! $classReflection->hasConstant($classConstFetch->name->toString())) {
-                // no constant found on new interface? skip node below ClassConstFetch on this rule
-                return NodeVisitor::DONT_TRAVERSE_CHILDREN;
+            if ($oldClassReflection->hasConstant($constFetchName) && ! $classReflection->hasConstant($constFetchName)) {
+                // should be skipped
+                return true;
             }
         }
 
-        // continue to next Name usage
-        return null;
+        return false;
+
+        // return $this->classRenamer->renameNode($fullyQualified, $oldToNewClasses, $scope);
     }
 }

src/DependencyInjection/LazyContainerFactory.php

@@ -99,6 +99,7 @@
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\AssignedToNodeVisitor;
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\ByRefReturnNodeVisitor;
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\ByRefVariableNodeVisitor;
+use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\ClassConstFetchNodeVisitor;
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\ContextNodeVisitor;
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\GlobalVariableNodeVisitor;
 use Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor\NameNodeVisitor;
@@ -247,6 +248,7 @@ final class LazyContainerFactory
         NameNodeVisitor::class,
         StaticVariableNodeVisitor::class,
         PropertyOrClassConstDefaultNodeVisitor::class,
+        ClassConstFetchNodeVisitor::class,
     ];
 
     /**

src/NodeTypeResolver/Node/AttributeKey.php

@@ -294,4 +294,6 @@ final class AttributeKey
     public const IS_INSIDE_SYMFONY_PHP_CLOSURE = 'is_inside_symfony_php_closure';
 
     public const IS_INSIDE_BYREF_FUNCTION_LIKE = 'is_inside_byref_function_like';
+
+    public const CLASS_CONST_FETCH_NAME = 'class_const_fetch_name';
 }

src/NodeTypeResolver/PHPStan/Scope/NodeVisitor/ClassConstFetchNodeVisitor.php

@@ -0,0 +1,31 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\NodeTypeResolver\PHPStan\Scope\NodeVisitor;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\ClassConstFetch;
+use PhpParser\Node\Identifier;
+use PhpParser\NodeVisitorAbstract;
+use Rector\Contract\PhpParser\DecoratingNodeVisitorInterface;
+use Rector\NodeTypeResolver\Node\AttributeKey;
+
+final class ClassConstFetchNodeVisitor extends NodeVisitorAbstract implements DecoratingNodeVisitorInterface
+{
+    public function enterNode(Node $node): ?Node
+    {
+        if (! $node instanceof ClassConstFetch) {
+            return null;
+        }
+
+        // pass value metadata to class node
+        if (! $node->name instanceof Identifier) {
+            return null;
+        }
+
+        $node->class->setAttribute(AttributeKey::CLASS_CONST_FETCH_NAME, $node->name->toString());
+
+        return null;
+    }
+}