vendor/symfony/property-info/Util/PhpDocTypeHelper.php line 108

  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\Util;
  14. use phpDocumentor\Reflection\PseudoType;
  15. use phpDocumentor\Reflection\PseudoTypes\ConstExpression;
  16. use phpDocumentor\Reflection\PseudoTypes\List_;
  17. use phpDocumentor\Reflection\Type as DocType;
  18. use phpDocumentor\Reflection\Types\Array_;
  19. use phpDocumentor\Reflection\Types\Collection;
  20. use phpDocumentor\Reflection\Types\Compound;
  21. use phpDocumentor\Reflection\Types\Integer;
  22. use phpDocumentor\Reflection\Types\Null_;
  23. use phpDocumentor\Reflection\Types\Nullable;
  24. use phpDocumentor\Reflection\Types\String_;
  25. use Symfony\Component\PropertyInfo\Type;
  27. // Workaround for phpdocumentor/type-resolver < 1.6
  28. // We trigger the autoloader here, so we don't need to trigger it inside the loop later.
  29. class_exists(List_::class);
  31. /**
  32.  * Transforms a php doc type to a {@link Type} instance.
  33.  *
  34.  * @author Kévin Dunglas <dunglas@gmail.com>
  35.  * @author Guilhem N. <egetick@gmail.com>
  36.  */
  37. final class PhpDocTypeHelper
  38. {
  39.     /**
  40.      * Creates a {@see Type} from a PHPDoc type.
  41.      *
  42.      * @return Type[]
  43.      */
  44.     public function getTypes(DocType $varType): array
  45.     {
  46.         if ($varType instanceof ConstExpression) {
  47.             // It's safer to fall back to other extractors here, as resolving const types correctly is not easy at the moment
  48.             return [];
  49.         }
  51.         $types = [];
  52.         $nullable = false;
  54.         if ($varType instanceof Nullable) {
  55.             $nullable = true;
  56.             $varType = $varType->getActualType();
  57.         }
  59.         if (!$varType instanceof Compound) {
  60.             if ($varType instanceof Null_) {
  61.                 $nullable = true;
  62.             }
  64.             $type = $this->createType($varType, $nullable);
  65.             if (null !== $type) {
  66.                 $types[] = $type;
  67.             }
  69.             return $types;
  70.         }
  72.         $varTypes = [];
  73.         for ($typeIndex = 0; $varType->has($typeIndex); ++$typeIndex) {
  74.             $type = $varType->get($typeIndex);
  76.             if ($type instanceof ConstExpression) {
  77.                 // It's safer to fall back to other extractors here, as resolving const types correctly is not easy at the moment
  78.                 return [];
  79.             }
  81.             // If null is present, all types are nullable
  82.             if ($type instanceof Null_) {
  83.                 $nullable = true;
  84.                 continue;
  85.             }
  87.             if ($type instanceof Nullable) {
  88.                 $nullable = true;
  89.                 $type = $type->getActualType();
  90.             }
  92.             $varTypes[] = $type;
  93.         }
  95.         foreach ($varTypes as $varType) {
  96.             $type = $this->createType($varType, $nullable);
  97.             if (null !== $type) {
  98.                 $types[] = $type;
  99.             }
  100.         }
  102.         return $types;
  103.     }
  105.     /**
  106.      * Creates a {@see Type} from a PHPDoc type.
  107.      */
  108.     private function createType(DocType $type, bool $nullable, string $docType = null): ?Type
  109.     {
  110.         $docType ??= (string) $type;
  112.         if ($type instanceof Collection) {
  113.             $fqsen = $type->getFqsen();
  114.             if ($fqsen && 'list' === $fqsen->getName() && !class_exists(List_::class, false) && !class_exists((string) $fqsen)) {
  115.                 // Workaround for phpdocumentor/type-resolver < 1.6
  116.                 return new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, new Type(Type::BUILTIN_TYPE_INT), $this->getTypes($type->getValueType()));
  117.             }
  119.             [$phpType, $class] = $this->getPhpTypeAndClass((string) $fqsen);
  121.             $key = $this->getTypes($type->getKeyType());
  122.             $value = $this->getTypes($type->getValueType());
  124.             // More than 1 type returned means it is a Compound type, which is
  125.             // not handled by Type, so better use a null value.
  126.             $key = 1 === \count($key) ? $key[0] : null;
  127.             $value = 1 === \count($value) ? $value[0] : null;
  129.             return new Type($phpType, $nullable, $class, true, $key, $value);
  130.         }
  132.         // Cannot guess
  133.         if (!$docType || 'mixed' === $docType) {
  134.             return null;
  135.         }
  137.         if (str_ends_with($docType, '[]')) {
  138.             $collectionKeyType = new Type(Type::BUILTIN_TYPE_INT);
  139.             $collectionValueType = $this->createType($type, false, substr($docType, 0, -2));
  141.             return new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, $collectionKeyType, $collectionValueType);
  142.         }
  144.         if ((str_starts_with($docType, 'list<') || str_starts_with($docType, 'array<')) && $type instanceof Array_) {
  145.             // array<value> is converted to x[] which is handled above
  146.             // so it's only necessary to handle array<key, value> here
  147.             $collectionKeyType = $this->getTypes($type->getKeyType())[0];
  149.             $collectionValueTypes = $this->getTypes($type->getValueType());
  150.             if (1 != \count($collectionValueTypes)) {
  151.                 // the Type class does not support union types yet, so assume that no type was defined
  152.                 $collectionValueType = null;
  153.             } else {
  154.                 $collectionValueType = $collectionValueTypes[0];
  155.             }
  157.             return new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, $collectionKeyType, $collectionValueType);
  158.         }
  160.         if ($type instanceof PseudoType) {
  161.             if ($type->underlyingType() instanceof Integer) {
  162.                 return new Type(Type::BUILTIN_TYPE_INT, $nullable, null);
  163.             } elseif ($type->underlyingType() instanceof String_) {
  164.                 return new Type(Type::BUILTIN_TYPE_STRING, $nullable, null);
  165.             }
  166.         }
  168.         $docType = $this->normalizeType($docType);
  169.         [$phpType, $class] = $this->getPhpTypeAndClass($docType);
  171.         if ('array' === $docType) {
  172.             return new Type(Type::BUILTIN_TYPE_ARRAY, $nullable, null, true, null, null);
  173.         }
  175.         return new Type($phpType, $nullable, $class);
  176.     }
  178.     private function normalizeType(string $docType): string
  179.     {
  180.         return match ($docType) {
  181.             'integer' => 'int',
  182.             'boolean' => 'bool',
  183.             // real is not part of the PHPDoc standard, so we ignore it
  184.             'double' => 'float',
  185.             'callback' => 'callable',
  186.             'void' => 'null',
  187.             default => $docType,
  188.         };
  189.     }
  191.     private function getPhpTypeAndClass(string $docType): array
  192.     {
  193.         if (\in_array($docType, Type::$builtinTypes)) {
  194.             return [$docType, null];
  195.         }
  197.         if (\in_array($docType, ['parent', 'self', 'static'], true)) {
  198.             return ['object', $docType];
  199.         }
  201.         return ['object', ltrim($docType, '\\')];
  202.     }
  203. }