Faster name resolving

packages/NodeNameResolver/NodeNameResolver.php

@@ -204,7 +204,7 @@ public function isStringName(string $resolvedName, string $desiredName): bool
             return $desiredName === $resolvedName;
         }
 
-        return strtolower($resolvedName) === strtolower($desiredName);
+        return strcasecmp($resolvedName, $desiredName) === 0;
     }
 
     public function matchesStringName(string|Identifier $resolvedName, string $desiredNamePattern): bool

rules/Arguments/Rector/ClassMethod/ArgumentAdderRector.php

@@ -318,8 +318,13 @@ private function processStaticCall(StaticCall $staticCall, int $position, Argume
 
     private function refactorCall(StaticCall|MethodCall $call): void
     {
+        $callName = $this->getName($call->name);
+        if ($callName === null) {
+            return;
+        }
+
         foreach ($this->addedArguments as $addedArgument) {
-            if (! $this->isName($call->name, $addedArgument->getMethod())) {
+            if (! $this->nodeNameResolver->isStringName($callName, $addedArgument->getMethod())) {
                 continue;
             }
 

rules/Arguments/Rector/ClassMethod/ReplaceArgumentDefaultValueRector.php

@@ -83,8 +83,13 @@ public function refactor(Node $node): MethodCall | StaticCall | ClassMethod | Ne
             return $this->refactorNew($node);
         }
 
+        $nodeName = $this->getName($node->name);
+        if ($nodeName === null) {
+            return null;
+        }
+
         foreach ($this->replaceArgumentDefaultValues as $replaceArgumentDefaultValue) {
-            if (! $this->isName($node->name, $replaceArgumentDefaultValue->getMethod())) {
+            if (! $this->nodeNameResolver->isStringName($nodeName, $replaceArgumentDefaultValue->getMethod())) {
                 continue;
             }
 

rules/Renaming/Rector/MethodCall/RenameMethodRector.php

@@ -157,23 +157,13 @@ private function refactorClass(Class_|Interface_ $classOrInterface, Scope $scope
         $hasChanged = false;
 
         foreach ($classOrInterface->getMethods() as $classMethod) {
-            foreach ($this->methodCallRenames as $methodCallRename) {
-                if (! $this->isName($classMethod->name, $methodCallRename->getOldMethod())) {
-                    continue;
-                }
-
-                if (! $this->nodeTypeResolver->isMethodStaticCallOrClassMethodObjectType(
-                    $classMethod,
-                    $methodCallRename->getObjectType()
-                )) {
-                    continue;
-                }
-
-                if ($this->shouldKeepForParentInterface($methodCallRename, $classReflection)) {
-                    continue;
-                }
+            $methodName = $this->getName($classMethod->name);
+            if ($methodName === null) {
+                continue;
+            }
 
-                if ($this->hasClassNewClassMethod($classOrInterface, $methodCallRename)) {
+            foreach ($this->methodCallRenames as $methodCallRename) {
+                if ($this->shouldSkipRename($methodName, $classMethod, $methodCallRename, $classReflection, $classOrInterface)) {
                     continue;
                 }
 
@@ -189,11 +179,46 @@ private function refactorClass(Class_|Interface_ $classOrInterface, Scope $scope
         return null;
     }
 
+    private function shouldSkipRename(
+        string $methodName,
+        Node\Stmt\ClassMethod $classMethod,
+        MethodCallRenameInterface $methodCallRename,
+        ClassReflection $classReflection,
+        Class_|Interface_ $classOrInterface
+    ): bool
+    {
+        if (! $this->nodeNameResolver->isStringName($methodName, $methodCallRename->getOldMethod())) {
+            return true;
+        }
+
+        if (! $this->nodeTypeResolver->isMethodStaticCallOrClassMethodObjectType(
+            $classMethod,
+            $methodCallRename->getObjectType()
+        )) {
+            return true;
+        }
+
+        if ($this->shouldKeepForParentInterface($methodCallRename, $classReflection)) {
+            return true;
+        }
+
+        if ($this->hasClassNewClassMethod($classOrInterface, $methodCallRename)) {
+            return true;
+        }
+
+        return false;
+    }
+
     private function refactorMethodCallAndStaticCall(
         StaticCall|MethodCall $call
     ): ArrayDimFetch|null|MethodCall|StaticCall {
+        $callName = $this->getName($call->name);
+        if ($callName === null) {
+            return null;
+        }
+
         foreach ($this->methodCallRenames as $methodCallRename) {
-            if (! $this->isName($call->name, $methodCallRename->getOldMethod())) {
+            if (! $this->nodeNameResolver->isStringName($callName, $methodCallRename->getOldMethod())) {
                 continue;
             }
 

rules/TypeDeclaration/Rector/ClassMethod/AddParamTypeDeclarationRector.php

@@ -88,8 +88,9 @@ public function refactor(Node $node): ?Node
                 continue;
             }
 
+            $methodName = $this->getName($classMethod);
             foreach ($this->addParamTypeDeclarations as $addParamTypeDeclaration) {
-                if (! $this->isName($classMethod, $addParamTypeDeclaration->getMethodName())) {
+                if (!$this->nodeNameResolver->isStringName($methodName, $addParamTypeDeclaration->getMethodName())) {
                     continue;
                 }