[perf] Speed up legacy Php rules with cheap guards before reflection and type lookup

rules/Php70/Rector/MethodCall/ThisCallOnStaticMethodToStaticCallRector.php

@@ -147,12 +147,12 @@ private function processThisToStatic(Class_ $class, ClassReflection $classReflec
                 return null;
             }
 
-            $isStaticMethod = $this->staticAnalyzer->isStaticMethod($classReflection, $methodName, $class);
-            if (! $isStaticMethod) {
+            if ($subNode->isFirstClassCallable()) {
                 return null;
             }
 
-            if ($subNode->isFirstClassCallable()) {
+            $isStaticMethod = $this->staticAnalyzer->isStaticMethod($classReflection, $methodName, $class);
+            if (! $isStaticMethod) {
                 return null;
             }
 

rules/Php71/Rector/BooleanOr/IsIterableRector.php

@@ -63,10 +63,10 @@ public function refactor(Node $node): ?Node
 
     private function shouldSkip(): bool
     {
-        if ($this->reflectionProvider->hasFunction(new Name('is_iterable'), null)) {
+        if ($this->phpVersionProvider->isAtLeastPhpVersion(PhpVersionFeature::IS_ITERABLE)) {
             return false;
         }
 
-        return ! $this->phpVersionProvider->isAtLeastPhpVersion(PhpVersionFeature::IS_ITERABLE);
+        return ! $this->reflectionProvider->hasFunction(new Name('is_iterable'), null);
     }
 }

rules/Php71/Rector/FuncCall/RemoveExtraParametersRector.php

@@ -63,6 +63,10 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
+        if ($node->isFirstClassCallable()) {
+            return null;
+        }
+
         // unreliable count of arguments
         $functionLikeReflection = $this->reflectionResolver->resolveFunctionLikeReflectionFromCall($node);
         if ($functionLikeReflection instanceof UnionTypeMethodReflection) {
@@ -90,9 +94,6 @@ public function refactor(Node $node): ?Node
         }
 
         $maximumAllowedParameterCount = $this->resolveMaximumAllowedParameterCount($functionLikeReflection);
-        if ($node->isFirstClassCallable()) {
-            return null;
-        }
 
         if ($this->shouldSkipFunctionReflection($functionLikeReflection)) {
             return null;

rules/Php73/Rector/ConstFetch/SensitiveConstantNameRector.php

@@ -140,11 +140,6 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        // constant is defined in current lower/upper case
-        if ($this->reflectionProvider->hasConstant(new Name($constantName), null)) {
-            return null;
-        }
-
         // is uppercase, all good
         if ($constantName === $uppercasedConstantName) {
             return null;
@@ -158,6 +153,11 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
+        // constant is defined in current lower/upper case
+        if ($this->reflectionProvider->hasConstant(new Name($constantName), null)) {
+            return null;
+        }
+
         $node->name = new FullyQualified($uppercasedConstantName);
 
         return $node;

rules/Php74/Rector/StaticCall/ExportToReflectionFunctionRector.php

@@ -78,13 +78,13 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
-        $callerType = $this->getType($node->class);
-        if (! $callerType->isSuperTypeOf(new ObjectType('ReflectionFunction'))->yes()) {
+        $firstArg = $node->getArgs()[0] ?? null;
+        if (! $firstArg instanceof Arg) {
             return null;
         }
 
-        $firstArg = $node->getArgs()[0] ?? null;
-        if (! $firstArg instanceof Arg) {
+        $callerType = $this->getType($node->class);
+        if (! $callerType->isSuperTypeOf(new ObjectType('ReflectionFunction'))->yes()) {
             return null;
         }