cleanup

packages/NodeCollector/NodeCollector/NodeRepository.php

@@ -98,11 +98,6 @@ final class NodeRepository
      */
     private $parsedPropertyFetchNodeCollector;
 
-    /**
-     * @var ParsedClassConstFetchNodeCollector
-     */
-    private $parsedClassConstFetchNodeCollector;
-
     /**
      * @var ParsedNodeCollector
      */
@@ -132,7 +127,6 @@ public function __construct(
         ArrayCallableMethodReferenceAnalyzer $arrayCallableMethodReferenceAnalyzer,
         ParsedPropertyFetchNodeCollector $parsedPropertyFetchNodeCollector,
         NodeNameResolver $nodeNameResolver,
-        ParsedClassConstFetchNodeCollector $parsedClassConstFetchNodeCollector,
         ParsedNodeCollector $parsedNodeCollector,
         TypeUnwrapper $typeUnwrapper,
         ReflectionProvider $reflectionProvider,
@@ -141,7 +135,6 @@ public function __construct(
         $this->nodeNameResolver = $nodeNameResolver;
         $this->arrayCallableMethodReferenceAnalyzer = $arrayCallableMethodReferenceAnalyzer;
         $this->parsedPropertyFetchNodeCollector = $parsedPropertyFetchNodeCollector;
-        $this->parsedClassConstFetchNodeCollector = $parsedClassConstFetchNodeCollector;
         $this->parsedNodeCollector = $parsedNodeCollector;
         $this->typeUnwrapper = $typeUnwrapper;
         $this->reflectionProvider = $reflectionProvider;
@@ -360,52 +353,6 @@ public function findCallsByClassMethod(ClassMethod $classMethod): array
         return $this->findCallsByClassAndMethod($class, $method);
     }
 
-    /**
-     * @return ClassReflection[]
-     */
-    public function findDirectClassConstantFetches(ClassReflection $classReflection, string $desiredConstantName): array
-    {
-        $classConstantFetchByClassAndName = $this->parsedClassConstFetchNodeCollector->getClassConstantFetchByClassAndName();
-        $classTypes = $classConstantFetchByClassAndName[$classReflection->getName()][$desiredConstantName] ?? [];
-
-        return $this->resolveClassReflectionsFromClassTypes($classTypes);
-    }
-
-    /**
-     * @return ClassReflection[]
-     */
-    public function findIndirectClassConstantFetches(
-        ClassReflection $classReflection,
-        string $desiredConstantName
-    ): array {
-        $classConstantFetchByClassAndName = $this->parsedClassConstFetchNodeCollector->getClassConstantFetchByClassAndName();
-
-        foreach ($classConstantFetchByClassAndName as $className => $classesByConstantName) {
-            if (! $this->reflectionProvider->hasClass($className)) {
-                return [];
-            }
-
-            $currentClassReflection = $this->reflectionProvider->getClass($className);
-            if (! isset($classesByConstantName[$desiredConstantName])) {
-                continue;
-            }
-
-            if (! $classReflection->isSubclassOf($currentClassReflection->getName()) &&
-                ! $currentClassReflection->isSubclassOf($classReflection->getName())) {
-                continue;
-            }
-
-            // include child usages and parent usages
-            if ($currentClassReflection->getName() === $classReflection->getName()) {
-                continue;
-            }
-
-            return $this->resolveClassReflectionsFromClassTypes($classesByConstantName[$desiredConstantName]);
-        }
-
-        return [];
-    }
-
     public function hasClassChildren(Class_ $desiredClass): bool
     {
         $desiredClassName = $desiredClass->getAttribute(AttributeKey::CLASS_NAME);

packages/NodeCollector/NodeVisitor/NodeCollectorNodeVisitor.php

@@ -7,7 +7,6 @@
 use PhpParser\Node;
 use PhpParser\NodeVisitorAbstract;
 use Rector\NodeCollector\NodeCollector\NodeRepository;
-use Rector\NodeCollector\NodeCollector\ParsedClassConstFetchNodeCollector;
 use Rector\NodeCollector\NodeCollector\ParsedNodeCollector;
 use Rector\NodeCollector\NodeCollector\ParsedPropertyFetchNodeCollector;
 
@@ -28,21 +27,14 @@ final class NodeCollectorNodeVisitor extends NodeVisitorAbstract
      */
     private $parsedPropertyFetchNodeCollector;
 
-    /**
-     * @var ParsedClassConstFetchNodeCollector
-     */
-    private $parsedClassConstFetchNodeCollector;
-
     public function __construct(
-        ParsedClassConstFetchNodeCollector $parsedClassConstFetchNodeCollector,
         NodeRepository $nodeRepository,
         ParsedNodeCollector $parsedNodeCollector,
         ParsedPropertyFetchNodeCollector $parsedPropertyFetchNodeCollector
     ) {
         $this->nodeRepository = $nodeRepository;
         $this->parsedNodeCollector = $parsedNodeCollector;
         $this->parsedPropertyFetchNodeCollector = $parsedPropertyFetchNodeCollector;
-        $this->parsedClassConstFetchNodeCollector = $parsedClassConstFetchNodeCollector;
     }
 
     public function enterNode(Node $node)
@@ -53,7 +45,6 @@ public function enterNode(Node $node)
 
         $this->nodeRepository->collect($node);
         $this->parsedPropertyFetchNodeCollector->collect($node);
-        $this->parsedClassConstFetchNodeCollector->collect($node);
 
         return null;
     }

rules-tests/DeadCode/Rector/ClassConst/RemoveUnusedPrivateClassConstantRector/Fixture/skip_used_constant.php.inc

@@ -0,0 +1,13 @@
+<?php
+
+namespace Rector\Tests\DeadCode\Rector\ClassConst\RemoveUnusedPrivateClassConstantRector\Fixture;
+
+final class SkipUsedConstant
+{
+    private const SOME_CONST = 'dead';
+
+    public function run()
+    {
+        return self::SOME_CONST;
+    }
+}

rules/DeadCode/Rector/ClassConst/RemoveUnusedPrivateClassConstantRector.php

@@ -10,6 +10,7 @@
 use PhpParser\Node\Stmt\ClassLike;
 use PHPStan\Analyser\Scope;
 use PHPStan\Reflection\ClassReflection;
+use PHPStan\Type\ObjectType;
 use Rector\BetterPhpDocParser\ValueObject\PhpDocNode\ApiPhpDocTagNode;
 use Rector\Core\NodeManipulator\ClassConstManipulator;
 use Rector\Core\Rector\AbstractRector;
@@ -91,13 +92,23 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
+        $classObjectType = new ObjectType($classReflection->getName());
+
+        /** @var ClassConstFetch[] $classConstFetches */
         $classConstFetches = $this->betterNodeFinder->findInstanceOf($classLike->stmts, ClassConstFetch::class);
         foreach ($classConstFetches as $classConstFetch) {
-            dump($classConstFetch);
-            dump($node);
+            if (! $this->nodeNameResolver->areNamesEqual($classConstFetch->name, $node->consts[0]->name)) {
+                continue;
+            }
+
+            $constFetchClassType = $this->nodeTypeResolver->resolve($classConstFetch->class);
+
+            // constant is used!
+            if ($constFetchClassType->isSuperTypeOf($classObjectType)->yes()) {
+                return null;
+            }
         }
 
-//
 //        $directUsingClassReflections = $this->nodeRepository->findDirectClassConstantFetches(
 //            $classReflection,
 //            $constant