wip

Author: micheleorselli

src/Analyzer/Docblock.php

@@ -0,0 +1,65 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Analyzer;
+
+use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
+use PHPStan\PhpDocParser\Ast\PhpDoc\ReturnTagValueNode;
+use PHPStan\PhpDocParser\Ast\Type\ArrayTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\GenericTypeNode;
+use PHPStan\PhpDocParser\Ast\Type\TypeNode;
+
+class Docblock
+{
+    private PhpDocNode $phpDocNode;
+
+    public function __construct(PhpDocNode $phpDocNode)
+    {
+        $this->phpDocNode = $phpDocNode;
+    }
+
+    public function getParamTagTypesByName(string $name): ?string
+    {
+        foreach ($this->phpDocNode->getParamTagValues() as $paramTag) {
+            if ($paramTag->parameterName === $name) {
+                return $this->getType($paramTag->type);
+            }
+        }
+
+        return null;
+    }
+
+    public function getReturnTagTypes(): array
+    {
+        $returnTypes = array_map(
+            fn (ReturnTagValueNode $returnTag) => $this->getType($returnTag->type),
+            $this->phpDocNode->getReturnTagValues()
+        );
+
+        // remove null values
+        return array_filter($returnTypes);
+    }
+
+    private function getType(TypeNode $typeNode): ?string
+    {
+        if ($typeNode instanceof GenericTypeNode) {
+            // this handles list<ClassName>
+            if (1 === \count($typeNode->genericTypes)) {
+                return (string) $typeNode->genericTypes[0];
+            }
+
+            // this handles array<int, ClassName>
+            if (2 === \count($typeNode->genericTypes)) {
+                return (string) $typeNode->genericTypes[1];
+            }
+        }
+
+        // this handles ClassName[]
+        if ($typeNode instanceof ArrayTypeNode) {
+            return (string) $typeNode->type;
+        }
+
+        return null;
+    }
+}

src/Analyzer/DocblockTypesResolver.php

@@ -133,32 +133,37 @@ private function resolveFunctionTypes(Node $node): void
             return;
         }
 
+        $docblock = new Docblock($phpDocNode);
+
+        // extract param types from param tags
         foreach ($node->params as $param) {
-            if (!$this->isNodeOfTypeArray($param)) { // not an array, nothing to do
+            if (!$this->isTypeArray($param->type)) { // not an array, nothing to do
                 continue;
             }
 
-            foreach ($phpDocNode->getParamTagValues() as $phpDocParam) {
-                if ($param->var instanceof Expr\Variable && \is_string($param->var->name) && $phpDocParam->parameterName === ('$'.$param->var->name)) {
-                    $arrayItemType = $this->getArrayItemType($phpDocParam->type);
+            if (!($param->var instanceof Expr\Variable) || !\is_string($param->var->name)) {
+                continue;
+            }
 
-                    if (null !== $arrayItemType) {
-                        $param->type = $this->resolveName(new Name($arrayItemType), Stmt\Use_::TYPE_NORMAL);
-                    }
-                }
+            $type = $docblock->getParamTagTypesByName('$'.$param->var->name);
+
+            if (null === $type) {
+                continue;
             }
+
+            $param->type = $this->resolveName(new Name($type), Stmt\Use_::TYPE_NORMAL);
         }
 
-        if ($node->returnType instanceof Node\Identifier && 'array' === $node->returnType->name) {
-            $arrayItemType = null;
+        // extract return type from return tag
+        if ($this->isTypeArray($node->returnType)) {
+            $type = $docblock->getReturnTagTypes();
+            $type = array_pop($type);
 
-            foreach ($phpDocNode->getReturnTagValues() as $tagValue) {
-                $arrayItemType = $this->getArrayItemType($tagValue->type);
+            if (null === $type) {
+                return;
             }
 
-            if (null !== $arrayItemType) {
-                $node->returnType = $this->resolveName(new Name($arrayItemType), Stmt\Use_::TYPE_NORMAL);
-            }
+            $node->returnType = $this->resolveName(new Name($type), Stmt\Use_::TYPE_NORMAL);
         }
     }
 
@@ -238,6 +243,14 @@ private function isNodeOfTypeArray($node): bool
         return null !== $node->type && isset($node->type->name) && 'array' === $node->type->name;
     }
 
+    /**
+     * @param Node\Identifier|Name|Node\ComplexType|null $type
+     */
+    private function isTypeArray($type): bool
+    {
+        return null !== $type && isset($type->name) && 'array' === $type->name;
+    }
+
     private function getArrayItemType(TypeNode $typeNode): ?string
     {
         $arrayItemType = null;

tests/Unit/Analyzer/DocblockParserTest.php

@@ -0,0 +1,70 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Arkitect\Tests\Unit\Analyzer;
+
+use Arkitect\Analyzer\Docblock;
+use Arkitect\Analyzer\DocblockParserFactory;
+use PHPUnit\Framework\TestCase;
+
+class DocblockParserTest extends TestCase
+{
+    public function test_it_should_exctract_types_from_param_tag(): void
+    {
+        $parser = DocblockParserFactory::create();
+
+        $code = <<< 'PHP'
+            /**
+             * @param MyDto[] $dtoList
+             * @param list<MyOtherDto> $dtoList2
+             * @param array<int, ValueObject> $voList
+             * @param array<User> $user
+             * @param array<User> $user
+             * @param int $aValue
+             * @param MyPlainDto $plainDto
+             */
+        }
+        PHP;
+
+        $phpdoc = $parser->parse($code);
+
+        $db = new Docblock($phpdoc);
+
+        self::assertEquals('MyDto', $db->getParamTagTypesByName('$dtoList'));
+        self::assertEquals('MyOtherDto', $db->getParamTagTypesByName('$dtoList2'));
+        self::assertEquals('ValueObject', $db->getParamTagTypesByName('$voList'));
+        self::assertEquals('User', $db->getParamTagTypesByName('$user'));
+
+        self::assertNull($db->getParamTagTypesByName('$aValue'));
+        self::assertNull($db->getParamTagTypesByName('$plainDto'));
+    }
+
+    public function test_it_should_extract_return_type_from_return_tag(): void
+    {
+        $parser = DocblockParserFactory::create();
+
+        $code = <<< 'PHP'
+            /**
+             * @return MyDto[]
+             * @return list<MyOtherDto>
+             * @return array<int, ValueObject>
+             * @return array<User>
+             * @return int
+             * @return MyPlainDto
+             */
+        }
+        PHP;
+
+        $phpdoc = $parser->parse($code);
+
+        $db = new Docblock($phpdoc);
+
+        $returnTypes = $db->getReturnTagTypes();
+        self::assertCount(4, $returnTypes);
+        self::assertEquals('MyDto', $returnTypes[0]);
+        self::assertEquals('MyOtherDto', $returnTypes[1]);
+        self::assertEquals('ValueObject', $returnTypes[2]);
+        self::assertEquals('User', $returnTypes[3]);
+    }
+}