fixup! fixup! fixup! fixup! [tdd] Add AddParamArrayDocblockBasedOnArrayMapRector

Author: TomasVotruba

rules/TypeDeclarationDocblocks/Rector/ClassMethod/AddParamArrayDocblockBasedOnArrayMapRector.php

@@ -5,17 +5,27 @@
 namespace Rector\TypeDeclarationDocblocks\Rector\ClassMethod;
 
 use PhpParser\Node;
+use PhpParser\Node\Identifier;
 use PhpParser\Node\Stmt\ClassMethod;
 use PhpParser\Node\Stmt\Function_;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
+use PHPStan\Type\ArrayType;
+use PHPStan\Type\MixedType;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
+use Rector\Comments\NodeDocBlock\DocBlockUpdater;
 use Rector\PhpParser\Node\BetterNodeFinder;
 use Rector\Rector\AbstractRector;
+use Rector\StaticTypeMapper\StaticTypeMapper;
 use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
 use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
 
 final class AddParamArrayDocblockBasedOnArrayMapRector extends AbstractRector
 {
     public function __construct(
-        private readonly BetterNodeFinder $betterNodeFinder
+        private readonly BetterNodeFinder $betterNodeFinder,
+        private readonly StaticTypeMapper $staticTypeMapper,
+        private readonly PhpDocInfoFactory $phpDocInfoFactory,
+        private readonly DocBlockUpdater $docBlockUpdater,
     ) {
 
     }
@@ -67,16 +77,108 @@ public function refactor(Node $node)
             return null;
         }
 
+        $hasChanged = false;
+        $functionPhpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node);
+
         foreach ($node->params as $param) {
             // handle only arrays
-            if (! $param->type instanceof Node\Identifier || ! $this->isName($param->type, 'array')) {
+            if (! $param->type instanceof Identifier || ! $this->isName($param->type, 'array')) {
                 continue;
             }
 
-            // find array_map usage
             $paramName = $this->getName($param->var);
 
+            $arrayMapClosures =  $this->findArrayMapFuncCallClosuresByVariableName($node, $paramName);
+            if ($arrayMapClosures === []) {
+                continue;
+            }
+
+            foreach ($arrayMapClosures as $arrayMapClosure) {
+                $params = $arrayMapClosure->getParams();
+                if ($params===[]) {
+                    continue;
+                }
+
+                $firstParam = $params[0];
+                $paramTypeNode = $firstParam->type;
+
+                if ($paramTypeNode === null) {
+                    continue;
+                }
+
+                $paramType = $this->staticTypeMapper->mapPhpParserNodePHPStanType($paramTypeNode);
+
+                $paramDocTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode($paramType);
+
+                $currentParamType = $functionPhpDocInfo->getParamType($paramName);
+
+                // has alreayd better type than arary?
+                if (! $currentParamType instanceof MixedType && ($currentParamType instanceof ArrayType && (! $currentParamType->getItemType() instanceof MixedType || ! $currentParamType->getKeyType() instanceof MixedType ))){
+                    continue;
+            }
+
+                $paramTagValueNode = new ParamTagValueNode(
+                    $paramDocTypeNode,
+                    $param->variadic,
+                    '$' . $paramName,
+                    '',
+                    $param->byRef
+                );
+                $functionPhpDocInfo->addTagValueNode($paramTagValueNode);
+
+                $hasChanged = true;
+            }
+
+        }
+
+        if (! $hasChanged) {
+            return null;
+        }
+
+        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+
+        return $node;
+    }
+
+    /**
+     * @return array<Node\Expr\Closure|Node\Expr\ArrowFunction>
+     */
+    private function findArrayMapFuncCallClosuresByVariableName(ClassMethod|Function_|Node $node, string $paramName): array
+    {
+        // find array_map usage
+        /** @var Node\Expr\FuncCall[] $funcCalls */
+        $funcCalls = $this->betterNodeFinder->findInstancesOfScoped($node->stmts, Node\Expr\FuncCall::class);
+
+        $arrayMapClosures = [];
+
+        foreach ($funcCalls as $funcCall) {
+            if (!$this->isName($funcCall, 'array_map')) {
+                continue;
+            }
+
+            if (!$funcCall->isFirstClassCallable()) {
+                continue;
+            }
+
+            $secondArg = $funcCall->getArgs()[1];
+            if (!$secondArg->value instanceof Node\Expr\Variable) {
+                continue;
+            }
+
+            if (!$this->isName($secondArg->value, $paramName)) {
+                continue;
+            }
+
+            $firstArg = $funcCall->getArgs()[1];
+
+
+            if (!$firstArg->value instanceof Node\Expr\Closure && !$firstArg->value instanceof Node\Expr\ArrowFunction) {
+                continue;
+            }
+
+            $arrayMapClosures[] = $firstArg->value;
         }
 
+        return $arrayMapClosures;
     }
 }