[Php71] Skip Type from @param doc on BinaryOpBetweenNumberAndStringRector (#1386)

* [Php71] Skip fType from @param doc on BinaryOpBetweenNumberAndStringRector

* final touch: from typed param

* [ci-review] Rector Rectify

* [ci-review] Rector Rectify

* [ci-review] Rector Rectify

* [ci-review] Rector Rectify

Co-authored-by: GitHub Action <action@github.com>

Author: samsonasik

rules-tests/Php71/Rector/BinaryOp/BinaryOpBetweenNumberAndStringRector/Fixture/from_typed_param.php.inc

@@ -0,0 +1,27 @@
+<?php
+
+namespace Rector\Tests\Php71\Rector\BinaryOp\BinaryOpBetweenNumberAndStringRector\Fixture;
+
+class FromTypedParam
+{
+    public function run(?int $id)
+    {
+        return $id !== null && $id !== 'null';
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\Php71\Rector\BinaryOp\BinaryOpBetweenNumberAndStringRector\Fixture;
+
+class FromTypedParam
+{
+    public function run(?int $id)
+    {
+        return $id !== null && $id !== 0;
+    }
+}
+
+?>

rules-tests/Php71/Rector/BinaryOp/BinaryOpBetweenNumberAndStringRector/Fixture/skip_type_by_param_doc.php.inc

@@ -0,0 +1,14 @@
+<?php
+
+namespace Rector\Tests\Php71\Rector\BinaryOp\BinaryOpBetweenNumberAndStringRector\Fixture;
+
+class SkipTypeByParamDoc
+{
+    /**
+     * @param int|null  $id
+     */
+    public function run($id)
+    {
+        return $id !== null && $id !== 'null';
+    }
+}

rules-tests/Php71/Rector/BinaryOp/BinaryOpBetweenNumberAndStringRector/Fixture/skip_type_by_param_doc2.php.inc

@@ -0,0 +1,14 @@
+<?php
+
+namespace Rector\Tests\Php71\Rector\BinaryOp\BinaryOpBetweenNumberAndStringRector\Fixture;
+
+class SkipTypeByParamDoc2
+{
+    /**
+     * @param int|null  $id
+     */
+    public function run($id)
+    {
+        return $id !== null && 'null' !== $id;
+    }
+}

rules/DeadCode/Rector/Cast/RecastingRemovalRector.php

@@ -15,7 +15,6 @@
 use PhpParser\Node\Expr\Cast\String_;
 use PhpParser\Node\Expr\PropertyFetch;
 use PhpParser\Node\Expr\StaticPropertyFetch;
-use PhpParser\Node\FunctionLike;
 use PHPStan\Reflection\Php\PhpPropertyReflection;
 use PHPStan\Type\ArrayType;
 use PHPStan\Type\BooleanType;
@@ -26,6 +25,7 @@
 use PHPStan\Type\StringType;
 use PHPStan\Type\Type;
 use PHPStan\Type\UnionType;
+use Rector\Core\NodeAnalyzer\ExprAnalyzer;
 use Rector\Core\NodeAnalyzer\PropertyFetchAnalyzer;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\Reflection\ReflectionResolver;
@@ -51,7 +51,8 @@ final class RecastingRemovalRector extends AbstractRector
 
     public function __construct(
         private readonly PropertyFetchAnalyzer $propertyFetchAnalyzer,
-        private readonly ReflectionResolver $reflectionResolver
+        private readonly ReflectionResolver $reflectionResolver,
+        private readonly ExprAnalyzer $exprAnalyzer
     ) {
     }
 
@@ -116,7 +117,7 @@ public function refactor(Node $node): ?Node
     private function shouldSkip(Expr $expr): bool
     {
         if (! $this->propertyFetchAnalyzer->isPropertyFetch($expr)) {
-            return $this->isNonTypedFromParam($expr);
+            return $this->exprAnalyzer->isNonTypedFromParam($expr);
         }
 
         /** @var PropertyFetch|StaticPropertyFetch $expr */
@@ -135,23 +136,4 @@ private function shouldSkip(Expr $expr): bool
         $nativeType = $phpPropertyReflection->getNativeType();
         return $nativeType instanceof MixedType;
     }
-
-    private function isNonTypedFromParam(Expr $expr): bool
-    {
-        $functionLike = $this->betterNodeFinder->findParentType($expr, FunctionLike::class);
-        if (! $functionLike instanceof FunctionLike) {
-            return false;
-        }
-
-        $params = $functionLike->getParams();
-        foreach ($params as $param) {
-            if (! $this->nodeComparator->areNodesEqual($param->var, $expr)) {
-                continue;
-            }
-
-            return $param->type === null;
-        }
-
-        return false;
-    }
 }

rules/Php71/Rector/BinaryOp/BinaryOpBetweenNumberAndStringRector.php

@@ -15,6 +15,7 @@
 use PhpParser\Node\Scalar\MagicConst\Line;
 use PhpParser\Node\Scalar\String_;
 use PHPStan\Type\Constant\ConstantStringType;
+use Rector\Core\NodeAnalyzer\ExprAnalyzer;
 use Rector\Core\Rector\AbstractRector;
 use Rector\Core\ValueObject\PhpVersionFeature;
 use Rector\VersionBonding\Contract\MinPhpVersionInterface;
@@ -28,6 +29,11 @@
  */
 final class BinaryOpBetweenNumberAndStringRector extends AbstractRector implements MinPhpVersionInterface
 {
+    public function __construct(
+        private readonly ExprAnalyzer $exprAnalyzer
+    ) {
+    }
+
     public function provideMinPhpVersion(): int
     {
         return PhpVersionFeature::BINARY_OP_NUMBER_STRING;
@@ -86,6 +92,14 @@ public function refactor(Node $node): ?Node
             return null;
         }
 
+        if ($this->exprAnalyzer->isNonTypedFromParam($node->left)) {
+            return null;
+        }
+
+        if ($this->exprAnalyzer->isNonTypedFromParam($node->right)) {
+            return null;
+        }
+
         if ($this->isStringOrStaticNonNumbericString($node->left) && $this->nodeTypeResolver->isNumberType(
             $node->right
         )) {

src/NodeAnalyzer/ExprAnalyzer.php

@@ -0,0 +1,43 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Core\NodeAnalyzer;
+
+use PhpParser\Node\Expr;
+use PhpParser\Node\Expr\Variable;
+use PhpParser\Node\FunctionLike;
+use Rector\Core\PhpParser\Comparing\NodeComparator;
+use Rector\Core\PhpParser\Node\BetterNodeFinder;
+
+final class ExprAnalyzer
+{
+    public function __construct(
+        private readonly NodeComparator $nodeComparator,
+        private readonly BetterNodeFinder $betterNodeFinder,
+    ) {
+    }
+
+    public function isNonTypedFromParam(Expr $expr): bool
+    {
+        if (! $expr instanceof Variable) {
+            return false;
+        }
+
+        $functionLike = $this->betterNodeFinder->findParentType($expr, FunctionLike::class);
+        if (! $functionLike instanceof FunctionLike) {
+            return false;
+        }
+
+        $params = $functionLike->getParams();
+        foreach ($params as $param) {
+            if (! $this->nodeComparator->areNodesEqual($param->var, $expr)) {
+                continue;
+            }
+
+            return $param->type === null;
+        }
+
+        return false;
+    }
+}