[Performance] Call cached class names collection on FamilyRelationsAnalyzer

rules/DeadCode/PhpDoc/TagRemover/ParamTagRemover.php

@@ -4,11 +4,11 @@
 
 namespace Rector\DeadCode\PhpDoc\TagRemover;
 
-use PHPStan\Type\Type;
 use PhpParser\Node\FunctionLike;
 use PHPStan\PhpDocParser\Ast\Node;
 use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
 use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
+use PHPStan\Type\Type;
 use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfo;
 use Rector\Comments\NodeDocBlock\DocBlockUpdater;
 use Rector\DeadCode\PhpDoc\DeadParamTagValueNodeAnalyzer;
@@ -22,8 +22,11 @@ public function __construct(
     ) {
     }
 
-    public function removeParamTagsIfUseless(PhpDocInfo $phpDocInfo, FunctionLike $functionLike, ?Type $type = null): bool
-    {
+    public function removeParamTagsIfUseless(
+        PhpDocInfo $phpDocInfo,
+        FunctionLike $functionLike,
+        ?Type $type = null
+    ): bool {
         $hasChanged = false;
 
         $phpDocNodeTraverser = new PhpDocNodeTraverser();

src/DependencyInjection/LazyContainerFactory.php

@@ -471,7 +471,6 @@ static function (Container $container): DynamicSourceLocatorProvider {
             DynamicSourceLocatorProvider::class,
             static function (DynamicSourceLocatorProvider $dynamicSourceLocatorProvider, Container $container): void {
                 $dynamicSourceLocatorProvider->autowire(
-                    $container->make(ReflectionProvider::class),
                     $container->make(Cache::class),
                     $container->make(FileHasher::class)
                 );

src/FamilyTree/Reflection/FamilyRelationsAnalyzer.php

@@ -7,17 +7,24 @@
 use PhpParser\Node\Name;
 use PhpParser\Node\Stmt\Class_;
 use PhpParser\Node\Stmt\Interface_;
+use PHPStan\Broker\ClassNotFoundException;
 use PHPStan\Reflection\ClassReflection;
 use PHPStan\Reflection\ReflectionProvider;
+use Rector\Caching\Cache;
+use Rector\Caching\Enum\CacheKey;
 use Rector\NodeNameResolver\NodeNameResolver;
+use Rector\NodeTypeResolver\Reflection\BetterReflection\SourceLocatorProvider\DynamicSourceLocatorProvider;
 use Rector\Util\Reflection\PrivatesAccessor;
 
-final readonly class FamilyRelationsAnalyzer
+final class FamilyRelationsAnalyzer
 {
     public function __construct(
-        private ReflectionProvider $reflectionProvider,
-        private NodeNameResolver $nodeNameResolver,
-        private PrivatesAccessor $privatesAccessor
+        private readonly ReflectionProvider $reflectionProvider,
+        private readonly NodeNameResolver $nodeNameResolver,
+        private readonly PrivatesAccessor $privatesAccessor,
+        private readonly DynamicSourceLocatorProvider $dynamicSourceLocatorProvider,
+        private readonly Cache $cache,
+        private bool $hasClassNamesCachedOrLoadOneLocator = false
     ) {
     }
 
@@ -30,6 +37,8 @@ public function getChildrenOfClassReflection(ClassReflection $desiredClassReflec
             return [];
         }
 
+        $this->loadClasses();
+
         /** @var ClassReflection[] $classReflections */
         $classReflections = $this->privatesAccessor->getPrivateProperty($this->reflectionProvider, 'classes');
         $childrenClassReflections = [];
@@ -90,4 +99,28 @@ public function getClassLikeAncestorNames(Class_ | Interface_ | Name $classOrNam
         /** @var string[] $ancestorNames */
         return $ancestorNames;
     }
+
+    private function loadClasses(): void
+    {
+        if ($this->hasClassNamesCachedOrLoadOneLocator) {
+            return;
+        }
+
+        $key = CacheKey::CLASSNAMES_HASH_KEY . '_' . $this->dynamicSourceLocatorProvider->getCacheClassNameKey();
+        $classNamesCache = $this->cache->load($key, CacheKey::CLASSNAMES_HASH_KEY);
+
+        if (is_string($classNamesCache)) {
+            $classNamesCache = json_decode($classNamesCache);
+            if (is_array($classNamesCache)) {
+                foreach ($classNamesCache as $classNameCache) {
+                    try {
+                        $this->reflectionProvider->getClass($classNameCache);
+                    } catch (ClassNotFoundException) {
+                    }
+                }
+            }
+        }
+
+        $this->hasClassNamesCachedOrLoadOneLocator = true;
+    }
 }

src/NodeTypeResolver/Reflection/BetterReflection/SourceLocatorProvider/DynamicSourceLocatorProvider.php

@@ -7,13 +7,11 @@
 use PHPStan\BetterReflection\Reflector\DefaultReflector;
 use PHPStan\BetterReflection\SourceLocator\Type\AggregateSourceLocator;
 use PHPStan\BetterReflection\SourceLocator\Type\SourceLocator;
-use PHPStan\Broker\ClassNotFoundException;
 use PHPStan\File\CouldNotReadFileException;
 use PHPStan\Reflection\BetterReflection\SourceLocator\FileNodesFetcher;
 use PHPStan\Reflection\BetterReflection\SourceLocator\NewOptimizedDirectorySourceLocator;
 use PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedDirectorySourceLocatorFactory;
 use PHPStan\Reflection\BetterReflection\SourceLocator\OptimizedSingleFileSourceLocator;
-use PHPStan\Reflection\ReflectionProvider;
 use Rector\Caching\Cache;
 use Rector\Caching\Enum\CacheKey;
 use Rector\Contract\DependencyInjection\ResetableInterface;
@@ -37,8 +35,6 @@ final class DynamicSourceLocatorProvider implements ResetableInterface
 
     private ?AggregateSourceLocator $aggregateSourceLocator = null;
 
-    private ReflectionProvider $reflectionProvider;
-
     private Cache $cache;
 
     private FileHasher $fileHasher;
@@ -49,13 +45,8 @@ public function __construct(
     ) {
     }
 
-    public function autowire(
-        ReflectionProvider $reflectionProvider,
-        Cache $cache,
-        FileHasher $fileHasher
-    ): void
+    public function autowire(Cache $cache, FileHasher $fileHasher): void
     {
-        $this->reflectionProvider = $reflectionProvider;
         $this->cache = $cache;
         $this->fileHasher = $fileHasher;
     }
@@ -138,19 +129,6 @@ public function reset(): void
         $this->aggregateSourceLocator = null;
     }
 
-    /**
-     * @param class-string[] $classNamesCache
-     */
-    private function locateCachedClassNames(array $classNamesCache): void
-    {
-        foreach ($classNamesCache as $classNameCache) {
-            try {
-                $this->reflectionProvider->getClass($classNameCache);
-            } catch (ClassNotFoundException) {
-            }
-        }
-    }
-
     /**
      * @param OptimizedSingleFileSourceLocator[]|NewOptimizedDirectorySourceLocator[] $sourceLocators
      */
@@ -169,11 +147,7 @@ private function collectClasses(AggregateSourceLocator $aggregateSourceLocator,
         $classNamesCache = $this->cache->load($key, CacheKey::CLASSNAMES_HASH_KEY);
 
         if (is_string($classNamesCache)) {
-            $classNamesCache = json_decode($classNamesCache);
-            if (is_array($classNamesCache)) {
-                $this->locateCachedClassNames($classNamesCache);
-                return;
-            }
+            return;
         }
 
         $reflector = new DefaultReflector($aggregateSourceLocator);
@@ -183,16 +157,7 @@ private function collectClasses(AggregateSourceLocator $aggregateSourceLocator,
         try {
             $reflections = $reflector->reflectAllClasses();
             foreach ($reflections as $reflection) {
-                $className = $reflection->getName();
-
-                // make 'classes' collection
-                try {
-                    $this->reflectionProvider->getClass($className);
-                } catch (ClassNotFoundException) {
-                    continue;
-                }
-
-                $classNames[] = $className;
+                $classNames[] = $reflection->getName();
             }
         } catch (CouldNotReadFileException) {
         }

src/NodeTypeResolver/TypeAnalyzer/ArrayTypeAnalyzer.php

@@ -17,6 +17,7 @@ public function __construct(
     public function isArrayType(Expr $expr): bool
     {
         $nodeType = $this->nodeTypeResolver->getNativeType($expr);
-        return $nodeType->isArray()->yes();
+        return $nodeType->isArray()
+            ->yes();
     }
 }

src/VendorLocker/NodeVendorLocker/ClassMethodReturnTypeOverrideGuard.php

@@ -88,7 +88,7 @@ private function hasChildrenDifferentTypeClassMethod(
     ): bool {
         $methodName = $classMethod->name->toString();
         foreach ($childrenClassReflections as $childClassReflection) {
-            if (!$childClassReflection->hasNativeMethod($methodName)) {
+            if (! $childClassReflection->hasNativeMethod($methodName)) {
                 continue;
             }