make use of PHP 8.2 readonly classes

.github/workflows/e2e.yaml

@@ -22,7 +22,7 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                php_version: ['8.1']
+                php_version: ['8.2']
                 directory:
                     - 'e2e/applied-rule-change-docblock'
                     - 'e2e/applied-rule-return-array-nodes'

.github/workflows/e2e_consecutive_changes.yaml

@@ -21,7 +21,7 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                php_version: ['8.1']
+                php_version: ['8.2']
                 rector_disable_parallel: ['true', 'false']
                 directory:
                     - 'e2e/consecutive-changes-with-cache'

.github/workflows/e2e_with_cache.yaml

@@ -22,7 +22,7 @@ jobs:
         strategy:
             fail-fast: false
             matrix:
-                php_version: ['8.1']
+                php_version: ['8.2']
                 directory:
                     - 'e2e/applied-rule-removed-node-with-cache'
                     - 'e2e/timeout-file-not-cached'

.github/workflows/rector.yaml

@@ -29,7 +29,7 @@ jobs:
             -
                 uses: shivammathur/setup-php@v2
                 with:
-                    # PHP 8.1 is required, so Rector's code is PHP 8.1 compatible even after refactoring
+                    # PHP 8.2 is required, so Rector's code is PHP 8.2 compatible even after refactoring
                     php-version: 8.2
                     coverage: none
 

.github/workflows/tests.yaml

@@ -22,7 +22,7 @@ jobs:
         runs-on: ${{ matrix.os }}
         timeout-minutes: 3
 
-        name: PHP 8.1 tests
+        name: PHP 8.2 tests
         steps:
             -   uses: actions/checkout@v4
 

rules/CodeQuality/NodeAnalyzer/ForeachAnalyzer.php

@@ -11,10 +11,10 @@
 use PhpParser\Node\Stmt\Foreach_;
 use Rector\PhpParser\Comparing\NodeComparator;
 
-final class ForeachAnalyzer
+final readonly class ForeachAnalyzer
 {
     public function __construct(
-        private readonly NodeComparator $nodeComparator,
+        private NodeComparator $nodeComparator,
     ) {
     }
 

rules/Naming/Guard/PropertyConflictingNameGuard/MatchPropertyTypeConflictingNameGuard.php

@@ -10,12 +10,12 @@
 use Rector\Naming\ValueObject\PropertyRename;
 use Rector\NodeNameResolver\NodeNameResolver;
 
-final class MatchPropertyTypeConflictingNameGuard
+final readonly class MatchPropertyTypeConflictingNameGuard
 {
     public function __construct(
-        private readonly MatchPropertyTypeExpectedNameResolver $matchPropertyTypeExpectedNameResolver,
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly ArrayFilter $arrayFilter
+        private MatchPropertyTypeExpectedNameResolver $matchPropertyTypeExpectedNameResolver,
+        private NodeNameResolver $nodeNameResolver,
+        private ArrayFilter $arrayFilter
     ) {
     }
 

rules/Naming/Naming/PropertyNaming.php

@@ -23,7 +23,7 @@
 /**
  * @see \Rector\Tests\Naming\Naming\PropertyNamingTest
  */
-final class PropertyNaming
+final readonly class PropertyNaming
 {
     /**
      * @var string[]
@@ -55,8 +55,8 @@ final class PropertyNaming
     private const GET_PREFIX_REGEX = '#^get(?<root_name>[A-Z].+)#';
 
     public function __construct(
-        private readonly RectorNamingInflector $rectorNamingInflector,
-        private readonly NodeTypeResolver $nodeTypeResolver,
+        private RectorNamingInflector $rectorNamingInflector,
+        private NodeTypeResolver $nodeTypeResolver,
     ) {
     }
 

rules/Naming/VariableRenamer.php

@@ -18,13 +18,13 @@
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\PhpDocParser\NodeTraverser\SimpleCallableNodeTraverser;
 
-final class VariableRenamer
+final readonly class VariableRenamer
 {
     public function __construct(
-        private readonly SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly VarTagValueNodeRenamer $varTagValueNodeRenamer,
-        private readonly PhpDocInfoFactory $phpDocInfoFactory
+        private SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
+        private NodeNameResolver $nodeNameResolver,
+        private VarTagValueNodeRenamer $varTagValueNodeRenamer,
+        private PhpDocInfoFactory $phpDocInfoFactory
     ) {
     }
 
@@ -78,7 +78,7 @@ function (Node $node) use (
                 }
 
                 // TODO: Should be implemented in BreakingVariableRenameGuard::shouldSkipParam()
-                if ($this->isParamInParentFunction($node, $currentClosure)) {
+                if ($this->isParamInParentFunction()) {
                     return null;
                 }
 
@@ -98,23 +98,8 @@ function (Node $node) use (
         return $hasRenamed;
     }
 
-    private function isParamInParentFunction(Variable $variable, ?Closure $closure): bool
+    private function isParamInParentFunction(): bool
     {
-        if (! $closure instanceof Closure) {
-            return false;
-        }
-
-        $variableName = $this->nodeNameResolver->getName($variable);
-        if ($variableName === null) {
-            return false;
-        }
-
-        foreach ($closure->params as $param) {
-            if ($this->nodeNameResolver->isName($param, $variableName)) {
-                return true;
-            }
-        }
-
         return false;
     }
 

rules/Php72/NodeFactory/AnonymousFunctionFactory.php

@@ -45,7 +45,7 @@
 use Rector\PHPStanStaticTypeMapper\Enum\TypeKind;
 use Rector\StaticTypeMapper\StaticTypeMapper;
 
-final class AnonymousFunctionFactory
+final readonly class AnonymousFunctionFactory
 {
     /**
      * @var string
@@ -54,14 +54,14 @@ final class AnonymousFunctionFactory
     private const DIM_FETCH_REGEX = '#(\\$|\\\\|\\x0)(?<number>\d+)#';
 
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly BetterNodeFinder $betterNodeFinder,
-        private readonly NodeFactory $nodeFactory,
-        private readonly StaticTypeMapper $staticTypeMapper,
-        private readonly SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
-        private readonly SimplePhpParser $simplePhpParser,
-        private readonly AstResolver $astResolver,
-        private readonly InlineCodeParser $inlineCodeParser
+        private NodeNameResolver $nodeNameResolver,
+        private BetterNodeFinder $betterNodeFinder,
+        private NodeFactory $nodeFactory,
+        private StaticTypeMapper $staticTypeMapper,
+        private SimpleCallableNodeTraverser $simpleCallableNodeTraverser,
+        private SimplePhpParser $simplePhpParser,
+        private AstResolver $astResolver,
+        private InlineCodeParser $inlineCodeParser
     ) {
     }
 

rules/Php74/Guard/PropertyTypeChangeGuard.php

@@ -11,13 +11,13 @@
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\Privatization\Guard\ParentPropertyLookupGuard;
 
-final class PropertyTypeChangeGuard
+final readonly class PropertyTypeChangeGuard
 {
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly PropertyAnalyzer $propertyAnalyzer,
-        private readonly PropertyManipulator $propertyManipulator,
-        private readonly ParentPropertyLookupGuard $parentPropertyLookupGuard
+        private NodeNameResolver $nodeNameResolver,
+        private PropertyAnalyzer $propertyAnalyzer,
+        private PropertyManipulator $propertyManipulator,
+        private ParentPropertyLookupGuard $parentPropertyLookupGuard
     ) {
     }
 

rules/Php74/NodeAnalyzer/ClosureArrowFunctionAnalyzer.php

@@ -14,12 +14,12 @@
 use Rector\PhpParser\Node\BetterNodeFinder;
 use Rector\Util\ArrayChecker;
 
-final class ClosureArrowFunctionAnalyzer
+final readonly class ClosureArrowFunctionAnalyzer
 {
     public function __construct(
-        private readonly BetterNodeFinder $betterNodeFinder,
-        private readonly NodeComparator $nodeComparator,
-        private readonly ArrayChecker $arrayChecker
+        private BetterNodeFinder $betterNodeFinder,
+        private NodeComparator $nodeComparator,
+        private ArrayChecker $arrayChecker
     ) {
     }
 

rules/Php80/DocBlock/PropertyPromotionDocBlockMerger.php

@@ -18,15 +18,15 @@
 use Rector\NodeTypeResolver\Node\AttributeKey;
 use Rector\StaticTypeMapper\StaticTypeMapper;
 
-final class PropertyPromotionDocBlockMerger
+final readonly class PropertyPromotionDocBlockMerger
 {
     public function __construct(
-        private readonly PhpDocInfoFactory $phpDocInfoFactory,
-        private readonly StaticTypeMapper $staticTypeMapper,
-        private readonly PhpDocTypeChanger $phpDocTypeChanger,
-        private readonly VarTagRemover $varTagRemover,
-        private readonly PhpDocInfoPrinter $phpDocInfoPrinter,
-        private readonly DocBlockUpdater $docBlockUpdater,
+        private PhpDocInfoFactory $phpDocInfoFactory,
+        private StaticTypeMapper $staticTypeMapper,
+        private PhpDocTypeChanger $phpDocTypeChanger,
+        private VarTagRemover $varTagRemover,
+        private PhpDocInfoPrinter $phpDocInfoPrinter,
+        private DocBlockUpdater $docBlockUpdater,
     ) {
     }
 

rules/Php80/MatchAndRefactor/StrStartsWithMatchAndRefactor/StrncmpMatchAndRefactor.php

@@ -19,18 +19,18 @@
 use Rector\Php80\ValueObjectFactory\StrStartsWithFactory;
 use Rector\PhpParser\Comparing\NodeComparator;
 
-final class StrncmpMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
+final readonly class StrncmpMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
 {
     /**
      * @var string
      */
     private const FUNCTION_NAME = 'strncmp';
 
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly StrStartsWithFactory $strStartsWithFactory,
-        private readonly NodeComparator $nodeComparator,
-        private readonly StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
+        private NodeNameResolver $nodeNameResolver,
+        private StrStartsWithFactory $strStartsWithFactory,
+        private NodeComparator $nodeComparator,
+        private StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
     ) {
     }
 

rules/Php80/MatchAndRefactor/StrStartsWithMatchAndRefactor/StrposMatchAndRefactor.php

@@ -19,12 +19,12 @@
 use Rector\Php80\ValueObject\StrStartsWith;
 use Rector\PhpParser\Node\Value\ValueResolver;
 
-final class StrposMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
+final readonly class StrposMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
 {
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly ValueResolver $valueResolver,
-        private readonly StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
+        private NodeNameResolver $nodeNameResolver,
+        private ValueResolver $valueResolver,
+        private StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
     ) {
     }
 

rules/Php80/MatchAndRefactor/StrStartsWithMatchAndRefactor/SubstrMatchAndRefactor.php

@@ -19,13 +19,13 @@
 use Rector\PhpParser\Comparing\NodeComparator;
 use Rector\PhpParser\Node\Value\ValueResolver;
 
-final class SubstrMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
+final readonly class SubstrMatchAndRefactor implements StrStartWithMatchAndRefactorInterface
 {
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly ValueResolver $valueResolver,
-        private readonly NodeComparator $nodeComparator,
-        private readonly StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
+        private NodeNameResolver $nodeNameResolver,
+        private ValueResolver $valueResolver,
+        private NodeComparator $nodeComparator,
+        private StrStartsWithFuncCallFactory $strStartsWithFuncCallFactory,
     ) {
     }
 

rules/Php80/NodeAnalyzer/MatchSwitchAnalyzer.php

@@ -20,13 +20,13 @@
 use Rector\PhpParser\Comparing\NodeComparator;
 use Rector\PhpParser\Printer\BetterStandardPrinter;
 
-final class MatchSwitchAnalyzer
+final readonly class MatchSwitchAnalyzer
 {
     public function __construct(
-        private readonly SwitchAnalyzer $switchAnalyzer,
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly NodeComparator $nodeComparator,
-        private readonly BetterStandardPrinter $betterStandardPrinter
+        private SwitchAnalyzer $switchAnalyzer,
+        private NodeNameResolver $nodeNameResolver,
+        private NodeComparator $nodeComparator,
+        private BetterStandardPrinter $betterStandardPrinter
     ) {
     }
 

rules/Php80/NodeAnalyzer/PhpAttributeAnalyzer.php

@@ -18,11 +18,11 @@
 use Rector\NodeNameResolver\NodeNameResolver;
 use Rector\PhpAttribute\Enum\DocTagNodeState;
 
-final class PhpAttributeAnalyzer
+final readonly class PhpAttributeAnalyzer
 {
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly ReflectionProvider $reflectionProvider,
+        private NodeNameResolver $nodeNameResolver,
+        private ReflectionProvider $reflectionProvider,
     ) {
     }
 

rules/Php80/NodeAnalyzer/PromotedPropertyCandidateResolver.php

@@ -19,13 +19,13 @@
 use Rector\PhpParser\Comparing\NodeComparator;
 use Rector\PhpParser\Node\BetterNodeFinder;
 
-final class PromotedPropertyCandidateResolver
+final readonly class PromotedPropertyCandidateResolver
 {
     public function __construct(
-        private readonly NodeNameResolver $nodeNameResolver,
-        private readonly BetterNodeFinder $betterNodeFinder,
-        private readonly NodeComparator $nodeComparator,
-        private readonly PropertyFetchAnalyzer $propertyFetchAnalyzer
+        private NodeNameResolver $nodeNameResolver,
+        private BetterNodeFinder $betterNodeFinder,
+        private NodeComparator $nodeComparator,
+        private PropertyFetchAnalyzer $propertyFetchAnalyzer
     ) {
     }
 

rules/Php80/NodeAnalyzer/SwitchAnalyzer.php

@@ -14,11 +14,11 @@
 use Rector\NodeTypeResolver\NodeTypeResolver;
 use Rector\NodeTypeResolver\PHPStan\Type\TypeFactory;
 
-final class SwitchAnalyzer
+final readonly class SwitchAnalyzer
 {
     public function __construct(
-        private readonly NodeTypeResolver $nodeTypeResolver,
-        private readonly TypeFactory $typeFactory
+        private NodeTypeResolver $nodeTypeResolver,
+        private TypeFactory $typeFactory
     ) {
     }
 

rules/Php80/NodeFactory/AttrGroupsFactory.php

@@ -9,10 +9,10 @@
 use Rector\Php80\ValueObject\DoctrineTagAndAnnotationToAttribute;
 use Rector\PhpAttribute\NodeFactory\PhpAttributeGroupFactory;
 
-final class AttrGroupsFactory
+final readonly class AttrGroupsFactory
 {
     public function __construct(
-        private readonly PhpAttributeGroupFactory $phpAttributeGroupFactory
+        private PhpAttributeGroupFactory $phpAttributeGroupFactory
     ) {
     }
 

rules/Php80/NodeFactory/MatchFactory.php

@@ -18,12 +18,12 @@
 use Rector\Php80\ValueObject\MatchResult;
 use Rector\PhpParser\Comparing\NodeComparator;
 
-final class MatchFactory
+final readonly class MatchFactory
 {
     public function __construct(
-        private readonly MatchArmsFactory $matchArmsFactory,
-        private readonly MatchSwitchAnalyzer $matchSwitchAnalyzer,
-        private readonly NodeComparator $nodeComparator
+        private MatchArmsFactory $matchArmsFactory,
+        private MatchSwitchAnalyzer $matchSwitchAnalyzer,
+        private NodeComparator $nodeComparator
     ) {
     }