[type-declaration-docblock] kick of docblock rules to help with iterables

config/set/type-declaration-docblocks.php

@@ -11,6 +11,7 @@
  */
 return static function (RectorConfig $rectorConfig): void {
     $rectorConfig->rules([
+        DocblockVarFromParamDocblockInConstructorRector::class,
         DocblockVarFromParamDocblockInConstructorRector::class,
         DocblockGetterReturnArrayFromPropertyDocblockVarRector::class,
     ]);

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/DocblockReturnArrayFromDirectArrayInstanceRectorTest.php

@@ -0,0 +1,28 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector;
+
+use Iterator;
+use PHPUnit\Framework\Attributes\DataProvider;
+use Rector\Testing\PHPUnit\AbstractRectorTestCase;
+
+final class DocblockReturnArrayFromDirectArrayInstanceRectorTest extends AbstractRectorTestCase
+{
+    #[DataProvider('provideData')]
+    public function test(string $filePath): void
+    {
+        $this->doTestFile($filePath);
+    }
+
+    public static function provideData(): Iterator
+    {
+        return self::yieldFilesFromDirectory(__DIR__ . '/Fixture');
+    }
+
+    public function provideConfigFilePath(): string
+    {
+        return __DIR__ . '/config/configured_rule.php';
+    }
+}

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/Fixture/include_missing_return_array.php.inc

@@ -0,0 +1,34 @@
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class IncludeMissingReturnArray
+{
+    public function getNames()
+    {
+        return [
+            'key' => 'value',
+        ];
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class IncludeMissingReturnArray
+{
+    /**
+     * @return array<string, string>
+     */
+    public function getNames()
+    {
+        return [
+            'key' => 'value',
+        ];
+    }
+}
+
+?>

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/Fixture/skip_already_set_docblock.php.inc

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class SkipAlreadySetDocblock
+{
+    /**
+     * @return array<string, int|string>
+     */
+    public function getNames(): array
+    {
+        return [
+            'key' => 'value',
+        ];
+    }
+}

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/Fixture/skip_more_variables.php.inc

@@ -0,0 +1,16 @@
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class SkipMoreVariables
+{
+    public function getNames()
+    {
+        $variable = [
+            'key' => 'value',
+        ];
+
+
+        return $variable;
+    }
+}

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/Fixture/some_property_with_array_docblock.php.inc

@@ -0,0 +1,34 @@
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class SomePropertyWithArrayDocblock
+{
+    public function getNames(): array
+    {
+        return [
+            'key' => 'value',
+        ];
+    }
+}
+
+?>
+-----
+<?php
+
+namespace Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\Fixture;
+
+final class SomePropertyWithArrayDocblock
+{
+    /**
+     * @return array<string, string>
+     */
+    public function getNames(): array
+    {
+        return [
+            'key' => 'value',
+        ];
+    }
+}
+
+?>

rules-tests/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector/config/configured_rule.php

@@ -0,0 +1,9 @@
+<?php
+
+declare(strict_types=1);
+
+use Rector\Config\RectorConfig;
+use Rector\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector;
+
+return RectorConfig::configure()
+    ->withRules([DocblockReturnArrayFromDirectArrayInstanceRector::class]);

rules/TypeDeclarationDocblocks/Rector/ClassMethod/DocblockReturnArrayFromDirectArrayInstanceRector.php

@@ -0,0 +1,162 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Rector\TypeDeclarationDocblocks\Rector\ClassMethod;
+
+use PHPStan\Type\Type;
+use PhpParser\Node;
+use PhpParser\Node\Expr\Array_;
+use PhpParser\Node\Stmt\ClassMethod;
+use PhpParser\Node\Stmt\Return_;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
+use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\IdentifierTypeNode;
+use PHPStan\Type\BooleanType;
+use PHPStan\Type\Constant\ConstantArrayType;
+use PHPStan\Type\FloatType;
+use PHPStan\Type\IntegerType;
+use PHPStan\Type\MixedType;
+use PHPStan\Type\StringType;
+use Rector\BetterPhpDocParser\PhpDocInfo\PhpDocInfoFactory;
+use Rector\Comments\NodeDocBlock\DocBlockUpdater;
+use Rector\Rector\AbstractRector;
+use Rector\StaticTypeMapper\StaticTypeMapper;
+use Symplify\RuleDocGenerator\ValueObject\CodeSample\CodeSample;
+use Symplify\RuleDocGenerator\ValueObject\RuleDefinition;
+
+/**
+ * @see \Rector\Tests\TypeDeclarationDocblocks\Rector\ClassMethod\DocblockReturnArrayFromDirectArrayInstanceRector\DocblockReturnArrayFromDirectArrayInstanceRectorTest
+ */
+final class DocblockReturnArrayFromDirectArrayInstanceRector extends AbstractRector
+{
+    public function __construct(
+        private readonly PhpDocInfoFactory $phpDocInfoFactory,
+        private readonly DocBlockUpdater $docBlockUpdater,
+        private readonly StaticTypeMapper $staticTypeMapper
+    ) {
+    }
+
+    public function getNodeTypes(): array
+    {
+        return [ClassMethod::class];
+    }
+
+    public function getRuleDefinition(): RuleDefinition
+    {
+        return new RuleDefinition(
+            'Add simple @return array docblock based on direct single level direct return of []',
+            [
+                new CodeSample(
+                    <<<'CODE_SAMPLE'
+class SomeClass
+{
+    public function getItems(): array
+    {
+        return [
+            'hey' => 'now',
+        ];
+    }
+}
+CODE_SAMPLE
+                    ,
+                    <<<'CODE_SAMPLE'
+class SomeClass
+{
+    /**
+     * @return array<string, string>
+     */
+    public function getItems(): array
+    {
+        return [
+            'hey' => 'now',
+        ];
+    }
+}
+CODE_SAMPLE
+                ),
+
+            ]
+        );
+    }
+
+    /**
+     * @param ClassMethod $node
+     */
+    public function refactor(Node $node): ?Node
+    {
+        $phpDocInfo = $this->phpDocInfoFactory->createFromNodeOrEmpty($node);
+
+        // return tag is already given
+        if ($phpDocInfo->getReturnTagValue() instanceof ReturnTagValueNode) {
+            return null;
+        }
+
+        if ($node->stmts === null || count($node->stmts) !== 1) {
+            return null;
+        }
+
+        $soleReturn = $node->stmts[0];
+        if (! $soleReturn instanceof Return_) {
+            return null;
+        }
+
+        if (! $soleReturn->expr instanceof Array_) {
+            return null;
+        }
+
+        // resolve simple type
+        $returnedType = $this->getType($soleReturn->expr);
+
+        if (! $returnedType instanceof ConstantArrayType) {
+            return null;
+        }
+
+        $genericKeyType = $this->constantToGenericType($returnedType->getKeyType());
+        $genericItemType = $this->constantToGenericType($returnedType->getItemType());
+
+        $genericTypeNode = $this->createArrayGenericTypeNode($genericKeyType, $genericItemType);
+
+        $returnTagValueNode = new ReturnTagValueNode($genericTypeNode, '');
+        $phpDocInfo->addTagValueNode($returnTagValueNode);
+
+        $this->docBlockUpdater->updateRefactoredNodeWithPhpDocInfo($node);
+
+        return $node;
+    }
+
+    /**
+     * covers constant types too and makes them more generic
+     */
+    private function constantToGenericType(Type $type): Type
+    {
+        if ($type instanceof StringType) {
+            return new StringType();
+        }
+
+        if ($type instanceof IntegerType) {
+            return new IntegerType();
+        }
+
+        if ($type instanceof BooleanType) {
+            return new BooleanType();
+        }
+
+        if ($type instanceof FloatType) {
+            return new FloatType();
+        }
+
+        // unclear
+        return new MixedType();
+    }
+
+    private function createArrayGenericTypeNode(
+        Type $keyType,
+        Type $itemType
+    ): GenericTypeNode {
+        $keyDocTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode($keyType);
+        $itemDocTypeNode = $this->staticTypeMapper->mapPHPStanTypeToPHPStanPhpDocTypeNode($itemType);
+
+        return new GenericTypeNode(new IdentifierTypeNode('array'), [$keyDocTypeNode, $itemDocTypeNode]);
+    }
+}