Updated Rector to commit 6e185e87230fc048f60ca26e93555af1bf26492f

rectorphp/rector-src@6e185e8 [phpstan] prefer isName() from abstract class over protected service (#6875)

Author: TomasVotruba

rules/CodeQuality/Rector/ClassConstFetch/ConvertStaticPrivateConstantToSelfRector.php

@@ -92,7 +92,7 @@ private function isPrivateConstant(ClassConstFetch $classConstFetch, Class_ $cla
             return \false;
         }
         foreach ($class->getConstants() as $classConst) {
-            if (!$this->nodeNameResolver->isName($classConst, $constantName)) {
+            if (!$this->isName($classConst, $constantName)) {
                 continue;
             }
             return $classConst->isPrivate();

rules/CodeQuality/Rector/Class_/CompleteDynamicPropertiesRector.php

@@ -132,7 +132,7 @@ private function shouldSkipClass(Class_ $class) : bool
         if ($this->classAnalyzer->isAnonymousClass($class)) {
             return \true;
         }
-        $className = (string) $this->nodeNameResolver->getName($class);
+        $className = (string) $this->getName($class);
         if (!$this->reflectionProvider->hasClass($className)) {
             return \true;
         }

rules/CodeQuality/Rector/Class_/InlineConstructorDefaultToPropertyRector.php

@@ -111,10 +111,10 @@ private function matchAssignedLocalPropertyName(Assign $assign) : ?string
             return null;
         }
         $propertyFetch = $assign->var;
-        if (!$this->nodeNameResolver->isName($propertyFetch->var, 'this')) {
+        if (!$this->isName($propertyFetch->var, 'this')) {
             return null;
         }
-        $propertyName = $this->nodeNameResolver->getName($propertyFetch->name);
+        $propertyName = $this->getName($propertyFetch->name);
         if (!\is_string($propertyName)) {
             return null;
         }

rules/CodeQuality/Rector/Identical/SimplifyArraySearchRector.php

@@ -53,7 +53,7 @@ public function refactor(Node $node) : ?Node
             if (!$node instanceof FuncCall) {
                 return \false;
             }
-            return $this->nodeNameResolver->isName($node, 'array_search');
+            return $this->isName($node, 'array_search');
         }, fn(Node $node): bool => $node instanceof Expr && $this->valueResolver->isFalse($node));
         if (!$twoNodeMatch instanceof TwoNodeMatch) {
             return null;

rules/CodeQuality/Rector/If_/ExplicitBoolCompareRector.php

@@ -129,7 +129,7 @@ public function refactor(Node $node)
     }
     private function resolveNewConditionNode(Expr $expr, bool $isNegated) : ?BinaryOp
     {
-        if ($expr instanceof FuncCall && $this->nodeNameResolver->isName($expr, 'count')) {
+        if ($expr instanceof FuncCall && $this->isName($expr, 'count')) {
             return $this->resolveCount($isNegated, $expr);
         }
         if ($this->arrayTypeAnalyzer->isArrayType($expr)) {

rules/CodingStyle/Rector/Catch_/CatchExceptionNameMatchingTypeRector.php

@@ -142,7 +142,7 @@ private function renameVariableInStmts(Catch_ $catch, string $oldVariableName, s
             if (!$node instanceof Variable) {
                 return null;
             }
-            if (!$this->nodeNameResolver->isName($node, $oldVariableName)) {
+            if (!$this->isName($node, $oldVariableName)) {
                 return null;
             }
             $node->name = $newVariableName;
@@ -166,7 +166,7 @@ private function replaceNextUsageVariable(string $oldVariableName, string $newVa
             if (!$node instanceof Variable) {
                 return null;
             }
-            if (!$this->nodeNameResolver->isName($node, $oldVariableName)) {
+            if (!$this->isName($node, $oldVariableName)) {
                 return null;
             }
             $nonAssignedVariables[] = $node;

rules/CodingStyle/Rector/ClassMethod/NewlineBeforeNewAssignSetRector.php

@@ -149,7 +149,7 @@ private function shouldSkipLeftVariable($node) : bool
             return \false;
         }
         // local method call
-        return $this->nodeNameResolver->isName($node->var, 'this');
+        return $this->isName($node->var, 'this');
     }
     private function isNewVariableThanBefore(?string $currentStmtVariableName) : bool
     {

rules/CodingStyle/Rector/FuncCall/ArraySpreadInsteadOfArrayMergeRector.php

@@ -172,7 +172,7 @@ private function isIteratorToArrayFuncCall(Expr $expr) : bool
         if (!$expr instanceof FuncCall) {
             return \false;
         }
-        if (!$this->nodeNameResolver->isName($expr, 'iterator_to_array')) {
+        if (!$this->isName($expr, 'iterator_to_array')) {
             return \false;
         }
         if ($expr->isFirstClassCallable()) {

rules/DeadCode/Rector/ClassMethod/RemoveEmptyClassMethodRector.php

@@ -150,11 +150,11 @@ private function shouldSkipClassMethod(Class_ $class, ClassMethod $classMethod)
         if ($this->controllerClassMethodManipulator->isControllerClassMethod($class, $classMethod)) {
             return \true;
         }
-        if ($this->nodeNameResolver->isName($classMethod, MethodName::CONSTRUCT)) {
+        if ($this->isName($classMethod, MethodName::CONSTRUCT)) {
             // has parent class?
             return $class->extends instanceof FullyQualified;
         }
-        return $this->nodeNameResolver->isName($classMethod, MethodName::INVOKE);
+        return $this->isName($classMethod, MethodName::INVOKE);
     }
     private function hasDeprecatedAnnotation(ClassMethod $classMethod) : bool
     {

rules/DeadCode/Rector/ClassMethod/RemoveUnusedPrivateMethodParameterRector.php

@@ -127,7 +127,7 @@ private function removeCallerArgs(Class_ $class, ClassMethod $classMethod, array
         if ($classMethods === []) {
             return;
         }
-        $methodName = $this->nodeNameResolver->getName($classMethod);
+        $methodName = $this->getName($classMethod);
         $keysArg = \array_keys($unusedParameters);
         foreach ($classMethods as $classMethod) {
             /** @var MethodCall[] $callers */
@@ -172,10 +172,10 @@ private function resolveCallers(ClassMethod $classMethod, string $methodName) :
             if (!$subNode->var instanceof Variable) {
                 return \false;
             }
-            if (!$this->nodeNameResolver->isName($subNode->var, 'this')) {
+            if (!$this->isName($subNode->var, 'this')) {
                 return \false;
             }
-            return $this->nodeNameResolver->isName($subNode->name, $methodName);
+            return $this->isName($subNode->name, $methodName);
         });
     }
     private function shouldSkipClassMethod(ClassMethod $classMethod) : bool