symfony · idbentley · Jun 26, 2024 · Jun 26, 2024
@@ -45,8 +45,15 @@
 *
 * @author Kévin Dunglas <dunglas@gmail.com>
 */
-abstract class AbstractObjectNormalizer extends AbstractNormalizer
+abstract class AbstractObjectNormalizer extends AbstractNormalizer implements DenormalizerInterface, DenormalizerAwareInterface
 {
+    use DenormalizerAwareTrait;
+
+    public function setDenormalizer(DenormalizerInterface $denormalizer): void
+    {
+        $this->denormalizer = $denormalizer;
+    }
+
    /**
     * Set to true to respect the max depth metadata on fields.
     */
@@ -122,13 +129,15 @@
    private array $typeCache = [];
    private array $attributesCache = [];
    private readonly \Closure $objectClassResolver;
+    private bool $consistentDenormalization;

    public function __construct(
        ?ClassMetadataFactoryInterface $classMetadataFactory = null,
        ?NameConverterInterface $nameConverter = null,
        private ?PropertyTypeExtractorInterface $propertyTypeExtractor = null,
        ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null,
        ?callable $objectClassResolver = null,
+        bool $consistentDenormalization = false,
        array $defaultContext = [],
    ) {
        parent::__construct($classMetadataFactory, $nameConverter, $defaultContext);
@@ -144,6 +153,7 @@
        }
        $this->classDiscriminatorResolver = $classDiscriminatorResolver;
        $this->objectClassResolver = ($objectClassResolver ?? 'get_class')(...);
+        $this->consistentDenormalization = $consistentDenormalization;
    }

    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
@@ -372,12 +382,16 @@

            if (null !== $type = $this->getType($resolvedClass, $attribute)) {
                try {
-                    // BC layer for PropertyTypeExtractorInterface::getTypes().
-                    // Can be removed as soon as PropertyTypeExtractorInterface::getTypes() is removed (8.0).
-                    if (\is_array($type)) {
-                        $value = $this->validateAndDenormalizeLegacy($type, $resolvedClass, $attribute, $value, $format, $attributeContext);
+                    if($this->consistentDenormalization) {
+                        $value = $this->denormalizer->denormalize($value, $type, $format, $context);
                    } else {
-                        $value = $this->validateAndDenormalize($type, $resolvedClass, $attribute, $value, $format, $attributeContext);
+                        // BC layer for PropertyTypeExtractorInterface::getTypes().
+                        // Can be removed as soon as PropertyTypeExtractorInterface::getTypes() is removed (8.0).
+                        if (\is_array($type)) {
+                            $value = $this->validateAndDenormalizeLegacy($type, $resolvedClass, $attribute, $value, $format, $attributeContext);
+                        } else {
+                            $value = $this->validateAndDenormalize($type, $resolvedClass, $attribute, $value, $format, $attributeContext);
+                        }
                    }
                } catch (NotNormalizableValueException $exception) {
                    if (isset($context['not_normalizable_value_exceptions'])) {

@@ -18,6 +18,8 @@
 use Symfony\Component\TypeInfo\Type;
 use Symfony\Component\TypeInfo\Type\UnionType;

+use Symfony\Component\PropertyInfo\Util\PhpDocTypeHelper;
+
 /**
 * Denormalizes arrays of objects.
 *
@@ -44,27 +46,38 @@
     */
    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): array
    {
+        $typeResolver = new \phpDocumentor\Reflection\TypeResolver();
+        $result = $typeResolver->resolve($type);
+
        if (null === $this->denormalizer) {
            throw new BadMethodCallException('Please set a denormalizer before calling denormalize()!');
        }
        if (!\is_array($data)) {
            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Data expected to be "%s", "%s" given.', $type, get_debug_type($data)), $data, ['array'], $context['deserialization_path'] ?? null);
        }
-        if (!str_ends_with($type, '[]')) {
+
+        if (!$result instanceof \phpDocumentor\Reflection\Types\AbstractList) {
            throw new InvalidArgumentException('Unsupported class: '.$type);
        }

-        $type = substr($type, 0, -2);
+
+        $type = (string) $result->getValueType();

        $typeIdentifiers = [];
-        if (null !== $keyType = ($context['key_type'] ?? null)) {
+        $keyTYye = $result->getKeyType();
+        if ($keyType == null) {
+            // Overwrite if context provides keyType
+            $keyType = $context['key_type'] ?? null;
+        }
+        if (null !== $keyType) {
            if ($keyType instanceof Type) {
                $typeIdentifiers = array_map(fn (Type $t): string => $t->getBaseType()->getTypeIdentifier()->value, $keyType instanceof UnionType ? $keyType->getTypes() : [$keyType]);
            } else {
                $typeIdentifiers = array_map(fn (LegacyType $t): string => $t->getBuiltinType(), \is_array($keyType) ? $keyType : [$keyType]);
            }
        }

+
        foreach ($data as $key => $value) {
            $subContext = $context;
            $subContext['deserialization_path'] = ($context['deserialization_path'] ?? false) ? sprintf('%s[%s]', $context['deserialization_path'], $key) : "[$key]";
@@ -83,8 +96,12 @@
            throw new BadMethodCallException(sprintf('The nested denormalizer needs to be set to allow "%s()" to be used.', __METHOD__));
        }

-        return str_ends_with($type, '[]')
-            && $this->denormalizer->supportsDenormalization($data, substr($type, 0, -2), $format, $context);
+        $typeResolver = new \phpDocumentor\Reflection\TypeResolver();
+        $result = $typeResolver->resolve($type);
+
+
+        return $result instanceof \phpDocumentor\Reflection\Types\AbstractList
+            && $this->denormalizer->supportsDenormalization($data, (string) $result->getValueType(), $format, $context);
    }

    /**

@@ -42,19 +42,29 @@ final class ObjectNormalizer extends AbstractObjectNormalizer

    private readonly \Closure $objectClassResolver;

-    public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory = null, ?NameConverterInterface $nameConverter = null, ?PropertyAccessorInterface $propertyAccessor = null, ?PropertyTypeExtractorInterface $propertyTypeExtractor = null, ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, ?callable $objectClassResolver = null, array $defaultContext = [], ?PropertyInfoExtractorInterface $propertyInfoExtractor = null)
+    public function __construct(
+        ?ClassMetadataFactoryInterface $classMetadataFactory = null,
+        ?NameConverterInterface $nameConverter = null,
+        ?PropertyAccessorInterface $propertyAccessor = null,
+        ?PropertyTypeExtractorInterface $propertyTypeExtractor = null,
+        ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null,
+        ?callable $objectClassResolver = null,
+        bool $consistentDenormalization = false,
+        array $defaultContext = [],
+        ?PropertyInfoExtractorInterface $propertyInfoExtractor = null)
    {
        if (!class_exists(PropertyAccess::class)) {
            throw new LogicException('The ObjectNormalizer class requires the "PropertyAccess" component. Try running "composer require symfony/property-access".');
        }

-        parent::__construct($classMetadataFactory, $nameConverter, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $defaultContext);
+        parent::__construct($classMetadataFactory, $nameConverter, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $consistentDenormalization, $defaultContext);

        $this->propertyAccessor = $propertyAccessor ?: PropertyAccess::createPropertyAccessor();

        $this->objectClassResolver = ($objectClassResolver ?? static fn ($class) => \is_object($class) ? $class::class : $class)(...);
        $this->propertyInfoExtractor = $propertyInfoExtractor ?: new ReflectionExtractor();
        $this->writeInfoExtractor = new ReflectionExtractor();
+
    }

    public function getSupportedTypes(?string $format): array

@@ -45,9 +45,9 @@ final class PropertyNormalizer extends AbstractObjectNormalizer
     */
    public const NORMALIZE_VISIBILITY = 'normalize_visibility';

-    public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory = null, ?NameConverterInterface $nameConverter = null, ?PropertyTypeExtractorInterface $propertyTypeExtractor = null, ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, ?callable $objectClassResolver = null, array $defaultContext = [])
+    public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory = null, ?NameConverterInterface $nameConverter = null, ?PropertyTypeExtractorInterface $propertyTypeExtractor = null, ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver = null, ?callable $objectClassResolver = null, bool $consistency = false, array $defaultContext = [])
    {
-        parent::__construct($classMetadataFactory, $nameConverter, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $defaultContext);
+        parent::__construct($classMetadataFactory, $nameConverter, $propertyTypeExtractor, $classDiscriminatorResolver, $objectClassResolver, $consistency, $defaultContext);

        if (!isset($this->defaultContext[self::NORMALIZE_VISIBILITY])) {
            $this->defaultContext[self::NORMALIZE_VISIBILITY] = self::NORMALIZE_PUBLIC | self::NORMALIZE_PROTECTED | self::NORMALIZE_PRIVATE;

@@ -0,0 +1,84 @@
+<?php
+
+/*
+ * This file is part of the Symfony package.
+ *
+ * (c) Fabien Potencier <fabien@symfony.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+namespace Symfony\Component\Serializer\Normalizer;
+
+use Symfony\Component\Serializer\Exception\MissingConstructorArgumentsException;
+use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
+use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerAwareTrait;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * @author Ian Bentley <ian@idbentley.com>
+ */
+final class UnionDenormalizer implements DenormalizerAwareInterface, DenormalizerInterface
+{
+    use DenormalizerAwareTrait;
+
+    public function setDenormalizer(DenormalizerInterface $denormalizer): void
+    {
+        $this->denormalizer = $denormalizer;
+    }
+
+    public function getSupportedTypes(?string $format): array
+    {
+        return ['*' => true];
+    }
+
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
+    {
+        if ($this->denormalizer === null) {
+            throw new \BadMethodCallException(sprintf('The nested denormalizer needs to be set to allow "%s()" to be used.', __METHOD__));
+        }
+        if (str_contains($type, '|')) {
+            $possibleTypes = explode('|', $type);
+            $support = true;
+
+            // all possible types must be supported
+            foreach ($possibleTypes as $possibleType) {
+                $typeSupport = $this->denormalizer->supportsDenormalization($data, $possibleType, $format, $context);
+                $support = $support && $typeSupport;
+            }
+            return $support;
+        }
+
+        return false;
+    }
+
+    /** @phpstan-ignore-next-line */
+    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
+    {
+        $typeResolver = new \phpDocumentor\Reflection\TypeResolver();
+        $result = $typeResolver->resolve($type);
+        $possibleTypes = explode('|', $type);
+
+        $extraAttributesException = null;
+        $missingConstructorArgumentsException = null;
+
+        if (count($possibleTypes) == 1) {
+            return $this->denormalizer->denormalize($data, $type, $format, $context);
+        }
+
+        foreach ($possibleTypes as $possibleType) {
+            if (null === $data && $possibleType->isNullable()) {
+                return null;
+            }
+
+            try {
+                return $this->denormalizer->denormalize($data, $possibleType, $format, $context);
+            } catch (MissingConstructorArgumentsException $e) {
+                echo "Couldn't denormalize $possibleType: $e\n";
+            }
+        }
+        throw new NotNormalizableValueException("Couldn't denormalize any of the possible types");
+    }
+}
@@ -23,17 +23,32 @@ class DeserializeNestedArrayOfObjectsTest extends TestCase
    public static function provider()
    {
        return [
-            // from property PhpDoc
-            [Zoo::class],
-            // from argument constructor PhpDoc
-            [ZooImmutable::class],
+            // from property PhpDoc, consistent
+            [Zoo::class, true],
+            // from property PhpDoc, legacy
+            [Zoo::class, false],
+            // from argument constructor PhpDoc, consistent
+            [ZooImmutable::class, true],
+            // from argument constructor PhpDoc, legacy
+            [ZooImmutable::class, false],
+
+        ];
+    }
+
+    public static function consistencyProvider()
+    {
+        return [
+            // consistent
+            [true],
+            // legacy
+            [false],
        ];
    }

    /**
     * @dataProvider provider
     */
-    public function testPropertyPhpDoc($class)
+    public function testPropertyPhpDoc($class, $consistent)
    {
        $json = <<<EOF
 {
@@ -43,7 +58,7 @@ public function testPropertyPhpDoc($class)
 }
 EOF;
        $serializer = new Serializer([
-            new ObjectNormalizer(null, null, null, new PhpDocExtractor()),
+            new ObjectNormalizer(null, null, null, new PhpDocExtractor(), null, null, $consistent),
            new ArrayDenormalizer(),
        ], ['json' => new JsonEncoder()]);

@@ -54,7 +69,10 @@ public function testPropertyPhpDoc($class)
        self::assertInstanceOf(Animal::class, $zoo->getAnimals()[0]);
    }

-    public function testPropertyPhpDocWithKeyTypes()
+    /**
+     * @dataProvider consistencyProvider
+     */
+    public function testPropertyPhpDocWithKeyTypes($consistent)
    {
        $json = <<<EOF
 {
@@ -75,7 +93,7 @@ public function testPropertyPhpDocWithKeyTypes()
 }
 EOF;
        $serializer = new Serializer([
-            new ObjectNormalizer(null, null, null, new PhpDocExtractor()),
+            new ObjectNormalizer(null, null, null, new PhpDocExtractor(), null, null, $consistent),
            new ArrayDenormalizer(),
        ], ['json' => new JsonEncoder()]);