[TypeInfo][PropertyInfo] Deprecate PropertyInfo Type

Co-authored-by: Baptiste Leduc <[email protected]>

Author: mtarld

src/Symfony/Component/PropertyInfo/CHANGELOG.md

@@ -1,6 +1,11 @@
 CHANGELOG
 =========
 
+7.1
+---
+
+ * Deprecate the `Type` class, use `Symfony\Component\TypeInfo\Type` class of `symfony/type-info` component instead
+
 6.4
 ---
 

src/Symfony/Component/PropertyInfo/Type.php

@@ -11,46 +11,57 @@
 
 namespace Symfony\Component\PropertyInfo;
 
+use Symfony\Component\TypeInfo\Type as TypeInfoType;
+use Symfony\Component\TypeInfo\Type\BuiltinType;
+use Symfony\Component\TypeInfo\Type\GenericType;
+use Symfony\Component\TypeInfo\Type\IntersectionType;
+use Symfony\Component\TypeInfo\Type\ObjectType;
+use Symfony\Component\TypeInfo\Type\UnionType;
+
+trigger_deprecation('symfony/property-info', '7.1', 'The "%s" class is deprecated. Use "%s" of "symfony/type-info" component instead.', Type::class, TypeInfoType::class);
+
 /**
  * Type value object (immutable).
  *
  * @author Kévin Dunglas <[email protected]>
  *
  * @final
+ *
+ * @deprecated since Symfony 7.1, use "Symfony\Component\TypeInfo\Type" of "symfony/type-info" component instead.
  */
 class Type
 {
-    public const BUILTIN_TYPE_INT = 'int';
-    public const BUILTIN_TYPE_FLOAT = 'float';
-    public const BUILTIN_TYPE_STRING = 'string';
-    public const BUILTIN_TYPE_BOOL = 'bool';
-    public const BUILTIN_TYPE_RESOURCE = 'resource';
-    public const BUILTIN_TYPE_OBJECT = 'object';
-    public const BUILTIN_TYPE_ARRAY = 'array';
-    public const BUILTIN_TYPE_NULL = 'null';
-    public const BUILTIN_TYPE_FALSE = 'false';
-    public const BUILTIN_TYPE_TRUE = 'true';
-    public const BUILTIN_TYPE_CALLABLE = 'callable';
-    public const BUILTIN_TYPE_ITERABLE = 'iterable';
+    public const BUILTIN_TYPE_INT = TypeInfoType::BUILTIN_TYPE_INT;
+    public const BUILTIN_TYPE_FLOAT = TypeInfoType::BUILTIN_TYPE_FLOAT;
+    public const BUILTIN_TYPE_STRING = TypeInfoType::BUILTIN_TYPE_STRING;
+    public const BUILTIN_TYPE_BOOL = TypeInfoType::BUILTIN_TYPE_BOOL;
+    public const BUILTIN_TYPE_RESOURCE = TypeInfoType::BUILTIN_TYPE_RESOURCE;
+    public const BUILTIN_TYPE_OBJECT = TypeInfoType::BUILTIN_TYPE_OBJECT;
+    public const BUILTIN_TYPE_ARRAY = TypeInfoType::BUILTIN_TYPE_ARRAY;
+    public const BUILTIN_TYPE_NULL = TypeInfoType::BUILTIN_TYPE_NULL;
+    public const BUILTIN_TYPE_FALSE = TypeInfoType::BUILTIN_TYPE_FALSE;
+    public const BUILTIN_TYPE_TRUE = TypeInfoType::BUILTIN_TYPE_TRUE;
+    public const BUILTIN_TYPE_CALLABLE = TypeInfoType::BUILTIN_TYPE_CALLABLE;
+    public const BUILTIN_TYPE_ITERABLE = TypeInfoType::BUILTIN_TYPE_ITERABLE;
 
     /**
      * List of PHP builtin types.
      *
      * @var string[]
      */
     public static array $builtinTypes = [
-        self::BUILTIN_TYPE_INT,
-        self::BUILTIN_TYPE_FLOAT,
-        self::BUILTIN_TYPE_STRING,
-        self::BUILTIN_TYPE_BOOL,
-        self::BUILTIN_TYPE_RESOURCE,
-        self::BUILTIN_TYPE_OBJECT,
-        self::BUILTIN_TYPE_ARRAY,
-        self::BUILTIN_TYPE_CALLABLE,
-        self::BUILTIN_TYPE_FALSE,
-        self::BUILTIN_TYPE_TRUE,
-        self::BUILTIN_TYPE_NULL,
-        self::BUILTIN_TYPE_ITERABLE,
+        TypeInfoType::BUILTIN_TYPE_INT,
+        TypeInfoType::BUILTIN_TYPE_FLOAT,
+        TypeInfoType::BUILTIN_TYPE_STRING,
+        TypeInfoType::BUILTIN_TYPE_BOOL,
+        TypeInfoType::BUILTIN_TYPE_RESOURCE,
+        TypeInfoType::BUILTIN_TYPE_OBJECT,
+        TypeInfoType::BUILTIN_TYPE_ARRAY,
+        TypeInfoType::BUILTIN_TYPE_CALLABLE,
+        TypeInfoType::BUILTIN_TYPE_FALSE,
+        TypeInfoType::BUILTIN_TYPE_TRUE,
+        TypeInfoType::BUILTIN_TYPE_NULL,
+        TypeInfoType::BUILTIN_TYPE_ITERABLE,
     ];
 
     /**
@@ -59,54 +70,59 @@ class Type
      * @var string[]
      */
     public static array $builtinCollectionTypes = [
-        self::BUILTIN_TYPE_ARRAY,
-        self::BUILTIN_TYPE_ITERABLE,
+        TypeInfoType::BUILTIN_TYPE_ARRAY,
+        TypeInfoType::BUILTIN_TYPE_ITERABLE,
     ];
 
-    private string $builtinType;
-    private bool $nullable;
-    private ?string $class;
-    private bool $collection;
-    private array $collectionKeyType;
-    private array $collectionValueType;
+    private TypeInfoType $internalType;
 
     /**
      * @param Type[]|Type|null $collectionKeyType
      * @param Type[]|Type|null $collectionValueType
      *
      * @throws \InvalidArgumentException
      */
-    public function __construct(string $builtinType, bool $nullable = false, string $class = null, bool $collection = false, array|Type $collectionKeyType = null, array|Type $collectionValueType = null)
+    public function __construct(string $builtinType, bool $nullable = false, string $class = null, bool $collection = false, array|self $collectionKeyType = null, array|self $collectionValueType = null)
     {
-        if (!\in_array($builtinType, self::$builtinTypes)) {
-            throw new \InvalidArgumentException(sprintf('"%s" is not a valid PHP type.', $builtinType));
-        }
+        $genericTypes = [];
 
-        $this->builtinType = $builtinType;
-        $this->nullable = $nullable;
-        $this->class = $class;
-        $this->collection = $collection;
-        $this->collectionKeyType = $this->validateCollectionArgument($collectionKeyType, 5, '$collectionKeyType') ?? [];
-        $this->collectionValueType = $this->validateCollectionArgument($collectionValueType, 6, '$collectionValueType') ?? [];
-    }
+        $collectionKeyType = $this->validateCollectionArgument($collectionKeyType, 5, '$collectionKeyType') ?? [];
+        $collectionValueType = $this->validateCollectionArgument($collectionValueType, 6, '$collectionValueType') ?? [];
 
-    private function validateCollectionArgument(array|Type|null $collectionArgument, int $argumentIndex, string $argumentName): ?array
-    {
-        if (null === $collectionArgument) {
-            return null;
+        if (null !== $collectionKeyType && [] !== $collectionKeyType) {
+            if (\is_array($collectionKeyType)) {
+                $collectionKeyType = array_unique(array_map(fn ($t): TypeInfoType => $t->getTypeInfoType(), $collectionKeyType));
+                $genericTypes[] = \count($collectionKeyType) > 1 ? TypeInfoType::union(...$collectionKeyType) : $collectionKeyType[0];
+            } else {
+                $genericTypes[] = $collectionKeyType->getTypeInfoType();
+            }
         }
 
-        if (\is_array($collectionArgument)) {
-            foreach ($collectionArgument as $type) {
-                if (!$type instanceof self) {
-                    throw new \TypeError(sprintf('"%s()": Argument #%d (%s) must be of type "%s[]", "%s" or "null", array value "%s" given.', __METHOD__, $argumentIndex, $argumentName, self::class, self::class, get_debug_type($collectionArgument)));
-                }
+        if (null !== $collectionValueType && [] !== $collectionValueType) {
+            if ([] === $genericTypes) {
+                $genericTypes[] = TypeInfoType::int();
             }
 
-            return $collectionArgument;
+            if (\is_array($collectionValueType)) {
+                $collectionValueType = array_unique(array_map(fn ($t): TypeInfoType => $t->getTypeInfoType(), $collectionValueType));
+                $genericTypes[] = \count($collectionValueType) > 1 ? TypeInfoType::union(...$collectionValueType) : $collectionValueType[0];
+            } else {
+                $genericTypes[] = $collectionValueType->getTypeInfoType();
+            }
         }
 
-        return [$collectionArgument];
+        $this->internalType = null !== $class ? new ObjectType($class) : new BuiltinType($builtinType);
+        $this->internalType->isCollection = $collection;
+
+        if (\count($genericTypes)) {
+            $this->internalType = TypeInfoType::generic($this->internalType, ...$genericTypes);
+            $this->internalType->isCollection = $collection;
+        }
+
+        if ($nullable) {
+            $this->internalType = TypeInfoType::nullable($this->internalType);
+            $this->internalType->isCollection = $collection;
+        }
     }
 
     /**
@@ -116,12 +132,15 @@ private function validateCollectionArgument(array|Type|null $collectionArgument,
      */
     public function getBuiltinType(): string
     {
-        return $this->builtinType;
+        $internalType = $this->unwrapNullableType($this->internalType);
+        $internalType = $this->unwrapGenericType($internalType);
+
+        return $internalType instanceof BuiltinType ? $internalType->getBuiltinType() : TypeInfoType::BUILTIN_TYPE_OBJECT;
     }
 
     public function isNullable(): bool
     {
-        return $this->nullable;
+        return $this->internalType->isNullable();
     }
 
     /**
@@ -131,12 +150,22 @@ public function isNullable(): bool
      */
     public function getClassName(): ?string
     {
-        return $this->class;
+        $internalType = $this->unwrapNullableType($this->internalType);
+        $internalType = $this->unwrapGenericType($internalType);
+
+        if (!$internalType instanceof ObjectType) {
+            return null;
+        }
+
+        return $internalType->getClassName();
     }
 
     public function isCollection(): bool
     {
-        return $this->collection;
+        $internalType = $this->unwrapNullableType($this->internalType);
+        $internalType = $this->unwrapGenericType($internalType);
+
+        return $internalType->isCollection;
     }
 
     /**
@@ -148,7 +177,22 @@ public function isCollection(): bool
      */
     public function getCollectionKeyTypes(): array
     {
-        return $this->collectionKeyType;
+        $internalType = $this->unwrapNullableType($this->internalType);
+
+        if (!$internalType instanceof GenericType) {
+            return [];
+        }
+
+        if (null === ($collectionKeyType = $internalType->getGenericTypes()[0] ?? null)) {
+            return [];
+        }
+
+        $collectionKeyType = $this->convertFromTypeInfoType($collectionKeyType);
+        if (!\is_array($collectionKeyType)) {
+            $collectionKeyType = [$collectionKeyType];
+        }
+
+        return $collectionKeyType;
     }
 
     /**
@@ -160,6 +204,108 @@ public function getCollectionKeyTypes(): array
      */
     public function getCollectionValueTypes(): array
     {
-        return $this->collectionValueType;
+        $internalType = $this->unwrapNullableType($this->internalType);
+
+        if (!$internalType instanceof GenericType) {
+            return [];
+        }
+
+        if (null === ($collectionValueType = $internalType->getGenericTypes()[1] ?? null)) {
+            return [];
+        }
+
+        $collectionValueType = $this->convertFromTypeInfoType($collectionValueType);
+        if (!\is_array($collectionValueType)) {
+            $collectionValueType = [$collectionValueType];
+        }
+
+        return $collectionValueType;
+    }
+
+    private function getTypeInfoType(): TypeInfoType
+    {
+        return $this->internalType;
+    }
+
+    private function convertFromTypeInfoType(TypeInfoType $typeInfoType): self|array
+    {
+        if ($typeInfoType instanceof UnionType) {
+            return array_map($this->convertFromTypeInfoType(...), $typeInfoType->getTypes());
+        }
+
+        if ($typeInfoType instanceof IntersectionType) {
+            return array_map($this->convertFromTypeInfoType(...), $typeInfoType->getTypes());
+        }
+
+        $builtinType = TypeInfoType::BUILTIN_TYPE_MIXED;
+        $className = null;
+        $collectionKeyType = $collectionValueType = null;
+
+        if ($typeInfoType instanceof ObjectType) {
+            $builtinType = TypeInfoType::BUILTIN_TYPE_OBJECT;
+            $className = $typeInfoType->getClassName();
+        }
+
+        if ($typeInfoType instanceof GenericType) {
+            /** @var BuiltinType $nestedType */
+            $nestedType = $this->unwrapNullableType($typeInfoType->getType());
+            $builtinType = $nestedType->getBuiltinType();
+
+            $genericTypes = $typeInfoType->getGenericTypes();
+            $collectionKeyType = isset($genericTypes[0]) ? $this->convertFromTypeInfoType($genericTypes[0]) : null;
+            $collectionValueType = isset($genericTypes[1]) ? $this->convertFromTypeInfoType($genericTypes[1]) : null;
+        }
+
+        if ($typeInfoType instanceof BuiltinType) {
+            $builtinType = $typeInfoType->getBuiltinType();
+        }
+
+        return new self(
+            builtinType: $builtinType,
+            nullable: $typeInfoType->isNullable(),
+            class: $className,
+            collection: $typeInfoType->isCollection,
+            collectionKeyType: $collectionKeyType,
+            collectionValueType: $collectionValueType,
+        );
+    }
+
+    private function validateCollectionArgument(array|self|null $collectionArgument, int $argumentIndex, string $argumentName): ?array
+    {
+        if (null === $collectionArgument) {
+            return null;
+        }
+
+        if (\is_array($collectionArgument)) {
+            foreach ($collectionArgument as $type) {
+                if (!$type instanceof self) {
+                    throw new \TypeError(sprintf('"%s()": Argument #%d (%s) must be of type "%s[]", "%s" or "null", array value "%s" given.', __METHOD__, $argumentIndex, $argumentName, self::class, self::class, get_debug_type($collectionArgument)));
+                }
+            }
+
+            return $collectionArgument;
+        }
+
+        return [$collectionArgument];
+    }
+
+    private function unwrapNullableType(TypeInfoType $type): TypeInfoType
+    {
+        if (!$type instanceof UnionType) {
+            return $type;
+        }
+
+        $unionTypes = $type->getTypes();
+
+        return (string) TypeInfoType::null() === (string) $unionTypes[0] ? $unionTypes[1] : $unionTypes[0];
+    }
+
+    private function unwrapGenericType(TypeInfoType $type): TypeInfoType
+    {
+        if (!$type instanceof GenericType) {
+            return $type;
+        }
+
+        return $type->getType();
     }
 }

src/Symfony/Component/PropertyInfo/composer.json

@@ -24,7 +24,8 @@
     ],
     "require": {
         "php": ">=8.2",
-        "symfony/string": "^6.4|^7.0"
+        "symfony/string": "^6.4|^7.0",
+        "symfony/type-info": "^7.1"
     },
     "require-dev": {
         "symfony/serializer": "^6.4|^7.0",

src/Symfony/Component/TypeInfo/Type.php

@@ -54,6 +54,13 @@ abstract class Type implements \Stringable
         self::BUILTIN_TYPE_MIXED,
     ];
 
+    /**
+     * BC Layer for Symfony\Component\PropertyInfo\Type.
+     *
+     * @internal
+     */
+    public bool $isCollection = false;
+
     public function isBuiltinType(string $builtinType): bool
     {
         if (!\in_array($builtinType, self::BUILTIN_TYPES)) {