[perf] Add static node-rule map for O(1) visitor lookup

.github/workflows/code_analysis.yaml

@@ -28,6 +28,10 @@ jobs:
                         name: 'Preload php-parser Order'
                         run: php preload.php
 
+                    -
+                        name: 'Node Rule Map Up To Date'
+                        run: php scripts/validate-node-rule-map.php
+
                     -
                         name: 'PHPStan'
                         run: vendor/bin/phpstan analyse --ansi

build/build-node-rule-map.php

@@ -0,0 +1,56 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Console\Style\SymfonyStyleFactory;
+use Rector\Scripts\Finder\RectorClassFinder;
+use Rector\Scripts\NodeRuleMap\NodeRuleMapFactory;
+use Rector\Util\Reflection\PrivatesAccessor;
+
+$possiblePaths = [
+    // rector-src
+    __DIR__ . '/../vendor/autoload.php',
+    // rector package dependency
+    __DIR__ . '/../../../../vendor/autoload.php',
+];
+
+foreach ($possiblePaths as $possiblePath) {
+    if (! file_exists($possiblePath)) {
+        continue;
+    }
+
+    require $possiblePath;
+    break;
+}
+
+$rootDirectory = __DIR__ . '/..';
+
+$symfonyStyleFactory = new SymfonyStyleFactory(new PrivatesAccessor());
+$symfonyStyle = $symfonyStyleFactory->create();
+
+// core rules + symfony/doctrine/phpunit extension packages
+$ruleDirectories = [
+    $rootDirectory . '/rules',
+    $rootDirectory . '/vendor/rector/rector-symfony/rules',
+    $rootDirectory . '/vendor/rector/rector-symfony/src',
+    $rootDirectory . '/vendor/rector/rector-doctrine/rules',
+    $rootDirectory . '/vendor/rector/rector-doctrine/src',
+    $rootDirectory . '/vendor/rector/rector-phpunit/rules',
+    $rootDirectory . '/vendor/rector/rector-phpunit/src',
+];
+
+$nodeDirectories = [
+    $rootDirectory . '/vendor/nikic/php-parser/lib/PhpParser/Node',
+    $rootDirectory . '/src/PhpParser/Node',
+];
+
+$nodeRuleMapFactory = new NodeRuleMapFactory(new RectorClassFinder());
+$nodeRuleMap = $nodeRuleMapFactory->create($ruleDirectories, $nodeDirectories);
+
+$json = json_encode($nodeRuleMap, JSON_PRETTY_PRINT | JSON_UNESCAPED_SLASHES) . "\n";
+file_put_contents($rootDirectory . '/config/node-rule-map.json', $json);
+
+$symfonyStyle->success(sprintf(
+    'Generated map for %d node classes into config/node-rule-map.json',
+    count($nodeRuleMap)
+));

composer.json

@@ -109,6 +109,7 @@
         "rector": "bin/rector process --ansi",
         "duplicated-code": "vendor/bin/swiss-knife duplicated-code src rules --min-tokens 150 --min-lines 5",
         "preload": "php build/build-preload.php .",
+        "build-node-rule-map": "php build/build-node-rule-map.php",
         "release": "vendor/bin/rng --from-commit X --to-commit Y --remote-repository rectorphp/rector-symfony --remote-repository rectorphp/rector-doctrine --remote-repository rectorphp/rector-phpunit"
     },
     "config": {

ecs.php

@@ -19,6 +19,7 @@
         __DIR__ . '/config',
         __DIR__ . '/scripts',
         __DIR__ . '/build/build-preload.php',
+        __DIR__ . '/build/build-node-rule-map.php',
     ])
     ->withSkip([
         '*/Source/*',

scripts/src/NodeRuleMap/NodeRuleMapFactory.php

@@ -0,0 +1,102 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Scripts\NodeRuleMap;
+
+use Nette\Loaders\RobotLoader;
+use PhpParser\Node;
+use Rector\Contract\Rector\RectorInterface;
+use Rector\Scripts\Finder\RectorClassFinder;
+use ReflectionClass;
+
+final readonly class NodeRuleMapFactory
+{
+    public function __construct(
+        private RectorClassFinder $rectorClassFinder
+    ) {
+    }
+
+    /**
+     * @param string[] $ruleDirectories
+     * @param string[] $nodeDirectories
+     * @return array<class-string<Node>, array<class-string<RectorInterface>>>
+     */
+    public function create(array $ruleDirectories, array $nodeDirectories): array
+    {
+        $nodeTypesByRectorClass = $this->resolveNodeTypesByRectorClass($ruleDirectories);
+        $nodeClasses = $this->resolveNodeClasses($nodeDirectories);
+
+        $nodeRuleMap = [];
+        foreach ($nodeClasses as $nodeClass) {
+            $matchedRectorClasses = [];
+            foreach ($nodeTypesByRectorClass as $rectorClass => $nodeTypes) {
+                foreach ($nodeTypes as $nodeType) {
+                    if (is_a($nodeClass, $nodeType, true)) {
+                        $matchedRectorClasses[] = $rectorClass;
+                        break;
+                    }
+                }
+            }
+
+            sort($matchedRectorClasses);
+            $nodeRuleMap[$nodeClass] = $matchedRectorClasses;
+        }
+
+        ksort($nodeRuleMap);
+
+        return $nodeRuleMap;
+    }
+
+    /**
+     * @param string[] $ruleDirectories
+     * @return array<class-string<RectorInterface>, array<class-string<Node>>>
+     */
+    private function resolveNodeTypesByRectorClass(array $ruleDirectories): array
+    {
+        $ruleDirectories = array_filter($ruleDirectories, is_dir(...));
+        $rectorClasses = $this->rectorClassFinder->find($ruleDirectories);
+
+        $nodeTypesByRectorClass = [];
+        foreach ($rectorClasses as $rectorClass) {
+            // skip PostRectors and other *Rector.php helpers
+            if (! is_a($rectorClass, RectorInterface::class, true)) {
+                continue;
+            }
+
+            $reflectionClass = new ReflectionClass($rectorClass);
+            $rector = $reflectionClass->newInstanceWithoutConstructor();
+
+            $nodeTypesByRectorClass[$rectorClass] = $rector->getNodeTypes();
+        }
+
+        return $nodeTypesByRectorClass;
+    }
+
+    /**
+     * @param string[] $nodeDirectories
+     * @return array<class-string<Node>>
+     */
+    private function resolveNodeClasses(array $nodeDirectories): array
+    {
+        $robotLoader = new RobotLoader();
+        $robotLoader->addDirectory(...$nodeDirectories);
+        $robotLoader->setCacheDirectory(sys_get_temp_dir() . '/rector-node-rule-map');
+        $robotLoader->refresh();
+
+        $nodeClasses = [];
+        foreach (array_keys($robotLoader->getIndexedClasses()) as $class) {
+            if (! is_a($class, Node::class, true)) {
+                continue;
+            }
+
+            if (! new ReflectionClass($class)->isInstantiable()) {
+                continue;
+            }
+
+            $nodeClasses[] = $class;
+        }
+
+        return $nodeClasses;
+    }
+}

scripts/validate-node-rule-map.php

@@ -0,0 +1,67 @@
+<?php
+
+declare(strict_types=1);
+
+use Nette\Utils\FileSystem;
+use Nette\Utils\Json;
+use Rector\Console\Style\SymfonyStyleFactory;
+use Rector\Scripts\Finder\RectorClassFinder;
+use Rector\Scripts\NodeRuleMap\NodeRuleMapFactory;
+use Rector\Util\Reflection\PrivatesAccessor;
+use Symfony\Component\Console\Command\Command;
+
+require __DIR__ . '/../vendor/autoload.php';
+
+$rootDirectory = __DIR__ . '/..';
+
+$symfonyStyleFactory = new SymfonyStyleFactory(new PrivatesAccessor());
+$symfonyStyle = $symfonyStyleFactory->create();
+
+// extension packages move independently (dev-main), so only the in-repo core rules are validated;
+// extension rules ship best-effort and the traverser falls back to is_a() resolution for any drift
+$siblingNamespacePrefixes = ['Rector\\Symfony\\', 'Rector\\Doctrine\\', 'Rector\\PHPUnit\\'];
+
+$nodeDirectories = [
+    $rootDirectory . '/vendor/nikic/php-parser/lib/PhpParser/Node',
+    $rootDirectory . '/src/PhpParser/Node',
+];
+
+$nodeRuleMapFactory = new NodeRuleMapFactory(new RectorClassFinder());
+$expectedCoreMap = $nodeRuleMapFactory->create([$rootDirectory . '/rules'], $nodeDirectories);
+
+$committedMap = Json::decode(FileSystem::read($rootDirectory . '/config/node-rule-map.json'), true);
+if (! is_array($committedMap)) {
+    $symfonyStyle->error('The committed config/node-rule-map.json is not valid.');
+    exit(Command::FAILURE);
+}
+
+// keep only core rules from the committed map
+$committedCoreMap = [];
+foreach ($committedMap as $nodeClass => $ruleClasses) {
+    $coreRuleClasses = array_filter($ruleClasses, static fn (string $ruleClass): bool => array_all($siblingNamespacePrefixes, fn (string $siblingNamespacePrefix): bool => ! str_starts_with($ruleClass, $siblingNamespacePrefix)));
+
+    $committedCoreMap[$nodeClass] = array_values($coreRuleClasses);
+}
+
+if (Json::encode($committedCoreMap) === Json::encode($expectedCoreMap)) {
+    $symfonyStyle->success('The core rules in config/node-rule-map.json are up to date.');
+    exit(Command::SUCCESS);
+}
+
+$symfonyStyle->error(
+    'The core rules in config/node-rule-map.json are out of date. Run "composer build-node-rule-map" and commit the result.'
+);
+
+// report the first differing node classes to make the fix obvious
+foreach ($expectedCoreMap as $nodeClass => $expectedRuleClasses) {
+    $committedRuleClasses = $committedCoreMap[$nodeClass] ?? [];
+    if ($committedRuleClasses === $expectedRuleClasses) {
+        continue;
+    }
+
+    $symfonyStyle->writeln('<comment>' . $nodeClass . '</comment>');
+    $symfonyStyle->writeln('  missing: ' . implode(', ', array_values(array_diff($expectedRuleClasses, $committedRuleClasses))));
+    $symfonyStyle->writeln('  unexpected: ' . implode(', ', array_values(array_diff($committedRuleClasses, $expectedRuleClasses))));
+}
+
+exit(Command::FAILURE);