[DowngradePhp83] Add DowngradeReadonlyAnonymousClassRector

config/set/downgrade-php83.php

@@ -3,12 +3,14 @@
 declare(strict_types=1);
 
 use Rector\Config\RectorConfig;
+use Rector\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector;
 use Rector\ValueObject\PhpVersion;
 use Rector\DowngradePhp83\Rector\ClassConst\DowngradeTypedClassConstRector;
 
 return static function (RectorConfig $rectorConfig): void {
     $rectorConfig->phpVersion(PhpVersion::PHP_82);
     $rectorConfig->rules([
         DowngradeTypedClassConstRector::class,
+        DowngradeReadonlyAnonymousClassRector::class,
     ]);
 };

rules-tests/DowngradePhp82/Rector/Class_/DowngradeReadonlyClassRector/Fixture/skip_anonymous_class.php.inc

@@ -0,0 +1,13 @@
+<?php
+
+namespace Rector\Tests\DowngradePhp82\Rector\Class_\DowngradeReadonlyClassRector\Fixture;
+
+final class SkipAnonymousClass
+{
+    public function run()
+    {
+        new readonly class {
+            public string $foo = 'bar';
+        };
+    }
+}

rules-tests/DowngradePhp83/Rector/Class_/DowngradeReadonlyAnonymousClassRector/DowngradeReadonlyAnonymousClassRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class DowngradeReadonlyAnonymousClassRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

rules-tests/DowngradePhp83/Rector/Class_/DowngradeReadonlyAnonymousClassRector/Fixture/fixture.php.inc

@@ -0,0 +1,31 @@
+<?php
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector\Fixture;
+
+final class Fixture
+{
+    public function run()
+    {
+        new readonly class {
+            public string $foo = 'bar';
+        };
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector\Fixture;
+
+final class Fixture
+{
+    public function run()
+    {
+        new class {
+            public readonly string $foo = 'bar';
+        };
+    }
+}
+
+?>

rules-tests/DowngradePhp83/Rector/Class_/DowngradeReadonlyAnonymousClassRector/Fixture/skip_named_class.php.inc

@@ -0,0 +1,9 @@
+<?php
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector\Fixture;
+
+final readonly class SkipNamedClass
+{
+    public string $foo;
+}
+

rules-tests/DowngradePhp83/Rector/Class_/DowngradeReadonlyAnonymousClassRector/Fixture/with_parentheses.php.inc

@@ -0,0 +1,31 @@
+<?php
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector\Fixture;
+
+final class WithParentheses
+{
+    public function run()
+    {
+        (new readonly class {
+            public string $foo = 'bar';
+        });
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector\Fixture;
+
+final class WithParentheses
+{
+    public function run()
+    {
+        (new class {
+            public readonly string $foo = 'bar';
+        });
+    }
+}
+
+?>

rules-tests/DowngradePhp83/Rector/Class_/DowngradeReadonlyAnonymousClassRector/config/configured_rule.php

@@ -0,0 +1,10 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\DowngradePhp83\Rector\Class_\DowngradeReadonlyAnonymousClassRector;
+
+return static function (RectorConfig $rectorConfig): void {
+    $rectorConfig->rule(DowngradeReadonlyAnonymousClassRector::class);
+};

rules/DowngradePhp82/NodeManipulator/DowngradeReadonlyClassManipulator.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\DowngradePhp82\NodeManipulator;
+
+use PhpParser\Node\Stmt\Class_;
+use PhpParser\Node\Stmt\ClassMethod;
+use Rector\Privatization\NodeManipulator\VisibilityManipulator;
+use Rector\ValueObject\MethodName;
+
+final readonly class DowngradeReadonlyClassManipulator
+{
+    public function __construct(
+        private VisibilityManipulator $visibilityManipulator
+    ) {
+
+    }
+
+    public function process(Class_ $class): ?Class_
+    {
+        if (! $this->visibilityManipulator->isReadonly($class)) {
+            return null;
+        }
+
+        $this->visibilityManipulator->removeReadonly($class);
+        $this->makePropertiesReadonly($class);
+        $this->makePromotedPropertiesReadonly($class);
+
+        return $class;
+    }
+
+    private function makePropertiesReadonly(Class_ $class): void
+    {
+        foreach ($class->getProperties() as $property) {
+            if ($property->isReadonly()) {
+                continue;
+            }
+
+            /**
+             * It technically impossible that readonly class has:
+             *
+             *  - non-typed property
+             *  - static property
+             *
+             * but here to ensure no flip-flop when using direct rule for multiple rules applied
+             */
+            if ($property->type === null) {
+                continue;
+            }
+
+            if ($property->isStatic()) {
+                continue;
+            }
+
+            $this->visibilityManipulator->makeReadonly($property);
+        }
+    }
+
+    private function makePromotedPropertiesReadonly(Class_ $class): void
+    {
+        $classMethod = $class->getMethod(MethodName::CONSTRUCT);
+        if (! $classMethod instanceof ClassMethod) {
+            return;
+        }
+
+        foreach ($classMethod->getParams() as $param) {
+            if ($this->visibilityManipulator->isReadonly($param)) {
+                continue;
+            }
+
+            /**
+             * not property promotion, just param
+             */
+            if ($param->flags === 0) {
+                continue;
+            }
+
+            /**
+             * also not typed, just param
+             */
+            if ($param->type === null) {
+                continue;
+            }
+
+            $this->visibilityManipulator->makeReadonly($param);
+        }
+    }
+}

rules/DowngradePhp82/Rector/Class_/DowngradeReadonlyClassRector.php

@@ -6,10 +6,8 @@
 
 use PhpParser\Node;
 use PhpParser\Node\Stmt\Class_;
-use PhpParser\Node\Stmt\ClassMethod;
-use Rector\Privatization\NodeManipulator\VisibilityManipulator;
+use Rector\DowngradePhp82\NodeManipulator\DowngradeReadonlyClassManipulator;
 use Rector\Rector\AbstractRector;
-use Rector\ValueObject\MethodName;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
@@ -21,7 +19,7 @@
 final class DowngradeReadonlyClassRector extends AbstractRector
 {
     public function __construct(
-        private readonly VisibilityManipulator $visibilityManipulator
+        private readonly DowngradeReadonlyClassManipulator $downgradeReadonlyClassManipulator
     ) {
     }
 
@@ -72,71 +70,10 @@ public function __construct()
      */
     public function refactor(Node $node): ?Node
     {
-        if (! $this->visibilityManipulator->isReadonly($node)) {
+        if ($node->isAnonymous()) {
             return null;
         }
 
-        $this->visibilityManipulator->removeReadonly($node);
-        $this->makePropertiesReadonly($node);
-        $this->makePromotedPropertiesReadonly($node);
-
-        return $node;
-    }
-
-    private function makePropertiesReadonly(Class_ $class): void
-    {
-        foreach ($class->getProperties() as $property) {
-            if ($property->isReadonly()) {
-                continue;
-            }
-
-            /**
-             * It technically impossible that readonly class has:
-             *
-             *  - non-typed property
-             *  - static property
-             *
-             * but here to ensure no flip-flop when using direct rule for multiple rules applied
-             */
-            if ($property->type === null) {
-                continue;
-            }
-
-            if ($property->isStatic()) {
-                continue;
-            }
-
-            $this->visibilityManipulator->makeReadonly($property);
-        }
-    }
-
-    private function makePromotedPropertiesReadonly(Class_ $class): void
-    {
-        $classMethod = $class->getMethod(MethodName::CONSTRUCT);
-        if (! $classMethod instanceof ClassMethod) {
-            return;
-        }
-
-        foreach ($classMethod->getParams() as $param) {
-            if ($this->visibilityManipulator->isReadonly($param)) {
-                continue;
-            }
-
-            /**
-             * not property promotion, just param
-             */
-            if ($param->flags === 0) {
-                continue;
-            }
-
-            /**
-             * also not typed, just param
-             */
-            if ($param->type === null) {
-                continue;
-            }
-
-            $this->visibilityManipulator->makeReadonly($param);
-        }
+        return $this->downgradeReadonlyClassManipulator->process($node);
     }
 }