vendor/symfony/property-info/Extractor/PhpStanExtractor.php line 78

  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Component\PropertyInfo\Extractor;
  14. use phpDocumentor\Reflection\Types\ContextFactory;
  15. use PHPStan\PhpDocParser\Ast\PhpDoc\InvalidTagValueNode;
  16. use PHPStan\PhpDocParser\Ast\PhpDoc\ParamTagValueNode;
  17. use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocNode;
  18. use PHPStan\PhpDocParser\Ast\PhpDoc\PhpDocTagNode;
  19. use PHPStan\PhpDocParser\Lexer\Lexer;
  20. use PHPStan\PhpDocParser\Parser\ConstExprParser;
  21. use PHPStan\PhpDocParser\Parser\PhpDocParser;
  22. use PHPStan\PhpDocParser\Parser\TokenIterator;
  23. use PHPStan\PhpDocParser\Parser\TypeParser;
  24. use Symfony\Component\PropertyInfo\PhpStan\NameScopeFactory;
  25. use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
  26. use Symfony\Component\PropertyInfo\Type;
  27. use Symfony\Component\PropertyInfo\Util\PhpStanTypeHelper;
  29. /**
  30.  * Extracts data using PHPStan parser.
  31.  *
  32.  * @author Baptiste Leduc <baptiste.leduc@gmail.com>
  33.  */
  34. final class PhpStanExtractor implements PropertyTypeExtractorInterface, ConstructorArgumentTypeExtractorInterface
  35. {
  36.     private const PROPERTY = 0;
  37.     private const ACCESSOR = 1;
  38.     private const MUTATOR = 2;
  40.     /** @var PhpDocParser */
  41.     private $phpDocParser;
  43.     /** @var Lexer */
  44.     private $lexer;
  46.     /** @var NameScopeFactory */
  47.     private $nameScopeFactory;
  49.     /** @var array<string, array{PhpDocNode|null, int|null, string|null, string|null}> */
  50.     private $docBlocks = [];
  51.     private $phpStanTypeHelper;
  52.     private $mutatorPrefixes;
  53.     private $accessorPrefixes;
  54.     private $arrayMutatorPrefixes;
  56.     /**
  57.      * @param list<string>|null $mutatorPrefixes
  58.      * @param list<string>|null $accessorPrefixes
  59.      * @param list<string>|null $arrayMutatorPrefixes
  60.      */
  61.     public function __construct(array $mutatorPrefixes = null, array $accessorPrefixes = null, array $arrayMutatorPrefixes = null)
  62.     {
  63.         if (!class_exists(ContextFactory::class)) {
  64.             throw new \LogicException(sprintf('Unable to use the "%s" class as the "phpdocumentor/type-resolver" package is not installed. Try running composer require "phpdocumentor/type-resolver".', __CLASS__));
  65.         }
  67.         if (!class_exists(PhpDocParser::class)) {
  68.             throw new \LogicException(sprintf('Unable to use the "%s" class as the "phpstan/phpdoc-parser" package is not installed. Try running composer require "phpstan/phpdoc-parser".', __CLASS__));
  69.         }
  71.         $this->phpStanTypeHelper = new PhpStanTypeHelper();
  72.         $this->mutatorPrefixes = $mutatorPrefixes ?? ReflectionExtractor::$defaultMutatorPrefixes;
  73.         $this->accessorPrefixes = $accessorPrefixes ?? ReflectionExtractor::$defaultAccessorPrefixes;
  74.         $this->arrayMutatorPrefixes = $arrayMutatorPrefixes ?? ReflectionExtractor::$defaultArrayMutatorPrefixes;
  76.         $this->phpDocParser = new PhpDocParser(new TypeParser(new ConstExprParser()), new ConstExprParser());
  77.         $this->lexer = new Lexer();
  78.         $this->nameScopeFactory = new NameScopeFactory();
  79.     }
  81.     public function getTypes(string $class, string $property, array $context = []): ?array
  82.     {
  83.         /** @var PhpDocNode|null $docNode */
  84.         [$docNode, $source, $prefix, $declaringClass] = $this->getDocBlock($class, $property);
  85.         $nameScope = $this->nameScopeFactory->create($class, $declaringClass);
  86.         if (null === $docNode) {
  87.             return null;
  88.         }
  90.         switch ($source) {
  91.             case self::PROPERTY:
  92.                 $tag = '@var';
  93.                 break;
  95.             case self::ACCESSOR:
  96.                 $tag = '@return';
  97.                 break;
  99.             case self::MUTATOR:
  100.                 $tag = '@param';
  101.                 break;
  102.         }
  104.         $parentClass = null;
  105.         $types = [];
  106.         foreach ($docNode->getTagsByName($tag) as $tagDocNode) {
  107.             if ($tagDocNode->value instanceof InvalidTagValueNode) {
  108.                 continue;
  109.             }
  111.             if (
  112.                 $tagDocNode->value instanceof ParamTagValueNode
  113.                 && null === $prefix
  114.                 && $tagDocNode->value->parameterName !== '$'.$property
  115.             ) {
  116.                 continue;
  117.             }
  119.             foreach ($this->phpStanTypeHelper->getTypes($tagDocNode->value, $nameScope) as $type) {
  120.                 switch ($type->getClassName()) {
  121.                     case 'self':
  122.                     case 'static':
  123.                         $resolvedClass = $class;
  124.                         break;
  126.                     case 'parent':
  127.                         if (false !== $resolvedClass = $parentClass ??= get_parent_class($class)) {
  128.                             break;
  129.                         }
  130.                         // no break
  132.                     default:
  133.                         $types[] = $type;
  134.                         continue 2;
  135.                 }
  137.                 $types[] = new Type(Type::BUILTIN_TYPE_OBJECT, $type->isNullable(), $resolvedClass, $type->isCollection(), $type->getCollectionKeyTypes(), $type->getCollectionValueTypes());
  138.             }
  139.         }
  141.         if (!isset($types[0])) {
  142.             return null;
  143.         }
  145.         if (!\in_array($prefix, $this->arrayMutatorPrefixes, true)) {
  146.             return $types;
  147.         }
  149.         return [new Type(Type::BUILTIN_TYPE_ARRAY, false, null, true, new Type(Type::BUILTIN_TYPE_INT), $types[0])];
  150.     }
  152.     public function getTypesFromConstructor(string $class, string $property): ?array
  153.     {
  154.         if (null === $tagDocNode = $this->getDocBlockFromConstructor($class, $property)) {
  155.             return null;
  156.         }
  158.         $types = [];
  159.         foreach ($this->phpStanTypeHelper->getTypes($tagDocNode, $this->nameScopeFactory->create($class)) as $type) {
  160.             $types[] = $type;
  161.         }
  163.         if (!isset($types[0])) {
  164.             return null;
  165.         }
  167.         return $types;
  168.     }
  170.     private function getDocBlockFromConstructor(string $class, string $property): ?ParamTagValueNode
  171.     {
  172.         try {
  173.             $reflectionClass = new \ReflectionClass($class);
  174.         } catch (\ReflectionException) {
  175.             return null;
  176.         }
  178.         if (null === $reflectionConstructor = $reflectionClass->getConstructor()) {
  179.             return null;
  180.         }
  182.         $rawDocNode = $reflectionConstructor->getDocComment();
  183.         $tokens = new TokenIterator($this->lexer->tokenize($rawDocNode));
  184.         $phpDocNode = $this->phpDocParser->parse($tokens);
  185.         $tokens->consumeTokenType(Lexer::TOKEN_END);
  187.         return $this->filterDocBlockParams($phpDocNode, $property);
  188.     }
  190.     private function filterDocBlockParams(PhpDocNode $docNode, string $allowedParam): ?ParamTagValueNode
  191.     {
  192.         $tags = array_values(array_filter($docNode->getTagsByName('@param'), function ($tagNode) use ($allowedParam) {
  193.             return $tagNode instanceof PhpDocTagNode && ('$'.$allowedParam) === $tagNode->value->parameterName;
  194.         }));
  196.         if (!$tags) {
  197.             return null;
  198.         }
  200.         return $tags[0]->value;
  201.     }
  203.     /**
  204.      * @return array{PhpDocNode|null, int|null, string|null, string|null}
  205.      */
  206.     private function getDocBlock(string $class, string $property): array
  207.     {
  208.         $propertyHash = $class.'::'.$property;
  210.         if (isset($this->docBlocks[$propertyHash])) {
  211.             return $this->docBlocks[$propertyHash];
  212.         }
  214.         $ucFirstProperty = ucfirst($property);
  216.         if ([$docBlock, $source, $declaringClass] = $this->getDocBlockFromProperty($class, $property)) {
  217.             $data = [$docBlock, $source, null, $declaringClass];
  218.         } elseif ([$docBlock, $_, $declaringClass] = $this->getDocBlockFromMethod($class, $ucFirstProperty, self::ACCESSOR)) {
  219.             $data = [$docBlock, self::ACCESSOR, null, $declaringClass];
  220.         } elseif ([$docBlock, $prefix, $declaringClass] = $this->getDocBlockFromMethod($class, $ucFirstProperty, self::MUTATOR)) {
  221.             $data = [$docBlock, self::MUTATOR, $prefix, $declaringClass];
  222.         } else {
  223.             $data = [null, null, null, null];
  224.         }
  226.         return $this->docBlocks[$propertyHash] = $data;
  227.     }
  229.     /**
  230.      * @return array{PhpDocNode, int, string}|null
  231.      */
  232.     private function getDocBlockFromProperty(string $class, string $property): ?array
  233.     {
  234.         // Use a ReflectionProperty instead of $class to get the parent class if applicable
  235.         try {
  236.             $reflectionProperty = new \ReflectionProperty($class, $property);
  237.         } catch (\ReflectionException) {
  238.             return null;
  239.         }
  241.         $source = self::PROPERTY;
  243.         if ($reflectionProperty->isPromoted()) {
  244.             $constructor = new \ReflectionMethod($class, '__construct');
  245.             $rawDocNode = $constructor->getDocComment();
  246.             $source = self::MUTATOR;
  247.         } else {
  248.             $rawDocNode = $reflectionProperty->getDocComment();
  249.         }
  251.         if (!$rawDocNode) {
  252.             return null;
  253.         }
  255.         $tokens = new TokenIterator($this->lexer->tokenize($rawDocNode));
  256.         $phpDocNode = $this->phpDocParser->parse($tokens);
  257.         $tokens->consumeTokenType(Lexer::TOKEN_END);
  259.         return [$phpDocNode, $source, $reflectionProperty->class];
  260.     }
  262.     /**
  263.      * @return array{PhpDocNode, string, string}|null
  264.      */
  265.     private function getDocBlockFromMethod(string $class, string $ucFirstProperty, int $type): ?array
  266.     {
  267.         $prefixes = self::ACCESSOR === $type ? $this->accessorPrefixes : $this->mutatorPrefixes;
  268.         $prefix = null;
  270.         foreach ($prefixes as $prefix) {
  271.             $methodName = $prefix.$ucFirstProperty;
  273.             try {
  274.                 $reflectionMethod = new \ReflectionMethod($class, $methodName);
  275.                 if ($reflectionMethod->isStatic()) {
  276.                     continue;
  277.                 }
  279.                 if (
  280.                     (self::ACCESSOR === $type && 0 === $reflectionMethod->getNumberOfRequiredParameters())
  281.                     || (self::MUTATOR === $type && $reflectionMethod->getNumberOfParameters() >= 1)
  282.                 ) {
  283.                     break;
  284.                 }
  285.             } catch (\ReflectionException) {
  286.                 // Try the next prefix if the method doesn't exist
  287.             }
  288.         }
  290.         if (!isset($reflectionMethod)) {
  291.             return null;
  292.         }
  294.         if (null === $rawDocNode = $reflectionMethod->getDocComment() ?: null) {
  295.             return null;
  296.         }
  298.         $tokens = new TokenIterator($this->lexer->tokenize($rawDocNode));
  299.         $phpDocNode = $this->phpDocParser->parse($tokens);
  300.         $tokens->consumeTokenType(Lexer::TOKEN_END);
  302.         return [$phpDocNode, $prefix, $reflectionMethod->class];
  303.     }
  304. }