feature #57630 [TypeInfo] Redesign Type methods and nullability (mtarld)

This PR was merged into the 7.2 branch.

Discussion
----------

[TypeInfo] Redesign Type methods and nullability

| Q             | A
| ------------- | ---
| Branch?       | 7.2
| Bug fix?      | no
| New feature?  | yes
| Deprecations? | no
| Issues        |
| License       | MIT

By using the component and trying to integrate it within several libs, I ended up finding some limitations due to the component design.

Basically, the issues were:
- Abstract classes (such as `Type`) knowing its concrete implementations (such as in `getBaseType` method).
- For API simplicity `CollectionType`, and `GenericType` are forwarding methods to their wrapped type using `__call`, but I think this must be avoided as much as possible.
- It is difficult to know if a type is "just" a nullable type (because we need to check the union content).
- Invalid types could be instantiated

To tackle these issues, I propose the following:
- Introduce `CompositeTypeInterface` and `WrappingTypeInterface` that describe whether a type is composed by several types or wrapping one.
- Add a `NullableType` which extends `UnionType` and is a `WrappingTypeInterface`, so that it is easy to recognize a nullable type and to get the non-nullable related type.
- Remove the `Type::asNonNullable` method as it's covered by `NullableType::getWrappedType`
- Get rid of the `__call` method as it is easy to know it a type is wrapping another one
- Rename `is` to `satisfy` and add the new `CompositeTypeInterface::composedTypesSatisfy` and `WrappingTypeInterface::wrappedTypeSatisfy` methods
- Rename `isA` to `isIdentifiedBy`

Plus, **thanks to `@skalpa`'s great work**, the following checks are added to prevent invalid type construction:
- `BackedEnumType`
    - Backed type can only be `int` or `string`
- `CollectionType`
    - Main type can only be `array` or `iterable` when it's a built-in type
- `GenericType`
    - Main type can only be `array` or `iterable` when it's a built-in type
- `IntersectionType`
    - Cannot contain other types than class types
- `UnionType`
    - Cannot contain `UnionType`
    - Cannot contain standalone types (`mixed`, `void`, and `never`)
    - Cannot contain either `true` and `false`
    - Cannot contain either `bool` and `true` or `false`
    - Cannot contain either `object` and a class type

Commits
-------

8c376c89c9b [TypeInfo] Redesign Type methods and nullability

Author: nicolas-grekas

Mapping/Loader/PropertyInfoLoader.php

@@ -16,11 +16,13 @@
 use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
 use Symfony\Component\PropertyInfo\Type as PropertyInfoType;
 use Symfony\Component\TypeInfo\Type as TypeInfoType;
+use Symfony\Component\TypeInfo\Type\BuiltinType;
 use Symfony\Component\TypeInfo\Type\CollectionType;
-use Symfony\Component\TypeInfo\Type\IntersectionType;
+use Symfony\Component\TypeInfo\Type\CompositeTypeInterface;
+use Symfony\Component\TypeInfo\Type\NullableType;
 use Symfony\Component\TypeInfo\Type\ObjectType;
-use Symfony\Component\TypeInfo\Type\UnionType;
 use Symfony\Component\TypeInfo\TypeIdentifier;
+use Symfony\Component\TypeInfo\Type\WrappingTypeInterface;
 use Symfony\Component\Validator\Constraints\All;
 use Symfony\Component\Validator\Constraints\NotBlank;
 use Symfony\Component\Validator\Constraints\NotNull;
@@ -139,11 +141,10 @@ public function loadClassMetadata(ClassMetadata $metadata): bool
                 }
 
                 $type = $types;
-                $nullable = false;
+                $nullable = $type->isNullable();
 
-                if ($type instanceof UnionType && $type->isNullable()) {
-                    $nullable = true;
-                    $type = $type->asNonNullable();
+                if ($type instanceof NullableType) {
+                    $type = $type->getWrappedType();
                 }
 
                 if ($type instanceof CollectionType) {
@@ -193,18 +194,27 @@ private function getTypeConstraintLegacy(string $builtinType, PropertyInfoType $
 
     private function getTypeConstraint(TypeInfoType $type): ?Type
     {
-        if ($type instanceof UnionType || $type instanceof IntersectionType) {
-            return ($type->isA(TypeIdentifier::INT) || $type->isA(TypeIdentifier::FLOAT) || $type->isA(TypeIdentifier::STRING) || $type->isA(TypeIdentifier::BOOL)) ? new Type(['type' => 'scalar']) : null;
+        if ($type instanceof CompositeTypeInterface) {
+            return $type->isIdentifiedBy(
+                TypeIdentifier::INT,
+                TypeIdentifier::FLOAT,
+                TypeIdentifier::STRING,
+                TypeIdentifier::BOOL,
+                TypeIdentifier::TRUE,
+                TypeIdentifier::FALSE,
+            ) ? new Type(['type' => 'scalar']) : null;
         }
 
-        $baseType = $type->getBaseType();
+        while ($type instanceof WrappingTypeInterface) {
+            $type = $type->getWrappedType();
+        }
 
-        if ($baseType instanceof ObjectType) {
-            return new Type(['type' => $baseType->getClassName()]);
+        if ($type instanceof ObjectType) {
+            return new Type(['type' => $type->getClassName()]);
         }
 
-        if (TypeIdentifier::MIXED !== $baseType->getTypeIdentifier()) {
-            return new Type(['type' => $baseType->getTypeIdentifier()->value]);
+        if ($type instanceof BuiltinType && TypeIdentifier::MIXED !== $type->getTypeIdentifier()) {
+            return new Type(['type' => $type->getTypeIdentifier()->value]);
         }
 
         return null;

composer.json

@@ -39,7 +39,7 @@
         "symfony/property-access": "^6.4|^7.0",
         "symfony/property-info": "^6.4|^7.0",
         "symfony/translation": "^6.4.3|^7.0.3",
-        "symfony/type-info": "^7.1",
+        "symfony/type-info": "^7.2",
         "egulias/email-validator": "^2.1.10|^3|^4"
     },
     "conflict": {