Collapse per-version PHP sets into single php-version-based.php, drop PhpLevelSetResolver

withPhpSets() and withPhpLevel() now load one config/set/php-version-based.php
set that lists every PHP version rule. The runtime PhpVersionedFilter already
gates each rule by MinPhpVersionInterface, so cumulative per-version file
selection is redundant - PhpLevelSetResolver is removed.

An explicitly picked withPhpSets(phpXX: true) version still caps the set: the
ceiling now applies to all rules in PhpVersionedFilter (previously only to
polyfilled ones, the rest were capped by file selection), preserving behavior.

Claude-Session: https://claude.ai/code/session_014Q25TQ4b7b13UQQXScu3Fg

Author: TomasVotruba

config/set/php-version-based.php

@@ -0,0 +1,29 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+
+// all PHP version rules, oldest to newest; each rule gates itself at runtime
+// via MinPhpVersionInterface, so only rules up to the target PHP version apply
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->sets([
+        __DIR__ . '/php52.php',
+        __DIR__ . '/php53.php',
+        __DIR__ . '/php54.php',
+        __DIR__ . '/php55.php',
+        __DIR__ . '/php56.php',
+        __DIR__ . '/php70.php',
+        __DIR__ . '/php71.php',
+        __DIR__ . '/php72.php',
+        __DIR__ . '/php73.php',
+        __DIR__ . '/php74.php',
+        __DIR__ . '/php80.php',
+        __DIR__ . '/php81.php',
+        __DIR__ . '/php82.php',
+        __DIR__ . '/php83.php',
+        __DIR__ . '/php84.php',
+        __DIR__ . '/php85.php',
+        __DIR__ . '/php86.php',
+    ]);
+};

phpstan.neon

@@ -76,13 +76,11 @@ parameters:
             message: '#EARLY_RETURN of class Rector\\Set\\ValueObject\\SetList#'
             path: src/Configuration/RectorConfigBuilder.php
 
-        # the deprecated SetList::PHP_* constants are still resolved internally, until withPhpSets()/withPhpLevel() replace them
+        # the deprecated SetList::PHP_* constants are still resolved internally by the level sets and their tests
         -
             identifier: classConstant.deprecated
             paths:
-                - src/Configuration/PhpLevelSetResolver.php
                 - config/set/level
-                - tests/Configuration/PhpLevelSetResolverTest.php
                 - tests/Bridge/SetRectorsResolverTest.php
 
         # the deprecated github/gitlab output formatters are still tested until removed in next minor version

src/Configuration/PhpLevelSetResolver.php

@@ -177,6 +177,11 @@ final class RectorConfigBuilder
 
     private ?string $editorUrl = null;
 
+    /**
+     * All PHP version rules in one set; each rule gates itself by PHP version at runtime
+     */
+    private const string PHP_VERSION_BASED_SET = __DIR__ . '/../../config/set/php-version-based.php';
+
     private ?bool $isWithPhpSetsUsed = null;
 
     private ?bool $isWithPhpLevelUsed = null;
@@ -562,15 +567,16 @@ public function withPhpSets(
             );
         }
 
-        // no version picked, resolve it from the project composer.json
+        // no version picked, target the project composer.json PHP version; validated here, gated at runtime
         if ($pickedPhpVersions === []) {
-            return $this->addPhpLevelSets(ComposerJsonPhpVersionResolver::resolveFromCwdOrFail());
+            ComposerJsonPhpVersionResolver::resolveFromCwdOrFail();
+            return $this->addPhpLevelSets();
         }
 
         // explicitly picked version is a ceiling, even for polyfilled rules
         $this->pickedPhpSetsVersion = $pickedPhpVersions[0];
 
-        return $this->addPhpLevelSets($pickedPhpVersions[0]);
+        return $this->addPhpLevelSets();
     }
 
     #[Deprecated(message: 'Use "withPhpLevel()" instead, it raises PHP level one rule at a time.')]
@@ -984,12 +990,10 @@ public function withPhpLevel(int $level): self
 
         $this->isWithPhpLevelUsed = true;
 
-        $phpVersion = ComposerJsonPhpVersionResolver::resolveFromCwdOrFail();
-
         $setRectorsResolver = new SetRectorsResolver();
-        $setFilePaths = PhpLevelSetResolver::resolveFromPhpVersion($phpVersion);
-
-        $rectorRulesWithConfiguration = $setRectorsResolver->resolveFromFilePathsIncludingConfiguration($setFilePaths);
+        $rectorRulesWithConfiguration = $setRectorsResolver->resolveFromFilePathIncludingConfiguration(
+            self::PHP_VERSION_BASED_SET
+        );
 
         foreach ($rectorRulesWithConfiguration as $position => $rectorRuleWithConfiguration) {
             // add rules until level is reached
@@ -1159,14 +1163,11 @@ public function withSetProviders(): self
         return $this;
     }
 
-    /**
-     * @param PhpVersion::* $phpVersion
-     */
-    private function addPhpLevelSets(int $phpVersion): self
+    private function addPhpLevelSets(): self
     {
         $this->isWithPhpSetsUsed = true;
 
-        $this->sets = array_merge($this->sets, PhpLevelSetResolver::resolveFromPhpVersion($phpVersion));
+        $this->sets[] = self::PHP_VERSION_BASED_SET;
 
         return $this;
     }

src/Configuration/RectorConfigBuilder.php

@@ -50,9 +50,15 @@ public function filter(array $rectors): array
                 continue;
             }
 
-            $maxPhpVersion = $rector instanceof RelatedPolyfillInterface && $ceilingPhpVersion !== null
-                ? $ceilingPhpVersion
-                : $minProjectPhpVersion;
+            // an explicitly picked withPhpSets() version caps the whole set:
+            // polyfilled rules up to the ceiling, the rest up to the lower of ceiling and project version
+            if ($ceilingPhpVersion !== null) {
+                $maxPhpVersion = $rector instanceof RelatedPolyfillInterface
+                    ? $ceilingPhpVersion
+                    : min($ceilingPhpVersion, $minProjectPhpVersion);
+            } else {
+                $maxPhpVersion = $minProjectPhpVersion;
+            }
 
             // does satisfy version? → include
             if ($rector->provideMinPhpVersion() <= $maxPhpVersion) {

src/VersionBonding/PhpVersionedFilter.php

@@ -6,11 +6,8 @@
 
 use PHPUnit\Framework\TestCase;
 use Rector\Bridge\SetRectorsResolver;
-use Rector\Configuration\PhpLevelSetResolver;
 use Rector\Contract\Rector\RectorInterface;
-use Rector\Php\PhpVersionResolver\ComposerJsonPhpVersionResolver;
 use Rector\Set\ValueObject\SetList;
-use Rector\ValueObject\PhpVersion;
 
 final class SetRectorsResolverTest extends TestCase
 {
@@ -21,31 +18,16 @@ protected function setUp(): void
         $this->setRectorsResolver = new SetRectorsResolver();
     }
 
-    public function testResolveFromFilePathForPhpVersion(): void
+    public function testResolvePhpVersionBasedSet(): void
     {
-        $configFilePaths = PhpLevelSetResolver::resolveFromPhpVersion(PhpVersion::PHP_70);
-        $this->assertCount(6, $configFilePaths);
-        $this->assertContainsOnlyString($configFilePaths);
-
-        foreach ($configFilePaths as $configFilePath) {
-            $this->assertFileExists($configFilePath);
-        }
-    }
-
-    public function testResolveFromFilePathForPhpLevel(): void
-    {
-        $projectPhpVersion = ComposerJsonPhpVersionResolver::resolve(__DIR__ . '/Fixture/some-composer.json');
-
-        $this->assertIsInt($projectPhpVersion);
-        $this->assertSame(PhpVersion::PHP_73, $projectPhpVersion);
-
-        $configFilePaths = PhpLevelSetResolver::resolveFromPhpVersion($projectPhpVersion);
-        $this->assertCount(9, $configFilePaths);
+        $phpVersionBasedSetFilePath = dirname(__DIR__, 2) . '/config/set/php-version-based.php';
 
         $rectorRulesWithConfiguration = $this->setRectorsResolver->resolveFromFilePathsIncludingConfiguration(
-            $configFilePaths
+            [$phpVersionBasedSetFilePath]
         );
-        $this->assertCount(63, $rectorRulesWithConfiguration);
+
+        $this->assertNotEmpty($rectorRulesWithConfiguration);
+        $this->assertContainsOnlyRules($rectorRulesWithConfiguration);
     }
 
     public function testResolveWithConfiguration(): void
@@ -58,6 +40,14 @@ public function testResolveWithConfiguration(): void
         $this->assertArrayHasKey(0, $rectorRulesWithConfiguration);
         $this->assertArrayHasKey(8, $rectorRulesWithConfiguration);
 
+        $this->assertContainsOnlyRules($rectorRulesWithConfiguration);
+    }
+
+    /**
+     * @param array<int, class-string<RectorInterface>|array<class-string<RectorInterface>, mixed[]>> $rectorRulesWithConfiguration
+     */
+    private function assertContainsOnlyRules(array $rectorRulesWithConfiguration): void
+    {
         foreach ($rectorRulesWithConfiguration as $rectorRuleWithConfiguration) {
             if (is_string($rectorRuleWithConfiguration)) {
                 $this->assertTrue(is_a($rectorRuleWithConfiguration, RectorInterface::class, true));