Updated Rector to commit 3893ea422afa3fb801ae64fa546c8a2cb24b0f97

rectorphp/rector-src@3893ea4 [reporting] Group unused skips by rule, skip reporting on narrowed runs (#8069)

Author: TomasVotruba

src/Application/VersionResolver.php

@@ -19,12 +19,12 @@ final class VersionResolver
      * @api
      * @var string
      */
-    public const PACKAGE_VERSION = '580b374ea3638fd50cf9b98b84445cd9fe53768e';
+    public const PACKAGE_VERSION = '3893ea422afa3fb801ae64fa546c8a2cb24b0f97';
     /**
      * @api
      * @var string
      */
-    public const RELEASE_DATE = '2026-06-21 00:26:52';
+    public const RELEASE_DATE = '2026-06-21 00:55:12';
     /**
      * @var int
      */

src/Configuration/ConfigurationFactory.php

@@ -53,6 +53,11 @@ public function createFromInput(InputInterface $input): Configuration
             $onlyRule = $this->onlyRuleResolver->resolve($onlyRule);
         }
         $onlySuffix = $input->getOption(\Rector\Configuration\Option::ONLY_SUFFIX);
+        // "--only"/"--only-suffix" narrow the run, so skips outside the scope look falsely unused;
+        // mark the run as narrowed to disable unused skip reporting and avoid false positives
+        if ($onlyRule !== null || $onlySuffix !== null) {
+            SimpleParameterProvider::setParameter(\Rector\Configuration\Option::IS_RUN_NARROWED, \true);
+        }
         $isParallel = SimpleParameterProvider::provideBoolParameter(\Rector\Configuration\Option::PARALLEL);
         $parallelPort = (string) $input->getOption(\Rector\Configuration\Option::PARALLEL_PORT);
         $parallelIdentifier = (string) $input->getOption(\Rector\Configuration\Option::PARALLEL_IDENTIFIER);
@@ -95,6 +100,8 @@ private function resolvePaths(InputInterface $input): array
         $commandLinePaths = (array) $input->getArgument(\Rector\Configuration\Option::SOURCE);
         // give priority to command line
         if ($commandLinePaths !== []) {
+            // mark the run as narrowed, so unused skip reporting can be disabled to avoid false positives
+            SimpleParameterProvider::setParameter(\Rector\Configuration\Option::IS_RUN_NARROWED, \true);
             $this->setFilesWithoutExtensionParameter($commandLinePaths);
             return $commandLinePaths;
         }

src/Configuration/Option.php

@@ -123,6 +123,15 @@ final class Option
      * @var string
      */
     public const REPORT_UNUSED_SKIPS = 'report_unused_skips';
+    /**
+     * True when the run is narrowed on the command line - via paths argument, "--only" or
+     * "--only-suffix". Unused skip reporting is then disabled, as skips outside the narrowed scope
+     * look falsely unused and would produce many false positives.
+     *
+     * @internal
+     * @var string
+     */
+    public const IS_RUN_NARROWED = 'is_run_narrowed';
     /**
      * @internal Use RectorConfig::fileExtensions() instead
      * @var string

src/Reporting/UnusedSkipResolver.php

@@ -34,9 +34,9 @@ public function __construct(SkippedClassResolver $skippedClassResolver, SkippedP
     }
     /**
      * Resolves skips configured via "->withSkip()" that never matched any element during the run.
-     * Rule-scoped skips are returned as "rule => path" so the user knows exactly what to remove;
-     * global skips are returned as a plain path. Returns an empty array unless
-     * "->reportUnusedSkips()" is enabled.
+     * Rule-scoped skips are grouped under their rule ("rule => path", or "rule => [ path\n path ]"
+     * for multiple paths) so the user knows exactly what to remove; global skips are returned as a
+     * plain path. Returns an empty array unless "->reportUnusedSkips()" is enabled.
      *
      * @return string[]
      */
@@ -45,32 +45,55 @@ public function resolve(ProcessResult $processResult): array
         if (!SimpleParameterProvider::provideBoolParameter(Option::REPORT_UNUSED_SKIPS, \false)) {
             return [];
         }
-        // map of trackable skip path => human-readable display; skips are tracked at runtime by
-        // their path, but rule-scoped ones are printed as "rule => path" so the user knows exactly
-        // what to remove. Skip-everywhere rule skips (null path) are forgotten from the container
-        // at boot, so they never reach the skipper and cannot be tracked.
-        $skipDisplaysByPath = [];
+        // a narrowed run (cli paths, "--only" or "--only-suffix") only touches part of the codebase,
+        // so skips outside that scope look falsely unused - reporting them would be noise
+        if (SimpleParameterProvider::provideBoolParameter(Option::IS_RUN_NARROWED, \false)) {
+            return [];
+        }
+        // map of rule => (trackable skip path => relative display path); skips are tracked at
+        // runtime by their path, but rule-scoped ones are printed grouped under their rule so the
+        // user knows exactly what to remove. Skip-everywhere rule skips (null path) are forgotten
+        // from the container at boot, so they never reach the skipper and cannot be tracked.
+        $relativePathsByClass = [];
         foreach ($this->skippedClassResolver->resolve() as $rectorClass => $paths) {
             if ($paths === null) {
                 continue;
             }
             // rule-scoped paths are intentional, so they are reported even as mask paths
             foreach ($paths as $path) {
-                $skipDisplaysByPath[$path] = $rectorClass . ' => ' . $this->filePathHelper->relativePath($path);
+                $relativePathsByClass[$rectorClass][$path] = $this->filePathHelper->relativePath($path);
             }
         }
         // global mask paths like "*/some/*" are hard to spot and report false positives, skip them
+        $globalRelativePaths = [];
         foreach ($this->skippedPathsResolver->resolve() as $globalPath) {
             if (strpos($globalPath, '*') !== \false) {
                 continue;
             }
-            $skipDisplaysByPath[$globalPath] = $this->filePathHelper->relativePath($globalPath);
+            $globalRelativePaths[$globalPath] = $this->filePathHelper->relativePath($globalPath);
         }
         $usedSkips = $processResult->getUsedSkips();
         $unusedSkips = [];
-        foreach ($skipDisplaysByPath as $path => $skipDisplay) {
+        // group unused rule-scoped paths under their rule, matching the "->withSkip()" config shape
+        foreach ($relativePathsByClass as $rectorClass => $relativePaths) {
+            $unusedRelativePaths = [];
+            foreach ($relativePaths as $path => $relativePath) {
+                if (!in_array($path, $usedSkips, \true)) {
+                    $unusedRelativePaths[] = $relativePath;
+                }
+            }
+            if ($unusedRelativePaths === []) {
+                continue;
+            }
+            if (count($unusedRelativePaths) === 1) {
+                $unusedSkips[] = $rectorClass . ' => ' . $unusedRelativePaths[0];
+                continue;
+            }
+            $unusedSkips[] = $rectorClass . ' => [ ' . implode("\n    ", $unusedRelativePaths) . ' ]';
+        }
+        foreach ($globalRelativePaths as $path => $relativePath) {
             if (!in_array($path, $usedSkips, \true)) {
-                $unusedSkips[] = $skipDisplay;
+                $unusedSkips[] = $relativePath;
             }
         }
         return $unusedSkips;