Add COLLECT_EXTRA_ATTRIBUTES_ERRORS and full deserialization path

NorthBlue333 · nicolas-grekas · commit 205dd709ed93 · 2026-04-30T15:43:13.000+02:00
diff --git a/UPGRADE-8.1.md b/UPGRADE-8.1.md
@@ -127,6 +127,8 @@ Serializer
 ----------
 
  * Deprecate datetime constructor as a fallback, in version 9.0 a `Symfony\Component\Serializer\Exception\NotNormalizableValueException` will be thrown when a date could not be parsed using the default format
+ * Change the signature of `PartialDenormalizationException::__construct($data, array $errors)` to `__construct(mixed $data, array $notNormalizableErrors, array $extraAttributesErrors = [])`
+ * Deprecate `PartialDenormalizationException::getErrors()`, use `getNotNormalizableValueErrors()` instead
 
 Uid
 ---
diff --git a/src/Symfony/Component/HttpKernel/Controller/ArgumentResolver/RequestPayloadValueResolver.php b/src/Symfony/Component/HttpKernel/Controller/ArgumentResolver/RequestPayloadValueResolver.php
@@ -133,7 +133,8 @@ public function onKernelControllerArguments(ControllerArgumentsEvent $event): vo
                     $payload = $payloadMapper($request, $argument->metadata, $argument);
                 } catch (PartialDenormalizationException $e) {
                     $trans = $this->translator ? $this->translator->trans(...) : static fn ($m, $p) => strtr($m, $p);
-                    foreach ($e->getErrors() as $error) {
+                    $errors = method_exists($e, 'getNotNormalizableValueErrors') ? $e->getNotNormalizableValueErrors() : $e->getErrors();
+                    foreach ($errors as $error) {
                         $parameters = [];
                         $template = 'This value was of an unexpected type.';
                         if ($expectedTypes = $error->getExpectedTypes()) {
@@ -173,7 +174,8 @@ public function onKernelControllerArguments(ControllerArgumentsEvent $event): vo
                 try {
                     $payload = $payloadMapper($request, $argument->metadata, $argument);
                 } catch (PartialDenormalizationException $e) {
-                    throw HttpException::fromStatusCode($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $e->getErrors())), $e);
+                    $errors = method_exists($e, 'getNotNormalizableValueErrors') ? $e->getNotNormalizableValueErrors() : $e->getErrors();
+                    throw HttpException::fromStatusCode($validationFailedCode, implode("\n", array_map(static fn ($e) => $e->getMessage(), $errors)), $e);
                 } catch (SerializerInvalidArgumentException $e) {
                     throw HttpException::fromStatusCode($validationFailedCode, $e->getMessage(), $e);
                 }
diff --git a/src/Symfony/Component/PropertyAccess/CHANGELOG.md b/src/Symfony/Component/PropertyAccess/CHANGELOG.md
@@ -1,6 +1,11 @@
 CHANGELOG
 =========
 
+8.1
+---
+
+ * Add `PropertyPath::append()`
+
 7.0
 ---
 
diff --git a/src/Symfony/Component/PropertyAccess/PropertyPath.php b/src/Symfony/Component/PropertyAccess/PropertyPath.php
@@ -202,4 +202,33 @@ public function isNullSafe(int $index): bool
 
         return $this->isNullSafe[$index];
     }
+
+    /**
+     * Utility method for dealing with property paths.
+     * For more extensive functionality, use instances of this class.
+     *
+     * Appends a path to a given property path.
+     *
+     * If the base path is empty, the appended path will be returned unchanged.
+     * If the base path is not empty, and the appended path starts with a
+     * squared opening bracket ("["), the concatenation of the two paths is
+     * returned. Otherwise, the concatenation of the two paths is returned,
+     * separated by a dot (".").
+     */
+    public static function append(string $basePath, string $subPath): string
+    {
+        if ('' === $subPath) {
+            return $basePath;
+        }
+
+        if ('[' === $subPath[0]) {
+            return $basePath.$subPath;
+        }
+
+        if ('' === $basePath) {
+            return $subPath;
+        }
+
+        return $basePath.'.'.$subPath;
+    }
 }
diff --git a/src/Symfony/Component/PropertyAccess/Tests/PropertyPathTest.php b/src/Symfony/Component/PropertyAccess/Tests/PropertyPathTest.php
@@ -203,4 +203,22 @@ public function testIsIndexDoesNotAcceptNegativeIndices()
 
         $propertyPath->isIndex(-1);
     }
+
+    #[DataProvider('provideAppendPaths')]
+    public function testAppend(string $basePath, string $subPath, string $expectedPath, string $message)
+    {
+        $this->assertSame($expectedPath, PropertyPath::append($basePath, $subPath), $message);
+    }
+
+    public static function provideAppendPaths()
+    {
+        return [
+            ['foo', '', 'foo', 'It returns the basePath if subPath is empty'],
+            ['', 'bar', 'bar', 'It returns the subPath if basePath is empty'],
+            ['foo', 'bar', 'foo.bar', 'It append the subPath to the basePath'],
+            ['foo', '[bar]', 'foo[bar]', 'It does not include the dot separator if subPath uses the array notation'],
+            ['0', 'bar', '0.bar', 'Leading zeros are kept.'],
+            ['0', '1', '0.1', 'Leading zeros are kept on subPath too.'],
+        ];
+    }
 }
diff --git a/src/Symfony/Component/Serializer/CHANGELOG.md b/src/Symfony/Component/Serializer/CHANGELOG.md
@@ -7,6 +7,8 @@ CHANGELOG
  * Improve `NotNormalizableValueException` exception messages in `BackedEnumNormalizer` to contain more useful information
  * Trigger a deprecation when a date could not be parsed using the default format
  * Add `AbstractObjectNormalizer::ENABLE_TYPE_CONVERSION` for scalar type transformation
+ * Add `COLLECT_EXTRA_ATTRIBUTES_ERRORS` option to `Serializer` to collect extra-attributes errors during denormalization
+ * Deprecate `PartialDenormalizationException::getErrors()`, use `getNotNormalizableValueErrors()` instead
 
 8.0
 ---
diff --git a/src/Symfony/Component/Serializer/Context/SerializerContextBuilder.php b/src/Symfony/Component/Serializer/Context/SerializerContextBuilder.php
@@ -36,4 +36,9 @@ public function withCollectDenormalizationErrors(?bool $collectDenormalizationEr
     {
         return $this->with(DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS, $collectDenormalizationErrors);
     }
+
+    public function withCollectExtraAttributesErrors(?bool $collectExtraAttributesErrors): static
+    {
+        return $this->with(DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS, $collectExtraAttributesErrors);
+    }
 }
diff --git a/src/Symfony/Component/Serializer/Exception/PartialDenormalizationException.php b/src/Symfony/Component/Serializer/Exception/PartialDenormalizationException.php
@@ -16,13 +16,24 @@
  */
 class PartialDenormalizationException extends UnexpectedValueException
 {
+    private ?ExtraAttributesException $extraAttributesError = null;
+
     /**
-     * @param NotNormalizableValueException[] $errors
+     * @param NotNormalizableValueException[] $notNormalizableErrors
+     * @param ExtraAttributesException[]      $extraAttributesErrors
      */
     public function __construct(
         private mixed $data,
-        private array $errors,
+        private array $notNormalizableErrors,
+        array $extraAttributesErrors = [],
     ) {
+        $extraAttributes = [];
+        foreach ($extraAttributesErrors as $error) {
+            $extraAttributes = array_merge($extraAttributes, $error->getExtraAttributes());
+        }
+        if ($extraAttributes) {
+            $this->extraAttributesError = new ExtraAttributesException($extraAttributes);
+        }
     }
 
     public function getData(): mixed
@@ -31,10 +42,25 @@ public function getData(): mixed
     }
 
     /**
-     * @return NotNormalizableValueException[]
+     * @deprecated since Symfony 8.1, use getNotNormalizableValueErrors() instead
      */
     public function getErrors(): array
     {
-        return $this->errors;
+        trigger_deprecation('symfony/serializer', '8.1', 'The "%s()" method is deprecated, use "%s::getNotNormalizableValueErrors()" instead.', __METHOD__, self::class);
+
+        return $this->getNotNormalizableValueErrors();
+    }
+
+    /**
+     * @return NotNormalizableValueException[]
+     */
+    public function getNotNormalizableValueErrors(): array
+    {
+        return $this->notNormalizableErrors;
+    }
+
+    public function getExtraAttributesError(): ?ExtraAttributesException
+    {
+        return $this->extraAttributesError;
     }
 }
diff --git a/src/Symfony/Component/Serializer/Normalizer/AbstractNormalizer.php b/src/Symfony/Component/Serializer/Normalizer/AbstractNormalizer.php
@@ -11,6 +11,7 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
+use Symfony\Component\PropertyAccess\PropertyPath;
 use Symfony\Component\Serializer\Exception\CircularReferenceException;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 use Symfony\Component\Serializer\Exception\LogicException;
@@ -593,7 +594,7 @@ protected function getAttributeNormalizationContext(object $object, string $attr
      */
     protected function getAttributeDenormalizationContext(string $class, string $attribute, array $context): array
     {
-        $context['deserialization_path'] = ($context['deserialization_path'] ?? false) ? $context['deserialization_path'].'.'.$attribute : $attribute;
+        $context['deserialization_path'] = PropertyPath::append($context['deserialization_path'] ?? '', $attribute);
 
         if (null === $metadata = $this->getAttributeMetadata($class, $attribute)) {
             return $context;
diff --git a/src/Symfony/Component/Serializer/Normalizer/AbstractObjectNormalizer.php b/src/Symfony/Component/Serializer/Normalizer/AbstractObjectNormalizer.php
@@ -15,6 +15,7 @@
 use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
 use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
 use Symfony\Component\PropertyAccess\PropertyAccess;
+use Symfony\Component\PropertyAccess\PropertyPath;
 use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
 use Symfony\Component\Serializer\Encoder\CsvEncoder;
 use Symfony\Component\Serializer\Encoder\JsonEncoder;
@@ -421,7 +422,11 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         }
 
         if ($extraAttributes) {
-            throw new ExtraAttributesException($extraAttributes);
+            $extraAttributeException = new ExtraAttributesException(array_map(static fn (string $extraAttribute) => PropertyPath::append($context['deserialization_path'] ?? '', $extraAttribute), $extraAttributes));
+            if (!isset($context['extra_attributes_exceptions'])) {
+                throw $extraAttributeException;
+            }
+            $context['extra_attributes_exceptions'][] = $extraAttributeException;
         }
 
         return $object;
diff --git a/src/Symfony/Component/Serializer/Normalizer/DenormalizerInterface.php b/src/Symfony/Component/Serializer/Normalizer/DenormalizerInterface.php
@@ -24,8 +24,16 @@
  */
 interface DenormalizerInterface
 {
+    /**
+     * Whether to collect all denormalization errors or to stop at first error.
+     */
     public const COLLECT_DENORMALIZATION_ERRORS = 'collect_denormalization_errors';
 
+    /**
+     * Whether to collect all extra attributes errors or to stop at first nested error.
+     */
+    public const COLLECT_EXTRA_ATTRIBUTES_ERRORS = 'collect_extra_attributes_errors';
+
     /**
      * Denormalizes data back into an object of the given class.
      *
diff --git a/src/Symfony/Component/Serializer/Normalizer/ProblemNormalizer.php b/src/Symfony/Component/Serializer/Normalizer/ProblemNormalizer.php
@@ -81,7 +81,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
                                 '{{ type }}' => implode('|', $e->getExpectedTypes() ?? ['?']),
                             ],
                         ] + ($debug || $e->canUseMessageForUser() ? ['hint' => $e->getMessage()] : []),
-                        $exception->getErrors()
+                        $exception->getNotNormalizableValueErrors()
                     ),
                 ];
                 $error['detail'] = implode("\n", array_map(static fn ($e) => $e['propertyPath'].': '.$e['title'], $error['violations']));
diff --git a/src/Symfony/Component/Serializer/Serializer.php b/src/Symfony/Component/Serializer/Serializer.php
@@ -194,6 +194,10 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
             throw new LogicException('Passing a value for "not_normalizable_value_exceptions" context key is not allowed.');
         }
 
+        if (isset($context[DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS], $context['extra_attributes_exceptions'])) {
+            throw new LogicException('Passing a value for "extra_attributes_exceptions" context key is not allowed.');
+        }
+
         $normalizer = $this->getDenormalizer($data, $type, $format, $context);
 
         // Check for a denormalizer first, e.g. the data is wrapped
@@ -213,31 +217,40 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
             throw new NotNormalizableValueException(\sprintf('Could not denormalize object of type "%s", no supporting normalizer found.', $type));
         }
 
-        if ((isset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS]) || isset($this->defaultContext[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS])) && !isset($context['not_normalizable_value_exceptions'])) {
+        $collectNotNormalizable = (isset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS]) || isset($this->defaultContext[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS])) && !isset($context['not_normalizable_value_exceptions']);
+        $collectExtraAttributes = ($context[DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS] ?? $this->defaultContext[DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS] ?? false) && !isset($context['extra_attributes_exceptions']);
+
+        $notNormalizableErrors = [];
+        $extraAttributesExceptions = [];
+
+        if ($collectNotNormalizable) {
             unset($context[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS]);
-            $context['not_normalizable_value_exceptions'] = [];
-            $errors = &$context['not_normalizable_value_exceptions'];
-            $denormalized = $normalizer->denormalize($data, $type, $format, $context);
-
-            if ($errors) {
-                // merge errors so that one path has only one error
-                $uniqueErrors = [];
-                foreach ($errors as $error) {
-                    if (null === $error->getPath()) {
-                        $uniqueErrors[] = $error;
-                        continue;
-                    }
+            $context['not_normalizable_value_exceptions'] = &$notNormalizableErrors;
+        }
+
+        if ($collectExtraAttributes) {
+            unset($context[DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS]);
+            $context['extra_attributes_exceptions'] = &$extraAttributesExceptions;
+        }
 
-                    $uniqueErrors[$error->getPath()] ??= $error;
+        $denormalized = $normalizer->denormalize($data, $type, $format, $context);
+
+        if ($notNormalizableErrors || $extraAttributesExceptions) {
+            // merge errors so that one path has only one error
+            $uniqueErrors = [];
+            foreach ($notNormalizableErrors as $error) {
+                if (null === $error->getPath()) {
+                    $uniqueErrors[] = $error;
+                    continue;
                 }
 
-                throw new PartialDenormalizationException($denormalized, array_values($uniqueErrors));
+                $uniqueErrors[$error->getPath()] ??= $error;
             }
 
-            return $denormalized;
+            throw new PartialDenormalizationException($denormalized, array_values($uniqueErrors), $extraAttributesExceptions);
         }
 
-        return $normalizer->denormalize($data, $type, $format, $context);
+        return $denormalized;
     }
 
     public function getSupportedTypes(?string $format): array
diff --git a/src/Symfony/Component/Serializer/Tests/Context/SerializerContextBuilderTest.php b/src/Symfony/Component/Serializer/Tests/Context/SerializerContextBuilderTest.php
@@ -38,6 +38,7 @@ public function testWithers(array $values)
         $context = $this->contextBuilder
             ->withEmptyArrayAsObject($values[Serializer::EMPTY_ARRAY_AS_OBJECT])
             ->withCollectDenormalizationErrors($values[DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS])
+            ->withCollectExtraAttributesErrors($values[DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS])
             ->toArray();
 
         $this->assertSame($values, $context);
@@ -51,11 +52,13 @@ public static function withersDataProvider(): iterable
         yield 'With values' => [[
             Serializer::EMPTY_ARRAY_AS_OBJECT => true,
             DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS => false,
+            DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS => false,
         ]];
 
         yield 'With null values' => [[
             Serializer::EMPTY_ARRAY_AS_OBJECT => null,
             DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS => null,
+            DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS => null,
         ]];
     }
 }
diff --git a/src/Symfony/Component/Serializer/Tests/Fixtures/Php74Full.php b/src/Symfony/Component/Serializer/Tests/Fixtures/Php74Full.php
@@ -34,6 +34,7 @@ final class Php74Full
     public TestFoo $nestedObject;
     /** @var Php74Full[] */
     public $anotherCollection;
+    public TestFoo $nestedObject2;
 }
 
 final class Php74FullWithConstructor
diff --git a/src/Symfony/Component/Serializer/Tests/Normalizer/ObjectNormalizerTest.php b/src/Symfony/Component/Serializer/Tests/Normalizer/ObjectNormalizerTest.php
@@ -528,8 +528,8 @@ public function testTypeMismatchOnTypedPropertyIsCollectedAsDenormalizationError
 
             $this->fail(\sprintf('Expected a "%s".', PartialDenormalizationException::class));
         } catch (PartialDenormalizationException $e) {
-            $this->assertCount(1, $e->getErrors());
-            $error = $e->getErrors()[0];
+            $this->assertCount(1, $e->getNotNormalizableValueErrors());
+            $error = $e->getNotNormalizableValueErrors()[0];
             $this->assertInstanceOf(NotNormalizableValueException::class, $error);
             $this->assertSame('name', $error->getPath());
             $this->assertSame('array', $error->getCurrentType());
diff --git a/src/Symfony/Component/Serializer/Tests/Normalizer/PropertyNormalizerTest.php b/src/Symfony/Component/Serializer/Tests/Normalizer/PropertyNormalizerTest.php
@@ -620,8 +620,8 @@ public function testTypeMismatchOnTypedPropertyIsCollectedAsDenormalizationError
 
             $this->fail(\sprintf('Expected a "%s".', PartialDenormalizationException::class));
         } catch (PartialDenormalizationException $e) {
-            $this->assertCount(1, $e->getErrors());
-            $error = $e->getErrors()[0];
+            $this->assertCount(1, $e->getNotNormalizableValueErrors());
+            $error = $e->getNotNormalizableValueErrors()[0];
             $this->assertInstanceOf(NotNormalizableValueException::class, $error);
             $this->assertSame('name', $error->getPath());
             $this->assertSame('array', $error->getCurrentType());
diff --git a/src/Symfony/Component/Serializer/Tests/SerializerTest.php b/src/Symfony/Component/Serializer/Tests/SerializerTest.php
diff --git a/src/Symfony/Component/Serializer/composer.json b/src/Symfony/Component/Serializer/composer.json

Original file line number	Diff line number	Diff line change
`@@ -36,4 +36,9 @@ public function withCollectDenormalizationErrors(?bool $collectDenormalizationEr`
`36`	`36`	`{`
`37`	`37`	`return $this->with(DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS, $collectDenormalizationErrors);`
`38`	`38`	`}`
	`39`	`+`
	`40`	`+ public function withCollectExtraAttributesErrors(?bool $collectExtraAttributesErrors): static`
	`41`	`+ {`
	`42`	`+ return $this->with(DenormalizerInterface::COLLECT_EXTRA_ATTRIBUTES_ERRORS, $collectExtraAttributesErrors);`
	`43`	`+ }`
`39`	`44`	`}`