diff --git a/Attribute/Context.php b/Attribute/Context.php
index baa958839..892af481a 100644
--- a/Attribute/Context.php
+++ b/Attribute/Context.php
@@ -14,12 +14,6 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @Context().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"PROPERTY", "METHOD"})
- *
  * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_CLASS | \Attribute::TARGET_PROPERTY | \Attribute::TARGET_METHOD | \Attribute::IS_REPEATABLE)]
@@ -28,7 +22,10 @@ class Context
     private array $groups;
 
     /**
-     * @param string|string[] $groups
+     * @param array<string, mixed> $context                The common context to use when serializing or deserializing
+     * @param array<string, mixed> $normalizationContext   The context to use when serializing
+     * @param array<string, mixed> $denormalizationContext The context to use when deserializing
+     * @param string|string[]      $groups                 The groups to use when serializing or deserializing
      *
      * @throws InvalidArgumentException
      */
@@ -39,14 +36,14 @@ public function __construct(
         string|array $groups = [],
     ) {
         if (!$context && !$normalizationContext && !$denormalizationContext) {
-            throw new InvalidArgumentException(sprintf('At least one of the "context", "normalizationContext", or "denormalizationContext" options must be provided as a non-empty array to "%s".', static::class));
+            throw new InvalidArgumentException(\sprintf('At least one of the "context", "normalizationContext", or "denormalizationContext" options must be provided as a non-empty array to "%s".', static::class));
         }
 
         $this->groups = (array) $groups;
 
         foreach ($this->groups as $group) {
             if (!\is_string($group)) {
-                throw new InvalidArgumentException(sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "%s" given.', static::class, get_debug_type($group)));
+                throw new InvalidArgumentException(\sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "%s" given.', static::class, get_debug_type($group)));
             }
         }
     }
diff --git a/Attribute/DiscriminatorMap.php b/Attribute/DiscriminatorMap.php
index 4c1f23722..48d0842aa 100644
--- a/Attribute/DiscriminatorMap.php
+++ b/Attribute/DiscriminatorMap.php
@@ -14,27 +14,27 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @DiscriminatorMap().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"CLASS"})
- *
  * @author Samuel Roze <samuel.roze@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_CLASS)]
 class DiscriminatorMap
 {
+    /**
+     * @param string                      $typeProperty The property holding the type discriminator
+     * @param array<string, class-string> $mapping      The mapping between types and classes (i.e. ['admin_user' => AdminUser::class])
+     *
+     * @throws InvalidArgumentException
+     */
     public function __construct(
         private readonly string $typeProperty,
         private readonly array $mapping,
     ) {
-        if (empty($typeProperty)) {
-            throw new InvalidArgumentException(sprintf('Parameter "typeProperty" given to "%s" cannot be empty.', static::class));
+        if (!$typeProperty) {
+            throw new InvalidArgumentException(\sprintf('Parameter "typeProperty" given to "%s" cannot be empty.', static::class));
         }
 
-        if (empty($mapping)) {
-            throw new InvalidArgumentException(sprintf('Parameter "mapping" given to "%s" cannot be empty.', static::class));
+        if (!$mapping) {
+            throw new InvalidArgumentException(\sprintf('Parameter "mapping" given to "%s" cannot be empty.', static::class));
         }
     }
 
diff --git a/Attribute/Groups.php b/Attribute/Groups.php
index 9a351910a..8747949a4 100644
--- a/Attribute/Groups.php
+++ b/Attribute/Groups.php
@@ -14,12 +14,6 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @Groups().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"PROPERTY", "METHOD", "CLASS"})
- *
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY | \Attribute::TARGET_CLASS)]
@@ -31,19 +25,19 @@ class Groups
     private readonly array $groups;
 
     /**
-     * @param string|string[] $groups
+     * @param string|string[] $groups The groups to define on the attribute target
      */
     public function __construct(string|array $groups)
     {
         $this->groups = (array) $groups;
 
         if (!$this->groups) {
-            throw new InvalidArgumentException(sprintf('Parameter given to "%s" cannot be empty.', static::class));
+            throw new InvalidArgumentException(\sprintf('Parameter given to "%s" cannot be empty.', static::class));
         }
 
         foreach ($this->groups as $group) {
             if (!\is_string($group) || '' === $group) {
-                throw new InvalidArgumentException(sprintf('Parameter given to "%s" must be a string or an array of non-empty strings.', static::class));
+                throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a string or an array of non-empty strings.', static::class));
             }
         }
     }
diff --git a/Attribute/Ignore.php b/Attribute/Ignore.php
index 2e04a45ff..bfc48b71e 100644
--- a/Attribute/Ignore.php
+++ b/Attribute/Ignore.php
@@ -12,11 +12,6 @@
 namespace Symfony\Component\Serializer\Attribute;
 
 /**
- * Annotation class for @Ignore().
- *
- * @Annotation
- * @Target({"PROPERTY", "METHOD"})
- *
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
diff --git a/Attribute/MaxDepth.php b/Attribute/MaxDepth.php
index 3ecfcb993..16d6a8120 100644
--- a/Attribute/MaxDepth.php
+++ b/Attribute/MaxDepth.php
@@ -14,28 +14,22 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @MaxDepth().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"PROPERTY", "METHOD"})
- *
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 class MaxDepth
 {
+    /**
+     * @param int $maxDepth The maximum serialization depth
+     */
     public function __construct(private readonly int $maxDepth)
     {
         if ($maxDepth <= 0) {
-            throw new InvalidArgumentException(sprintf('Parameter given to "%s" must be a positive integer.', static::class));
+            throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a positive integer.', static::class));
         }
     }
 
-    /**
-     * @return int
-     */
-    public function getMaxDepth()
+    public function getMaxDepth(): int
     {
         return $this->maxDepth;
     }
diff --git a/Attribute/SerializedName.php b/Attribute/SerializedName.php
index e278990c9..f1c6cefe2 100644
--- a/Attribute/SerializedName.php
+++ b/Attribute/SerializedName.php
@@ -14,21 +14,18 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @SerializedName().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"PROPERTY", "METHOD"})
- *
  * @author Fabien Bourigault <bourigaultfabien@gmail.com>
  */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
 class SerializedName
 {
+    /**
+     * @param string $serializedName The name of the property as it will be serialized
+     */
     public function __construct(private readonly string $serializedName)
     {
         if ('' === $serializedName) {
-            throw new InvalidArgumentException(sprintf('Parameter given to "%s" must be a non-empty string.', self::class));
+            throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a non-empty string.', self::class));
         }
     }
 
diff --git a/Attribute/SerializedPath.php b/Attribute/SerializedPath.php
index 18b84ed53..71254bfb9 100644
--- a/Attribute/SerializedPath.php
+++ b/Attribute/SerializedPath.php
@@ -16,12 +16,6 @@
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 
 /**
- * Annotation class for @SerializedPath().
- *
- * @Annotation
- * @NamedArgumentConstructor
- * @Target({"PROPERTY", "METHOD"})
- *
  * @author Tobias Bönner <tobi@boenner.family>
  */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
@@ -29,12 +23,15 @@ class SerializedPath
 {
     private PropertyPath $serializedPath;
 
+    /**
+     * @param string $serializedPath A path using a valid PropertyAccess syntax where the value is stored in a normalized representation
+     */
     public function __construct(string $serializedPath)
     {
         try {
             $this->serializedPath = new PropertyPath($serializedPath);
         } catch (InvalidPropertyPathException $pathException) {
-            throw new InvalidArgumentException(sprintf('Parameter given to "%s" must be a valid property path.', self::class));
+            throw new InvalidArgumentException(\sprintf('Parameter given to "%s" must be a valid property path.', self::class));
         }
     }
 
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 69829709f..4c36d5885 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,43 @@
 CHANGELOG
 =========
 
+7.2
+---
+
+ * Deprecate the `csv_escape_char` context option of `CsvEncoder`, the `CsvEncoder::ESCAPE_CHAR_KEY` constant
+   and the `CsvEncoderContextBuilder::withEscapeChar()` method, following its deprecation in PHP 8.4
+ * Add `SnakeCaseToCamelCaseNameConverter`
+ * Support subclasses of `\DateTime` and `\DateTimeImmutable` for denormalization
+ * Add the `UidNormalizer::NORMALIZATION_FORMAT_RFC9562` constant
+ * Add support for configuring multiple serializer instances with different
+   default contexts, name converters, sets of normalizers and encoders
+ * Add support for collection profiles of multiple serializer instances
+ * Deprecate `AdvancedNameConverterInterface`, use `NameConverterInterface` instead
+
+7.1
+---
+
+ * Add arguments `$class`, `$format` and `$context` to `NameConverterInterface::normalize()` and `NameConverterInterface::denormalize()`
+ * Add `DateTimeNormalizer::CAST_KEY` context option
+ * Add `AbstractNormalizer::FILTER_BOOL` context option
+ * Add `CamelCaseToSnakeCaseNameConverter::REQUIRE_SNAKE_CASE_PROPERTIES` context option
+ * Deprecate `AbstractNormalizerContextBuilder::withDefaultContructorArguments(?array $defaultContructorArguments)`, use `withDefaultConstructorArguments(?array $defaultConstructorArguments)` instead (note the missing `s` character in Contructor word in deprecated method)
+ * Add `XmlEncoder::CDATA_WRAPPING_PATTERN` context option
+
+7.0
+---
+
+ * Add method `getSupportedTypes()` to `DenormalizerInterface` and `NormalizerInterface`
+ * Remove denormalization support for `AbstractUid` in `UidNormalizer`, use one of `AbstractUid` child class instead
+ * Denormalizing to an abstract class in `UidNormalizer` now throws an `\Error`
+ * Remove `ContextAwareDenormalizerInterface`, use `DenormalizerInterface` instead
+ * Remove `ContextAwareNormalizerInterface`, use `NormalizerInterface` instead
+ * Remove `CacheableSupportsMethodInterface`, use `NormalizerInterface` and `DenormalizerInterface` instead
+ * Require explicit argument when calling `AttributeMetadata::setSerializedName()` and `ClassMetadata::setClassDiscriminatorMapping()`
+ * Add argument `$context` to `NormalizerInterface::supportsNormalization()` and `DenormalizerInterface::supportsDenormalization()`
+ * Remove Doctrine annotations support in favor of native attributes
+ * Remove `AnnotationLoader`, use `AttributeLoader` instead
+
 6.4
 ---
 
diff --git a/Command/DebugCommand.php b/Command/DebugCommand.php
index 13873dd1f..7df4d6bc8 100644
--- a/Command/DebugCommand.php
+++ b/Command/DebugCommand.php
@@ -49,7 +49,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
 
         if (!class_exists($class)) {
             $io = new SymfonyStyle($input, $output);
-            $io->error(sprintf('Class "%s" was not found.', $class));
+            $io->error(\sprintf('Class "%s" was not found.', $class));
 
             return Command::FAILURE;
         }
@@ -62,7 +62,7 @@ protected function execute(InputInterface $input, OutputInterface $output): int
     private function dumpSerializerDataForClass(InputInterface $input, OutputInterface $output, string $class): void
     {
         $io = new SymfonyStyle($input, $output);
-        $title = sprintf('<info>%s</info>', $class);
+        $title = \sprintf('<info>%s</info>', $class);
         $rows = [];
         $dump = new Dumper($output);
 
@@ -75,15 +75,14 @@ private function dumpSerializerDataForClass(InputInterface $input, OutputInterfa
             ];
         }
 
+        $io->section($title);
+
         if (!$rows) {
-            $io->section($title);
             $io->text('No Serializer data were found for this class.');
 
             return;
         }
 
-        $io->section($title);
-
         $table = new Table($output);
         $table->setHeaders(['Property', 'Options']);
         $table->setRows($rows);
@@ -102,6 +101,7 @@ private function getAttributesData(ClassMetadataInterface $classMetadata): array
                 'groups' => $attributeMetadata->getGroups(),
                 'maxDepth' => $attributeMetadata->getMaxDepth(),
                 'serializedName' => $attributeMetadata->getSerializedName(),
+                'serializedPath' => $attributeMetadata->getSerializedPath() ? (string) $attributeMetadata->getSerializedPath() : null,
                 'ignore' => $attributeMetadata->isIgnored(),
                 'normalizationContexts' => $attributeMetadata->getNormalizationContexts(),
                 'denormalizationContexts' => $attributeMetadata->getDenormalizationContexts(),
diff --git a/Context/Encoder/CsvEncoderContextBuilder.php b/Context/Encoder/CsvEncoderContextBuilder.php
index f75759031..9f0d6da6f 100644
--- a/Context/Encoder/CsvEncoderContextBuilder.php
+++ b/Context/Encoder/CsvEncoderContextBuilder.php
@@ -35,7 +35,7 @@ final class CsvEncoderContextBuilder implements ContextBuilderInterface
     public function withDelimiter(?string $delimiter): static
     {
         if (null !== $delimiter && 1 !== \strlen($delimiter)) {
-            throw new InvalidArgumentException(sprintf('The "%s" delimiter must be a single character.', $delimiter));
+            throw new InvalidArgumentException(\sprintf('The "%s" delimiter must be a single character.', $delimiter));
         }
 
         return $this->with(CsvEncoder::DELIMITER_KEY, $delimiter);
@@ -51,7 +51,7 @@ public function withDelimiter(?string $delimiter): static
     public function withEnclosure(?string $enclosure): static
     {
         if (null !== $enclosure && 1 !== \strlen($enclosure)) {
-            throw new InvalidArgumentException(sprintf('The "%s" enclosure must be a single character.', $enclosure));
+            throw new InvalidArgumentException(\sprintf('The "%s" enclosure must be a single character.', $enclosure));
         }
 
         return $this->with(CsvEncoder::ENCLOSURE_KEY, $enclosure);
@@ -62,12 +62,16 @@ public function withEnclosure(?string $enclosure): static
      *
      * Must be empty or a single character.
      *
+     * @deprecated since Symfony 7.2, to be removed in 8.0
+     *
      * @throws InvalidArgumentException
      */
     public function withEscapeChar(?string $escapeChar): static
     {
+        trigger_deprecation('symfony/serializer', '7.2', 'The "%s" method is deprecated. It will be removed in 8.0.', __METHOD__);
+
         if (null !== $escapeChar && \strlen($escapeChar) > 1) {
-            throw new InvalidArgumentException(sprintf('The "%s" escape character must be empty or a single character.', $escapeChar));
+            throw new InvalidArgumentException(\sprintf('The "%s" escape character must be empty or a single character.', $escapeChar));
         }
 
         return $this->with(CsvEncoder::ESCAPE_CHAR_KEY, $escapeChar);
diff --git a/Context/Encoder/XmlEncoderContextBuilder.php b/Context/Encoder/XmlEncoderContextBuilder.php
index 34cf78198..0fd1f2f44 100644
--- a/Context/Encoder/XmlEncoderContextBuilder.php
+++ b/Context/Encoder/XmlEncoderContextBuilder.php
@@ -152,4 +152,12 @@ public function withCdataWrapping(?bool $cdataWrapping): static
     {
         return $this->with(XmlEncoder::CDATA_WRAPPING, $cdataWrapping);
     }
+
+    /**
+     * Configures the pattern used to evaluate if a CDATA section should be added.
+     */
+    public function withCdataWrappingPattern(?string $cdataWrappingPattern): static
+    {
+        return $this->with(XmlEncoder::CDATA_WRAPPING_PATTERN, $cdataWrappingPattern);
+    }
 }
diff --git a/Context/Normalizer/AbstractNormalizerContextBuilder.php b/Context/Normalizer/AbstractNormalizerContextBuilder.php
index f365ac8df..a63e1a507 100644
--- a/Context/Normalizer/AbstractNormalizerContextBuilder.php
+++ b/Context/Normalizer/AbstractNormalizerContextBuilder.php
@@ -87,7 +87,7 @@ public function withAttributes(?array $attributes): static
 
         foreach ($it as $attribute) {
             if (!\is_string($attribute)) {
-                throw new InvalidArgumentException(sprintf('Each attribute must be a string, "%s" given.', get_debug_type($attribute)));
+                throw new InvalidArgumentException(\sprintf('Each attribute must be a string, "%s" given.', get_debug_type($attribute)));
             }
         }
 
@@ -103,6 +103,18 @@ public function withAllowExtraAttributes(?bool $allowExtraAttributes): static
         return $this->with(AbstractNormalizer::ALLOW_EXTRA_ATTRIBUTES, $allowExtraAttributes);
     }
 
+    /**
+     * @deprecated since Symfony 7.1, use withDefaultConstructorArguments(?array $defaultConstructorArguments)" instead
+     *
+     * @param array<class-string, array<string, mixed>>|null $defaultContructorArguments
+     */
+    public function withDefaultContructorArguments(?array $defaultContructorArguments): static
+    {
+        trigger_deprecation('symfony/serializer', '7.1', 'The "%s()" method is deprecated, use "withDefaultConstructorArguments(?array $defaultConstructorArguments)" instead.', __METHOD__);
+
+        return self::withDefaultConstructorArguments($defaultContructorArguments);
+    }
+
     /**
      * Configures a hashmap of classes containing hashmaps of constructor argument => default value.
      *
@@ -117,14 +129,6 @@ public function withDefaultConstructorArguments(?array $defaultConstructorArgume
         return $this->with(AbstractNormalizer::DEFAULT_CONSTRUCTOR_ARGUMENTS, $defaultConstructorArguments);
     }
 
-    /**
-     * Deprecated in Symfony 7.1, use withDefaultConstructorArguments() instead.
-     */
-    public function withDefaultContructorArguments(?array $defaultContructorArguments): static
-    {
-        return self::withDefaultConstructorArguments($defaultContructorArguments);
-    }
-
     /**
      * Configures an hashmap of field name => callable to normalize this field.
      *
diff --git a/Context/Normalizer/AbstractObjectNormalizerContextBuilder.php b/Context/Normalizer/AbstractObjectNormalizerContextBuilder.php
index a27f00c5b..45b47bc1b 100644
--- a/Context/Normalizer/AbstractObjectNormalizerContextBuilder.php
+++ b/Context/Normalizer/AbstractObjectNormalizerContextBuilder.php
@@ -47,7 +47,7 @@ public function withDepthKeyPattern(?string $depthKeyPattern): static
         preg_match_all('/(?<!%)(?:%{2})*%(?<specifier>[a-z])/', $depthKeyPattern, $matches);
 
         if (2 !== \count($matches['specifier']) || 's' !== $matches['specifier'][0] || 's' !== $matches['specifier'][1]) {
-            throw new InvalidArgumentException(sprintf('The depth key pattern "%s" is not valid. You must set exactly two string placeholders.', $depthKeyPattern));
+            throw new InvalidArgumentException(\sprintf('The depth key pattern "%s" is not valid. You must set exactly two string placeholders.', $depthKeyPattern));
         }
 
         return $this->with(AbstractObjectNormalizer::DEPTH_KEY_PATTERN, $depthKeyPattern);
diff --git a/Context/Normalizer/DateTimeNormalizerContextBuilder.php b/Context/Normalizer/DateTimeNormalizerContextBuilder.php
index 99517afb1..de83b1245 100644
--- a/Context/Normalizer/DateTimeNormalizerContextBuilder.php
+++ b/Context/Normalizer/DateTimeNormalizerContextBuilder.php
@@ -55,10 +55,18 @@ public function withTimezone(\DateTimeZone|string|null $timezone): static
             try {
                 $timezone = new \DateTimeZone($timezone);
             } catch (\Exception $e) {
-                throw new InvalidArgumentException(sprintf('The "%s" timezone is invalid.', $timezone), previous: $e);
+                throw new InvalidArgumentException(\sprintf('The "%s" timezone is invalid.', $timezone), previous: $e);
             }
         }
 
         return $this->with(DateTimeNormalizer::TIMEZONE_KEY, $timezone);
     }
+
+    /**
+     * @param 'int'|'float'|null $cast
+     */
+    public function withCast(?string $cast): static
+    {
+        return $this->with(DateTimeNormalizer::CAST_KEY, $cast);
+    }
 }
diff --git a/Context/Normalizer/UidNormalizerContextBuilder.php b/Context/Normalizer/UidNormalizerContextBuilder.php
index 1d889e502..b809fe3eb 100644
--- a/Context/Normalizer/UidNormalizerContextBuilder.php
+++ b/Context/Normalizer/UidNormalizerContextBuilder.php
@@ -33,7 +33,7 @@ final class UidNormalizerContextBuilder implements ContextBuilderInterface
     public function withNormalizationFormat(?string $normalizationFormat): static
     {
         if (null !== $normalizationFormat && !\in_array($normalizationFormat, UidNormalizer::NORMALIZATION_FORMATS, true)) {
-            throw new InvalidArgumentException(sprintf('The "%s" normalization format is not valid.', $normalizationFormat));
+            throw new InvalidArgumentException(\sprintf('The "%s" normalization format is not valid.', $normalizationFormat));
         }
 
         return $this->with(UidNormalizer::NORMALIZATION_FORMAT_KEY, $normalizationFormat);
diff --git a/Context/Normalizer/UnwrappingDenormalizerContextBuilder.php b/Context/Normalizer/UnwrappingDenormalizerContextBuilder.php
index 5beb4e984..2945cb961 100644
--- a/Context/Normalizer/UnwrappingDenormalizerContextBuilder.php
+++ b/Context/Normalizer/UnwrappingDenormalizerContextBuilder.php
@@ -45,7 +45,7 @@ public function withUnwrapPath(?string $unwrapPath): static
         try {
             new PropertyPath($unwrapPath);
         } catch (InvalidPropertyPathException $e) {
-            throw new InvalidArgumentException(sprintf('The "%s" property path is not valid.', $unwrapPath), previous: $e);
+            throw new InvalidArgumentException(\sprintf('The "%s" property path is not valid.', $unwrapPath), previous: $e);
         }
 
         return $this->with(UnwrappingDenormalizer::UNWRAP_PATH, $unwrapPath);
diff --git a/DataCollector/SerializerDataCollector.php b/DataCollector/SerializerDataCollector.php
index 2880dea37..e87c51ca1 100644
--- a/DataCollector/SerializerDataCollector.php
+++ b/DataCollector/SerializerDataCollector.php
@@ -25,11 +25,22 @@
  */
 class SerializerDataCollector extends DataCollector implements LateDataCollectorInterface
 {
+    private const DATA_TEMPLATE = [
+        'serialize' => [],
+        'deserialize' => [],
+        'normalize' => [],
+        'denormalize' => [],
+        'encode' => [],
+        'decode' => [],
+    ];
+
+    private array $dataGroupedByName;
     private array $collected = [];
 
     public function reset(): void
     {
         $this->data = [];
+        unset($this->dataGroupedByName);
         $this->collected = [];
     }
 
@@ -43,14 +54,14 @@ public function getName(): string
         return 'serializer';
     }
 
-    public function getData(): Data|array
+    public function getData(?string $name = null): Data|array
     {
-        return $this->data;
+        return null === $name ? $this->data : $this->getDataGroupedByName()[$name];
     }
 
-    public function getHandledCount(): int
+    public function getHandledCount(?string $name = null): int
     {
-        return array_sum(array_map('count', $this->data));
+        return array_sum(array_map('count', $this->getData($name)));
     }
 
     public function getTotalTime(): float
@@ -64,110 +75,108 @@ public function getTotalTime(): float
         return $totalTime;
     }
 
-    public function collectSerialize(string $traceId, mixed $data, string $format, array $context, float $time, array $caller): void
+    public function getSerializerNames(): array
+    {
+        return array_keys($this->getDataGroupedByName());
+    }
+
+    public function collectSerialize(string $traceId, mixed $data, string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'context', 'time', 'caller'),
+            compact('data', 'format', 'context', 'time', 'caller', 'name'),
             ['method' => 'serialize'],
         );
     }
 
-    public function collectDeserialize(string $traceId, mixed $data, string $type, string $format, array $context, float $time, array $caller): void
+    public function collectDeserialize(string $traceId, mixed $data, string $type, string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'type', 'context', 'time', 'caller'),
+            compact('data', 'format', 'type', 'context', 'time', 'caller', 'name'),
             ['method' => 'deserialize'],
         );
     }
 
-    public function collectNormalize(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
+    public function collectNormalize(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'context', 'time', 'caller'),
+            compact('data', 'format', 'context', 'time', 'caller', 'name'),
             ['method' => 'normalize'],
         );
     }
 
-    public function collectDenormalize(string $traceId, mixed $data, string $type, ?string $format, array $context, float $time, array $caller): void
+    public function collectDenormalize(string $traceId, mixed $data, string $type, ?string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'type', 'context', 'time', 'caller'),
+            compact('data', 'format', 'type', 'context', 'time', 'caller', 'name'),
             ['method' => 'denormalize'],
         );
     }
 
-    public function collectEncode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
+    public function collectEncode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'context', 'time', 'caller'),
+            compact('data', 'format', 'context', 'time', 'caller', 'name'),
             ['method' => 'encode'],
         );
     }
 
-    public function collectDecode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller): void
+    public function collectDecode(string $traceId, mixed $data, ?string $format, array $context, float $time, array $caller, string $name): void
     {
         unset($context[TraceableSerializer::DEBUG_TRACE_ID]);
 
         $this->collected[$traceId] = array_merge(
             $this->collected[$traceId] ?? [],
-            compact('data', 'format', 'context', 'time', 'caller'),
+            compact('data', 'format', 'context', 'time', 'caller', 'name'),
             ['method' => 'decode'],
         );
     }
 
-    public function collectNormalization(string $traceId, string $normalizer, float $time): void
+    public function collectNormalization(string $traceId, string $normalizer, float $time, string $name): void
     {
         $method = 'normalize';
 
-        $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time');
+        $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time', 'name');
     }
 
-    public function collectDenormalization(string $traceId, string $normalizer, float $time): void
+    public function collectDenormalization(string $traceId, string $normalizer, float $time, string $name): void
     {
         $method = 'denormalize';
 
-        $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time');
+        $this->collected[$traceId]['normalization'][] = compact('normalizer', 'method', 'time', 'name');
     }
 
-    public function collectEncoding(string $traceId, string $encoder, float $time): void
+    public function collectEncoding(string $traceId, string $encoder, float $time, string $name): void
     {
         $method = 'encode';
 
-        $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time');
+        $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time', 'name');
     }
 
-    public function collectDecoding(string $traceId, string $encoder, float $time): void
+    public function collectDecoding(string $traceId, string $encoder, float $time, string $name): void
     {
         $method = 'decode';
 
-        $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time');
+        $this->collected[$traceId]['encoding'][] = compact('encoder', 'method', 'time', 'name');
     }
 
     public function lateCollect(): void
     {
-        $this->data = [
-            'serialize' => [],
-            'deserialize' => [],
-            'normalize' => [],
-            'denormalize' => [],
-            'encode' => [],
-            'decode' => [],
-        ];
+        $this->data = self::DATA_TEMPLATE;
 
         foreach ($this->collected as $collected) {
             if (!isset($collected['data'])) {
@@ -184,6 +193,7 @@ public function lateCollect(): void
                 'normalization' => [],
                 'encoding' => [],
                 'caller' => $collected['caller'] ?? null,
+                'name' => $collected['name'],
             ];
 
             if (isset($collected['normalization'])) {
@@ -220,6 +230,22 @@ public function lateCollect(): void
         }
     }
 
+    private function getDataGroupedByName(): array
+    {
+        if (!isset($this->dataGroupedByName)) {
+            $this->dataGroupedByName = [];
+
+            foreach ($this->data as $method => $items) {
+                foreach ($items as $item) {
+                    $this->dataGroupedByName[$item['name']] ??= self::DATA_TEMPLATE;
+                    $this->dataGroupedByName[$item['name']][$method][] = $item;
+                }
+            }
+        }
+
+        return $this->dataGroupedByName;
+    }
+
     private function getMethodLocation(string $class, string $method): array
     {
         $reflection = new \ReflectionClass($class);
diff --git a/Debug/TraceableEncoder.php b/Debug/TraceableEncoder.php
index afefee0ee..39e75e34f 100644
--- a/Debug/TraceableEncoder.php
+++ b/Debug/TraceableEncoder.php
@@ -30,13 +30,14 @@ class TraceableEncoder implements EncoderInterface, DecoderInterface, Serializer
     public function __construct(
         private EncoderInterface|DecoderInterface $encoder,
         private SerializerDataCollector $dataCollector,
+        private readonly string $serializerName = 'default',
     ) {
     }
 
     public function encode(mixed $data, string $format, array $context = []): string
     {
         if (!$this->encoder instanceof EncoderInterface) {
-            throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested encoder doesn\'t implements "%s".', __METHOD__, EncoderInterface::class));
+            throw new \BadMethodCallException(\sprintf('The "%s()" method cannot be called as nested encoder doesn\'t implements "%s".', __METHOD__, EncoderInterface::class));
         }
 
         $startTime = microtime(true);
@@ -44,7 +45,7 @@ public function encode(mixed $data, string $format, array $context = []): string
         $time = microtime(true) - $startTime;
 
         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
-            $this->dataCollector->collectEncoding($traceId, $this->encoder::class, $time);
+            $this->dataCollector->collectEncoding($traceId, $this->encoder::class, $time, $this->serializerName);
         }
 
         return $encoded;
@@ -62,7 +63,7 @@ public function supportsEncoding(string $format, array $context = []): bool
     public function decode(string $data, string $format, array $context = []): mixed
     {
         if (!$this->encoder instanceof DecoderInterface) {
-            throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested encoder doesn\'t implements "%s".', __METHOD__, DecoderInterface::class));
+            throw new \BadMethodCallException(\sprintf('The "%s()" method cannot be called as nested encoder doesn\'t implements "%s".', __METHOD__, DecoderInterface::class));
         }
 
         $startTime = microtime(true);
@@ -70,7 +71,7 @@ public function decode(string $data, string $format, array $context = []): mixed
         $time = microtime(true) - $startTime;
 
         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
-            $this->dataCollector->collectDecoding($traceId, $this->encoder::class, $time);
+            $this->dataCollector->collectDecoding($traceId, $this->encoder::class, $time, $this->serializerName);
         }
 
         return $encoded;
diff --git a/Debug/TraceableNormalizer.php b/Debug/TraceableNormalizer.php
index 88ab4863d..1b143e295 100644
--- a/Debug/TraceableNormalizer.php
+++ b/Debug/TraceableNormalizer.php
@@ -12,7 +12,6 @@
 namespace Symfony\Component\Serializer\Debug;
 
 use Symfony\Component\Serializer\DataCollector\SerializerDataCollector;
-use Symfony\Component\Serializer\Normalizer\CacheableSupportsMethodInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
@@ -27,31 +26,24 @@
  *
  * @final
  */
-class TraceableNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, NormalizerAwareInterface, DenormalizerAwareInterface, CacheableSupportsMethodInterface
+class TraceableNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, NormalizerAwareInterface, DenormalizerAwareInterface
 {
     public function __construct(
         private NormalizerInterface|DenormalizerInterface $normalizer,
         private SerializerDataCollector $dataCollector,
+        private readonly string $serializerName = 'default',
     ) {
-        if (!method_exists($normalizer, 'getSupportedTypes')) {
-            trigger_deprecation('symfony/serializer', '6.3', 'Not implementing the "NormalizerInterface::getSupportedTypes()" in "%s" is deprecated.', get_debug_type($normalizer));
-        }
     }
 
     public function getSupportedTypes(?string $format): array
     {
-        // @deprecated remove condition in 7.0
-        if (!method_exists($this->normalizer, 'getSupportedTypes')) {
-            return ['*' => $this->normalizer instanceof CacheableSupportsMethodInterface && $this->normalizer->hasCacheableSupportsMethod()];
-        }
-
         return $this->normalizer->getSupportedTypes($format);
     }
 
     public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
     {
         if (!$this->normalizer instanceof NormalizerInterface) {
-            throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, NormalizerInterface::class));
+            throw new \BadMethodCallException(\sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, NormalizerInterface::class));
         }
 
         $startTime = microtime(true);
@@ -59,7 +51,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
         $time = microtime(true) - $startTime;
 
         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
-            $this->dataCollector->collectNormalization($traceId, $this->normalizer::class, $time);
+            $this->dataCollector->collectNormalization($traceId, $this->normalizer::class, $time, $this->serializerName);
         }
 
         return $normalized;
@@ -77,7 +69,7 @@ public function supportsNormalization(mixed $data, ?string $format = null, array
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
     {
         if (!$this->normalizer instanceof DenormalizerInterface) {
-            throw new \BadMethodCallException(sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, DenormalizerInterface::class));
+            throw new \BadMethodCallException(\sprintf('The "%s()" method cannot be called as nested normalizer doesn\'t implements "%s".', __METHOD__, DenormalizerInterface::class));
         }
 
         $startTime = microtime(true);
@@ -85,7 +77,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         $time = microtime(true) - $startTime;
 
         if ($traceId = ($context[TraceableSerializer::DEBUG_TRACE_ID] ?? null)) {
-            $this->dataCollector->collectDenormalization($traceId, $this->normalizer::class, $time);
+            $this->dataCollector->collectDenormalization($traceId, $this->normalizer::class, $time, $this->serializerName);
         }
 
         return $denormalized;
@@ -127,16 +119,6 @@ public function setDenormalizer(DenormalizerInterface $denormalizer): void
         $this->normalizer->setDenormalizer($denormalizer);
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this->normalizer));
-
-        return $this->normalizer instanceof CacheableSupportsMethodInterface && $this->normalizer->hasCacheableSupportsMethod();
-    }
-
     /**
      * Proxies all method calls to the original normalizer.
      */
diff --git a/Debug/TraceableSerializer.php b/Debug/TraceableSerializer.php
index dd22e8678..a05bf4bf8 100644
--- a/Debug/TraceableSerializer.php
+++ b/Debug/TraceableSerializer.php
@@ -14,7 +14,6 @@
 use Symfony\Component\Serializer\DataCollector\SerializerDataCollector;
 use Symfony\Component\Serializer\Encoder\DecoderInterface;
 use Symfony\Component\Serializer\Encoder\EncoderInterface;
-use Symfony\Component\Serializer\Normalizer\CacheableSupportsMethodInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Symfony\Component\Serializer\SerializerInterface;
@@ -33,15 +32,13 @@ class TraceableSerializer implements SerializerInterface, NormalizerInterface, D
     public function __construct(
         private SerializerInterface&NormalizerInterface&DenormalizerInterface&EncoderInterface&DecoderInterface $serializer,
         private SerializerDataCollector $dataCollector,
+        private readonly string $serializerName = 'default',
     ) {
-        if (!method_exists($serializer, 'getSupportedTypes')) {
-            trigger_deprecation('symfony/serializer', '6.3', 'Not implementing the "NormalizerInterface::getSupportedTypes()" in "%s" is deprecated.', get_debug_type($serializer));
-        }
     }
 
     public function serialize(mixed $data, string $format, array $context = []): string
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->serialize($data, $format, $context);
@@ -49,14 +46,14 @@ public function serialize(mixed $data, string $format, array $context = []): str
 
         $caller = $this->getCaller(__FUNCTION__, SerializerInterface::class);
 
-        $this->dataCollector->collectSerialize($traceId, $data, $format, $context, $time, $caller);
+        $this->dataCollector->collectSerialize($traceId, $data, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function deserialize(mixed $data, string $type, string $format, array $context = []): mixed
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->deserialize($data, $type, $format, $context);
@@ -64,14 +61,14 @@ public function deserialize(mixed $data, string $type, string $format, array $co
 
         $caller = $this->getCaller(__FUNCTION__, SerializerInterface::class);
 
-        $this->dataCollector->collectDeserialize($traceId, $data, $type, $format, $context, $time, $caller);
+        $this->dataCollector->collectDeserialize($traceId, $data, $type, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->normalize($object, $format, $context);
@@ -79,14 +76,14 @@ public function normalize(mixed $object, ?string $format = null, array $context
 
         $caller = $this->getCaller(__FUNCTION__, NormalizerInterface::class);
 
-        $this->dataCollector->collectNormalize($traceId, $object, $format, $context, $time, $caller);
+        $this->dataCollector->collectNormalize($traceId, $object, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->denormalize($data, $type, $format, $context);
@@ -94,14 +91,14 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
 
         $caller = $this->getCaller(__FUNCTION__, DenormalizerInterface::class);
 
-        $this->dataCollector->collectDenormalize($traceId, $data, $type, $format, $context, $time, $caller);
+        $this->dataCollector->collectDenormalize($traceId, $data, $type, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function encode(mixed $data, string $format, array $context = []): string
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->encode($data, $format, $context);
@@ -109,14 +106,14 @@ public function encode(mixed $data, string $format, array $context = []): string
 
         $caller = $this->getCaller(__FUNCTION__, EncoderInterface::class);
 
-        $this->dataCollector->collectEncode($traceId, $data, $format, $context, $time, $caller);
+        $this->dataCollector->collectEncode($traceId, $data, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function decode(string $data, string $format, array $context = []): mixed
     {
-        $context[self::DEBUG_TRACE_ID] = $traceId = uniqid('', true);
+        $context[self::DEBUG_TRACE_ID] = $traceId = bin2hex(random_bytes(4));
 
         $startTime = microtime(true);
         $result = $this->serializer->decode($data, $format, $context);
@@ -124,18 +121,13 @@ public function decode(string $data, string $format, array $context = []): mixed
 
         $caller = $this->getCaller(__FUNCTION__, DecoderInterface::class);
 
-        $this->dataCollector->collectDecode($traceId, $data, $format, $context, $time, $caller);
+        $this->dataCollector->collectDecode($traceId, $data, $format, $context, $time, $caller, $this->serializerName);
 
         return $result;
     }
 
     public function getSupportedTypes(?string $format): array
     {
-        // @deprecated remove condition in 7.0
-        if (!method_exists($this->serializer, 'getSupportedTypes')) {
-            return ['*' => $this->serializer instanceof CacheableSupportsMethodInterface && $this->serializer->hasCacheableSupportsMethod()];
-        }
-
         return $this->serializer->getSupportedTypes($format);
     }
 
diff --git a/DependencyInjection/SerializerPass.php b/DependencyInjection/SerializerPass.php
index c2959ecda..179b7a3d9 100644
--- a/DependencyInjection/SerializerPass.php
+++ b/DependencyInjection/SerializerPass.php
@@ -19,6 +19,8 @@
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\Serializer\Debug\TraceableEncoder;
 use Symfony\Component\Serializer\Debug\TraceableNormalizer;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+use Symfony\Component\Serializer\SerializerInterface;
 
 /**
  * Adds all services with the tags "serializer.encoder" and "serializer.normalizer" as
@@ -31,48 +33,201 @@ class SerializerPass implements CompilerPassInterface
 {
     use PriorityTaggedServiceTrait;
 
-    /**
-     * @return void
-     */
-    public function process(ContainerBuilder $container)
+    private const NAME_CONVERTER_METADATA_AWARE_ID = 'serializer.name_converter.metadata_aware';
+
+    public function process(ContainerBuilder $container): void
     {
         if (!$container->hasDefinition('serializer')) {
             return;
         }
 
-        if (!$normalizers = $this->findAndSortTaggedServices('serializer.normalizer', $container)) {
+        $namedSerializers = $container->hasParameter('.serializer.named_serializers')
+            ? $container->getParameter('.serializer.named_serializers') : [];
+
+        $this->createNamedSerializerTags($container, 'serializer.normalizer', 'include_built_in_normalizers', $namedSerializers);
+        $this->createNamedSerializerTags($container, 'serializer.encoder', 'include_built_in_encoders', $namedSerializers);
+
+        if (!$normalizers = $this->findAndSortTaggedServices('serializer.normalizer.default', $container)) {
             throw new RuntimeException('You must tag at least one service as "serializer.normalizer" to use the "serializer" service.');
         }
 
-        if (!$encoders = $this->findAndSortTaggedServices('serializer.encoder', $container)) {
+        if (!$encoders = $this->findAndSortTaggedServices('serializer.encoder.default', $container)) {
             throw new RuntimeException('You must tag at least one service as "serializer.encoder" to use the "serializer" service.');
         }
 
+        $defaultContext = [];
         if ($container->hasParameter('serializer.default_context')) {
             $defaultContext = $container->getParameter('serializer.default_context');
-            foreach (array_merge($normalizers, $encoders) as $service) {
-                $definition = $container->getDefinition($service);
-                $definition->setBindings(['array $defaultContext' => new BoundArgument($defaultContext, false)] + $definition->getBindings());
-            }
-
             $container->getParameterBag()->remove('serializer.default_context');
             $container->getDefinition('serializer')->setArgument('$defaultContext', $defaultContext);
         }
 
+        /** @var ?string $circularReferenceHandler */
+        $circularReferenceHandler = $container->hasParameter('.serializer.circular_reference_handler')
+            ? $container->getParameter('.serializer.circular_reference_handler') : null;
+
+        /** @var ?string $maxDepthHandler */
+        $maxDepthHandler = $container->hasParameter('.serializer.max_depth_handler')
+            ? $container->getParameter('.serializer.max_depth_handler') : null;
+
+        $this->bindDefaultContext($container, array_merge($normalizers, $encoders), $defaultContext, $circularReferenceHandler, $maxDepthHandler);
+
+        $this->configureSerializer($container, 'serializer', $normalizers, $encoders, 'default');
+
+        if ($namedSerializers) {
+            $this->configureNamedSerializers($container, $circularReferenceHandler, $maxDepthHandler);
+        }
+    }
+
+    private function createNamedSerializerTags(ContainerBuilder $container, string $tagName, string $configName, array $namedSerializers): void
+    {
+        $serializerNames = array_keys($namedSerializers);
+        $withBuiltIn = array_filter($serializerNames, fn (string $name) => $namedSerializers[$name][$configName] ?? false);
+
+        foreach ($container->findTaggedServiceIds($tagName) as $serviceId => $tags) {
+            $definition = $container->getDefinition($serviceId);
+
+            foreach ($tags as $tag) {
+                $names = (array) ($tag['serializer'] ?? []);
+
+                if (!$names) {
+                    $names = ['default'];
+                } elseif (\in_array('*', $names, true)) {
+                    $names = array_unique(['default', ...$serializerNames]);
+                }
+
+                if ($tag['built_in'] ?? false) {
+                    $names = array_unique(['default', ...$names, ...$withBuiltIn]);
+                }
+
+                unset($tag['serializer'], $tag['built_in']);
+
+                foreach ($names as $name) {
+                    $definition->addTag($tagName.'.'.$name, $tag);
+                }
+            }
+        }
+    }
+
+    private function bindDefaultContext(ContainerBuilder $container, array $services, array $defaultContext, ?string $circularReferenceHandler, ?string $maxDepthHandler): void
+    {
+        foreach ($services as $id) {
+            $definition = $container->getDefinition((string) $id);
+
+            $context = $defaultContext;
+            if (is_a($definition->getClass(), ObjectNormalizer::class, true)) {
+                if (null !== $circularReferenceHandler) {
+                    $context += ['circular_reference_handler' => new Reference($circularReferenceHandler)];
+                }
+                if (null !== $maxDepthHandler) {
+                    $context += ['max_depth_handler' => new Reference($maxDepthHandler)];
+                }
+            }
+
+            $definition->setBindings(['array $defaultContext' => new BoundArgument($context, false)] + $definition->getBindings());
+        }
+    }
+
+    private function configureSerializer(ContainerBuilder $container, string $id, array $normalizers, array $encoders, string $serializerName): void
+    {
         if ($container->getParameter('kernel.debug') && $container->hasDefinition('serializer.data_collector')) {
             foreach ($normalizers as $i => $normalizer) {
                 $normalizers[$i] = $container->register('.debug.serializer.normalizer.'.$normalizer, TraceableNormalizer::class)
-                    ->setArguments([$normalizer, new Reference('serializer.data_collector')]);
+                    ->setArguments([$normalizer, new Reference('serializer.data_collector'), $serializerName]);
             }
 
             foreach ($encoders as $i => $encoder) {
                 $encoders[$i] = $container->register('.debug.serializer.encoder.'.$encoder, TraceableEncoder::class)
-                    ->setArguments([$encoder, new Reference('serializer.data_collector')]);
+                    ->setArguments([$encoder, new Reference('serializer.data_collector'), $serializerName]);
             }
         }
 
-        $serializerDefinition = $container->getDefinition('serializer');
+        $serializerDefinition = $container->getDefinition($id);
         $serializerDefinition->replaceArgument(0, $normalizers);
         $serializerDefinition->replaceArgument(1, $encoders);
     }
+
+    private function configureNamedSerializers(ContainerBuilder $container, ?string $circularReferenceHandler, ?string $maxDepthHandler): void
+    {
+        $defaultSerializerNameConverter = $container->hasParameter('.serializer.name_converter')
+            ? $container->getParameter('.serializer.name_converter') : null;
+
+        foreach ($container->getParameter('.serializer.named_serializers') as $serializerName => $config) {
+            $config += ['default_context' => [], 'name_converter' => null];
+            $serializerId = 'serializer.'.$serializerName;
+
+            if (!$normalizers = $this->findAndSortTaggedServices('serializer.normalizer.'.$serializerName, $container)) {
+                throw new RuntimeException(\sprintf('The named serializer "%1$s" requires at least one registered normalizer. Tag the normalizers as "serializer.normalizer" with the "serializer" attribute set to "%1$s".', $serializerName));
+            }
+
+            if (!$encoders = $this->findAndSortTaggedServices('serializer.encoder.'.$serializerName, $container)) {
+                throw new RuntimeException(\sprintf('The named serializer "%1$s" requires at least one registered encoder. Tag the encoders as "serializer.encoder" with the "serializer" attribute set to "%1$s".', $serializerName));
+            }
+
+            $config['name_converter'] = $defaultSerializerNameConverter !== $config['name_converter']
+                ? $this->buildChildNameConverterDefinition($container, $config['name_converter'])
+                : self::NAME_CONVERTER_METADATA_AWARE_ID;
+
+            $normalizers = $this->buildChildDefinitions($container, $serializerName, $normalizers, $config);
+            $encoders = $this->buildChildDefinitions($container, $serializerName, $encoders, $config);
+
+            $this->bindDefaultContext($container, array_merge($normalizers, $encoders), $config['default_context'], $circularReferenceHandler, $maxDepthHandler);
+
+            $container->registerChild($serializerId, 'serializer')->setArgument('$defaultContext', $config['default_context']);
+            $container->registerAliasForArgument($serializerId, SerializerInterface::class, $serializerName.'.serializer');
+
+            $this->configureSerializer($container, $serializerId, $normalizers, $encoders, $serializerName);
+
+            if ($container->getParameter('kernel.debug') && $container->hasDefinition('debug.serializer')) {
+                $container->registerChild($debugId = 'debug.'.$serializerId, 'debug.serializer')
+                    ->setDecoratedService($serializerId)
+                    ->replaceArgument(0, new Reference($debugId.'.inner'))
+                    ->replaceArgument(2, $serializerName);
+            }
+        }
+    }
+
+    private function buildChildNameConverterDefinition(ContainerBuilder $container, ?string $nameConverter): ?string
+    {
+        $childId = self::NAME_CONVERTER_METADATA_AWARE_ID.'.'.ContainerBuilder::hash($nameConverter);
+
+        if (!$container->hasDefinition($childId)) {
+            $childDefinition = $container->registerChild($childId, self::NAME_CONVERTER_METADATA_AWARE_ID.'.abstract');
+            if (null !== $nameConverter) {
+                $childDefinition->addArgument(new Reference($nameConverter));
+            }
+        }
+
+        return $childId;
+    }
+
+    private function buildChildDefinitions(ContainerBuilder $container, string $serializerName, array $services, array $config): array
+    {
+        foreach ($services as &$id) {
+            $childId = $id.'.'.$serializerName;
+
+            $definition = $container->registerChild($childId, (string) $id)
+                ->setClass($container->getDefinition((string) $id)->getClass())
+            ;
+
+            if (null !== $nameConverterIndex = $this->findNameConverterIndex($container, (string) $id)) {
+                $definition->replaceArgument($nameConverterIndex, new Reference($config['name_converter']));
+            }
+
+            $id = new Reference($childId);
+        }
+
+        return $services;
+    }
+
+    private function findNameConverterIndex(ContainerBuilder $container, string $id): int|string|null
+    {
+        foreach ($container->getDefinition($id)->getArguments() as $index => $argument) {
+            if ($argument instanceof Reference && self::NAME_CONVERTER_METADATA_AWARE_ID === (string) $argument) {
+                return $index;
+            }
+        }
+
+        return null;
+    }
 }
diff --git a/Encoder/ChainDecoder.php b/Encoder/ChainDecoder.php
index f1b0cd2e2..8df5cd8b8 100644
--- a/Encoder/ChainDecoder.php
+++ b/Encoder/ChainDecoder.php
@@ -33,7 +33,7 @@ class ChainDecoder implements ContextAwareDecoderInterface
      * @param array<DecoderInterface> $decoders
      */
     public function __construct(
-        private readonly array $decoders = []
+        private readonly array $decoders = [],
     ) {
     }
 
@@ -78,6 +78,6 @@ private function getDecoder(string $format, array $context): DecoderInterface
             }
         }
 
-        throw new RuntimeException(sprintf('No decoder found for format "%s".', $format));
+        throw new RuntimeException(\sprintf('No decoder found for format "%s".', $format));
     }
 }
diff --git a/Encoder/ChainEncoder.php b/Encoder/ChainEncoder.php
index 731cfc601..3621471b4 100644
--- a/Encoder/ChainEncoder.php
+++ b/Encoder/ChainEncoder.php
@@ -34,7 +34,7 @@ class ChainEncoder implements ContextAwareEncoderInterface
      * @param array<EncoderInterface> $encoders
      */
     public function __construct(
-        private readonly array $encoders = []
+        private readonly array $encoders = [],
     ) {
     }
 
@@ -101,6 +101,6 @@ private function getEncoder(string $format, array $context): EncoderInterface
             }
         }
 
-        throw new RuntimeException(sprintf('No encoder found for format "%s".', $format));
+        throw new RuntimeException(\sprintf('No encoder found for format "%s".', $format));
     }
 }
diff --git a/Encoder/CsvEncoder.php b/Encoder/CsvEncoder.php
index 8f9c3cff0..3902b5613 100644
--- a/Encoder/CsvEncoder.php
+++ b/Encoder/CsvEncoder.php
@@ -25,6 +25,9 @@ class CsvEncoder implements EncoderInterface, DecoderInterface
     public const FORMAT = 'csv';
     public const DELIMITER_KEY = 'csv_delimiter';
     public const ENCLOSURE_KEY = 'csv_enclosure';
+    /**
+     * @deprecated since Symfony 7.2, to be removed in 8.0
+     */
     public const ESCAPE_CHAR_KEY = 'csv_escape_char';
     public const KEY_SEPARATOR_KEY = 'csv_key_separator';
     public const HEADERS_KEY = 'csv_headers';
@@ -53,6 +56,10 @@ class CsvEncoder implements EncoderInterface, DecoderInterface
 
     public function __construct(array $defaultContext = [])
     {
+        if (\array_key_exists(self::ESCAPE_CHAR_KEY, $defaultContext)) {
+            trigger_deprecation('symfony/serializer', '7.2', 'Setting the "csv_escape_char" option is deprecated. The option will be removed in 8.0.');
+        }
+
         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
     }
 
@@ -62,7 +69,7 @@ public function encode(mixed $data, string $format, array $context = []): string
 
         if (!is_iterable($data)) {
             $data = [[$data]];
-        } elseif (empty($data)) {
+        } elseif (!$data) {
             $data = [[]];
         } else {
             // Sequential arrays of arrays are considered as collections
@@ -197,7 +204,7 @@ public function decode(string $data, string $format, array $context = []): mixed
             return $result;
         }
 
-        if (empty($result) || isset($result[1])) {
+        if (!$result || isset($result[1])) {
             return $result;
         }
 
@@ -241,7 +248,7 @@ private function getCsvOptions(array $context): array
         $asCollection = $context[self::AS_COLLECTION_KEY] ?? $this->defaultContext[self::AS_COLLECTION_KEY];
 
         if (!\is_array($headers)) {
-            throw new InvalidArgumentException(sprintf('The "%s" context variable must be an array or null, given "%s".', self::HEADERS_KEY, get_debug_type($headers)));
+            throw new InvalidArgumentException(\sprintf('The "%s" context variable must be an array or null, given "%s".', self::HEADERS_KEY, get_debug_type($headers)));
         }
 
         return [$delimiter, $enclosure, $escapeChar, $keySeparator, $headers, $escapeFormulas, $outputBom, $asCollection];
diff --git a/Encoder/DecoderInterface.php b/Encoder/DecoderInterface.php
index 84a84ad1f..09ec9434d 100644
--- a/Encoder/DecoderInterface.php
+++ b/Encoder/DecoderInterface.php
@@ -30,18 +30,14 @@ interface DecoderInterface
      * are encouraged to document which formats they support in a non-inherited
      * phpdoc comment.
      *
-     * @return mixed
-     *
      * @throws UnexpectedValueException
      */
-    public function decode(string $data, string $format, array $context = []);
+    public function decode(string $data, string $format, array $context = []): mixed;
 
     /**
      * Checks whether the deserializer can decode from given format.
      *
      * @param string $format Format name
-     *
-     * @return bool
      */
-    public function supportsDecoding(string $format);
+    public function supportsDecoding(string $format): bool;
 }
diff --git a/Encoder/JsonDecode.php b/Encoder/JsonDecode.php
index 6875ff81c..b50538175 100644
--- a/Encoder/JsonDecode.php
+++ b/Encoder/JsonDecode.php
@@ -22,11 +22,6 @@
  */
 class JsonDecode implements DecoderInterface
 {
-    /**
-     * @deprecated since Symfony 6.4, to be removed in 7.0
-     */
-    protected $serializer;
-
     /**
      * True to return the result as an associative array, false for a nested stdClass hierarchy.
      */
@@ -111,7 +106,7 @@ public function decode(string $data, string $format, array $context = []): mixed
         }
 
         if (!class_exists(JsonParser::class)) {
-            throw new UnsupportedException(sprintf('Enabling "%s" serializer option requires seld/jsonlint. Try running "composer require seld/jsonlint".', self::DETAILED_ERROR_MESSAGES));
+            throw new UnsupportedException(\sprintf('Enabling "%s" serializer option requires seld/jsonlint. Try running "composer require seld/jsonlint".', self::DETAILED_ERROR_MESSAGES));
         }
 
         throw new NotEncodableValueException((new JsonParser())->lint($data)?->getMessage() ?: $errorMessage);
diff --git a/Encoder/JsonEncoder.php b/Encoder/JsonEncoder.php
index e63d2d515..5727e7be0 100644
--- a/Encoder/JsonEncoder.php
+++ b/Encoder/JsonEncoder.php
@@ -20,8 +20,8 @@ class JsonEncoder implements EncoderInterface, DecoderInterface
 {
     public const FORMAT = 'json';
 
-    protected $encodingImpl;
-    protected $decodingImpl;
+    protected JsonEncode $encodingImpl;
+    protected JsonDecode $decodingImpl;
 
     private array $defaultContext = [
         JsonDecode::ASSOCIATIVE => true,
diff --git a/Encoder/XmlEncoder.php b/Encoder/XmlEncoder.php
index dc28771b8..e1a816380 100644
--- a/Encoder/XmlEncoder.php
+++ b/Encoder/XmlEncoder.php
@@ -59,6 +59,7 @@ class XmlEncoder implements EncoderInterface, DecoderInterface, NormalizationAwa
     public const TYPE_CAST_ATTRIBUTES = 'xml_type_cast_attributes';
     public const VERSION = 'xml_version';
     public const CDATA_WRAPPING = 'cdata_wrapping';
+    public const CDATA_WRAPPING_PATTERN = 'cdata_wrapping_pattern';
 
     private array $defaultContext = [
         self::AS_COLLECTION => false,
@@ -70,6 +71,7 @@ class XmlEncoder implements EncoderInterface, DecoderInterface, NormalizationAwa
         self::ROOT_NODE_NAME => 'response',
         self::TYPE_CAST_ATTRIBUTES => true,
         self::CDATA_WRAPPING => true,
+        self::CDATA_WRAPPING_PATTERN => '/[<>&]/',
     ];
 
     public function __construct(array $defaultContext = [])
@@ -82,7 +84,7 @@ public function encode(mixed $data, string $format, array $context = []): string
         $encoderIgnoredNodeTypes = $context[self::ENCODER_IGNORED_NODE_TYPES] ?? $this->defaultContext[self::ENCODER_IGNORED_NODE_TYPES];
         $ignorePiNode = \in_array(\XML_PI_NODE, $encoderIgnoredNodeTypes, true);
         if ($data instanceof \DOMDocument) {
-            return $data->saveXML($ignorePiNode ? $data->documentElement : null);
+            return $this->saveXml($data, $ignorePiNode ? $data->documentElement : null);
         }
 
         $xmlRootNodeName = $context[self::ROOT_NODE_NAME] ?? $this->defaultContext[self::ROOT_NODE_NAME];
@@ -97,7 +99,7 @@ public function encode(mixed $data, string $format, array $context = []): string
             $this->appendNode($dom, $data, $format, $context, $xmlRootNodeName);
         }
 
-        return $dom->saveXML($ignorePiNode ? $dom->documentElement : null, $context[self::SAVE_OPTIONS] ?? $this->defaultContext[self::SAVE_OPTIONS]);
+        return $this->saveXml($dom, $ignorePiNode ? $dom->documentElement : null, $context[self::SAVE_OPTIONS] ?? $this->defaultContext[self::SAVE_OPTIONS]);
     }
 
     public function decode(string $data, string $format, array $context = []): mixed
@@ -150,9 +152,8 @@ public function decode(string $data, string $format, array $context = []): mixed
         }
 
         $data = array_merge($this->parseXmlAttributes($rootNode, $context), ['#' => $rootNode->nodeValue]);
-        $data = $this->addXmlNamespaces($data, $rootNode, $dom);
 
-        return $data;
+        return $this->addXmlNamespaces($data, $rootNode, $dom);
     }
 
     public function supportsEncoding(string $format): bool
@@ -196,13 +197,9 @@ final protected function appendCData(\DOMNode $node, string $val): bool
 
     final protected function appendDocumentFragment(\DOMNode $node, \DOMDocumentFragment $fragment): bool
     {
-        if ($fragment instanceof \DOMDocumentFragment) {
-            $node->appendChild($fragment);
-
-            return true;
-        }
+        $node->appendChild($fragment);
 
-        return false;
+        return true;
     }
 
     final protected function appendComment(\DOMNode $node, string $data): bool
@@ -391,7 +388,7 @@ private function buildXml(\DOMNode $parentNode, mixed $data, string $format, arr
 
         if (\is_object($data)) {
             if (null === $this->serializer) {
-                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
+                throw new BadMethodCallException(\sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
             }
 
             $data = $this->serializer->normalize($data, $format, $context);
@@ -410,7 +407,7 @@ private function buildXml(\DOMNode $parentNode, mixed $data, string $format, arr
             return $this->appendNode($parentNode, $data, $format, $context, 'data');
         }
 
-        throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('%s resource', get_resource_type($data))));
+        throw new NotEncodableValueException('An unexpected value could not be serialized: '.(!\is_resource($data) ? var_export($data, true) : \sprintf('%s resource', get_resource_type($data))));
     }
 
     /**
@@ -437,7 +434,7 @@ private function appendNode(\DOMNode $parentNode, mixed $data, string $format, a
      */
     private function needsCdataWrapping(string $val, array $context): bool
     {
-        return ($context[self::CDATA_WRAPPING] ?? $this->defaultContext[self::CDATA_WRAPPING]) && preg_match('/[<>&]/', $val);
+        return ($context[self::CDATA_WRAPPING] ?? $this->defaultContext[self::CDATA_WRAPPING]) && preg_match($context[self::CDATA_WRAPPING_PATTERN] ?? $this->defaultContext[self::CDATA_WRAPPING_PATTERN], $val);
     }
 
     /**
@@ -459,7 +456,7 @@ private function selectNodeType(\DOMNode $node, mixed $val, string $format, arra
             $node->appendChild($child);
         } elseif (\is_object($val)) {
             if (null === $this->serializer) {
-                throw new BadMethodCallException(sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
+                throw new BadMethodCallException(\sprintf('The serializer needs to be set to allow "%s()" to be used with object data.', __METHOD__));
             }
 
             return $this->selectNodeType($node, $this->serializer->normalize($val, $format, $context), $format, $context);
@@ -502,4 +499,23 @@ private function createDomDocument(array $context): \DOMDocument
 
         return $document;
     }
+
+    /**
+     * @throws NotEncodableValueException
+     */
+    private function saveXml(\DOMDocument $document, ?\DOMNode $node = null, ?int $options = null): string
+    {
+        $prevErrorHandler = set_error_handler(static function ($type, $message, $file, $line, $context = []) use (&$prevErrorHandler) {
+            if (\E_ERROR === $type || \E_WARNING === $type) {
+                throw new NotEncodableValueException($message);
+            }
+
+            return $prevErrorHandler ? $prevErrorHandler($type, $message, $file, $line, $context) : false;
+        });
+        try {
+            return $document->saveXML($node, $options);
+        } finally {
+            restore_error_handler();
+        }
+    }
 }
diff --git a/Exception/ExtraAttributesException.php b/Exception/ExtraAttributesException.php
index 24b031ae3..639808b10 100644
--- a/Exception/ExtraAttributesException.php
+++ b/Exception/ExtraAttributesException.php
@@ -22,7 +22,7 @@ public function __construct(
         private readonly array $extraAttributes,
         ?\Throwable $previous = null,
     ) {
-        $msg = sprintf('Extra attributes are not allowed ("%s" %s unknown).', implode('", "', $extraAttributes), \count($extraAttributes) > 1 ? 'are' : 'is');
+        $msg = \sprintf('Extra attributes are not allowed ("%s" %s unknown).', implode('", "', $extraAttributes), \count($extraAttributes) > 1 ? 'are' : 'is');
 
         parent::__construct($msg, 0, $previous);
     }
diff --git a/Exception/NotNormalizableValueException.php b/Exception/NotNormalizableValueException.php
index 279be4127..4b956f1b0 100644
--- a/Exception/NotNormalizableValueException.php
+++ b/Exception/NotNormalizableValueException.php
@@ -22,17 +22,17 @@ class NotNormalizableValueException extends UnexpectedValueException
     private bool $useMessageForUser = false;
 
     /**
-     * @param string[] $expectedTypes
-     * @param bool     $useMessageForUser If the message passed to this exception is something that can be shown
-     *                                    safely to your user. In other words, avoid catching other exceptions and
-     *                                    passing their message directly to this class.
+     * @param list<string|\Stringable> $expectedTypes
+     * @param bool                     $useMessageForUser If the message passed to this exception is something that can be shown
+     *                                                    safely to your user. In other words, avoid catching other exceptions and
+     *                                                    passing their message directly to this class.
      */
     public static function createForUnexpectedDataType(string $message, mixed $data, array $expectedTypes, ?string $path = null, bool $useMessageForUser = false, int $code = 0, ?\Throwable $previous = null): self
     {
         $self = new self($message, $code, $previous);
 
         $self->currentType = get_debug_type($data);
-        $self->expectedTypes = $expectedTypes;
+        $self->expectedTypes = array_map(strval(...), $expectedTypes);
         $self->path = $path;
         $self->useMessageForUser = $useMessageForUser;
 
diff --git a/Exception/PartialDenormalizationException.php b/Exception/PartialDenormalizationException.php
index b684fddb2..5edc146cf 100644
--- a/Exception/PartialDenormalizationException.php
+++ b/Exception/PartialDenormalizationException.php
@@ -25,10 +25,7 @@ public function __construct(
     ) {
     }
 
-    /**
-     * @return mixed
-     */
-    public function getData()
+    public function getData(): mixed
     {
         return $this->data;
     }
diff --git a/Exception/UnexpectedPropertyException.php b/Exception/UnexpectedPropertyException.php
new file mode 100644
index 000000000..03e42fca5
--- /dev/null
+++ b/Exception/UnexpectedPropertyException.php
@@ -0,0 +1,29 @@
+<?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\Exception;
+
+/**
+ * UnexpectedPropertyException.
+ *
+ * @author Aurélien Pillevesse <aurelienpillevesse@hotmail.fr>
+ */
+class UnexpectedPropertyException extends \UnexpectedValueException implements ExceptionInterface
+{
+    public function __construct(
+        public readonly string $property,
+        ?\Throwable $previous = null,
+    ) {
+        $msg = \sprintf('Property is not allowed ("%s" is unknown).', $this->property);
+
+        parent::__construct($msg, 0, $previous);
+    }
+}
diff --git a/Extractor/ObjectPropertyListExtractor.php b/Extractor/ObjectPropertyListExtractor.php
index 8422b0786..42a546805 100644
--- a/Extractor/ObjectPropertyListExtractor.php
+++ b/Extractor/ObjectPropertyListExtractor.php
@@ -18,12 +18,12 @@
  */
 final class ObjectPropertyListExtractor implements ObjectPropertyListExtractorInterface
 {
-    private PropertyListExtractorInterface $propertyListExtractor;
     private \Closure $objectClassResolver;
 
-    public function __construct(PropertyListExtractorInterface $propertyListExtractor, ?callable $objectClassResolver = null)
-    {
-        $this->propertyListExtractor = $propertyListExtractor;
+    public function __construct(
+        private PropertyListExtractorInterface $propertyListExtractor,
+        ?callable $objectClassResolver = null,
+    ) {
         $this->objectClassResolver = ($objectClassResolver ?? 'get_class')(...);
     }
 
diff --git a/Mapping/AttributeMetadata.php b/Mapping/AttributeMetadata.php
index eaa14eb6e..12d1cf6bf 100644
--- a/Mapping/AttributeMetadata.php
+++ b/Mapping/AttributeMetadata.php
@@ -90,7 +90,7 @@ public function getName(): string
 
     public function addGroup(string $group): void
     {
-        if (!\in_array($group, $this->groups)) {
+        if (!\in_array($group, $this->groups, true)) {
             $this->groups[] = $group;
         }
     }
@@ -110,12 +110,8 @@ public function getMaxDepth(): ?int
         return $this->maxDepth;
     }
 
-    public function setSerializedName(?string $serializedName = null): void
+    public function setSerializedName(?string $serializedName): void
     {
-        if (1 > \func_num_args()) {
-            trigger_deprecation('symfony/serializer', '6.2', 'Calling "%s()" without any arguments is deprecated, pass null explicitly instead.', __METHOD__);
-        }
-
         $this->serializedName = $serializedName;
     }
 
diff --git a/Mapping/ClassMetadata.php b/Mapping/ClassMetadata.php
index 5cec14c91..b635ee10b 100644
--- a/Mapping/ClassMetadata.php
+++ b/Mapping/ClassMetadata.php
@@ -78,11 +78,7 @@ public function merge(ClassMetadataInterface $classMetadata): void
 
     public function getReflectionClass(): \ReflectionClass
     {
-        if (!$this->reflClass) {
-            $this->reflClass = new \ReflectionClass($this->getName());
-        }
-
-        return $this->reflClass;
+        return $this->reflClass ??= new \ReflectionClass($this->getName());
     }
 
     public function getClassDiscriminatorMapping(): ?ClassDiscriminatorMapping
@@ -90,11 +86,8 @@ public function getClassDiscriminatorMapping(): ?ClassDiscriminatorMapping
         return $this->classDiscriminatorMapping;
     }
 
-    public function setClassDiscriminatorMapping(?ClassDiscriminatorMapping $mapping = null): void
+    public function setClassDiscriminatorMapping(?ClassDiscriminatorMapping $mapping): void
     {
-        if (1 > \func_num_args()) {
-            trigger_deprecation('symfony/serializer', '6.2', 'Calling "%s()" without any arguments is deprecated, pass null explicitly instead.', __METHOD__);
-        }
         $this->classDiscriminatorMapping = $mapping;
     }
 
diff --git a/Mapping/Factory/ClassMetadataFactoryCompiler.php b/Mapping/Factory/ClassMetadataFactoryCompiler.php
index f01fe9ce2..1e9202b7d 100644
--- a/Mapping/Factory/ClassMetadataFactoryCompiler.php
+++ b/Mapping/Factory/ClassMetadataFactoryCompiler.php
@@ -57,7 +57,7 @@ private function generateDeclaredClassMetadata(array $classMetadatas): string
                 $classMetadata->getClassDiscriminatorMapping()->getTypesMapping(),
             ] : null;
 
-            $compiled .= sprintf("\n'%s' => %s,", $classMetadata->getName(), VarExporter::export([
+            $compiled .= \sprintf("\n'%s' => %s,", $classMetadata->getName(), VarExporter::export([
                 $attributesMetadata,
                 $classDiscriminatorMapping,
             ]));
diff --git a/Mapping/Factory/ClassResolverTrait.php b/Mapping/Factory/ClassResolverTrait.php
index 7af722d55..d7037f894 100644
--- a/Mapping/Factory/ClassResolverTrait.php
+++ b/Mapping/Factory/ClassResolverTrait.php
@@ -31,7 +31,7 @@ private function getClass(object|string $value): string
     {
         if (\is_string($value)) {
             if (!class_exists($value) && !interface_exists($value, false)) {
-                throw new InvalidArgumentException(sprintf('The class or interface "%s" does not exist.', $value));
+                throw new InvalidArgumentException(\sprintf('The class or interface "%s" does not exist.', $value));
             }
 
             return ltrim($value, '\\');
diff --git a/Mapping/Factory/CompiledClassMetadataFactory.php b/Mapping/Factory/CompiledClassMetadataFactory.php
index f4d41c1e6..ec25d7440 100644
--- a/Mapping/Factory/CompiledClassMetadataFactory.php
+++ b/Mapping/Factory/CompiledClassMetadataFactory.php
@@ -35,7 +35,7 @@ public function __construct(
 
         $compiledClassMetadata = require $compiledClassMetadataFile;
         if (!\is_array($compiledClassMetadata)) {
-            throw new \RuntimeException(sprintf('Compiled metadata must be of the type array, %s given.', \gettype($compiledClassMetadata)));
+            throw new \RuntimeException(\sprintf('Compiled metadata must be of the type array, %s given.', \gettype($compiledClassMetadata)));
         }
 
         $this->compiledClassMetadata = $compiledClassMetadata;
diff --git a/Mapping/Loader/AnnotationLoader.php b/Mapping/Loader/AnnotationLoader.php
deleted file mode 100644
index 5ffbb3406..000000000
--- a/Mapping/Loader/AnnotationLoader.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?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\Mapping\Loader;
-
-trigger_deprecation('symfony/serializer', '6.4', 'The "%s" class is deprecated, use "%s" instead.', AnnotationLoader::class, AttributeLoader::class);
-
-class_exists(AttributeLoader::class);
-
-if (false) {
-    /**
-     * @deprecated since Symfony 6.4, to be removed in 7.0, use {@link AttributeLoader} instead
-     */
-    class AnnotationLoader extends AttributeLoader
-    {
-    }
-}
diff --git a/Mapping/Loader/AttributeLoader.php b/Mapping/Loader/AttributeLoader.php
index 6bd967b5f..13c59d1c3 100644
--- a/Mapping/Loader/AttributeLoader.php
+++ b/Mapping/Loader/AttributeLoader.php
@@ -11,7 +11,6 @@
 
 namespace Symfony\Component\Serializer\Mapping\Loader;
 
-use Doctrine\Common\Annotations\Reader;
 use Symfony\Component\Serializer\Attribute\Context;
 use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
 use Symfony\Component\Serializer\Attribute\Groups;
@@ -44,12 +43,8 @@ class AttributeLoader implements LoaderInterface
         Context::class,
     ];
 
-    public function __construct(
-        private readonly ?Reader $reader = null,
-    ) {
-        if ($reader) {
-            trigger_deprecation('symfony/serializer', '6.4', 'Passing a "%s" instance as argument 1 to "%s()" is deprecated, pass null or omit the parameter instead.', get_debug_type($reader), __METHOD__);
-        }
+    public function __construct()
+    {
     }
 
     public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
@@ -58,28 +53,17 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
         $className = $reflectionClass->name;
         $loaded = false;
         $classGroups = [];
-        $classContextAnnotation = null;
+        $classContextAttribute = null;
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
 
-        foreach ($this->loadAttributes($reflectionClass) as $annotation) {
-            if ($annotation instanceof DiscriminatorMap) {
-                $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping(
-                    $annotation->getTypeProperty(),
-                    $annotation->getMapping()
-                ));
-                continue;
-            }
-
-            if ($annotation instanceof Groups) {
-                $classGroups = $annotation->getGroups();
-
-                continue;
-            }
-
-            if ($annotation instanceof Context) {
-                $classContextAnnotation = $annotation;
-            }
+        foreach ($this->loadAttributes($reflectionClass) as $attribute) {
+            match (true) {
+                $attribute instanceof DiscriminatorMap => $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping($attribute->getTypeProperty(), $attribute->getMapping())),
+                $attribute instanceof Groups => $classGroups = $attribute->getGroups(),
+                $attribute instanceof Context => $classContextAttribute = $attribute,
+                default => null,
+            };
         }
 
         foreach ($reflectionClass->getProperties() as $property) {
@@ -88,33 +72,35 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
                 $classMetadata->addAttributeMetadata($attributesMetadata[$property->name]);
             }
 
+            $attributeMetadata = $attributesMetadata[$property->name];
             if ($property->getDeclaringClass()->name === $className) {
-                if ($classContextAnnotation) {
-                    $this->setAttributeContextsForGroups($classContextAnnotation, $attributesMetadata[$property->name]);
+                if ($classContextAttribute) {
+                    $this->setAttributeContextsForGroups($classContextAttribute, $attributeMetadata);
                 }
 
                 foreach ($classGroups as $group) {
-                    $attributesMetadata[$property->name]->addGroup($group);
+                    $attributeMetadata->addGroup($group);
                 }
 
-                foreach ($this->loadAttributes($property) as $annotation) {
-                    if ($annotation instanceof Groups) {
-                        foreach ($annotation->getGroups() as $group) {
-                            $attributesMetadata[$property->name]->addGroup($group);
+                foreach ($this->loadAttributes($property) as $attribute) {
+                    $loaded = true;
+
+                    if ($attribute instanceof Groups) {
+                        foreach ($attribute->getGroups() as $group) {
+                            $attributeMetadata->addGroup($group);
                         }
-                    } elseif ($annotation instanceof MaxDepth) {
-                        $attributesMetadata[$property->name]->setMaxDepth($annotation->getMaxDepth());
-                    } elseif ($annotation instanceof SerializedName) {
-                        $attributesMetadata[$property->name]->setSerializedName($annotation->getSerializedName());
-                    } elseif ($annotation instanceof SerializedPath) {
-                        $attributesMetadata[$property->name]->setSerializedPath($annotation->getSerializedPath());
-                    } elseif ($annotation instanceof Ignore) {
-                        $attributesMetadata[$property->name]->setIgnore(true);
-                    } elseif ($annotation instanceof Context) {
-                        $this->setAttributeContextsForGroups($annotation, $attributesMetadata[$property->name]);
+
+                        continue;
                     }
 
-                    $loaded = true;
+                    match (true) {
+                        $attribute instanceof MaxDepth => $attributeMetadata->setMaxDepth($attribute->getMaxDepth()),
+                        $attribute instanceof SerializedName => $attributeMetadata->setSerializedName($attribute->getSerializedName()),
+                        $attribute instanceof SerializedPath => $attributeMetadata->setSerializedPath($attribute->getSerializedPath()),
+                        $attribute instanceof Ignore => $attributeMetadata->setIgnore(true),
+                        $attribute instanceof Context => $this->setAttributeContextsForGroups($attribute, $attributeMetadata),
+                        default => null,
+                    };
                 }
             }
         }
@@ -140,43 +126,43 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
                 }
             }
 
-            foreach ($this->loadAttributes($method) as $annotation) {
-                if ($annotation instanceof Groups) {
+            foreach ($this->loadAttributes($method) as $attribute) {
+                if ($attribute instanceof Groups) {
                     if (!$accessorOrMutator) {
-                        throw new MappingException(sprintf('Groups on "%s::%s()" cannot be added. Groups can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
+                        throw new MappingException(\sprintf('Groups on "%s::%s()" cannot be added. Groups can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
                     }
 
-                    foreach ($annotation->getGroups() as $group) {
+                    foreach ($attribute->getGroups() as $group) {
                         $attributeMetadata->addGroup($group);
                     }
-                } elseif ($annotation instanceof MaxDepth) {
+                } elseif ($attribute instanceof MaxDepth) {
                     if (!$accessorOrMutator) {
-                        throw new MappingException(sprintf('MaxDepth on "%s::%s()" cannot be added. MaxDepth can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
+                        throw new MappingException(\sprintf('MaxDepth on "%s::%s()" cannot be added. MaxDepth can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
                     }
 
-                    $attributeMetadata->setMaxDepth($annotation->getMaxDepth());
-                } elseif ($annotation instanceof SerializedName) {
+                    $attributeMetadata->setMaxDepth($attribute->getMaxDepth());
+                } elseif ($attribute instanceof SerializedName) {
                     if (!$accessorOrMutator) {
-                        throw new MappingException(sprintf('SerializedName on "%s::%s()" cannot be added. SerializedName can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
+                        throw new MappingException(\sprintf('SerializedName on "%s::%s()" cannot be added. SerializedName can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
                     }
 
-                    $attributeMetadata->setSerializedName($annotation->getSerializedName());
-                } elseif ($annotation instanceof SerializedPath) {
+                    $attributeMetadata->setSerializedName($attribute->getSerializedName());
+                } elseif ($attribute instanceof SerializedPath) {
                     if (!$accessorOrMutator) {
-                        throw new MappingException(sprintf('SerializedPath on "%s::%s()" cannot be added. SerializedPath can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
+                        throw new MappingException(\sprintf('SerializedPath on "%s::%s()" cannot be added. SerializedPath can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
                     }
 
-                    $attributeMetadata->setSerializedPath($annotation->getSerializedPath());
-                } elseif ($annotation instanceof Ignore) {
+                    $attributeMetadata->setSerializedPath($attribute->getSerializedPath());
+                } elseif ($attribute instanceof Ignore) {
                     if ($accessorOrMutator) {
                         $attributeMetadata->setIgnore(true);
                     }
-                } elseif ($annotation instanceof Context) {
+                } elseif ($attribute instanceof Context) {
                     if (!$accessorOrMutator) {
-                        throw new MappingException(sprintf('Context on "%s::%s()" cannot be added. Context can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
+                        throw new MappingException(\sprintf('Context on "%s::%s()" cannot be added. Context can only be added on methods beginning with "get", "is", "has" or "set".', $className, $method->name));
                     }
 
-                    $this->setAttributeContextsForGroups($annotation, $attributeMetadata);
+                    $this->setAttributeContextsForGroups($attribute, $attributeMetadata);
                 }
 
                 $loaded = true;
@@ -198,54 +184,30 @@ private function loadAttributes(\ReflectionMethod|\ReflectionClass|\ReflectionPr
                     }
                     $on = match (true) {
                         $reflector instanceof \ReflectionClass => ' on class '.$reflector->name,
-                        $reflector instanceof \ReflectionMethod => sprintf(' on "%s::%s()"', $reflector->getDeclaringClass()->name, $reflector->name),
-                        $reflector instanceof \ReflectionProperty => sprintf(' on "%s::$%s"', $reflector->getDeclaringClass()->name, $reflector->name),
+                        $reflector instanceof \ReflectionMethod => \sprintf(' on "%s::%s()"', $reflector->getDeclaringClass()->name, $reflector->name),
+                        $reflector instanceof \ReflectionProperty => \sprintf(' on "%s::$%s"', $reflector->getDeclaringClass()->name, $reflector->name),
                         default => '',
                     };
 
-                    throw new MappingException(sprintf('Could not instantiate attribute "%s"%s.', $attribute->getName(), $on), 0, $e);
+                    throw new MappingException(\sprintf('Could not instantiate attribute "%s"%s.', $attribute->getName(), $on), 0, $e);
                 }
             }
         }
-
-        if (null === $this->reader) {
-            return;
-        }
-
-        if ($reflector instanceof \ReflectionClass) {
-            yield from $this->getClassAnnotations($reflector);
-        }
-        if ($reflector instanceof \ReflectionMethod) {
-            yield from $this->getMethodAnnotations($reflector);
-        }
-        if ($reflector instanceof \ReflectionProperty) {
-            yield from $this->getPropertyAnnotations($reflector);
-        }
     }
 
-    /**
-     * @deprecated since Symfony 6.4 without replacement
-     */
-    public function loadAnnotations(\ReflectionMethod|\ReflectionClass|\ReflectionProperty $reflector): iterable
+    private function setAttributeContextsForGroups(Context $attribute, AttributeMetadataInterface $attributeMetadata): void
     {
-        trigger_deprecation('symfony/serializer', '6.4', 'Method "%s()" is deprecated without replacement.', __METHOD__);
+        $context = $attribute->getContext();
+        $groups = $attribute->getGroups();
+        $normalizationContext = $attribute->getNormalizationContext();
+        $denormalizationContext = $attribute->getDenormalizationContext();
 
-        return $this->loadAttributes($reflector);
-    }
-
-    private function setAttributeContextsForGroups(Context $annotation, AttributeMetadataInterface $attributeMetadata): void
-    {
-        if ($annotation->getContext()) {
-            $attributeMetadata->setNormalizationContextForGroups($annotation->getContext(), $annotation->getGroups());
-            $attributeMetadata->setDenormalizationContextForGroups($annotation->getContext(), $annotation->getGroups());
-        }
-
-        if ($annotation->getNormalizationContext()) {
-            $attributeMetadata->setNormalizationContextForGroups($annotation->getNormalizationContext(), $annotation->getGroups());
+        if ($normalizationContext || $context) {
+            $attributeMetadata->setNormalizationContextForGroups($normalizationContext ?: $context, $groups);
         }
 
-        if ($annotation->getDenormalizationContext()) {
-            $attributeMetadata->setDenormalizationContextForGroups($annotation->getDenormalizationContext(), $annotation->getGroups());
+        if ($denormalizationContext || $context) {
+            $attributeMetadata->setDenormalizationContextForGroups($denormalizationContext ?: $context, $groups);
         }
     }
 
@@ -259,53 +221,4 @@ private function isKnownAttribute(string $attributeName): bool
 
         return false;
     }
-
-    /**
-     * @return object[]
-     */
-    private function getClassAnnotations(\ReflectionClass $reflector): array
-    {
-        if ($annotations = array_filter(
-            $this->reader->getClassAnnotations($reflector),
-            fn (object $annotation): bool => $this->isKnownAttribute($annotation::class),
-        )) {
-            trigger_deprecation('symfony/serializer', '6.4', 'Class "%s" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.', $reflector->getName());
-        }
-
-        return $annotations;
-    }
-
-    /**
-     * @return object[]
-     */
-    private function getMethodAnnotations(\ReflectionMethod $reflector): array
-    {
-        if ($annotations = array_filter(
-            $this->reader->getMethodAnnotations($reflector),
-            fn (object $annotation): bool => $this->isKnownAttribute($annotation::class),
-        )) {
-            trigger_deprecation('symfony/serializer', '6.4', 'Method "%s::%s()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.', $reflector->getDeclaringClass()->getName(), $reflector->getName());
-        }
-
-        return $annotations;
-    }
-
-    /**
-     * @return object[]
-     */
-    private function getPropertyAnnotations(\ReflectionProperty $reflector): array
-    {
-        if ($annotations = array_filter(
-            $this->reader->getPropertyAnnotations($reflector),
-            fn (object $annotation): bool => $this->isKnownAttribute($annotation::class),
-        )) {
-            trigger_deprecation('symfony/serializer', '6.4', 'Property "%s::$%s" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.', $reflector->getDeclaringClass()->getName(), $reflector->getName());
-        }
-
-        return $annotations;
-    }
-}
-
-if (!class_exists(AnnotationLoader::class, false)) {
-    class_alias(AttributeLoader::class, AnnotationLoader::class);
 }
diff --git a/Mapping/Loader/FileLoader.php b/Mapping/Loader/FileLoader.php
index f4947ef4c..ac68d21e8 100644
--- a/Mapping/Loader/FileLoader.php
+++ b/Mapping/Loader/FileLoader.php
@@ -20,23 +20,20 @@
  */
 abstract class FileLoader implements LoaderInterface
 {
-    protected $file;
-
     /**
      * @param string $file The mapping file to load
      *
      * @throws MappingException if the mapping file does not exist or is not readable
      */
-    public function __construct(string $file)
-    {
+    public function __construct(
+        protected string $file,
+    ) {
         if (!is_file($file)) {
-            throw new MappingException(sprintf('The mapping file "%s" does not exist.', $file));
+            throw new MappingException(\sprintf('The mapping file "%s" does not exist.', $file));
         }
 
         if (!is_readable($file)) {
-            throw new MappingException(sprintf('The mapping file "%s" is not readable.', $file));
+            throw new MappingException(\sprintf('The mapping file "%s" is not readable.', $file));
         }
-
-        $this->file = $file;
     }
 }
diff --git a/Mapping/Loader/LoaderChain.php b/Mapping/Loader/LoaderChain.php
index e93a0a7b0..41abf8cec 100644
--- a/Mapping/Loader/LoaderChain.php
+++ b/Mapping/Loader/LoaderChain.php
@@ -38,7 +38,7 @@ public function __construct(private readonly array $loaders)
     {
         foreach ($loaders as $loader) {
             if (!$loader instanceof LoaderInterface) {
-                throw new MappingException(sprintf('Class "%s" is expected to implement LoaderInterface.', get_debug_type($loader)));
+                throw new MappingException(\sprintf('Class "%s" is expected to implement LoaderInterface.', get_debug_type($loader)));
             }
         }
     }
diff --git a/Mapping/Loader/XmlFileLoader.php b/Mapping/Loader/XmlFileLoader.php
index b36fb871d..44ba89df1 100644
--- a/Mapping/Loader/XmlFileLoader.php
+++ b/Mapping/Loader/XmlFileLoader.php
@@ -70,7 +70,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
                     try {
                         $attributeMetadata->setSerializedPath(new PropertyPath((string) $attribute['serialized-path']));
                     } catch (InvalidPropertyPathException) {
-                        throw new MappingException(sprintf('The "serialized-path" value must be a valid property path for the attribute "%s" of the class "%s".', $attributeName, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "serialized-path" value must be a valid property path for the attribute "%s" of the class "%s".', $attributeName, $classMetadata->getName()));
                     }
                 }
 
diff --git a/Mapping/Loader/YamlFileLoader.php b/Mapping/Loader/YamlFileLoader.php
index d47ad7430..ca71cbcba 100644
--- a/Mapping/Loader/YamlFileLoader.php
+++ b/Mapping/Loader/YamlFileLoader.php
@@ -59,12 +59,12 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
 
                 if (isset($data['groups'])) {
                     if (!\is_array($data['groups'])) {
-                        throw new MappingException(sprintf('The "groups" key must be an array of strings in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "groups" key must be an array of strings in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                     }
 
                     foreach ($data['groups'] as $group) {
                         if (!\is_string($group)) {
-                            throw new MappingException(sprintf('Group names must be strings in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                            throw new MappingException(\sprintf('Group names must be strings in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                         }
 
                         $attributeMetadata->addGroup($group);
@@ -73,7 +73,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
 
                 if (isset($data['max_depth'])) {
                     if (!\is_int($data['max_depth'])) {
-                        throw new MappingException(sprintf('The "max_depth" value must be an integer in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "max_depth" value must be an integer in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                     }
 
                     $attributeMetadata->setMaxDepth($data['max_depth']);
@@ -81,7 +81,7 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
 
                 if (isset($data['serialized_name'])) {
                     if (!\is_string($data['serialized_name']) || '' === $data['serialized_name']) {
-                        throw new MappingException(sprintf('The "serialized_name" value must be a non-empty string in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "serialized_name" value must be a non-empty string in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                     }
 
                     $attributeMetadata->setSerializedName($data['serialized_name']);
@@ -91,13 +91,13 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
                     try {
                         $attributeMetadata->setSerializedPath(new PropertyPath((string) $data['serialized_path']));
                     } catch (InvalidPropertyPathException) {
-                        throw new MappingException(sprintf('The "serialized_path" value must be a valid property path in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "serialized_path" value must be a valid property path in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                     }
                 }
 
                 if (isset($data['ignore'])) {
                     if (!\is_bool($data['ignore'])) {
-                        throw new MappingException(sprintf('The "ignore" value must be a boolean in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
+                        throw new MappingException(\sprintf('The "ignore" value must be a boolean in "%s" for the attribute "%s" of the class "%s".', $this->file, $attribute, $classMetadata->getName()));
                     }
 
                     $attributeMetadata->setIgnore($data['ignore']);
@@ -124,11 +124,11 @@ public function loadClassMetadata(ClassMetadataInterface $classMetadata): bool
 
         if (isset($yaml['discriminator_map'])) {
             if (!isset($yaml['discriminator_map']['type_property'])) {
-                throw new MappingException(sprintf('The "type_property" key must be set for the discriminator map of the class "%s" in "%s".', $classMetadata->getName(), $this->file));
+                throw new MappingException(\sprintf('The "type_property" key must be set for the discriminator map of the class "%s" in "%s".', $classMetadata->getName(), $this->file));
             }
 
             if (!isset($yaml['discriminator_map']['mapping'])) {
-                throw new MappingException(sprintf('The "mapping" key must be set for the discriminator map of the class "%s" in "%s".', $classMetadata->getName(), $this->file));
+                throw new MappingException(\sprintf('The "mapping" key must be set for the discriminator map of the class "%s" in "%s".', $classMetadata->getName(), $this->file));
             }
 
             $classMetadata->setClassDiscriminatorMapping(new ClassDiscriminatorMapping(
@@ -153,19 +153,19 @@ public function getMappedClasses(): array
     private function getClassesFromYaml(): array
     {
         if (!stream_is_local($this->file)) {
-            throw new MappingException(sprintf('This is not a local file "%s".', $this->file));
+            throw new MappingException(\sprintf('This is not a local file "%s".', $this->file));
         }
 
         $this->yamlParser ??= new Parser();
 
         $classes = $this->yamlParser->parseFile($this->file, Yaml::PARSE_CONSTANT);
 
-        if (empty($classes)) {
+        if (!$classes) {
             return [];
         }
 
         if (!\is_array($classes)) {
-            throw new MappingException(sprintf('The file "%s" must contain a YAML array.', $this->file));
+            throw new MappingException(\sprintf('The file "%s" must contain a YAML array.', $this->file));
         }
 
         return $classes;
diff --git a/NameConverter/AdvancedNameConverterInterface.php b/NameConverter/AdvancedNameConverterInterface.php
index 1e74f4d20..975d28fd3 100644
--- a/NameConverter/AdvancedNameConverterInterface.php
+++ b/NameConverter/AdvancedNameConverterInterface.php
@@ -15,6 +15,8 @@
  * Gives access to the class, the format and the context in the property name converters.
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
+ *
+ * @deprecated since Symfony 7.2, use NameConverterInterface instead
  */
 interface AdvancedNameConverterInterface extends NameConverterInterface
 {
diff --git a/NameConverter/CamelCaseToSnakeCaseNameConverter.php b/NameConverter/CamelCaseToSnakeCaseNameConverter.php
index ab6f99e13..033ec94b7 100644
--- a/NameConverter/CamelCaseToSnakeCaseNameConverter.php
+++ b/NameConverter/CamelCaseToSnakeCaseNameConverter.php
@@ -11,16 +11,24 @@
 
 namespace Symfony\Component\Serializer\NameConverter;
 
+use Symfony\Component\Serializer\Exception\UnexpectedPropertyException;
+
 /**
  * CamelCase to Underscore name converter.
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Aurélien Pillevesse <aurelienpillevesse@hotmail.fr>
  */
 class CamelCaseToSnakeCaseNameConverter implements NameConverterInterface
 {
     /**
-     * @param array|null $attributes     The list of attributes to rename or null for all attributes
-     * @param bool       $lowerCamelCase Use lowerCamelCase style
+     * Require all properties to be written in snake_case.
+     */
+    public const REQUIRE_SNAKE_CASE_PROPERTIES = 'require_snake_case_properties';
+
+    /**
+     * @param string[]|null $attributes     The list of attributes to rename or null for all attributes
+     * @param bool          $lowerCamelCase Use lowerCamelCase style
      */
     public function __construct(
         private ?array $attributes = null,
@@ -28,24 +36,42 @@ public function __construct(
     ) {
     }
 
-    public function normalize(string $propertyName): string
+    /**
+     * @param class-string|null    $class
+     * @param string|null          $format
+     * @param array<string, mixed> $context
+     */
+    public function normalize(string $propertyName/* , ?string $class = null, ?string $format = null, array $context = [] */): string
     {
-        if (null === $this->attributes || \in_array($propertyName, $this->attributes)) {
+        if (null === $this->attributes || \in_array($propertyName, $this->attributes, true)) {
             return strtolower(preg_replace('/[A-Z]/', '_\\0', lcfirst($propertyName)));
         }
 
         return $propertyName;
     }
 
-    public function denormalize(string $propertyName): string
+    /**
+     * @param class-string|null    $class
+     * @param string|null          $format
+     * @param array<string, mixed> $context
+     */
+    public function denormalize(string $propertyName/* , ?string $class = null, ?string $format = null, array $context = [] */): string
     {
+        $class = 1 < \func_num_args() ? func_get_arg(1) : null;
+        $format = 2 < \func_num_args() ? func_get_arg(2) : null;
+        $context = 3 < \func_num_args() ? func_get_arg(3) : [];
+
+        if (($context[self::REQUIRE_SNAKE_CASE_PROPERTIES] ?? false) && $propertyName !== $this->normalize($propertyName, $class, $format, $context)) {
+            throw new UnexpectedPropertyException($propertyName);
+        }
+
         $camelCasedName = preg_replace_callback('/(^|_|\.)+(.)/', fn ($match) => ('.' === $match[1] ? '_' : '').strtoupper($match[2]), $propertyName);
 
         if ($this->lowerCamelCase) {
             $camelCasedName = lcfirst($camelCasedName);
         }
 
-        if (null === $this->attributes || \in_array($camelCasedName, $this->attributes)) {
+        if (null === $this->attributes || \in_array($camelCasedName, $this->attributes, true)) {
             return $camelCasedName;
         }
 
diff --git a/NameConverter/MetadataAwareNameConverter.php b/NameConverter/MetadataAwareNameConverter.php
index 445ad7422..c72f148eb 100644
--- a/NameConverter/MetadataAwareNameConverter.php
+++ b/NameConverter/MetadataAwareNameConverter.php
@@ -80,7 +80,7 @@ private function getCacheValueForNormalization(string $propertyName, string $cla
         }
 
         if (null !== $attributesMetadata[$propertyName]->getSerializedName() && null !== $attributesMetadata[$propertyName]->getSerializedPath()) {
-            throw new LogicException(sprintf('Found SerializedName and SerializedPath attributes on property "%s" of class "%s".', $propertyName, $class));
+            throw new LogicException(\sprintf('Found SerializedName and SerializedPath attributes on property "%s" of class "%s".', $propertyName, $class));
         }
 
         return $attributesMetadata[$propertyName]->getSerializedName() ?? null;
@@ -124,7 +124,7 @@ private function getCacheValueForAttributesMetadata(string $class, array $contex
             }
 
             if (null !== $metadata->getSerializedName() && null !== $metadata->getSerializedPath()) {
-                throw new LogicException(sprintf('Found SerializedName and SerializedPath attributes on property "%s" of class "%s".', $name, $class));
+                throw new LogicException(\sprintf('Found SerializedName and SerializedPath attributes on property "%s" of class "%s".', $name, $class));
             }
 
             $metadataGroups = $metadata->getGroups();
diff --git a/NameConverter/NameConverterInterface.php b/NameConverter/NameConverterInterface.php
index aba69a49e..d6bfeceb4 100644
--- a/NameConverter/NameConverterInterface.php
+++ b/NameConverter/NameConverterInterface.php
@@ -20,11 +20,19 @@ interface NameConverterInterface
 {
     /**
      * Converts a property name to its normalized value.
+     *
+     * @param class-string|null    $class
+     * @param string|null          $format
+     * @param array<string, mixed> $context
      */
-    public function normalize(string $propertyName): string;
+    public function normalize(string $propertyName/* , ?string $class = null, ?string $format = null, array $context = [] */): string;
 
     /**
      * Converts a property name to its denormalized value.
+     *
+     * @param class-string|null    $class
+     * @param string|null          $format
+     * @param array<string, mixed> $context
      */
-    public function denormalize(string $propertyName): string;
+    public function denormalize(string $propertyName/* , ?string $class = null, ?string $format = null, array $context = [] */): string;
 }
diff --git a/NameConverter/SnakeCaseToCamelCaseNameConverter.php b/NameConverter/SnakeCaseToCamelCaseNameConverter.php
new file mode 100644
index 000000000..cb93d3e98
--- /dev/null
+++ b/NameConverter/SnakeCaseToCamelCaseNameConverter.php
@@ -0,0 +1,78 @@
+<?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\NameConverter;
+
+use Symfony\Component\Serializer\Exception\UnexpectedPropertyException;
+
+/**
+ * Underscore to camelCase name converter.
+ *
+ * @author Kévin Dunglas <kevin@dunglas.dev>
+ */
+final readonly class SnakeCaseToCamelCaseNameConverter implements NameConverterInterface
+{
+    /**
+     * Require all properties to be written in camelCase.
+     */
+    public const REQUIRE_CAMEL_CASE_PROPERTIES = 'require_camel_case_properties';
+
+    /**
+     * @param string[]|null $attributes     The list of attributes to rename or null for all attributes
+     * @param bool          $lowerCamelCase Use lowerCamelCase style
+     */
+    public function __construct(
+        private ?array $attributes = null,
+        private bool $lowerCamelCase = true,
+    ) {
+    }
+
+    /**
+     * @param class-string|null    $class
+     * @param array<string, mixed> $context
+     */
+    public function normalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
+    {
+        if (null !== $this->attributes && !\in_array($propertyName, $this->attributes, true)) {
+            return $propertyName;
+        }
+
+        $camelCasedName = preg_replace_callback(
+            '/(^|_|\.)+(.)/',
+            fn ($match) => ('.' === $match[1] ? '_' : '').strtoupper($match[2]),
+            $propertyName
+        );
+
+        if ($this->lowerCamelCase) {
+            $camelCasedName = lcfirst($camelCasedName);
+        }
+
+        return $camelCasedName;
+    }
+
+    /**
+     * @param class-string|null    $class
+     * @param array<string, mixed> $context
+     */
+    public function denormalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
+    {
+        if (($context[self::REQUIRE_CAMEL_CASE_PROPERTIES] ?? false) && $propertyName !== $this->normalize($propertyName, $class, $format, $context)) {
+            throw new UnexpectedPropertyException($propertyName);
+        }
+
+        $snakeCased = strtolower(preg_replace('/[A-Z]/', '_\\0', lcfirst($propertyName)));
+        if (null === $this->attributes || \in_array($snakeCased, $this->attributes, true)) {
+            return $snakeCased;
+        }
+
+        return $propertyName;
+    }
+}
diff --git a/Normalizer/AbstractNormalizer.php b/Normalizer/AbstractNormalizer.php
index c28a1f6cd..04f378c46 100644
--- a/Normalizer/AbstractNormalizer.php
+++ b/Normalizer/AbstractNormalizer.php
@@ -28,7 +28,7 @@
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
-abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
+abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface
 {
     use ObjectToPopulateTrait;
     use SerializerAwareTrait;
@@ -118,54 +118,45 @@ abstract class AbstractNormalizer implements NormalizerInterface, DenormalizerIn
      */
     public const REQUIRE_ALL_PROPERTIES = 'require_all_properties';
 
+    /**
+     * Flag to control whether a non-boolean value should be filtered using the
+     * filter_var function with the {@see https://www.php.net/manual/fr/filter.filters.validate.php}
+     * \FILTER_VALIDATE_BOOL filter before casting it to a boolean.
+     *
+     * "0", "false", "off", "no" and "" will be cast to false.
+     * "1", "true", "on" and "yes" will be cast to true.
+     */
+    public const FILTER_BOOL = 'filter_bool';
+
     /**
      * @internal
      */
     protected const CIRCULAR_REFERENCE_LIMIT_COUNTERS = 'circular_reference_limit_counters';
 
-    protected $defaultContext = [
+    protected array $defaultContext = [
         self::ALLOW_EXTRA_ATTRIBUTES => true,
         self::CIRCULAR_REFERENCE_HANDLER => null,
         self::CIRCULAR_REFERENCE_LIMIT => 1,
         self::IGNORED_ATTRIBUTES => [],
     ];
 
-    /**
-     * @var ClassMetadataFactoryInterface|null
-     */
-    protected $classMetadataFactory;
-
-    /**
-     * @var NameConverterInterface|null
-     */
-    protected $nameConverter;
-
     /**
      * Sets the {@link ClassMetadataFactoryInterface} to use.
      */
-    public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory = null, ?NameConverterInterface $nameConverter = null, array $defaultContext = [])
-    {
-        $this->classMetadataFactory = $classMetadataFactory;
-        $this->nameConverter = $nameConverter;
+    public function __construct(
+        protected ?ClassMetadataFactoryInterface $classMetadataFactory = null,
+        protected ?NameConverterInterface $nameConverter = null,
+        array $defaultContext = [],
+    ) {
         $this->defaultContext = array_merge($this->defaultContext, $defaultContext);
 
         $this->validateCallbackContext($this->defaultContext, 'default');
 
         if (isset($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER]) && !\is_callable($this->defaultContext[self::CIRCULAR_REFERENCE_HANDLER])) {
-            throw new InvalidArgumentException(sprintf('Invalid callback found in the "%s" default context option.', self::CIRCULAR_REFERENCE_HANDLER));
+            throw new InvalidArgumentException(\sprintf('Invalid callback found in the "%s" default context option.', self::CIRCULAR_REFERENCE_HANDLER));
         }
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return false;
-    }
-
     /**
      * Detects if the configured circular reference limit is reached.
      *
@@ -208,7 +199,7 @@ protected function handleCircularReference(object $object, ?string $format = nul
             return $circularReferenceHandler($object, $format, $context);
         }
 
-        throw new CircularReferenceException(sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', get_debug_type($object), $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT]));
+        throw new CircularReferenceException(\sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', get_debug_type($object), $context[self::CIRCULAR_REFERENCE_LIMIT] ?? $this->defaultContext[self::CIRCULAR_REFERENCE_LIMIT]));
     }
 
     /**
@@ -220,12 +211,12 @@ protected function handleCircularReference(object $object, ?string $format = nul
      *
      * @throws LogicException if the 'allow_extra_attributes' context variable is false and no class metadata factory is provided
      */
-    protected function getAllowedAttributes(string|object $classOrObject, array $context, bool $attributesAsString = false)
+    protected function getAllowedAttributes(string|object $classOrObject, array $context, bool $attributesAsString = false): array|bool
     {
         $allowExtraAttributes = $context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES];
         if (!$this->classMetadataFactory) {
             if (!$allowExtraAttributes) {
-                throw new LogicException(sprintf('A class metadata factory must be provided in the constructor when setting "%s" to false.', self::ALLOW_EXTRA_ATTRIBUTES));
+                throw new LogicException(\sprintf('A class metadata factory must be provided in the constructor when setting "%s" to false.', self::ALLOW_EXTRA_ATTRIBUTES));
             }
 
             return false;
@@ -235,6 +226,7 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con
 
         $allowedAttributes = [];
         $ignoreUsed = false;
+
         foreach ($this->classMetadataFactory->getMetadataFor($classOrObject)->getAttributesMetadata() as $attributeMetadata) {
             if ($ignore = $attributeMetadata->isIgnored()) {
                 $ignoreUsed = true;
@@ -243,7 +235,7 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con
             // If you update this check, update accordingly the one in Symfony\Component\PropertyInfo\Extractor\SerializerExtractor::getProperties()
             if (
                 !$ignore
-                && ([] === $groups || array_intersect(array_merge($attributeMetadata->getGroups(), ['*']), $groups))
+                && ([] === $groups || \in_array('*', $groups, true) || array_intersect($attributeMetadata->getGroups(), $groups))
                 && $this->isAllowedAttribute($classOrObject, $name = $attributeMetadata->getName(), null, $context)
             ) {
                 $allowedAttributes[] = $attributesAsString ? $name : $attributeMetadata;
@@ -267,13 +259,11 @@ protected function getGroups(array $context): array
 
     /**
      * Is this attribute allowed?
-     *
-     * @return bool
      */
-    protected function isAllowedAttribute(object|string $classOrObject, string $attribute, ?string $format = null, array $context = [])
+    protected function isAllowedAttribute(object|string $classOrObject, string $attribute, ?string $format = null, array $context = []): bool
     {
         $ignoredAttributes = $context[self::IGNORED_ATTRIBUTES] ?? $this->defaultContext[self::IGNORED_ATTRIBUTES];
-        if (\in_array($attribute, $ignoredAttributes)) {
+        if (\in_array($attribute, $ignoredAttributes, true)) {
             return false;
         }
 
@@ -316,12 +306,10 @@ protected function getConstructor(array &$data, string $class, array &$context,
      * is removed from the context before being returned to avoid side effects
      * when recursively normalizing an object graph.
      *
-     * @return object
-     *
      * @throws RuntimeException
      * @throws MissingConstructorArgumentsException
      */
-    protected function instantiateObject(array &$data, string $class, array &$context, \ReflectionClass $reflectionClass, array|bool $allowedAttributes, ?string $format = null)
+    protected function instantiateObject(array &$data, string $class, array &$context, \ReflectionClass $reflectionClass, array|bool $allowedAttributes, ?string $format = null): object
     {
         if (null !== $object = $this->extractObjectToPopulate($class, $context, self::OBJECT_TO_POPULATE)) {
             unset($context[self::OBJECT_TO_POPULATE]);
@@ -348,12 +336,12 @@ protected function instantiateObject(array &$data, string $class, array &$contex
                 $attributeContext = $this->getAttributeDenormalizationContext($class, $paramName, $context);
                 $key = $this->nameConverter ? $this->nameConverter->normalize($paramName, $class, $format, $context) : $paramName;
 
-                $allowed = false === $allowedAttributes || \in_array($paramName, $allowedAttributes);
+                $allowed = false === $allowedAttributes || \in_array($paramName, $allowedAttributes, true);
                 $ignored = !$this->isAllowedAttribute($class, $paramName, $format, $context);
                 if ($constructorParameter->isVariadic()) {
                     if ($allowed && !$ignored && (isset($data[$key]) || \array_key_exists($key, $data))) {
                         if (!\is_array($data[$key])) {
-                            throw new RuntimeException(sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));
+                            throw new RuntimeException(\sprintf('Cannot create an instance of "%s" from serialized data because the variadic parameter "%s" can only accept an array.', $class, $constructorParameter->name));
                         }
 
                         $variadicParameters = [];
@@ -415,7 +403,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
                     }
 
                     $exception = NotNormalizableValueException::createForUnexpectedDataType(
-                        sprintf('Failed to create object because the class misses the "%s" property.', $constructorParameter->name),
+                        \sprintf('Failed to create object because the class misses the "%s" property.', $constructorParameter->name),
                         null,
                         [$constructorParameterType],
                         $attributeContext['deserialization_path'] ?? null,
@@ -426,7 +414,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
             }
 
             if ($missingConstructorArguments) {
-                throw new MissingConstructorArgumentsException(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$%s".', $class, implode('", "$', $missingConstructorArguments)), 0, null, $missingConstructorArguments, $class);
+                throw new MissingConstructorArgumentsException(\sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$%s".', $class, implode('", "$', $missingConstructorArguments)), 0, null, $missingConstructorArguments, $class);
             }
 
             if (!$constructor->isConstructor()) {
@@ -461,12 +449,7 @@ protected function instantiateObject(array &$data, string $class, array &$contex
         unset($context['has_constructor']);
 
         if (!$reflectionClass->isInstantiable()) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(
-                sprintf('Failed to create object because the class "%s" is not instantiable.', $class),
-                $data,
-                ['unknown'],
-                $context['deserialization_path'] ?? null
-            );
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Failed to create object because the class "%s" is not instantiable.', $class), $data, ['unknown'], $context['deserialization_path'] ?? null);
         }
 
         return new $class();
@@ -483,13 +466,13 @@ protected function denormalizeParameter(\ReflectionClass $class, \ReflectionPara
                 new \ReflectionClass($parameterClass); // throws a \ReflectionException if the class doesn't exist
 
                 if (!$this->serializer instanceof DenormalizerInterface) {
-                    throw new LogicException(sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameterClass, static::class));
+                    throw new LogicException(\sprintf('Cannot create an instance of "%s" from serialized data because the serializer inject in "%s" is not a denormalizer.', $parameterClass, static::class));
                 }
 
                 $parameterData = $this->serializer->denormalize($parameterData, $parameterClass, $format, $this->createChildContext($context, $parameterName, $format));
             }
         } catch (\ReflectionException $e) {
-            throw new RuntimeException(sprintf('Could not determine the class of the parameter "%s".', $parameterName), 0, $e);
+            throw new RuntimeException(\sprintf('Could not determine the class of the parameter "%s".', $parameterName), 0, $e);
         } catch (MissingConstructorArgumentsException $e) {
             if (!$parameter->getType()->allowsNull()) {
                 throw $e;
@@ -498,7 +481,9 @@ protected function denormalizeParameter(\ReflectionClass $class, \ReflectionPara
             return null;
         }
 
-        return $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
+        $parameterData = $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
+
+        return $this->applyFilterBool($parameter, $parameterData, $context);
     }
 
     /**
@@ -529,12 +514,12 @@ final protected function validateCallbackContext(array $context, string $context
         }
 
         if (!\is_array($context[self::CALLBACKS])) {
-            throw new InvalidArgumentException(sprintf('The "%s"%s context option must be an array of callables.', self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
+            throw new InvalidArgumentException(\sprintf('The "%s"%s context option must be an array of callables.', self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
         }
 
         foreach ($context[self::CALLBACKS] as $attribute => $callback) {
             if (!\is_callable($callback)) {
-                throw new InvalidArgumentException(sprintf('Invalid callback found for attribute "%s" in the "%s"%s context option.', $attribute, self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
+                throw new InvalidArgumentException(\sprintf('Invalid callback found for attribute "%s" in the "%s"%s context option.', $attribute, self::CALLBACKS, '' !== $contextType ? " $contextType" : ''));
             }
         }
     }
@@ -549,6 +534,19 @@ final protected function applyCallbacks(mixed $value, object|string $object, str
         return $callback ? $callback($value, $object, $attribute, $format, $context) : $value;
     }
 
+    final protected function applyFilterBool(\ReflectionParameter $parameter, mixed $value, array $context): mixed
+    {
+        if (!($context[self::FILTER_BOOL] ?? false)) {
+            return $value;
+        }
+
+        if (!($parameterType = $parameter->getType()) instanceof \ReflectionNamedType || 'bool' !== $parameterType->getName()) {
+            return $value;
+        }
+
+        return filter_var($value, \FILTER_VALIDATE_BOOL, \FILTER_NULL_ON_FAILURE) ?? $value;
+    }
+
     /**
      * Computes the normalization context merged with current one. Metadata always wins over global context, as more specific.
      *
diff --git a/Normalizer/AbstractObjectNormalizer.php b/Normalizer/AbstractObjectNormalizer.php
index b27b1985e..00d2e3b00 100644
--- a/Normalizer/AbstractObjectNormalizer.php
+++ b/Normalizer/AbstractObjectNormalizer.php
@@ -12,11 +12,12 @@
 namespace Symfony\Component\Serializer\Normalizer;
 
 use Symfony\Component\PropertyAccess\Exception\InvalidArgumentException as PropertyAccessInvalidArgumentException;
+use Symfony\Component\PropertyAccess\Exception\InvalidTypeException;
 use Symfony\Component\PropertyAccess\Exception\NoSuchPropertyException;
 use Symfony\Component\PropertyAccess\Exception\UninitializedPropertyException;
 use Symfony\Component\PropertyAccess\PropertyAccess;
 use Symfony\Component\PropertyInfo\PropertyTypeExtractorInterface;
-use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\PropertyInfo\Type as LegacyType;
 use Symfony\Component\Serializer\Encoder\CsvEncoder;
 use Symfony\Component\Serializer\Encoder\JsonEncoder;
 use Symfony\Component\Serializer\Encoder\XmlEncoder;
@@ -31,6 +32,16 @@
 use Symfony\Component\Serializer\Mapping\ClassMetadataInterface;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
+use Symfony\Component\TypeInfo\Exception\LogicException as TypeInfoLogicException;
+use Symfony\Component\TypeInfo\Type;
+use Symfony\Component\TypeInfo\Type\BuiltinType;
+use Symfony\Component\TypeInfo\Type\CollectionType;
+use Symfony\Component\TypeInfo\Type\IntersectionType;
+use Symfony\Component\TypeInfo\Type\NullableType;
+use Symfony\Component\TypeInfo\Type\ObjectType;
+use Symfony\Component\TypeInfo\Type\UnionType;
+use Symfony\Component\TypeInfo\Type\WrappingTypeInterface;
+use Symfony\Component\TypeInfo\TypeIdentifier;
 
 /**
  * Base class for a normalizer dealing with objects.
@@ -50,7 +61,7 @@ abstract class AbstractObjectNormalizer extends AbstractNormalizer
     public const DEPTH_KEY_PATTERN = 'depth_%s::%s';
 
     /**
-     * While denormalizing, we can verify that types match.
+     * While denormalizing, we can verify that type matches.
      *
      * You can disable this by setting this flag to true.
      */
@@ -106,14 +117,14 @@ abstract class AbstractObjectNormalizer extends AbstractNormalizer
      */
     public const PRESERVE_EMPTY_OBJECTS = 'preserve_empty_objects';
 
-    private array $typesCache = [];
-    private array $attributesCache = [];
-    private readonly \Closure $objectClassResolver;
+    protected ?ClassDiscriminatorResolverInterface $classDiscriminatorResolver;
 
     /**
-     * @var ClassDiscriminatorResolverInterface|null
+     * @var array<string, Type|list<LegacyType>|false>
      */
-    protected $classDiscriminatorResolver;
+    private array $typeCache = [];
+    private array $attributesCache = [];
+    private readonly \Closure $objectClassResolver;
 
     public function __construct(
         ?ClassMetadataFactoryInterface $classMetadataFactory = null,
@@ -126,7 +137,7 @@ public function __construct(
         parent::__construct($classMetadataFactory, $nameConverter, $defaultContext);
 
         if (isset($this->defaultContext[self::MAX_DEPTH_HANDLER]) && !\is_callable($this->defaultContext[self::MAX_DEPTH_HANDLER])) {
-            throw new InvalidArgumentException(sprintf('The "%s" given in the default context is not callable.', self::MAX_DEPTH_HANDLER));
+            throw new InvalidArgumentException(\sprintf('The "%s" given in the default context is not callable.', self::MAX_DEPTH_HANDLER));
         }
 
         $this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] = array_merge($this->defaultContext[self::EXCLUDE_FROM_CACHE_KEY] ?? [], [self::CIRCULAR_REFERENCE_LIMIT_COUNTERS]);
@@ -138,20 +149,12 @@ public function __construct(
         $this->objectClassResolver = ($objectClassResolver ?? 'get_class')(...);
     }
 
-    /**
-     * @param array $context
-     *
-     * @return bool
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */)
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return \is_object($data) && !$data instanceof \Traversable;
     }
 
-    /**
-     * @return array|string|int|float|bool|\ArrayObject|null
-     */
-    public function normalize(mixed $object, ?string $format = null, array $context = [])
+    public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
     {
         $context['_read_attributes'] = true;
 
@@ -174,7 +177,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
         if (isset($context[self::MAX_DEPTH_HANDLER])) {
             $maxDepthHandler = $context[self::MAX_DEPTH_HANDLER];
             if (!\is_callable($maxDepthHandler)) {
-                throw new InvalidArgumentException(sprintf('The "%s" given in the context is not callable.', self::MAX_DEPTH_HANDLER));
+                throw new InvalidArgumentException(\sprintf('The "%s" given in the context is not callable.', self::MAX_DEPTH_HANDLER));
             }
         } else {
             $maxDepthHandler = null;
@@ -215,7 +218,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
             }
 
             if (!$this->serializer instanceof NormalizerInterface) {
-                throw new LogicException(sprintf('Cannot normalize attribute "%s" because the injected serializer is not a normalizer.', $attribute));
+                throw new LogicException(\sprintf('Cannot normalize attribute "%s" because the injected serializer is not a normalizer.', $attribute));
             }
 
             $childContext = $this->createChildContext($attributeContext, $attribute, $format);
@@ -231,10 +234,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
         return $data;
     }
 
-    /**
-     * @return object
-     */
-    protected function instantiateObject(array &$data, string $class, array &$context, \ReflectionClass $reflectionClass, array|bool $allowedAttributes, ?string $format = null)
+    protected function instantiateObject(array &$data, string $class, array &$context, \ReflectionClass $reflectionClass, array|bool $allowedAttributes, ?string $format = null): object
     {
         if ($class !== $mappedClass = $this->getMappedClass($data, $class, $context)) {
             return $this->instantiateObject($data, $mappedClass, $context, new \ReflectionClass($mappedClass), $allowedAttributes, $format);
@@ -285,29 +285,19 @@ protected function getAttributes(object $object, ?string $format, array $context
      *
      * @return string[]
      */
-    abstract protected function extractAttributes(object $object, ?string $format = null, array $context = []);
+    abstract protected function extractAttributes(object $object, ?string $format = null, array $context = []): array;
 
     /**
      * Gets the attribute value.
-     *
-     * @return mixed
      */
-    abstract protected function getAttributeValue(object $object, string $attribute, ?string $format = null, array $context = []);
+    abstract protected function getAttributeValue(object $object, string $attribute, ?string $format = null, array $context = []): mixed;
 
-    /**
-     * @param array $context
-     *
-     * @return bool
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */)
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return class_exists($type) || (interface_exists($type, false) && null !== $this->classDiscriminatorResolver?->getMappingForClass($type));
     }
 
-    /**
-     * @return mixed
-     */
-    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = [])
+    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
     {
         $context['_read_attributes'] = false;
 
@@ -317,7 +307,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
 
         $this->validateCallbackContext($context);
 
-        if (null === $data && isset($context['value_type']) && $context['value_type'] instanceof Type && $context['value_type']->isNullable()) {
+        if (null === $data && isset($context['value_type']) && ($context['value_type'] instanceof Type || $context['value_type'] instanceof LegacyType) && $context['value_type']->isNullable()) {
             return null;
         }
 
@@ -354,13 +344,13 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
                 $notConverted = $attribute;
                 $attribute = $this->nameConverter->denormalize($attribute, $resolvedClass, $format, $context);
                 if (isset($nestedData[$notConverted]) && !isset($originalNestedData[$attribute])) {
-                    throw new LogicException(sprintf('Duplicate values for key "%s" found. One value is set via the SerializedPath attribute: "%s", the other one is set via the SerializedName attribute: "%s".', $notConverted, implode('->', $nestedAttributes[$notConverted]->getElements()), $attribute));
+                    throw new LogicException(\sprintf('Duplicate values for key "%s" found. One value is set via the SerializedPath attribute: "%s", the other one is set via the SerializedName attribute: "%s".', $notConverted, implode('->', $nestedAttributes[$notConverted]->getElements()), $attribute));
                 }
             }
 
             $attributeContext = $this->getAttributeDenormalizationContext($resolvedClass, $attribute, $context);
 
-            if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes)) || !$this->isAllowedAttribute($resolvedClass, $attribute, $format, $context)) {
+            if ((false !== $allowedAttributes && !\in_array($attribute, $allowedAttributes, true)) || !$this->isAllowedAttribute($resolvedClass, $attribute, $format, $context)) {
                 if (!($context[self::ALLOW_EXTRA_ATTRIBUTES] ?? $this->defaultContext[self::ALLOW_EXTRA_ATTRIBUTES])) {
                     $extraAttributes[] = $attribute;
                 }
@@ -383,11 +373,15 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
                 }
             }
 
-            $types = $this->getTypes($resolvedClass, $attribute);
-
-            if (null !== $types) {
+            if (null !== $type = $this->getType($resolvedClass, $attribute)) {
                 try {
-                    $value = $this->validateAndDenormalize($types, $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'])) {
                         $context['not_normalizable_value_exceptions'][] = $exception;
@@ -403,9 +397,9 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
                 $this->setAttributeValue($object, $attribute, $value, $format, $attributeContext);
             } catch (PropertyAccessInvalidArgumentException $e) {
                 $exception = NotNormalizableValueException::createForUnexpectedDataType(
-                    sprintf('Failed to denormalize attribute "%s" value for class "%s": '.$e->getMessage(), $attribute, $type),
+                    \sprintf('Failed to denormalize attribute "%s" value for class "%s": '.$e->getMessage(), $attribute, $resolvedClass),
                     $data,
-                    ['unknown'],
+                    $e instanceof InvalidTypeException ? [$e->expectedType] : ['unknown'],
                     $attributeContext['deserialization_path'] ?? null,
                     false,
                     $e->getCode(),
@@ -426,22 +420,22 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         return $object;
     }
 
-    /**
-     * @return void
-     */
-    abstract protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []);
+    abstract protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void;
 
     /**
      * Validates the submitted data and denormalizes it.
      *
-     * @param Type[] $types
+     * BC layer for PropertyTypeExtractorInterface::getTypes().
+     * Can be removed as soon as PropertyTypeExtractorInterface::getTypes() is removed (8.0).
+     *
+     * @param LegacyType[] $types
      *
      * @throws NotNormalizableValueException
      * @throws ExtraAttributesException
      * @throws MissingConstructorArgumentsException
      * @throws LogicException
      */
-    private function validateAndDenormalize(array $types, string $currentClass, string $attribute, mixed $data, ?string $format, array $context): mixed
+    private function validateAndDenormalizeLegacy(array $types, string $currentClass, string $attribute, mixed $data, ?string $format, array $context): mixed
     {
         $expectedTypes = [];
         $isUnionType = \count($types) > 1;
@@ -474,11 +468,11 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                 $builtinType = $type->getBuiltinType();
                 if (\is_string($data) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
                     if ('' === $data) {
-                        if (Type::BUILTIN_TYPE_ARRAY === $builtinType) {
+                        if (LegacyType::BUILTIN_TYPE_ARRAY === $builtinType) {
                             return [];
                         }
 
-                        if (Type::BUILTIN_TYPE_STRING === $builtinType) {
+                        if (LegacyType::BUILTIN_TYPE_STRING === $builtinType) {
                             return '';
                         }
 
@@ -487,24 +481,24 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                     }
 
                     switch ($builtinType) {
-                        case Type::BUILTIN_TYPE_BOOL:
+                        case LegacyType::BUILTIN_TYPE_BOOL:
                             // according to https://www.w3.org/TR/xmlschema-2/#boolean, valid representations are "false", "true", "0" and "1"
                             if ('false' === $data || '0' === $data) {
                                 $data = false;
                             } elseif ('true' === $data || '1' === $data) {
                                 $data = true;
                             } else {
-                                throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be bool ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_BOOL], $context['deserialization_path'] ?? null);
+                                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be bool ("%s" given).', $attribute, $currentClass, $data), $data, [LegacyType::BUILTIN_TYPE_BOOL], $context['deserialization_path'] ?? null);
                             }
                             break;
-                        case Type::BUILTIN_TYPE_INT:
+                        case LegacyType::BUILTIN_TYPE_INT:
                             if (ctype_digit(isset($data[0]) && '-' === $data[0] ? substr($data, 1) : $data)) {
                                 $data = (int) $data;
                             } else {
-                                throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be int ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_INT], $context['deserialization_path'] ?? null);
+                                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be int ("%s" given).', $attribute, $currentClass, $data), $data, [LegacyType::BUILTIN_TYPE_INT], $context['deserialization_path'] ?? null);
                             }
                             break;
-                        case Type::BUILTIN_TYPE_FLOAT:
+                        case LegacyType::BUILTIN_TYPE_FLOAT:
                             if (is_numeric($data)) {
                                 return (float) $data;
                             }
@@ -513,13 +507,13 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                                 'NaN' => \NAN,
                                 'INF' => \INF,
                                 '-INF' => -\INF,
-                                default => throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be float ("%s" given).', $attribute, $currentClass, $data), $data, [Type::BUILTIN_TYPE_FLOAT], $context['deserialization_path'] ?? null),
+                                default => throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be float ("%s" given).', $attribute, $currentClass, $data), $data, [LegacyType::BUILTIN_TYPE_FLOAT], $context['deserialization_path'] ?? null),
                             };
                     }
                 }
 
-                if (null !== $collectionValueType && Type::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
-                    $builtinType = Type::BUILTIN_TYPE_OBJECT;
+                if (null !== $collectionValueType && LegacyType::BUILTIN_TYPE_OBJECT === $collectionValueType->getBuiltinType()) {
+                    $builtinType = LegacyType::BUILTIN_TYPE_OBJECT;
                     $class = $collectionValueType->getClassName().'[]';
 
                     if (\count($collectionKeyType = $type->getCollectionKeyTypes()) > 0) {
@@ -527,13 +521,13 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                     }
 
                     $context['value_type'] = $collectionValueType;
-                } elseif ($type->isCollection() && \count($collectionValueType = $type->getCollectionValueTypes()) > 0 && Type::BUILTIN_TYPE_ARRAY === $collectionValueType[0]->getBuiltinType()) {
+                } elseif ($type->isCollection() && \count($collectionValueType = $type->getCollectionValueTypes()) > 0 && LegacyType::BUILTIN_TYPE_ARRAY === $collectionValueType[0]->getBuiltinType()) {
                     // get inner type for any nested array
                     [$innerType] = $collectionValueType;
 
                     // note that it will break for any other builtinType
                     $dimensions = '[]';
-                    while (\count($innerType->getCollectionValueTypes()) > 0 && Type::BUILTIN_TYPE_ARRAY === $innerType->getBuiltinType()) {
+                    while (\count($innerType->getCollectionValueTypes()) > 0 && LegacyType::BUILTIN_TYPE_ARRAY === $innerType->getBuiltinType()) {
                         $dimensions .= '[]';
                         [$innerType] = $innerType->getCollectionValueTypes();
                     }
@@ -552,11 +546,11 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                     $class = $type->getClassName();
                 }
 
-                $expectedTypes[Type::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
+                $expectedTypes[LegacyType::BUILTIN_TYPE_OBJECT === $builtinType && $class ? $class : $builtinType] = true;
 
-                if (Type::BUILTIN_TYPE_OBJECT === $builtinType && null !== $class) {
+                if (LegacyType::BUILTIN_TYPE_OBJECT === $builtinType && null !== $class) {
                     if (!$this->serializer instanceof DenormalizerInterface) {
-                        throw new LogicException(sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
+                        throw new LogicException(\sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
                     }
 
                     $childContext = $this->createChildContext($context, $attribute, $format);
@@ -571,25 +565,29 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
                 // PHP's json_decode automatically converts Numbers without a decimal part to integers.
                 // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
                 // a float is expected.
-                if (Type::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && null !== $format && str_contains($format, JsonEncoder::FORMAT)) {
+                if (LegacyType::BUILTIN_TYPE_FLOAT === $builtinType && \is_int($data) && null !== $format && str_contains($format, JsonEncoder::FORMAT)) {
                     return (float) $data;
                 }
 
-                if ((Type::BUILTIN_TYPE_FALSE === $builtinType && false === $data) || (Type::BUILTIN_TYPE_TRUE === $builtinType && true === $data)) {
+                if (LegacyType::BUILTIN_TYPE_BOOL === $builtinType && (\is_string($data) || \is_int($data)) && ($context[self::FILTER_BOOL] ?? false)) {
+                    return filter_var($data, \FILTER_VALIDATE_BOOL, \FILTER_NULL_ON_FAILURE);
+                }
+
+                if ((LegacyType::BUILTIN_TYPE_FALSE === $builtinType && false === $data) || (LegacyType::BUILTIN_TYPE_TRUE === $builtinType && true === $data)) {
                     return $data;
                 }
 
                 switch ($builtinType) {
-                    case Type::BUILTIN_TYPE_ARRAY:
-                    case Type::BUILTIN_TYPE_BOOL:
-                    case Type::BUILTIN_TYPE_CALLABLE:
-                    case Type::BUILTIN_TYPE_FLOAT:
-                    case Type::BUILTIN_TYPE_INT:
-                    case Type::BUILTIN_TYPE_ITERABLE:
-                    case Type::BUILTIN_TYPE_NULL:
-                    case Type::BUILTIN_TYPE_OBJECT:
-                    case Type::BUILTIN_TYPE_RESOURCE:
-                    case Type::BUILTIN_TYPE_STRING:
+                    case LegacyType::BUILTIN_TYPE_ARRAY:
+                    case LegacyType::BUILTIN_TYPE_BOOL:
+                    case LegacyType::BUILTIN_TYPE_CALLABLE:
+                    case LegacyType::BUILTIN_TYPE_FLOAT:
+                    case LegacyType::BUILTIN_TYPE_INT:
+                    case LegacyType::BUILTIN_TYPE_ITERABLE:
+                    case LegacyType::BUILTIN_TYPE_NULL:
+                    case LegacyType::BUILTIN_TYPE_OBJECT:
+                    case LegacyType::BUILTIN_TYPE_RESOURCE:
+                    case LegacyType::BUILTIN_TYPE_STRING:
                         if (('is_'.$builtinType)($data)) {
                             return $data;
                         }
@@ -635,7 +633,292 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
             return $data;
         }
 
-        throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), get_debug_type($data)), $data, array_keys($expectedTypes), $context['deserialization_path'] ?? $attribute);
+        throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), get_debug_type($data)), $data, array_keys($expectedTypes), $context['deserialization_path'] ?? $attribute);
+    }
+
+    /**
+     * Validates the submitted data and denormalizes it.
+     *
+     * @throws NotNormalizableValueException
+     * @throws ExtraAttributesException
+     * @throws MissingConstructorArgumentsException
+     * @throws LogicException
+     */
+    private function validateAndDenormalize(Type $type, string $currentClass, string $attribute, mixed $data, ?string $format, array $context): mixed
+    {
+        $expectedTypes = [];
+
+        // BC layer for type-info < 7.2
+        if (method_exists(Type::class, 'asNonNullable')) {
+            $isUnionType = $type->asNonNullable() instanceof UnionType;
+        } else {
+            $isUnionType = $type instanceof UnionType;
+        }
+
+        $e = null;
+        $extraAttributesException = null;
+        $missingConstructorArgumentsException = null;
+
+        $types = match (true) {
+            $type instanceof IntersectionType => throw new LogicException('Unable to handle intersection type.'),
+            $type instanceof UnionType => $type->getTypes(),
+            default => [$type],
+        };
+
+        foreach ($types as $t) {
+            if (null === $data && $type->isNullable()) {
+                return null;
+            }
+
+            $collectionKeyType = $collectionValueType = null;
+            if ($t instanceof CollectionType) {
+                $collectionKeyType = $t->getCollectionKeyType();
+                $collectionValueType = $t->getCollectionValueType();
+            }
+
+            // BC layer for type-info < 7.2
+            if (method_exists(Type::class, 'getBaseType')) {
+                $t = $t->getBaseType();
+            } else {
+                while ($t instanceof WrappingTypeInterface) {
+                    $t = $t->getWrappedType();
+                }
+            }
+
+            // Fix a collection that contains the only one element
+            // This is special to xml format only
+            if ('xml' === $format && $collectionValueType && (!\is_array($data) || !\is_int(key($data)))) {
+                // BC layer for type-info < 7.2
+                $isMixedType = method_exists(Type::class, 'isA') ? $collectionValueType->isA(TypeIdentifier::MIXED) : $collectionValueType->isIdentifiedBy(TypeIdentifier::MIXED);
+                if (!$isMixedType) {
+                    $data = [$data];
+                }
+            }
+
+            // This try-catch should cover all NotNormalizableValueException (and all return branches after the first
+            // exception) so we could try denormalizing all types of an union type. If the target type is not an union
+            // type, we will just re-throw the catched exception.
+            // In the case of no denormalization succeeds with an union type, it will fall back to the default exception
+            // with the acceptable types list.
+            try {
+                // In XML and CSV all basic datatypes are represented as strings, it is e.g. not possible to determine,
+                // if a value is meant to be a string, float, int or a boolean value from the serialized representation.
+                // That's why we have to transform the values, if one of these non-string basic datatypes is expected.
+                $typeIdentifier = $t->getTypeIdentifier();
+                if (\is_string($data) && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format)) {
+                    if ('' === $data) {
+                        if (TypeIdentifier::ARRAY === $typeIdentifier) {
+                            return [];
+                        }
+
+                        if (TypeIdentifier::STRING === $typeIdentifier) {
+                            return '';
+                        }
+                    }
+
+                    switch ($typeIdentifier) {
+                        case TypeIdentifier::BOOL:
+                            // according to https://www.w3.org/TR/xmlschema-2/#boolean, valid representations are "false", "true", "0" and "1"
+                            if ('false' === $data || '0' === $data) {
+                                $data = false;
+                            } elseif ('true' === $data || '1' === $data) {
+                                $data = true;
+                            } else {
+                                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be bool ("%s" given).', $attribute, $currentClass, $data), $data, [Type::bool()], $context['deserialization_path'] ?? null);
+                            }
+                            break;
+                        case TypeIdentifier::INT:
+                            if (ctype_digit(isset($data[0]) && '-' === $data[0] ? substr($data, 1) : $data)) {
+                                $data = (int) $data;
+                            } else {
+                                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be int ("%s" given).', $attribute, $currentClass, $data), $data, [Type::int()], $context['deserialization_path'] ?? null);
+                            }
+                            break;
+                        case TypeIdentifier::FLOAT:
+                            if (is_numeric($data)) {
+                                return (float) $data;
+                            }
+
+                            return match ($data) {
+                                'NaN' => \NAN,
+                                'INF' => \INF,
+                                '-INF' => -\INF,
+                                default => throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be float ("%s" given).', $attribute, $currentClass, $data), $data, [Type::float()], $context['deserialization_path'] ?? null),
+                            };
+                    }
+                }
+
+                if ($collectionValueType) {
+                    try {
+                        $collectionValueBaseType = $collectionValueType;
+
+                        // BC layer for type-info < 7.2
+                        if (!interface_exists(WrappingTypeInterface::class)) {
+                            $collectionValueBaseType = $collectionValueType->getBaseType();
+                        } else {
+                            while ($collectionValueBaseType instanceof WrappingTypeInterface) {
+                                $collectionValueBaseType = $collectionValueBaseType->getWrappedType();
+                            }
+                        }
+                    } catch (TypeInfoLogicException) {
+                        $collectionValueBaseType = Type::mixed();
+                    }
+
+                    if ($collectionValueBaseType instanceof ObjectType) {
+                        $typeIdentifier = TypeIdentifier::OBJECT;
+                        $class = $collectionValueBaseType->getClassName().'[]';
+                        $context['key_type'] = $collectionKeyType;
+                        $context['value_type'] = $collectionValueType;
+                    } elseif (
+                        // BC layer for type-info < 7.2
+                        !class_exists(NullableType::class) && TypeIdentifier::ARRAY === $collectionValueBaseType->getTypeIdentifier()
+                        || $collectionValueBaseType instanceof BuiltinType && TypeIdentifier::ARRAY === $collectionValueBaseType->getTypeIdentifier()
+                    ) {
+                        // get inner type for any nested array
+                        $innerType = $collectionValueType;
+                        if ($innerType instanceof NullableType) {
+                            $innerType = $innerType->getWrappedType();
+                        }
+
+                        // note that it will break for any other builtinType
+                        $dimensions = '[]';
+                        while ($innerType instanceof CollectionType) {
+                            $dimensions .= '[]';
+                            $innerType = $innerType->getCollectionValueType();
+                            if ($innerType instanceof NullableType) {
+                                $innerType = $innerType->getWrappedType();
+                            }
+                        }
+
+                        while ($innerType instanceof WrappingTypeInterface) {
+                            $innerType = $innerType->getWrappedType();
+                        }
+
+                        if ($innerType instanceof ObjectType) {
+                            // the builtinType is the inner one and the class is the class followed by []...[]
+                            $typeIdentifier = TypeIdentifier::OBJECT;
+                            $class = $innerType->getClassName().$dimensions;
+                        } else {
+                            // default fallback (keep it as array)
+                            if ($t instanceof ObjectType) {
+                                $typeIdentifier = TypeIdentifier::OBJECT;
+                                $class = $t->getClassName();
+                            } else {
+                                $typeIdentifier = $t->getTypeIdentifier();
+                                $class = null;
+                            }
+                        }
+                    } elseif ($t instanceof ObjectType) {
+                        $typeIdentifier = TypeIdentifier::OBJECT;
+                        $class = $t->getClassName();
+                    } else {
+                        $typeIdentifier = $t->getTypeIdentifier();
+                        $class = null;
+                    }
+                } else {
+                    if ($t instanceof ObjectType) {
+                        $typeIdentifier = TypeIdentifier::OBJECT;
+                        $class = $t->getClassName();
+                    } else {
+                        $typeIdentifier = $t->getTypeIdentifier();
+                        $class = null;
+                    }
+                }
+
+                $expectedTypes[TypeIdentifier::OBJECT === $typeIdentifier && $class ? $class : $typeIdentifier->value] = true;
+
+                if (TypeIdentifier::OBJECT === $typeIdentifier && null !== $class) {
+                    if (!$this->serializer instanceof DenormalizerInterface) {
+                        throw new LogicException(\sprintf('Cannot denormalize attribute "%s" for class "%s" because injected serializer is not a denormalizer.', $attribute, $class));
+                    }
+
+                    $childContext = $this->createChildContext($context, $attribute, $format);
+                    if ($this->serializer->supportsDenormalization($data, $class, $format, $childContext)) {
+                        return $this->serializer->denormalize($data, $class, $format, $childContext);
+                    }
+                }
+
+                // JSON only has a Number type corresponding to both int and float PHP types.
+                // PHP's json_encode, JavaScript's JSON.stringify, Go's json.Marshal as well as most other JSON encoders convert
+                // floating-point numbers like 12.0 to 12 (the decimal part is dropped when possible).
+                // PHP's json_decode automatically converts Numbers without a decimal part to integers.
+                // To circumvent this behavior, integers are converted to floats when denormalizing JSON based formats and when
+                // a float is expected.
+                if (TypeIdentifier::FLOAT === $typeIdentifier && \is_int($data) && null !== $format && str_contains($format, JsonEncoder::FORMAT)) {
+                    return (float) $data;
+                }
+
+                if (TypeIdentifier::BOOL === $typeIdentifier && (\is_string($data) || \is_int($data)) && ($context[self::FILTER_BOOL] ?? false)) {
+                    return filter_var($data, \FILTER_VALIDATE_BOOL, \FILTER_NULL_ON_FAILURE);
+                }
+
+                $dataMatchesExpectedType = match ($typeIdentifier) {
+                    TypeIdentifier::ARRAY => \is_array($data),
+                    TypeIdentifier::BOOL => \is_bool($data),
+                    TypeIdentifier::CALLABLE => \is_callable($data),
+                    TypeIdentifier::FALSE => false === $data,
+                    TypeIdentifier::FLOAT => \is_float($data),
+                    TypeIdentifier::INT => \is_int($data),
+                    TypeIdentifier::ITERABLE => is_iterable($data),
+                    TypeIdentifier::MIXED => true,
+                    TypeIdentifier::NULL => null === $data,
+                    TypeIdentifier::OBJECT => \is_object($data),
+                    TypeIdentifier::RESOURCE => \is_resource($data),
+                    TypeIdentifier::STRING => \is_string($data),
+                    TypeIdentifier::TRUE => true === $data,
+                    default => false,
+                };
+
+                if ($dataMatchesExpectedType) {
+                    return $data;
+                }
+            } catch (NotNormalizableValueException|InvalidArgumentException $e) {
+                if (!$type instanceof UnionType) {
+                    throw $e;
+                }
+            } catch (ExtraAttributesException $e) {
+                if (!$type instanceof UnionType) {
+                    throw $e;
+                }
+
+                $extraAttributesException ??= $e;
+            } catch (MissingConstructorArgumentsException $e) {
+                if (!$type instanceof UnionType) {
+                    throw $e;
+                }
+
+                $missingConstructorArgumentsException ??= $e;
+            }
+        }
+
+        if ('' === $data && (XmlEncoder::FORMAT === $format || CsvEncoder::FORMAT === $format) && $type->isNullable()) {
+            return null;
+        }
+
+        if ($extraAttributesException) {
+            throw $extraAttributesException;
+        }
+
+        if ($missingConstructorArgumentsException) {
+            throw $missingConstructorArgumentsException;
+        }
+
+        // BC layer for type-info < 7.2
+        if (!class_exists(NullableType::class)) {
+            if (!$isUnionType && $e) {
+                throw $e;
+            }
+        } else {
+            if ($e && !($type instanceof UnionType && !$type instanceof NullableType)) {
+                throw $e;
+            }
+        }
+
+        if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
+            return $data;
+        }
+
+        throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the "%s" attribute for class "%s" must be one of "%s" ("%s" given).', $attribute, $currentClass, implode('", "', array_keys($expectedTypes)), get_debug_type($data)), $data, array_keys($expectedTypes), $context['deserialization_path'] ?? $attribute);
     }
 
     /**
@@ -643,52 +926,73 @@ private function validateAndDenormalize(array $types, string $currentClass, stri
      */
     protected function denormalizeParameter(\ReflectionClass $class, \ReflectionParameter $parameter, string $parameterName, mixed $parameterData, array $context, ?string $format = null): mixed
     {
-        if ($parameter->isVariadic() || null === $this->propertyTypeExtractor || null === $types = $this->getTypes($class->getName(), $parameterName)) {
+        if ($parameter->isVariadic() || null === $this->propertyTypeExtractor || null === $type = $this->getType($class->getName(), $parameterName)) {
             return parent::denormalizeParameter($class, $parameter, $parameterName, $parameterData, $context, $format);
         }
 
-        $parameterData = $this->validateAndDenormalize($types, $class->getName(), $parameterName, $parameterData, $format, $context);
+        // BC layer for PropertyTypeExtractorInterface::getTypes().
+        // Can be removed as soon as PropertyTypeExtractorInterface::getTypes() is removed (8.0).
+        if (\is_array($type)) {
+            $parameterData = $this->validateAndDenormalizeLegacy($type, $class->getName(), $parameterName, $parameterData, $format, $context);
+        } else {
+            $parameterData = $this->validateAndDenormalize($type, $class->getName(), $parameterName, $parameterData, $format, $context);
+        }
+
+        $parameterData = $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
 
-        return $this->applyCallbacks($parameterData, $class->getName(), $parameterName, $format, $context);
+        return $this->applyFilterBool($parameter, $parameterData, $context);
     }
 
     /**
-     * @return Type[]|null
+     * @return Type|list<LegacyType>|null
      */
-    private function getTypes(string $currentClass, string $attribute): ?array
+    private function getType(string $currentClass, string $attribute): Type|array|null
     {
         if (null === $this->propertyTypeExtractor) {
             return null;
         }
 
         $key = $currentClass.'::'.$attribute;
-        if (isset($this->typesCache[$key])) {
-            return false === $this->typesCache[$key] ? null : $this->typesCache[$key];
+        if (isset($this->typeCache[$key])) {
+            return false === $this->typeCache[$key] ? null : $this->typeCache[$key];
         }
 
-        if (null !== $types = $this->propertyTypeExtractor->getTypes($currentClass, $attribute)) {
-            return $this->typesCache[$key] = $types;
+        if (null !== $type = $this->getPropertyType($currentClass, $attribute)) {
+            return $this->typeCache[$key] = $type;
         }
 
         if ($discriminatorMapping = $this->classDiscriminatorResolver?->getMappingForClass($currentClass)) {
             if ($discriminatorMapping->getTypeProperty() === $attribute) {
-                return $this->typesCache[$key] = [
-                    new Type(Type::BUILTIN_TYPE_STRING),
-                ];
+                return $this->typeCache[$key] = Type::string();
             }
 
             foreach ($discriminatorMapping->getTypesMapping() as $mappedClass) {
-                if (null !== $types = $this->propertyTypeExtractor->getTypes($mappedClass, $attribute)) {
-                    return $this->typesCache[$key] = $types;
+                if (null !== $type = $this->getPropertyType($mappedClass, $attribute)) {
+                    return $this->typeCache[$key] = $type;
                 }
             }
         }
 
-        $this->typesCache[$key] = false;
+        $this->typeCache[$key] = false;
 
         return null;
     }
 
+    /**
+     * BC layer for PropertyTypeExtractorInterface::getTypes().
+     * Can be removed as soon as PropertyTypeExtractorInterface::getTypes() is removed (8.0).
+     *
+     * @return Type|list<LegacyType>|null
+     */
+    private function getPropertyType(string $className, string $property): Type|array|null
+    {
+        if (class_exists(Type::class) && method_exists($this->propertyTypeExtractor, 'getType')) {
+            return $this->propertyTypeExtractor->getType($className, $property);
+        }
+
+        return $this->propertyTypeExtractor->getTypes($className, $property);
+    }
+
     /**
      * Sets an attribute and apply the name converter if necessary.
      */
@@ -701,7 +1005,7 @@ private function updateData(array $data, string $attribute, mixed $attributeValu
         if (null !== $classMetadata && null !== $serializedPath = ($attributesMetadata[$attribute] ?? null)?->getSerializedPath()) {
             $propertyAccessor = PropertyAccess::createPropertyAccessor();
             if ($propertyAccessor->isReadable($data, $serializedPath) && null !== $propertyAccessor->getValue($data, $serializedPath)) {
-                throw new LogicException(sprintf('The element you are trying to set is already populated: "%s".', (string) $serializedPath));
+                throw new LogicException(\sprintf('The element you are trying to set is already populated: "%s".', (string) $serializedPath));
             }
             $propertyAccessor->setValue($data, $serializedPath, $attributeValue);
 
@@ -730,7 +1034,7 @@ private function isMaxDepthReached(array $attributesMetadata, string $class, str
             return false;
         }
 
-        $key = sprintf(self::DEPTH_KEY_PATTERN, $class, $attribute);
+        $key = \sprintf(self::DEPTH_KEY_PATTERN, $class, $attribute);
         if (!isset($context[$key])) {
             $context[$key] = 1;
 
@@ -819,7 +1123,7 @@ private function getNestedAttributes(string $class): array
             }
             $pathIdentifier = implode(',', $serializedPath->getElements());
             if (isset($serializedPaths[$pathIdentifier])) {
-                throw new LogicException(sprintf('Duplicate serialized path: "%s" used for properties "%s" and "%s".', $pathIdentifier, $serializedPaths[$pathIdentifier], $name));
+                throw new LogicException(\sprintf('Duplicate serialized path: "%s" used for properties "%s" and "%s".', $pathIdentifier, $serializedPaths[$pathIdentifier], $name));
             }
             $serializedPaths[$pathIdentifier] = $name;
             $properties[$name] = $serializedPath;
@@ -852,11 +1156,11 @@ private function getMappedClass(array $data, string $class, array $context): str
         }
 
         if (null === $type = $data[$mapping->getTypeProperty()] ?? null) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Type property "%s" not found for the abstract object "%s".', $mapping->getTypeProperty(), $class), null, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), false);
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Type property "%s" not found for the abstract object "%s".', $mapping->getTypeProperty(), $class), null, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), false);
         }
 
         if (null === $mappedClass = $mapping->getClassForType($type)) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type "%s" is not a valid value.', $type), $type, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), true);
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type "%s" is not a valid value.', $type), $type, ['string'], isset($context['deserialization_path']) ? $context['deserialization_path'].'.'.$mapping->getTypeProperty() : $mapping->getTypeProperty(), true);
         }
 
         return $mappedClass;
diff --git a/Normalizer/ArrayDenormalizer.php b/Normalizer/ArrayDenormalizer.php
index 38aee6d86..96c4d259c 100644
--- a/Normalizer/ArrayDenormalizer.php
+++ b/Normalizer/ArrayDenormalizer.php
@@ -11,10 +11,14 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
-use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\PropertyInfo\Type as LegacyType;
 use Symfony\Component\Serializer\Exception\BadMethodCallException;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
+use Symfony\Component\TypeInfo\Type;
+use Symfony\Component\TypeInfo\Type\BuiltinType;
+use Symfony\Component\TypeInfo\Type\UnionType;
+use Symfony\Component\TypeInfo\TypeIdentifier;
 
 /**
  * Denormalizes arrays of objects.
@@ -23,19 +27,10 @@
  *
  * @final
  */
-class ArrayDenormalizer implements ContextAwareDenormalizerInterface, DenormalizerAwareInterface, CacheableSupportsMethodInterface
+class ArrayDenormalizer implements DenormalizerInterface, DenormalizerAwareInterface
 {
     use DenormalizerAwareTrait;
 
-    public function setDenormalizer(DenormalizerInterface $denormalizer): void
-    {
-        if (!method_exists($denormalizer, 'getSupportedTypes')) {
-            trigger_deprecation('symfony/serializer', '6.3', 'Not implementing the "DenormalizerInterface::getSupportedTypes()" in "%s" is deprecated.', get_debug_type($denormalizer));
-        }
-
-        $this->denormalizer = $denormalizer;
-    }
-
     public function getSupportedTypes(?string $format): array
     {
         return ['object' => null, '*' => false];
@@ -46,11 +41,11 @@ public function getSupportedTypes(?string $format): array
      */
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): array
     {
-        if (null === $this->denormalizer) {
+        if (!isset($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, [Type::BUILTIN_TYPE_ARRAY], $context['deserialization_path'] ?? null);
+            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, '[]')) {
             throw new InvalidArgumentException('Unsupported class: '.$type);
@@ -58,15 +53,28 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
 
         $type = substr($type, 0, -2);
 
-        $builtinTypes = array_map(static function (Type $keyType) {
-            return $keyType->getBuiltinType();
-        }, \is_array($keyType = $context['key_type'] ?? []) ? $keyType : [$keyType]);
+        $typeIdentifiers = [];
+        if (null !== $keyType = ($context['key_type'] ?? null)) {
+            if ($keyType instanceof Type) {
+                // BC layer for type-info < 7.2
+                if (method_exists(Type::class, 'getBaseType')) {
+                    $typeIdentifiers = array_map(fn (Type $t): string => $t->getBaseType()->getTypeIdentifier()->value, $keyType instanceof UnionType ? $keyType->getTypes() : [$keyType]);
+                } else {
+                    /** @var list<BuiltinType<TypeIdentifier::INT>|BuiltinType<TypeIdentifier::STRING>> */
+                    $keyTypes = $keyType instanceof UnionType ? $keyType->getTypes() : [$keyType];
+
+                    $typeIdentifiers = array_map(fn (BuiltinType $t): string => $t->getTypeIdentifier()->value, $keyTypes);
+                }
+            } 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]";
+            $subContext['deserialization_path'] = ($context['deserialization_path'] ?? false) ? \sprintf('%s[%s]', $context['deserialization_path'], $key) : "[$key]";
 
-            $this->validateKeyType($builtinTypes, $key, $subContext['deserialization_path']);
+            $this->validateKeyType($typeIdentifiers, $key, $subContext['deserialization_path']);
 
             $data[$key] = $this->denormalizer->denormalize($value, $type, $format, $subContext);
         }
@@ -76,8 +84,8 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
 
     public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
-        if (null === $this->denormalizer) {
-            throw new BadMethodCallException(sprintf('The nested denormalizer needs to be set to allow "%s()" to be used.', __METHOD__));
+        if (!isset($this->denormalizer)) {
+            throw new BadMethodCallException(\sprintf('The nested denormalizer needs to be set to allow "%s()" to be used.', __METHOD__));
         }
 
         return str_ends_with($type, '[]')
@@ -85,30 +93,20 @@ public function supportsDenormalization(mixed $data, string $type, ?string $form
     }
 
     /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.', __METHOD__);
-
-        return $this->denormalizer instanceof CacheableSupportsMethodInterface && $this->denormalizer->hasCacheableSupportsMethod();
-    }
-
-    /**
-     * @param mixed $key
+     * @param list<string> $typeIdentifiers
      */
-    private function validateKeyType(array $builtinTypes, $key, string $path): void
+    private function validateKeyType(array $typeIdentifiers, mixed $key, string $path): void
     {
-        if (!$builtinTypes) {
+        if (!$typeIdentifiers) {
             return;
         }
 
-        foreach ($builtinTypes as $builtinType) {
-            if (('is_'.$builtinType)($key)) {
+        foreach ($typeIdentifiers as $typeIdentifier) {
+            if (('is_'.$typeIdentifier)($key)) {
                 return;
             }
         }
 
-        throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The type of the key "%s" must be "%s" ("%s" given).', $key, implode('", "', $builtinTypes), get_debug_type($key)), $key, $builtinTypes, $path, true);
+        throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The type of the key "%s" must be "%s" ("%s" given).', $key, implode('", "', $typeIdentifiers), get_debug_type($key)), $key, $typeIdentifiers, $path, true);
     }
 }
diff --git a/Normalizer/BackedEnumNormalizer.php b/Normalizer/BackedEnumNormalizer.php
index 8b0aa7f5a..3d8e7e7c5 100644
--- a/Normalizer/BackedEnumNormalizer.php
+++ b/Normalizer/BackedEnumNormalizer.php
@@ -11,7 +11,6 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
-use Symfony\Component\PropertyInfo\Type;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
 
@@ -20,7 +19,7 @@
  *
  * @author Alexandre Daubois <alex.daubois@gmail.com>
  */
-final class BackedEnumNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class BackedEnumNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     /**
      * If true, will denormalize any invalid value into null.
@@ -30,7 +29,7 @@ final class BackedEnumNormalizer implements NormalizerInterface, DenormalizerInt
     public function getSupportedTypes(?string $format): array
     {
         return [
-           \BackedEnum::class => true,
+            \BackedEnum::class => true,
         ];
     }
 
@@ -70,7 +69,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         }
 
         if (!\is_int($data) && !\is_string($data)) {
-            throw NotNormalizableValueException::createForUnexpectedDataType('The data is neither an integer nor a string, you should pass an integer or a string that can be parsed as an enumeration case of type '.$type.'.', $data, [Type::BUILTIN_TYPE_INT, Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
+            throw NotNormalizableValueException::createForUnexpectedDataType('The data is neither an integer nor a string, you should pass an integer or a string that can be parsed as an enumeration case of type '.$type.'.', $data, ['int', 'string'], $context['deserialization_path'] ?? null, true);
         }
 
         try {
@@ -88,14 +87,4 @@ public function supportsDenormalization(mixed $data, string $type, ?string $form
     {
         return is_subclass_of($type, \BackedEnum::class);
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.', __METHOD__);
-
-        return true;
-    }
 }
diff --git a/Normalizer/CacheableSupportsMethodInterface.php b/Normalizer/CacheableSupportsMethodInterface.php
deleted file mode 100644
index ea2df15b2..000000000
--- a/Normalizer/CacheableSupportsMethodInterface.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?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;
-
-/**
- * Marker interface for normalizers and denormalizers that use
- * only the type and the format in their supports*() methods.
- *
- * By implementing this interface, the return value of the
- * supports*() methods will be cached by type and format.
- *
- * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @deprecated since Symfony 6.3, implement "getSupportedTypes(?string $format)" instead
- */
-interface CacheableSupportsMethodInterface
-{
-    public function hasCacheableSupportsMethod(): bool;
-}
diff --git a/Normalizer/ConstraintViolationListNormalizer.php b/Normalizer/ConstraintViolationListNormalizer.php
index 814b6f872..eda3b758e 100644
--- a/Normalizer/ConstraintViolationListNormalizer.php
+++ b/Normalizer/ConstraintViolationListNormalizer.php
@@ -21,10 +21,8 @@
  *
  * @author Grégoire Pineau <lyrixx@lyrixx.info>
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class ConstraintViolationListNormalizer implements NormalizerInterface, CacheableSupportsMethodInterface
+final class ConstraintViolationListNormalizer implements NormalizerInterface
 {
     public const INSTANCE = 'instance';
     public const STATUS = 'status';
@@ -41,7 +39,7 @@ public function __construct(
     public function getSupportedTypes(?string $format): array
     {
         return [
-            ConstraintViolationListInterface::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
+            ConstraintViolationListInterface::class => true,
         ];
     }
 
@@ -71,7 +69,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
                 'parameters' => $violation->getParameters(),
             ];
             if (null !== $code = $violation->getCode()) {
-                $violationEntry['type'] = sprintf('urn:uuid:%s', $code);
+                $violationEntry['type'] = \sprintf('urn:uuid:%s', $code);
             }
 
             $constraint = $violation->getConstraint();
@@ -87,7 +85,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
 
             $violations[] = $violationEntry;
 
-            $prefix = $propertyPath ? sprintf('%s: ', $propertyPath) : '';
+            $prefix = $propertyPath ? \sprintf('%s: ', $propertyPath) : '';
             $messages[] = $prefix.$violation->getMessage();
         }
 
@@ -108,21 +106,8 @@ public function normalize(mixed $object, ?string $format = null, array $context
         return $result + ['violations' => $violations];
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof ConstraintViolationListInterface;
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
 }
diff --git a/Normalizer/ContextAwareDenormalizerInterface.php b/Normalizer/ContextAwareDenormalizerInterface.php
deleted file mode 100644
index 19fe3ad1f..000000000
--- a/Normalizer/ContextAwareDenormalizerInterface.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?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;
-
-/**
- * Adds the support of an extra $context parameter for the supportsDenormalization method.
- *
- * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @deprecated since symfony/serializer 6.1, use DenormalizerInterface instead
- */
-interface ContextAwareDenormalizerInterface extends DenormalizerInterface
-{
-    /**
-     * @param array $context options that denormalizers have access to
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool;
-}
diff --git a/Normalizer/ContextAwareNormalizerInterface.php b/Normalizer/ContextAwareNormalizerInterface.php
deleted file mode 100644
index 164d638e5..000000000
--- a/Normalizer/ContextAwareNormalizerInterface.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?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;
-
-/**
- * Adds the support of an extra $context parameter for the supportsNormalization method.
- *
- * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @deprecated since symfony/serializer 6.1, use NormalizerInterface instead
- */
-interface ContextAwareNormalizerInterface extends NormalizerInterface
-{
-    /**
-     * @param array $context options that normalizers have access to
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool;
-}
diff --git a/Normalizer/CustomNormalizer.php b/Normalizer/CustomNormalizer.php
index 85c4662ee..d97108312 100644
--- a/Normalizer/CustomNormalizer.php
+++ b/Normalizer/CustomNormalizer.php
@@ -16,10 +16,8 @@
 
 /**
  * @author Jordi Boggiano <j.boggiano@seld.be>
- *
- * @final since Symfony 6.3
  */
-class CustomNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
+final class CustomNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface
 {
     use ObjectToPopulateTrait;
     use SerializerAwareTrait;
@@ -27,8 +25,8 @@ class CustomNormalizer implements NormalizerInterface, DenormalizerInterface, Se
     public function getSupportedTypes(?string $format): array
     {
         return [
-            NormalizableInterface::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
-            DenormalizableInterface::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
+            NormalizableInterface::class => true,
+            DenormalizableInterface::class => true,
         ];
     }
 
@@ -48,11 +46,10 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
     /**
      * Checks if the given class implements the NormalizableInterface.
      *
-     * @param mixed       $data    Data to normalize
-     * @param string|null $format  The format being (de-)serialized from or into
-     * @param array       $context
+     * @param mixed       $data   Data to normalize
+     * @param string|null $format The format being (de-)serialized from or into
      */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof NormalizableInterface;
     }
@@ -60,23 +57,12 @@ public function supportsNormalization(mixed $data, ?string $format = null /* , a
     /**
      * Checks if the given class implements the DenormalizableInterface.
      *
-     * @param mixed       $data    Data to denormalize from
-     * @param string      $type    The class to which the data should be denormalized
-     * @param string|null $format  The format being deserialized from
-     * @param array       $context
+     * @param mixed       $data   Data to denormalize from
+     * @param string      $type   The class to which the data should be denormalized
+     * @param string|null $format The format being deserialized from
      */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return is_subclass_of($type, DenormalizableInterface::class);
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
 }
diff --git a/Normalizer/DataUriNormalizer.php b/Normalizer/DataUriNormalizer.php
index 9252a69b5..5ee076be6 100644
--- a/Normalizer/DataUriNormalizer.php
+++ b/Normalizer/DataUriNormalizer.php
@@ -22,10 +22,8 @@
  * Denormalizes a data URI to a {@see \SplFileObject} object.
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class DataUriNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class DataUriNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     private const SUPPORTED_TYPES = [
         \SplFileInfo::class => true,
@@ -46,13 +44,7 @@ public function __construct(?MimeTypeGuesserInterface $mimeTypeGuesser = null)
 
     public function getSupportedTypes(?string $format): array
     {
-        $isCacheable = __CLASS__ === static::class || $this->hasCacheableSupportsMethod();
-
-        return [
-            \SplFileInfo::class => $isCacheable,
-            \SplFileObject::class => $isCacheable,
-            File::class => $isCacheable,
-        ];
+        return self::SUPPORTED_TYPES;
     }
 
     public function normalize(mixed $object, ?string $format = null, array $context = []): string
@@ -72,16 +64,13 @@ public function normalize(mixed $object, ?string $format = null, array $context
         }
 
         if ('text' === explode('/', $mimeType, 2)[0]) {
-            return sprintf('data:%s,%s', $mimeType, rawurlencode($data));
+            return \sprintf('data:%s,%s', $mimeType, rawurlencode($data));
         }
 
-        return sprintf('data:%s;base64,%s', $mimeType, base64_encode($data));
+        return \sprintf('data:%s;base64,%s', $mimeType, base64_encode($data));
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof \SplFileInfo;
     }
@@ -96,7 +85,7 @@ public function supportsNormalization(mixed $data, ?string $format = null /* , a
      */
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): \SplFileInfo
     {
-        if (null === $data || !preg_match('/^data:([a-z0-9][a-z0-9\!\#\$\&\-\^\_\+\.]{0,126}\/[a-z0-9][a-z0-9\!\#\$\&\-\^\_\+\.]{0,126}(;[a-z0-9\-]+\=[a-z0-9\-]+)?)?(;base64)?,[a-z0-9\!\$\&\\\'\,\(\)\*\+\,\;\=\-\.\_\~\:\@\/\?\%\s]*\s*$/i', $data)) {
+        if (null === $data || !preg_match('/^data:([a-z0-9][a-z0-9\!\#\$\&\-\^\_\+\.]{0,126}\/[a-z0-9][a-z0-9\!\#\$\&\-\^\_\+\.]{0,126}(;[a-z0-9\-]+\=[a-z0-9\-]+)?)?(;base64)?,[a-z0-9\!\$\&\\\'\,\(\)\*\+\;\=\-\.\_\~\:\@\/\?\%\s]*\s*$/i', $data)) {
             throw NotNormalizableValueException::createForUnexpectedDataType('The provided "data:" URI is not valid.', $data, ['string'], $context['deserialization_path'] ?? null, true);
         }
 
@@ -104,7 +93,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
             switch ($type) {
                 case File::class:
                     if (!class_exists(File::class)) {
-                        throw new InvalidArgumentException(sprintf('Cannot denormalize to a "%s" without the HttpFoundation component installed. Try running "composer require symfony/http-foundation".', File::class));
+                        throw new InvalidArgumentException(\sprintf('Cannot denormalize to a "%s" without the HttpFoundation component installed. Try running "composer require symfony/http-foundation".', File::class));
                     }
 
                     return new File($data, false);
@@ -117,27 +106,14 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
             throw NotNormalizableValueException::createForUnexpectedDataType($exception->getMessage(), $data, ['string'], $context['deserialization_path'] ?? null, false, $exception->getCode(), $exception);
         }
 
-        throw new InvalidArgumentException(sprintf('The class parameter "%s" is not supported. It must be one of "SplFileInfo", "SplFileObject" or "Symfony\Component\HttpFoundation\File\File".', $type));
+        throw new InvalidArgumentException(\sprintf('The class parameter "%s" is not supported. It must be one of "SplFileInfo", "SplFileObject" or "Symfony\Component\HttpFoundation\File\File".', $type));
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return isset(self::SUPPORTED_TYPES[$type]);
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
-
     /**
      * Gets the mime type of the object. Defaults to application/octet-stream.
      */
diff --git a/Normalizer/DateIntervalNormalizer.php b/Normalizer/DateIntervalNormalizer.php
index ce59a71a9..05d1a8529 100644
--- a/Normalizer/DateIntervalNormalizer.php
+++ b/Normalizer/DateIntervalNormalizer.php
@@ -19,10 +19,8 @@
  * Denormalizes an interval string to an instance of {@see \DateInterval}.
  *
  * @author Jérôme Parmentier <jerome@prmntr.me>
- *
- * @final since Symfony 6.3
  */
-class DateIntervalNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class DateIntervalNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     public const FORMAT_KEY = 'dateinterval_format';
 
@@ -38,7 +36,7 @@ public function __construct(array $defaultContext = [])
     public function getSupportedTypes(?string $format): array
     {
         return [
-            \DateInterval::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
+            \DateInterval::class => true,
         ];
     }
 
@@ -54,24 +52,11 @@ public function normalize(mixed $object, ?string $format = null, array $context
         return $object->format($context[self::FORMAT_KEY] ?? $this->defaultContext[self::FORMAT_KEY]);
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof \DateInterval;
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
-
     /**
      * @throws NotNormalizableValueException
      */
@@ -100,7 +85,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         }
         $valuePattern = '/^'.$signPattern.preg_replace('/%([yYmMdDhHiIsSwW])(\w)/', '(?:(?P<$1>\d+)$2)?', preg_replace('/(T.*)$/', '($1)?', $dateIntervalFormat)).'$/';
         if (!preg_match($valuePattern, $data)) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Value "%s" contains intervals not accepted by format "%s".', $data, $dateIntervalFormat), $data, ['string'], $context['deserialization_path'] ?? null, false);
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Value "%s" contains intervals not accepted by format "%s".', $data, $dateIntervalFormat), $data, ['string'], $context['deserialization_path'] ?? null, false);
         }
 
         try {
@@ -121,10 +106,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         }
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return \DateInterval::class === $type;
     }
diff --git a/Normalizer/DateTimeNormalizer.php b/Normalizer/DateTimeNormalizer.php
index 43a9a06c9..dfc498c19 100644
--- a/Normalizer/DateTimeNormalizer.php
+++ b/Normalizer/DateTimeNormalizer.php
@@ -11,7 +11,6 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
-use Symfony\Component\PropertyInfo\Type;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
 
@@ -20,17 +19,17 @@
  * Denormalizes a date string to an instance of {@see \DateTime} or {@see \DateTimeImmutable}.
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class DateTimeNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class DateTimeNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     public const FORMAT_KEY = 'datetime_format';
     public const TIMEZONE_KEY = 'datetime_timezone';
+    public const CAST_KEY = 'datetime_cast';
 
     private array $defaultContext = [
         self::FORMAT_KEY => \DateTimeInterface::RFC3339,
         self::TIMEZONE_KEY => null,
+        self::CAST_KEY => null,
     ];
 
     private const SUPPORTED_TYPES = [
@@ -51,19 +50,13 @@ public function setDefaultContext(array $defaultContext): void
 
     public function getSupportedTypes(?string $format): array
     {
-        $isCacheable = __CLASS__ === static::class || $this->hasCacheableSupportsMethod();
-
-        return [
-            \DateTimeInterface::class => $isCacheable,
-            \DateTimeImmutable::class => $isCacheable,
-            \DateTime::class => $isCacheable,
-        ];
+        return self::SUPPORTED_TYPES;
     }
 
     /**
      * @throws InvalidArgumentException
      */
-    public function normalize(mixed $object, ?string $format = null, array $context = []): string
+    public function normalize(mixed $object, ?string $format = null, array $context = []): int|float|string
     {
         if (!$object instanceof \DateTimeInterface) {
             throw new InvalidArgumentException('The object must implement the "\DateTimeInterface".');
@@ -77,13 +70,14 @@ public function normalize(mixed $object, ?string $format = null, array $context
             $object = $object->setTimezone($timezone);
         }
 
-        return $object->format($dateTimeFormat);
+        return match ($context[self::CAST_KEY] ?? $this->defaultContext[self::CAST_KEY] ?? false) {
+            'int' => (int) $object->format($dateTimeFormat),
+            'float' => (float) $object->format($dateTimeFormat),
+            default => $object->format($dateTimeFormat),
+        };
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof \DateTimeInterface;
     }
@@ -95,13 +89,17 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
     {
         if (\is_int($data) || \is_float($data)) {
             switch ($context[self::FORMAT_KEY] ?? $this->defaultContext[self::FORMAT_KEY] ?? null) {
-                case 'U': $data = sprintf('%d', $data); break;
-                case 'U.u': $data = sprintf('%.6F', $data); break;
+                case 'U':
+                    $data = \sprintf('%d', $data);
+                    break;
+                case 'U.u':
+                    $data = \sprintf('%.6F', $data);
+                    break;
             }
         }
 
         if (!\is_string($data) || '' === trim($data)) {
-            throw NotNormalizableValueException::createForUnexpectedDataType('The data is either not an string, an empty string, or null; you should pass a string that can be parsed with the passed format or a valid DateTime string.', $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
+            throw NotNormalizableValueException::createForUnexpectedDataType('The data is either not an string, an empty string, or null; you should pass a string that can be parsed with the passed format or a valid DateTime string.', $data, ['string'], $context['deserialization_path'] ?? null, true);
         }
 
         try {
@@ -119,7 +117,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
 
                 $dateTimeErrors = $type::getLastErrors();
 
-                throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Parsing datetime string "%s" using format "%s" resulted in %d errors: ', $data, $dateTimeFormat, $dateTimeErrors['error_count'])."\n".implode("\n", $this->formatDateTimeErrors($dateTimeErrors['errors'])), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
+                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Parsing datetime string "%s" using format "%s" resulted in %d errors: ', $data, $dateTimeFormat, $dateTimeErrors['error_count'])."\n".implode("\n", $this->formatDateTimeErrors($dateTimeErrors['errors'])), $data, ['string'], $context['deserialization_path'] ?? null, true);
             }
 
             $defaultDateTimeFormat = $this->defaultContext[self::FORMAT_KEY] ?? null;
@@ -134,26 +132,13 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         } catch (NotNormalizableValueException $e) {
             throw $e;
         } catch (\Exception $e) {
-            throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, false, $e->getCode(), $e);
+            throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, ['string'], $context['deserialization_path'] ?? null, false, $e->getCode(), $e);
         }
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
-    {
-        return isset(self::SUPPORTED_TYPES[$type]);
-    }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
+        return is_a($type, \DateTimeInterface::class, true);
     }
 
     /**
@@ -166,7 +151,7 @@ private function formatDateTimeErrors(array $errors): array
         $formattedErrors = [];
 
         foreach ($errors as $pos => $message) {
-            $formattedErrors[] = sprintf('at position %d: %s', $pos, $message);
+            $formattedErrors[] = \sprintf('at position %d: %s', $pos, $message);
         }
 
         return $formattedErrors;
diff --git a/Normalizer/DateTimeZoneNormalizer.php b/Normalizer/DateTimeZoneNormalizer.php
index 892a576ce..f4528a03d 100644
--- a/Normalizer/DateTimeZoneNormalizer.php
+++ b/Normalizer/DateTimeZoneNormalizer.php
@@ -11,7 +11,6 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
-use Symfony\Component\PropertyInfo\Type;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
 use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
 
@@ -19,15 +18,13 @@
  * Normalizes a {@see \DateTimeZone} object to a timezone string.
  *
  * @author Jérôme Desjardins <jewome62@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class DateTimeZoneNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class DateTimeZoneNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     public function getSupportedTypes(?string $format): array
     {
         return [
-            \DateTimeZone::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
+            \DateTimeZone::class => true,
         ];
     }
 
@@ -43,10 +40,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
         return $object->getName();
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof \DateTimeZone;
     }
@@ -57,31 +51,18 @@ public function supportsNormalization(mixed $data, ?string $format = null /* , a
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): \DateTimeZone
     {
         if ('' === $data || null === $data) {
-            throw NotNormalizableValueException::createForUnexpectedDataType('The data is either an empty string or null, you should pass a string that can be parsed as a DateTimeZone.', $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
+            throw NotNormalizableValueException::createForUnexpectedDataType('The data is either an empty string or null, you should pass a string that can be parsed as a DateTimeZone.', $data, ['string'], $context['deserialization_path'] ?? null, true);
         }
 
         try {
             return new \DateTimeZone($data);
         } catch (\Exception $e) {
-            throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true, $e->getCode(), $e);
+            throw NotNormalizableValueException::createForUnexpectedDataType($e->getMessage(), $data, ['string'], $context['deserialization_path'] ?? null, true, $e->getCode(), $e);
         }
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return \DateTimeZone::class === $type;
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
 }
diff --git a/Normalizer/DenormalizableInterface.php b/Normalizer/DenormalizableInterface.php
index 1811c93a4..48df97624 100644
--- a/Normalizer/DenormalizableInterface.php
+++ b/Normalizer/DenormalizableInterface.php
@@ -33,8 +33,6 @@ interface DenormalizableInterface
      * @param string|null                 $format       The format is optionally given to be able to denormalize
      *                                                  differently based on different input formats
      * @param array                       $context      Options for denormalizing
-     *
-     * @return void
      */
-    public function denormalize(DenormalizerInterface $denormalizer, array|string|int|float|bool $data, ?string $format = null, array $context = []);
+    public function denormalize(DenormalizerInterface $denormalizer, array|string|int|float|bool $data, ?string $format = null, array $context = []): void;
 }
diff --git a/Normalizer/DenormalizerAwareInterface.php b/Normalizer/DenormalizerAwareInterface.php
index 48e8c3fb5..84bf8d89d 100644
--- a/Normalizer/DenormalizerAwareInterface.php
+++ b/Normalizer/DenormalizerAwareInterface.php
@@ -18,8 +18,6 @@ interface DenormalizerAwareInterface
 {
     /**
      * Sets the owning Denormalizer object.
-     *
-     * @return void
      */
-    public function setDenormalizer(DenormalizerInterface $denormalizer);
+    public function setDenormalizer(DenormalizerInterface $denormalizer): void;
 }
diff --git a/Normalizer/DenormalizerAwareTrait.php b/Normalizer/DenormalizerAwareTrait.php
index c5cc86ecf..f4620e1c0 100644
--- a/Normalizer/DenormalizerAwareTrait.php
+++ b/Normalizer/DenormalizerAwareTrait.php
@@ -16,15 +16,9 @@
  */
 trait DenormalizerAwareTrait
 {
-    /**
-     * @var DenormalizerInterface
-     */
-    protected $denormalizer;
+    protected DenormalizerInterface $denormalizer;
 
-    /**
-     * @return void
-     */
-    public function setDenormalizer(DenormalizerInterface $denormalizer)
+    public function setDenormalizer(DenormalizerInterface $denormalizer): void
     {
         $this->denormalizer = $denormalizer;
     }
diff --git a/Normalizer/DenormalizerInterface.php b/Normalizer/DenormalizerInterface.php
index 98c59fc66..23ee3928a 100644
--- a/Normalizer/DenormalizerInterface.php
+++ b/Normalizer/DenormalizerInterface.php
@@ -21,8 +21,6 @@
 
 /**
  * @author Jordi Boggiano <j.boggiano@seld.be>
- *
- * @method array getSupportedTypes(?string $format)
  */
 interface DenormalizerInterface
 {
@@ -36,8 +34,6 @@ interface DenormalizerInterface
      * @param string|null $format  Format the given data was extracted from
      * @param array       $context Options available to the denormalizer
      *
-     * @return mixed
-     *
      * @throws BadMethodCallException   Occurs when the normalizer is not called in an expected context
      * @throws InvalidArgumentException Occurs when the arguments are not coherent or not supported
      * @throws UnexpectedValueException Occurs when the item cannot be hydrated with the given data
@@ -46,19 +42,16 @@ interface DenormalizerInterface
      * @throws RuntimeException         Occurs if the class cannot be instantiated
      * @throws ExceptionInterface       Occurs for all the other cases of errors
      */
-    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []);
+    public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed;
 
     /**
      * Checks whether the given class is supported for denormalization by this normalizer.
      *
-     * @param mixed       $data    Data to denormalize from
-     * @param string      $type    The class to which the data should be denormalized
-     * @param string|null $format  The format being deserialized from
-     * @param array       $context Options available to the denormalizer
-     *
-     * @return bool
+     * @param mixed       $data   Data to denormalize from
+     * @param string      $type   The class to which the data should be denormalized
+     * @param string|null $format The format being deserialized from
      */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */);
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool;
 
     /**
      * Returns the types potentially supported by this denormalizer.
@@ -75,5 +68,5 @@ public function supportsDenormalization(mixed $data, string $type, ?string $form
      *
      * @return array<class-string|'*'|'object'|string, bool|null>
      */
-    /* public function getSupportedTypes(?string $format): array; */
+    public function getSupportedTypes(?string $format): array;
 }
diff --git a/Normalizer/FormErrorNormalizer.php b/Normalizer/FormErrorNormalizer.php
index 8c0d3a1c0..9ef13a669 100644
--- a/Normalizer/FormErrorNormalizer.php
+++ b/Normalizer/FormErrorNormalizer.php
@@ -16,7 +16,7 @@
 /**
  * Normalizes invalid Form instances.
  */
-final class FormErrorNormalizer implements NormalizerInterface, CacheableSupportsMethodInterface
+final class FormErrorNormalizer implements NormalizerInterface
 {
     public const TITLE = 'title';
     public const TYPE = 'type';
@@ -82,14 +82,4 @@ private function convertFormChildrenToArray(FormInterface $data): array
 
         return $children;
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.', __METHOD__);
-
-        return true;
-    }
 }
diff --git a/Normalizer/GetSetMethodNormalizer.php b/Normalizer/GetSetMethodNormalizer.php
index 3cb9b992b..4d2d7829a 100644
--- a/Normalizer/GetSetMethodNormalizer.php
+++ b/Normalizer/GetSetMethodNormalizer.php
@@ -34,45 +34,27 @@
  *
  * @author Nils Adermann <naderman@naderman.de>
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class GetSetMethodNormalizer extends AbstractObjectNormalizer
+final class GetSetMethodNormalizer extends AbstractObjectNormalizer
 {
     private static $reflectionCache = [];
     private static array $setterAccessibleCache = [];
 
     public function getSupportedTypes(?string $format): array
     {
-        return ['object' => __CLASS__ === static::class || $this->hasCacheableSupportsMethod()];
+        return ['object' => true];
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return parent::supportsNormalization($data, $format) && $this->supports($data::class, true);
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return parent::supportsDenormalization($data, $type, $format) && $this->supports($type, false);
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
-
     /**
      * Checks if the given class has any getter or setter method.
      */
@@ -165,10 +147,7 @@ protected function getAttributeValue(object $object, string $attribute, ?string
         return null;
     }
 
-    /**
-     * @return void
-     */
-    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = [])
+    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void
     {
         $setter = 'set'.$attribute;
         $key = $object::class.':'.$setter;
@@ -182,13 +161,13 @@ protected function setAttributeValue(object $object, string $attribute, mixed $v
         }
     }
 
-    protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = [])
+    protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
     {
         if (!parent::isAllowedAttribute($classOrObject, $attribute, $format, $context)) {
             return false;
         }
 
-        $class = \is_object($classOrObject) ? \get_class($classOrObject) : $classOrObject;
+        $class = \is_object($classOrObject) ? $classOrObject::class : $classOrObject;
 
         if (!isset(self::$reflectionCache[$class])) {
             self::$reflectionCache[$class] = new \ReflectionClass($class);
diff --git a/Normalizer/JsonSerializableNormalizer.php b/Normalizer/JsonSerializableNormalizer.php
index 0753c8ba7..31c224175 100644
--- a/Normalizer/JsonSerializableNormalizer.php
+++ b/Normalizer/JsonSerializableNormalizer.php
@@ -18,10 +18,8 @@
  * A normalizer that uses an objects own JsonSerializable implementation.
  *
  * @author Fred Cox <mcfedr@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class JsonSerializableNormalizer extends AbstractNormalizer
+final class JsonSerializableNormalizer extends AbstractNormalizer
 {
     public function normalize(mixed $object, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null
     {
@@ -30,7 +28,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
         }
 
         if (!$object instanceof \JsonSerializable) {
-            throw new InvalidArgumentException(sprintf('The object must implement "%s".', \JsonSerializable::class));
+            throw new InvalidArgumentException(\sprintf('The object must implement "%s".', \JsonSerializable::class));
         }
 
         if (!$this->serializer instanceof NormalizerInterface) {
@@ -43,38 +41,22 @@ public function normalize(mixed $object, ?string $format = null, array $context
     public function getSupportedTypes(?string $format): array
     {
         return [
-            \JsonSerializable::class => __CLASS__ === static::class || $this->hasCacheableSupportsMethod(),
+            \JsonSerializable::class => true,
         ];
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof \JsonSerializable;
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return false;
     }
 
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
     {
-        throw new LogicException(sprintf('Cannot denormalize with "%s".', \JsonSerializable::class));
-    }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
+        throw new LogicException(\sprintf('Cannot denormalize with "%s".', \JsonSerializable::class));
     }
 }
diff --git a/Normalizer/MimeMessageNormalizer.php b/Normalizer/MimeMessageNormalizer.php
index 07a170d6b..633edf369 100644
--- a/Normalizer/MimeMessageNormalizer.php
+++ b/Normalizer/MimeMessageNormalizer.php
@@ -30,7 +30,7 @@
  *
  * Emails using resources for any parts are not serializable.
  */
-final class MimeMessageNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
+final class MimeMessageNormalizer implements NormalizerInterface, DenormalizerInterface, SerializerAwareInterface
 {
     private NormalizerInterface&DenormalizerInterface $serializer;
     private array $headerClassMap;
@@ -44,21 +44,19 @@ public function __construct(private readonly PropertyNormalizer $normalizer)
 
     public function getSupportedTypes(?string $format): array
     {
-        $isCacheable = __CLASS__ === static::class || $this->hasCacheableSupportsMethod();
-
         return [
-            Message::class => $isCacheable,
-            Headers::class => $isCacheable,
-            HeaderInterface::class => $isCacheable,
-            Address::class => $isCacheable,
-            AbstractPart::class => $isCacheable,
+            Message::class => true,
+            Headers::class => true,
+            HeaderInterface::class => true,
+            Address::class => true,
+            AbstractPart::class => true,
         ];
     }
 
     public function setSerializer(SerializerInterface $serializer): void
     {
         if (!$serializer instanceof NormalizerInterface || !$serializer instanceof DenormalizerInterface) {
-            throw new LogicException(sprintf('The passed serializer should implement both NormalizerInterface and DenormalizerInterface, "%s" given.', get_debug_type($serializer)));
+            throw new LogicException(\sprintf('The passed serializer should implement both NormalizerInterface and DenormalizerInterface, "%s" given.', get_debug_type($serializer)));
         }
         $this->serializer = $serializer;
         $this->normalizer->setSerializer($serializer);
@@ -120,14 +118,4 @@ public function supportsDenormalization(mixed $data, string $type, ?string $form
     {
         return is_a($type, Message::class, true) || Headers::class === $type || AbstractPart::class === $type;
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return true;
-    }
 }
diff --git a/Normalizer/NormalizerAwareInterface.php b/Normalizer/NormalizerAwareInterface.php
index 5f3deaa01..1079ab6dd 100644
--- a/Normalizer/NormalizerAwareInterface.php
+++ b/Normalizer/NormalizerAwareInterface.php
@@ -18,8 +18,6 @@ interface NormalizerAwareInterface
 {
     /**
      * Sets the owning Normalizer object.
-     *
-     * @return void
      */
-    public function setNormalizer(NormalizerInterface $normalizer);
+    public function setNormalizer(NormalizerInterface $normalizer): void;
 }
diff --git a/Normalizer/NormalizerAwareTrait.php b/Normalizer/NormalizerAwareTrait.php
index 40a4fa0e8..e21c6c175 100644
--- a/Normalizer/NormalizerAwareTrait.php
+++ b/Normalizer/NormalizerAwareTrait.php
@@ -16,15 +16,9 @@
  */
 trait NormalizerAwareTrait
 {
-    /**
-     * @var NormalizerInterface
-     */
-    protected $normalizer;
+    protected NormalizerInterface $normalizer;
 
-    /**
-     * @return void
-     */
-    public function setNormalizer(NormalizerInterface $normalizer)
+    public function setNormalizer(NormalizerInterface $normalizer): void
     {
         $this->normalizer = $normalizer;
     }
diff --git a/Normalizer/NormalizerInterface.php b/Normalizer/NormalizerInterface.php
index 4bf04602e..bbc8a94e7 100644
--- a/Normalizer/NormalizerInterface.php
+++ b/Normalizer/NormalizerInterface.php
@@ -18,15 +18,13 @@
 
 /**
  * @author Jordi Boggiano <j.boggiano@seld.be>
- *
- * @method array getSupportedTypes(?string $format)
  */
 interface NormalizerInterface
 {
     /**
-     * Normalizes an object into a set of arrays/scalars.
+     * Normalizes data into a set of arrays/scalars.
      *
-     * @param mixed       $object  Object to normalize
+     * @param mixed       $data    Data to normalize
      * @param string|null $format  Format the normalization result will be encoded as
      * @param array       $context Context options for the normalizer
      *
@@ -38,18 +36,15 @@ interface NormalizerInterface
      * @throws LogicException             Occurs when the normalizer is not called in an expected context
      * @throws ExceptionInterface         Occurs for all the other cases of errors
      */
-    public function normalize(mixed $object, ?string $format = null, array $context = []);
+    public function normalize(mixed $data, ?string $format = null, array $context = []): array|string|int|float|bool|\ArrayObject|null;
 
     /**
      * Checks whether the given class is supported for normalization by this normalizer.
      *
-     * @param mixed       $data    Data to normalize
-     * @param string|null $format  The format being (de-)serialized from or into
-     * @param array       $context Context options for the normalizer
-     *
-     * @return bool
+     * @param mixed       $data   Data to normalize
+     * @param string|null $format The format being (de-)serialized from or into
      */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */);
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool;
 
     /**
      * Returns the types potentially supported by this normalizer.
@@ -66,5 +61,5 @@ public function supportsNormalization(mixed $data, ?string $format = null /* , a
      *
      * @return array<class-string|'*'|'object'|string, bool|null>
      */
-    /* public function getSupportedTypes(?string $format): array; */
+    public function getSupportedTypes(?string $format): array;
 }
diff --git a/Normalizer/ObjectNormalizer.php b/Normalizer/ObjectNormalizer.php
index e93d7b4cc..1d60cba50 100644
--- a/Normalizer/ObjectNormalizer.php
+++ b/Normalizer/ObjectNormalizer.php
@@ -29,16 +29,14 @@
  * Converts between objects and arrays using the PropertyAccess component.
  *
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class ObjectNormalizer extends AbstractObjectNormalizer
+final class ObjectNormalizer extends AbstractObjectNormalizer
 {
     private static $reflectionCache = [];
     private static $isReadableCache = [];
     private static $isWritableCache = [];
 
-    protected $propertyAccessor;
+    protected PropertyAccessorInterface $propertyAccessor;
     protected $propertyInfoExtractor;
     private $writeInfoExtractor;
 
@@ -61,17 +59,7 @@ public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory
 
     public function getSupportedTypes(?string $format): array
     {
-        return ['object' => __CLASS__ === static::class || $this->hasCacheableSupportsMethod()];
-    }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
+        return ['object' => true];
     }
 
     protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
@@ -152,10 +140,7 @@ protected function getAttributeValue(object $object, string $attribute, ?string
             : $this->propertyAccessor->getValue($object, $attribute);
     }
 
-    /**
-     * @return void
-     */
-    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = [])
+    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void
     {
         try {
             $this->propertyAccessor->setValue($object, $attribute, $value);
@@ -188,13 +173,13 @@ protected function getAllowedAttributes(string|object $classOrObject, array $con
         return $allowedAttributes;
     }
 
-    protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = [])
+    protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
     {
         if (!parent::isAllowedAttribute($classOrObject, $attribute, $format, $context)) {
             return false;
         }
 
-        $class = \is_object($classOrObject) ? \get_class($classOrObject) : $classOrObject;
+        $class = \is_object($classOrObject) ? $classOrObject::class : $classOrObject;
 
         if ($context['_read_attributes'] ?? true) {
             if (!isset(self::$isReadableCache[$class.$attribute])) {
diff --git a/Normalizer/ProblemNormalizer.php b/Normalizer/ProblemNormalizer.php
index 7113b2476..08aca6796 100644
--- a/Normalizer/ProblemNormalizer.php
+++ b/Normalizer/ProblemNormalizer.php
@@ -29,7 +29,7 @@
  * @author Kévin Dunglas <dunglas@gmail.com>
  * @author Yonel Ceruto <yonelceruto@gmail.com>
  */
-class ProblemNormalizer implements NormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
+class ProblemNormalizer implements NormalizerInterface, SerializerAwareInterface
 {
     use SerializerAwareTrait;
 
@@ -47,14 +47,14 @@ public function __construct(
     public function getSupportedTypes(?string $format): array
     {
         return [
-            FlattenException::class => __CLASS__ === self::class || $this->hasCacheableSupportsMethod(),
+            FlattenException::class => __CLASS__ === self::class,
         ];
     }
 
     public function normalize(mixed $object, ?string $format = null, array $context = []): array
     {
         if (!$object instanceof FlattenException) {
-            throw new InvalidArgumentException(sprintf('The object must implement "%s".', FlattenException::class));
+            throw new InvalidArgumentException(\sprintf('The object must implement "%s".', FlattenException::class));
         }
 
         $data = [];
@@ -107,21 +107,8 @@ public function normalize(mixed $object, ?string $format = null, array $context
         return $data;
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return $data instanceof FlattenException;
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return true;
-    }
 }
diff --git a/Normalizer/PropertyNormalizer.php b/Normalizer/PropertyNormalizer.php
index 6a5d0acd8..1619f35bf 100644
--- a/Normalizer/PropertyNormalizer.php
+++ b/Normalizer/PropertyNormalizer.php
@@ -33,10 +33,8 @@
  *
  * @author Matthieu Napoli <matthieu@mnapoli.fr>
  * @author Kévin Dunglas <dunglas@gmail.com>
- *
- * @final since Symfony 6.3
  */
-class PropertyNormalizer extends AbstractObjectNormalizer
+final class PropertyNormalizer extends AbstractObjectNormalizer
 {
     public const NORMALIZE_PUBLIC = 1;
     public const NORMALIZE_PROTECTED = 2;
@@ -58,35 +56,19 @@ public function __construct(?ClassMetadataFactoryInterface $classMetadataFactory
 
     public function getSupportedTypes(?string $format): array
     {
-        return ['object' => __CLASS__ === static::class || $this->hasCacheableSupportsMethod()];
+        return ['object' => true];
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsNormalization(mixed $data, ?string $format = null /* , array $context = [] */): bool
+    public function supportsNormalization(mixed $data, ?string $format = null, array $context = []): bool
     {
         return parent::supportsNormalization($data, $format) && $this->supports($data::class);
     }
 
-    /**
-     * @param array $context
-     */
-    public function supportsDenormalization(mixed $data, string $type, ?string $format = null /* , array $context = [] */): bool
+    public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
         return parent::supportsDenormalization($data, $type, $format) && $this->supports($type);
     }
 
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, implement "%s::getSupportedTypes()" instead.', __METHOD__, get_debug_type($this));
-
-        return __CLASS__ === static::class;
-    }
-
     /**
      * Checks if the given class has any non-static property.
      */
@@ -180,17 +162,14 @@ protected function getAttributeValue(object $object, string $attribute, ?string
                 || ($reflectionProperty->isProtected() && !\array_key_exists("\0*\0{$reflectionProperty->name}", $propertyValues))
                 || ($reflectionProperty->isPrivate() && !\array_key_exists("\0{$reflectionProperty->class}\0{$reflectionProperty->name}", $propertyValues))
             ) {
-                throw new UninitializedPropertyException(sprintf('The property "%s::$%s" is not initialized.', $object::class, $reflectionProperty->name));
+                throw new UninitializedPropertyException(\sprintf('The property "%s::$%s" is not initialized.', $object::class, $reflectionProperty->name));
             }
         }
 
         return $reflectionProperty->getValue($object);
     }
 
-    /**
-     * @return void
-     */
-    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = [])
+    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void
     {
         try {
             $reflectionProperty = $this->getReflectionProperty($object, $attribute);
diff --git a/Normalizer/TranslatableNormalizer.php b/Normalizer/TranslatableNormalizer.php
index 398e00b79..463616e72 100644
--- a/Normalizer/TranslatableNormalizer.php
+++ b/Normalizer/TranslatableNormalizer.php
@@ -37,7 +37,7 @@ public function __construct(
     public function normalize(mixed $object, ?string $format = null, array $context = []): string
     {
         if (!$object instanceof TranslatableInterface) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The object must implement the "%s".', TranslatableInterface::class), $object, [TranslatableInterface::class]);
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The object must implement the "%s".', TranslatableInterface::class), $object, [TranslatableInterface::class]);
         }
 
         return $object->trans($this->translator, $context[self::NORMALIZATION_LOCALE_KEY] ?? $this->defaultContext[self::NORMALIZATION_LOCALE_KEY]);
diff --git a/Normalizer/UidNormalizer.php b/Normalizer/UidNormalizer.php
index 5e9f8e29f..0bee1f704 100644
--- a/Normalizer/UidNormalizer.php
+++ b/Normalizer/UidNormalizer.php
@@ -11,20 +11,20 @@
 
 namespace Symfony\Component\Serializer\Normalizer;
 
-use Symfony\Component\PropertyInfo\Type;
 use Symfony\Component\Serializer\Exception\LogicException;
 use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
 use Symfony\Component\Uid\AbstractUid;
-use Symfony\Component\Uid\Uuid;
 
-final class UidNormalizer implements NormalizerInterface, DenormalizerInterface, CacheableSupportsMethodInterface
+final class UidNormalizer implements NormalizerInterface, DenormalizerInterface
 {
     public const NORMALIZATION_FORMAT_KEY = 'uid_normalization_format';
 
     public const NORMALIZATION_FORMAT_CANONICAL = 'canonical';
     public const NORMALIZATION_FORMAT_BASE58 = 'base58';
     public const NORMALIZATION_FORMAT_BASE32 = 'base32';
-    public const NORMALIZATION_FORMAT_RFC4122 = 'rfc4122'; // RFC 9562 obsoleted RFC 4122 but the format is the same
+    public const NORMALIZATION_FORMAT_RFC4122 = 'rfc4122';
+    public const NORMALIZATION_FORMAT_RFC9562 = self::NORMALIZATION_FORMAT_RFC4122; // RFC 9562 obsoleted RFC 4122 but the format is the same
+
     public const NORMALIZATION_FORMATS = [
         self::NORMALIZATION_FORMAT_CANONICAL,
         self::NORMALIZATION_FORMAT_BASE58,
@@ -58,7 +58,7 @@ public function normalize(mixed $object, ?string $format = null, array $context
             self::NORMALIZATION_FORMAT_BASE58 => $object->toBase58(),
             self::NORMALIZATION_FORMAT_BASE32 => $object->toBase32(),
             self::NORMALIZATION_FORMAT_RFC4122 => $object->toRfc4122(),
-            default => throw new LogicException(sprintf('The "%s" format is not valid.', $context[self::NORMALIZATION_FORMAT_KEY] ?? $this->defaultContext[self::NORMALIZATION_FORMAT_KEY])),
+            default => throw new LogicException(\sprintf('The "%s" format is not valid.', $context[self::NORMALIZATION_FORMAT_KEY] ?? $this->defaultContext[self::NORMALIZATION_FORMAT_KEY])),
         };
     }
 
@@ -70,42 +70,14 @@ public function supportsNormalization(mixed $data, ?string $format = null, array
     public function denormalize(mixed $data, string $type, ?string $format = null, array $context = []): mixed
     {
         try {
-            if (AbstractUid::class === $type) {
-                trigger_deprecation('symfony/serializer', '6.1', 'Denormalizing to an abstract class in "%s" is deprecated.', __CLASS__);
-
-                return Uuid::fromString($data);
-            }
-
             return $type::fromString($data);
         } catch (\InvalidArgumentException|\TypeError) {
-            throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('The data is not a valid "%s" string representation.', $type), $data, [Type::BUILTIN_TYPE_STRING], $context['deserialization_path'] ?? null, true);
-        } catch (\Error $e) { // @deprecated remove this catch block in 7.0
-            if (str_starts_with($e->getMessage(), 'Cannot instantiate abstract class')) {
-                return $this->denormalize($data, AbstractUid::class, $format, $context);
-            }
-
-            throw $e;
+            throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('The data is not a valid "%s" string representation.', $type), $data, ['string'], $context['deserialization_path'] ?? null, true);
         }
     }
 
     public function supportsDenormalization(mixed $data, string $type, ?string $format = null, array $context = []): bool
     {
-        if (AbstractUid::class === $type) {
-            trigger_deprecation('symfony/serializer', '6.1', 'Supporting denormalization for the "%s" type in "%s" is deprecated, use one of "%s" child class instead.', AbstractUid::class, __CLASS__, AbstractUid::class);
-
-            return true;
-        }
-
         return is_subclass_of($type, AbstractUid::class, true);
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.', __METHOD__);
-
-        return true;
-    }
 }
diff --git a/Normalizer/UnwrappingDenormalizer.php b/Normalizer/UnwrappingDenormalizer.php
index aa4d74c45..9f01d2a71 100644
--- a/Normalizer/UnwrappingDenormalizer.php
+++ b/Normalizer/UnwrappingDenormalizer.php
@@ -20,7 +20,7 @@
 /**
  * @author Eduard Bulava <bulavaeduard@gmail.com>
  */
-final class UnwrappingDenormalizer implements DenormalizerInterface, SerializerAwareInterface, CacheableSupportsMethodInterface
+final class UnwrappingDenormalizer implements DenormalizerInterface, SerializerAwareInterface
 {
     use SerializerAwareTrait;
 
@@ -62,14 +62,4 @@ public function supportsDenormalization(mixed $data, string $type, ?string $form
     {
         return \array_key_exists(self::UNWRAP_PATH, $context) && !isset($context['unwrapped']);
     }
-
-    /**
-     * @deprecated since Symfony 6.3, use "getSupportedTypes()" instead
-     */
-    public function hasCacheableSupportsMethod(): bool
-    {
-        trigger_deprecation('symfony/serializer', '6.3', 'The "%s()" method is deprecated, use "getSupportedTypes()" instead.', __METHOD__);
-
-        return $this->serializer instanceof CacheableSupportsMethodInterface && $this->serializer->hasCacheableSupportsMethod();
-    }
 }
diff --git a/Serializer.php b/Serializer.php
index e17042097..f95f2d72e 100644
--- a/Serializer.php
+++ b/Serializer.php
@@ -23,9 +23,6 @@
 use Symfony\Component\Serializer\Exception\PartialDenormalizationException;
 use Symfony\Component\Serializer\Exception\UnsupportedFormatException;
 use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
-use Symfony\Component\Serializer\Normalizer\CacheableSupportsMethodInterface;
-use Symfony\Component\Serializer\Normalizer\ContextAwareDenormalizerInterface;
-use Symfony\Component\Serializer\Normalizer\ContextAwareNormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
 use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
@@ -46,7 +43,7 @@
  * @author Lukas Kahwe Smith <smith@pooteeweet.org>
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
-class Serializer implements SerializerInterface, ContextAwareNormalizerInterface, ContextAwareDenormalizerInterface, ContextAwareEncoderInterface, ContextAwareDecoderInterface
+class Serializer implements SerializerInterface, NormalizerInterface, DenormalizerInterface, ContextAwareEncoderInterface, ContextAwareDecoderInterface
 {
     /**
      * Flag to control whether an empty array should be transformed to an
@@ -61,15 +58,9 @@ class Serializer implements SerializerInterface, ContextAwareNormalizerInterface
         'string' => true,
     ];
 
-    /**
-     * @var ChainEncoder
-     */
-    protected $encoder;
+    protected ChainEncoder $encoder;
 
-    /**
-     * @var ChainDecoder
-     */
-    protected $decoder;
+    protected ChainDecoder $decoder;
 
     /**
      * @var array<string, array<string, array<bool>>>
@@ -105,7 +96,7 @@ public function __construct(
             }
 
             if (!($normalizer instanceof NormalizerInterface || $normalizer instanceof DenormalizerInterface)) {
-                throw new InvalidArgumentException(sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($normalizer), NormalizerInterface::class, DenormalizerInterface::class));
+                throw new InvalidArgumentException(\sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($normalizer), NormalizerInterface::class, DenormalizerInterface::class));
             }
         }
 
@@ -123,7 +114,7 @@ public function __construct(
             }
 
             if (!($encoder instanceof EncoderInterface || $encoder instanceof DecoderInterface)) {
-                throw new InvalidArgumentException(sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($encoder), EncoderInterface::class, DecoderInterface::class));
+                throw new InvalidArgumentException(\sprintf('The class "%s" neither implements "%s" nor "%s".', get_debug_type($encoder), EncoderInterface::class, DecoderInterface::class));
             }
         }
         $this->encoder = new ChainEncoder($realEncoders);
@@ -133,7 +124,7 @@ public function __construct(
     final public function serialize(mixed $data, string $format, array $context = []): string
     {
         if (!$this->supportsEncoding($format, $context)) {
-            throw new UnsupportedFormatException(sprintf('Serialization for the format "%s" is not supported.', $format));
+            throw new UnsupportedFormatException(\sprintf('Serialization for the format "%s" is not supported.', $format));
         }
 
         if ($this->encoder->needsNormalization($format, $context)) {
@@ -146,7 +137,7 @@ final public function serialize(mixed $data, string $format, array $context = []
     final public function deserialize(mixed $data, string $type, string $format, array $context = []): mixed
     {
         if (!$this->supportsDecoding($format, $context)) {
-            throw new UnsupportedFormatException(sprintf('Deserialization for the format "%s" is not supported.', $format));
+            throw new UnsupportedFormatException(\sprintf('Deserialization for the format "%s" is not supported.', $format));
         }
 
         $data = $this->decode($data, $format, $context);
@@ -187,10 +178,10 @@ public function normalize(mixed $data, ?string $format = null, array $context =
                 throw new LogicException('You must register at least one normalizer to be able to normalize objects.');
             }
 
-            throw new NotNormalizableValueException(sprintf('Could not normalize object of type "%s", no supporting normalizer found.', get_debug_type($data)));
+            throw new NotNormalizableValueException(\sprintf('Could not normalize object of type "%s", no supporting normalizer found.', get_debug_type($data)));
         }
 
-        throw new NotNormalizableValueException('An unexpected value could not be normalized: '.(!\is_resource($data) ? var_export($data, true) : sprintf('"%s" resource', get_resource_type($data))));
+        throw new NotNormalizableValueException('An unexpected value could not be normalized: '.(!\is_resource($data) ? var_export($data, true) : \sprintf('"%s" resource', get_resource_type($data))));
     }
 
     /**
@@ -208,7 +199,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         // Check for a denormalizer first, e.g. the data is wrapped
         if (!$normalizer && isset(self::SCALAR_TYPES[$type])) {
             if (!('is_'.$type)($data)) {
-                throw NotNormalizableValueException::createForUnexpectedDataType(sprintf('Data expected to be of type "%s" ("%s" given).', $type, get_debug_type($data)), $data, [$type], $context['deserialization_path'] ?? null, true);
+                throw NotNormalizableValueException::createForUnexpectedDataType(\sprintf('Data expected to be of type "%s" ("%s" given).', $type, get_debug_type($data)), $data, [$type], $context['deserialization_path'] ?? null, true);
             }
 
             return $data;
@@ -219,7 +210,7 @@ public function denormalize(mixed $data, string $type, ?string $format = null, a
         }
 
         if (!$normalizer) {
-            throw new NotNormalizableValueException(sprintf('Could not denormalize object of type "%s", no supporting normalizer found.', $type));
+            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])) {
@@ -289,19 +280,6 @@ private function getNormalizer(mixed $data, ?string $format, array $context): ?N
                     continue;
                 }
 
-                if (!method_exists($normalizer, 'getSupportedTypes')) {
-                    trigger_deprecation('symfony/serializer', '6.3', '"%s" should implement "NormalizerInterface::getSupportedTypes(?string $format): array".', $normalizer::class);
-
-                    if (!$normalizer instanceof CacheableSupportsMethodInterface || !$normalizer->hasCacheableSupportsMethod()) {
-                        $this->normalizerCache[$format][$type][$k] = false;
-                    } elseif ($normalizer->supportsNormalization($data, $format, $context)) {
-                        $this->normalizerCache[$format][$type][$k] = true;
-                        break;
-                    }
-
-                    continue;
-                }
-
                 $supportedTypes = $normalizer->getSupportedTypes($format);
 
                 foreach ($supportedTypes as $supportedType => $isCacheable) {
@@ -359,19 +337,6 @@ private function getDenormalizer(mixed $data, string $class, ?string $format, ar
                     continue;
                 }
 
-                if (!method_exists($normalizer, 'getSupportedTypes')) {
-                    trigger_deprecation('symfony/serializer', '6.3', '"%s" should implement "DenormalizerInterface::getSupportedTypes(?string $format): array".', $normalizer::class);
-
-                    if (!$normalizer instanceof CacheableSupportsMethodInterface || !$normalizer->hasCacheableSupportsMethod()) {
-                        $this->denormalizerCache[$format][$class][$k] = false;
-                    } elseif ($normalizer->supportsDenormalization(null, $class, $format, $context)) {
-                        $this->denormalizerCache[$format][$class][$k] = true;
-                        break;
-                    }
-
-                    continue;
-                }
-
                 $supportedTypes = $normalizer->getSupportedTypes($format);
 
                 $doesClassRepresentCollection = str_ends_with($class, '[]');
diff --git a/SerializerAwareInterface.php b/SerializerAwareInterface.php
index 4919436d9..0b4db4c77 100644
--- a/SerializerAwareInterface.php
+++ b/SerializerAwareInterface.php
@@ -18,8 +18,6 @@ interface SerializerAwareInterface
 {
     /**
      * Sets the owning Serializer object.
-     *
-     * @return void
      */
-    public function setSerializer(SerializerInterface $serializer);
+    public function setSerializer(SerializerInterface $serializer): void;
 }
diff --git a/SerializerAwareTrait.php b/SerializerAwareTrait.php
index 183556874..495e5889c 100644
--- a/SerializerAwareTrait.php
+++ b/SerializerAwareTrait.php
@@ -16,15 +16,9 @@
  */
 trait SerializerAwareTrait
 {
-    /**
-     * @var SerializerInterface
-     */
-    protected $serializer;
+    protected ?SerializerInterface $serializer = null;
 
-    /**
-     * @return void
-     */
-    public function setSerializer(SerializerInterface $serializer)
+    public function setSerializer(SerializerInterface $serializer): void
     {
         $this->serializer = $serializer;
     }
diff --git a/Tests/Annotation/ContextTest.php b/Tests/Attribute/ContextTest.php
similarity index 94%
rename from Tests/Annotation/ContextTest.php
rename to Tests/Attribute/ContextTest.php
index 9584d6f1b..cfe175050 100644
--- a/Tests/Annotation/ContextTest.php
+++ b/Tests/Attribute/ContextTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Attribute\Context;
@@ -40,7 +40,7 @@ public function testThrowsOnEmptyContext()
     public function testInvalidGroupOption()
     {
         $this->expectException(InvalidArgumentException::class);
-        $this->expectExceptionMessage(sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "stdClass" given', Context::class));
+        $this->expectExceptionMessage(\sprintf('Parameter "groups" given to "%s" must be a string or an array of strings, "stdClass" given', Context::class));
 
         new Context(context: ['foo' => 'bar'], groups: ['fine', new \stdClass()]);
     }
diff --git a/Tests/Annotation/DiscriminatorMapTest.php b/Tests/Attribute/DiscriminatorMapTest.php
similarity index 82%
rename from Tests/Annotation/DiscriminatorMapTest.php
rename to Tests/Attribute/DiscriminatorMapTest.php
index bbd112e26..497bc6201 100644
--- a/Tests/Annotation/DiscriminatorMapTest.php
+++ b/Tests/Attribute/DiscriminatorMapTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
@@ -22,16 +22,16 @@ class DiscriminatorMapTest extends TestCase
 {
     public function testGetTypePropertyAndMapping()
     {
-        $annotation = new DiscriminatorMap(typeProperty: 'type', mapping: [
+        $attribute = new DiscriminatorMap(typeProperty: 'type', mapping: [
             'foo' => 'FooClass',
             'bar' => 'BarClass',
         ]);
 
-        $this->assertEquals('type', $annotation->getTypeProperty());
+        $this->assertEquals('type', $attribute->getTypeProperty());
         $this->assertEquals([
             'foo' => 'FooClass',
             'bar' => 'BarClass',
-        ], $annotation->getMapping());
+        ], $attribute->getMapping());
     }
 
     public function testExceptionWithEmptyTypeProperty()
diff --git a/Tests/Annotation/GroupsTest.php b/Tests/Attribute/GroupsTest.php
similarity index 95%
rename from Tests/Annotation/GroupsTest.php
rename to Tests/Attribute/GroupsTest.php
index 38ec518bd..266cbc4f4 100644
--- a/Tests/Annotation/GroupsTest.php
+++ b/Tests/Attribute/GroupsTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Attribute\Groups;
diff --git a/Tests/Annotation/MaxDepthTest.php b/Tests/Attribute/MaxDepthTest.php
similarity index 94%
rename from Tests/Annotation/MaxDepthTest.php
rename to Tests/Attribute/MaxDepthTest.php
index f2ff35c87..e611bfbc4 100644
--- a/Tests/Annotation/MaxDepthTest.php
+++ b/Tests/Attribute/MaxDepthTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Attribute\MaxDepth;
diff --git a/Tests/Annotation/SerializedNameTest.php b/Tests/Attribute/SerializedNameTest.php
similarity index 83%
rename from Tests/Annotation/SerializedNameTest.php
rename to Tests/Attribute/SerializedNameTest.php
index c2b5e5f2a..c645e7e85 100644
--- a/Tests/Annotation/SerializedNameTest.php
+++ b/Tests/Attribute/SerializedNameTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Attribute\SerializedName;
@@ -30,7 +30,7 @@ public function testNotAStringSerializedNameParameter()
 
     public function testSerializedNameParameters()
     {
-        $maxDepth = new SerializedName('foo');
-        $this->assertEquals('foo', $maxDepth->getSerializedName());
+        $foo = new SerializedName('foo');
+        $this->assertEquals('foo', $foo->getSerializedName());
     }
 }
diff --git a/Tests/Annotation/SerializedPathTest.php b/Tests/Attribute/SerializedPathTest.php
similarity index 95%
rename from Tests/Annotation/SerializedPathTest.php
rename to Tests/Attribute/SerializedPathTest.php
index f5bbfa62b..7ba31fc22 100644
--- a/Tests/Annotation/SerializedPathTest.php
+++ b/Tests/Attribute/SerializedPathTest.php
@@ -9,7 +9,7 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Annotation;
+namespace Symfony\Component\Serializer\Tests\Attribute;
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\PropertyAccess\PropertyPath;
diff --git a/Tests/Command/DebugCommandTest.php b/Tests/Command/DebugCommandTest.php
index 879231160..7bfdf93dd 100644
--- a/Tests/Command/DebugCommandTest.php
+++ b/Tests/Command/DebugCommandTest.php
@@ -36,41 +36,43 @@ public function testOutputWithClassArgument()
             Symfony\Component\Serializer\Tests\Dummy\DummyClassOne
             ------------------------------------------------------
 
-            +----------+-------------------------------------+
-            | Property | Options                             |
-            +----------+-------------------------------------+
-            | code     | [                                   |
-            |          |   "groups" => [                     |
-            |          |     "book:read",                    |
-            |          |     "book:write"                    |
-            |          |   ],                                |
-            |          |   "maxDepth" => 1,                  |
-            |          |   "serializedName" => "identifier", |
-            |          |   "ignore" => true,                 |
-            |          |   "normalizationContexts" => [      |
-            |          |     "*" => [                        |
-            |          |       "groups" => [                 |
-            |          |         "book:read"                 |
-            |          |       ]                             |
-            |          |     ]                               |
-            |          |   ],                                |
-            |          |   "denormalizationContexts" => [    |
-            |          |     "*" => [                        |
-            |          |       "groups" => [                 |
-            |          |         "book:write"                |
-            |          |       ]                             |
-            |          |     ]                               |
-            |          |   ]                                 |
-            |          | ]                                   |
-            | name     | [                                   |
-            |          |   "groups" => [],                   |
-            |          |   "maxDepth" => null,               |
-            |          |   "serializedName" => null,         |
-            |          |   "ignore" => false,                |
-            |          |   "normalizationContexts" => [],    |
-            |          |   "denormalizationContexts" => []   |
-            |          | ]                                   |
-            +----------+-------------------------------------+
+            +----------+---------------------------------------+
+            | Property | Options                               |
+            +----------+---------------------------------------+
+            | code     | [                                     |
+            |          |   "groups" => [                       |
+            |          |     "book:read",                      |
+            |          |     "book:write"                      |
+            |          |   ],                                  |
+            |          |   "maxDepth" => 1,                    |
+            |          |   "serializedName" => "identifier",   |
+            |          |   "serializedPath" => null,           |
+            |          |   "ignore" => true,                   |
+            |          |   "normalizationContexts" => [        |
+            |          |     "*" => [                          |
+            |          |       "groups" => [                   |
+            |          |         "book:read"                   |
+            |          |       ]                               |
+            |          |     ]                                 |
+            |          |   ],                                  |
+            |          |   "denormalizationContexts" => [      |
+            |          |     "*" => [                          |
+            |          |       "groups" => [                   |
+            |          |         "book:write"                  |
+            |          |       ]                               |
+            |          |     ]                                 |
+            |          |   ]                                   |
+            |          | ]                                     |
+            | name     | [                                     |
+            |          |   "groups" => [],                     |
+            |          |   "maxDepth" => null,                 |
+            |          |   "serializedName" => null,           |
+            |          |   "serializedPath" => "[data][name]", |
+            |          |   "ignore" => false,                  |
+            |          |   "normalizationContexts" => [],      |
+            |          |   "denormalizationContexts" => []     |
+            |          | ]                                     |
+            +----------+---------------------------------------+
 
             TXT,
             $tester->getDisplay(true),
diff --git a/Tests/Context/ContextBuilderTraitTest.php b/Tests/Context/ContextBuilderTraitTest.php
index 17ad231a0..edd3937e2 100644
--- a/Tests/Context/ContextBuilderTraitTest.php
+++ b/Tests/Context/ContextBuilderTraitTest.php
@@ -22,7 +22,7 @@ class ContextBuilderTraitTest extends TestCase
 {
     public function testWithContext()
     {
-        $contextBuilder = new class() implements ContextBuilderInterface {
+        $contextBuilder = new class implements ContextBuilderInterface {
             use ContextBuilderTrait;
         };
 
@@ -37,7 +37,7 @@ public function testWithContext()
 
     public function testWith()
     {
-        $contextBuilder = new class() {
+        $contextBuilder = new class {
             use ContextBuilderTrait;
 
             public function withFoo(string $value): static
diff --git a/Tests/Context/Encoder/CsvEncoderContextBuilderTest.php b/Tests/Context/Encoder/CsvEncoderContextBuilderTest.php
index c71d41b63..fe39feb81 100644
--- a/Tests/Context/Encoder/CsvEncoderContextBuilderTest.php
+++ b/Tests/Context/Encoder/CsvEncoderContextBuilderTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Serializer\Tests\Context\Encoder;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\PhpUnit\ExpectUserDeprecationMessageTrait;
 use Symfony\Component\Serializer\Context\Encoder\CsvEncoderContextBuilder;
 use Symfony\Component\Serializer\Encoder\CsvEncoder;
 use Symfony\Component\Serializer\Exception\InvalidArgumentException;
@@ -21,6 +22,8 @@
  */
 class CsvEncoderContextBuilderTest extends TestCase
 {
+    use ExpectUserDeprecationMessageTrait;
+
     private CsvEncoderContextBuilder $contextBuilder;
 
     protected function setUp(): void
@@ -38,7 +41,6 @@ public function testWithers(array $values)
         $context = $this->contextBuilder
             ->withDelimiter($values[CsvEncoder::DELIMITER_KEY])
             ->withEnclosure($values[CsvEncoder::ENCLOSURE_KEY])
-            ->withEscapeChar($values[CsvEncoder::ESCAPE_CHAR_KEY])
             ->withKeySeparator($values[CsvEncoder::KEY_SEPARATOR_KEY])
             ->withHeaders($values[CsvEncoder::HEADERS_KEY])
             ->withEscapedFormulas($values[CsvEncoder::ESCAPE_FORMULAS_KEY])
@@ -59,7 +61,6 @@ public static function withersDataProvider(): iterable
         yield 'With values' => [[
             CsvEncoder::DELIMITER_KEY => ';',
             CsvEncoder::ENCLOSURE_KEY => '"',
-            CsvEncoder::ESCAPE_CHAR_KEY => '\\',
             CsvEncoder::KEY_SEPARATOR_KEY => '_',
             CsvEncoder::HEADERS_KEY => ['h1', 'h2'],
             CsvEncoder::ESCAPE_FORMULAS_KEY => true,
@@ -72,7 +73,6 @@ public static function withersDataProvider(): iterable
         yield 'With null values' => [[
             CsvEncoder::DELIMITER_KEY => null,
             CsvEncoder::ENCLOSURE_KEY => null,
-            CsvEncoder::ESCAPE_CHAR_KEY => null,
             CsvEncoder::KEY_SEPARATOR_KEY => null,
             CsvEncoder::HEADERS_KEY => null,
             CsvEncoder::ESCAPE_FORMULAS_KEY => null,
@@ -88,7 +88,6 @@ public function testWithersWithoutValue()
         $context = $this->contextBuilder
             ->withDelimiter(null)
             ->withEnclosure(null)
-            ->withEscapeChar(null)
             ->withKeySeparator(null)
             ->withHeaders(null)
             ->withEscapedFormulas(null)
@@ -101,7 +100,6 @@ public function testWithersWithoutValue()
         $this->assertSame([
             CsvEncoder::DELIMITER_KEY => null,
             CsvEncoder::ENCLOSURE_KEY => null,
-            CsvEncoder::ESCAPE_CHAR_KEY => null,
             CsvEncoder::KEY_SEPARATOR_KEY => null,
             CsvEncoder::HEADERS_KEY => null,
             CsvEncoder::ESCAPE_FORMULAS_KEY => null,
@@ -124,9 +122,25 @@ public function testCannotSetMultipleBytesAsEnclosure()
         $this->contextBuilder->withEnclosure('ọ');
     }
 
+    /**
+     * @group legacy
+     */
     public function testCannotSetMultipleBytesAsEscapeChar()
     {
+        $this->expectUserDeprecationMessage('Since symfony/serializer 7.2: The "Symfony\Component\Serializer\Context\Encoder\CsvEncoderContextBuilder::withEscapeChar" method is deprecated. It will be removed in 8.0.');
+
         $this->expectException(InvalidArgumentException::class);
         $this->contextBuilder->withEscapeChar('ọ');
     }
+
+    /**
+     * @group legacy
+     */
+    public function testWithEscapeCharIsDeprecated()
+    {
+        $this->expectUserDeprecationMessage('Since symfony/serializer 7.2: The "Symfony\Component\Serializer\Context\Encoder\CsvEncoderContextBuilder::withEscapeChar" method is deprecated. It will be removed in 8.0.');
+        $context = $this->contextBuilder->withEscapeChar('\\');
+
+        $this->assertSame(['csv_escape_char' => '\\'], $context->toArray());
+    }
 }
diff --git a/Tests/Context/Encoder/XmlEncoderContextBuilderTest.php b/Tests/Context/Encoder/XmlEncoderContextBuilderTest.php
index d1ea307a9..2f71c6012 100644
--- a/Tests/Context/Encoder/XmlEncoderContextBuilderTest.php
+++ b/Tests/Context/Encoder/XmlEncoderContextBuilderTest.php
@@ -46,6 +46,7 @@ public function testWithers(array $values)
             ->withTypeCastAttributes($values[XmlEncoder::TYPE_CAST_ATTRIBUTES])
             ->withVersion($values[XmlEncoder::VERSION])
             ->withCdataWrapping($values[XmlEncoder::CDATA_WRAPPING])
+            ->withCdataWrappingPattern($values[XmlEncoder::CDATA_WRAPPING_PATTERN])
             ->toArray();
 
         $this->assertSame($values, $context);
@@ -67,6 +68,7 @@ public static function withersDataProvider(): iterable
             XmlEncoder::TYPE_CAST_ATTRIBUTES => true,
             XmlEncoder::VERSION => '1.0',
             XmlEncoder::CDATA_WRAPPING => false,
+            XmlEncoder::CDATA_WRAPPING_PATTERN => '/[<>&"\']/',
         ]];
 
         yield 'With null values' => [[
@@ -83,6 +85,7 @@ public static function withersDataProvider(): iterable
             XmlEncoder::TYPE_CAST_ATTRIBUTES => null,
             XmlEncoder::VERSION => null,
             XmlEncoder::CDATA_WRAPPING => null,
+            XmlEncoder::CDATA_WRAPPING_PATTERN => null,
         ]];
     }
 }
diff --git a/Tests/Context/Normalizer/AbstractNormalizerContextBuilderTest.php b/Tests/Context/Normalizer/AbstractNormalizerContextBuilderTest.php
index 4b8f0cc3f..4e92c54d8 100644
--- a/Tests/Context/Normalizer/AbstractNormalizerContextBuilderTest.php
+++ b/Tests/Context/Normalizer/AbstractNormalizerContextBuilderTest.php
@@ -25,7 +25,7 @@ class AbstractNormalizerContextBuilderTest extends TestCase
 
     protected function setUp(): void
     {
-        $this->contextBuilder = new class() extends AbstractNormalizerContextBuilder {};
+        $this->contextBuilder = new class extends AbstractNormalizerContextBuilder {};
     }
 
     /**
diff --git a/Tests/Context/Normalizer/AbstractObjectNormalizerContextBuilderTest.php b/Tests/Context/Normalizer/AbstractObjectNormalizerContextBuilderTest.php
index 410f2972b..c13760118 100644
--- a/Tests/Context/Normalizer/AbstractObjectNormalizerContextBuilderTest.php
+++ b/Tests/Context/Normalizer/AbstractObjectNormalizerContextBuilderTest.php
@@ -25,7 +25,7 @@ class AbstractObjectNormalizerContextBuilderTest extends TestCase
 
     protected function setUp(): void
     {
-        $this->contextBuilder = new class() extends AbstractObjectNormalizerContextBuilder {};
+        $this->contextBuilder = new class extends AbstractObjectNormalizerContextBuilder {};
     }
 
     /**
diff --git a/Tests/Context/Normalizer/DateTimeNormalizerContextBuilderTest.php b/Tests/Context/Normalizer/DateTimeNormalizerContextBuilderTest.php
index 8ab41f949..ac4badc19 100644
--- a/Tests/Context/Normalizer/DateTimeNormalizerContextBuilderTest.php
+++ b/Tests/Context/Normalizer/DateTimeNormalizerContextBuilderTest.php
@@ -38,6 +38,7 @@ public function testWithers(array $values)
         $context = $this->contextBuilder
             ->withFormat($values[DateTimeNormalizer::FORMAT_KEY])
             ->withTimezone($values[DateTimeNormalizer::TIMEZONE_KEY])
+            ->withCast($values[DateTimeNormalizer::CAST_KEY])
             ->toArray();
 
         $this->assertEquals($values, $context);
@@ -51,11 +52,13 @@ public static function withersDataProvider(): iterable
         yield 'With values' => [[
             DateTimeNormalizer::FORMAT_KEY => 'format',
             DateTimeNormalizer::TIMEZONE_KEY => new \DateTimeZone('GMT'),
+            DateTimeNormalizer::CAST_KEY => 'int',
         ]];
 
         yield 'With null values' => [[
             DateTimeNormalizer::FORMAT_KEY => null,
             DateTimeNormalizer::TIMEZONE_KEY => null,
+            DateTimeNormalizer::CAST_KEY => null,
         ]];
     }
 
diff --git a/Tests/DataCollector/SerializerDataCollectorTest.php b/Tests/DataCollector/SerializerDataCollectorTest.php
index aebde8efa..6a26565a8 100644
--- a/Tests/DataCollector/SerializerDataCollectorTest.php
+++ b/Tests/DataCollector/SerializerDataCollectorTest.php
@@ -25,8 +25,8 @@ public function testCollectSerialize()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller);
+        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
 
         $dataCollector->lateCollect();
         $collectedData = $this->castCollectedData($dataCollector->getData());
@@ -41,6 +41,7 @@ public function testCollectSerialize()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['serialize']);
 
         $this->assertSame([[
@@ -53,6 +54,7 @@ public function testCollectSerialize()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['deserialize']);
     }
 
@@ -61,8 +63,8 @@ public function testCollectNormalize()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectNormalize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectDenormalize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller);
+        $dataCollector->collectNormalize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectDenormalize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
 
         $dataCollector->lateCollect();
         $collectedData = $this->castCollectedData($dataCollector->getData());
@@ -77,6 +79,7 @@ public function testCollectNormalize()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['normalize']);
 
         $this->assertSame([[
@@ -89,6 +92,7 @@ public function testCollectNormalize()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['denormalize']);
     }
 
@@ -97,8 +101,8 @@ public function testCollectEncode()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectEncode('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectDecode('traceIdTwo', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
+        $dataCollector->collectEncode('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectDecode('traceIdTwo', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
 
         $dataCollector->lateCollect();
         $collectedData = $this->castCollectedData($dataCollector->getData());
@@ -113,6 +117,7 @@ public function testCollectEncode()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['encode']);
 
         $this->assertSame([[
@@ -125,6 +130,7 @@ public function testCollectEncode()
             'normalization' => [],
             'encoding' => [],
             'caller' => $caller,
+            'name' => 'default',
         ]], $collectedData['decode']);
     }
 
@@ -133,18 +139,18 @@ public function testCollectNormalization()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectNormalize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectDenormalize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 20.0, $caller);
+        $dataCollector->collectNormalize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectDenormalize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
 
-        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 1.0);
-        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 2.0);
-        $dataCollector->collectNormalization('traceIdOne', ObjectNormalizer::class, 5.0);
-        $dataCollector->collectNormalization('traceIdOne', ObjectNormalizer::class, 10.0);
+        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 1.0, 'default');
+        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 2.0, 'default');
+        $dataCollector->collectNormalization('traceIdOne', ObjectNormalizer::class, 5.0, 'default');
+        $dataCollector->collectNormalization('traceIdOne', ObjectNormalizer::class, 10.0, 'default');
 
-        $dataCollector->collectNormalization('traceIdTwo', DateTimeNormalizer::class, 1.0);
-        $dataCollector->collectNormalization('traceIdTwo', DateTimeNormalizer::class, 2.0);
-        $dataCollector->collectNormalization('traceIdTwo', ObjectNormalizer::class, 5.0);
-        $dataCollector->collectNormalization('traceIdTwo', ObjectNormalizer::class, 10.0);
+        $dataCollector->collectNormalization('traceIdTwo', DateTimeNormalizer::class, 1.0, 'default');
+        $dataCollector->collectNormalization('traceIdTwo', DateTimeNormalizer::class, 2.0, 'default');
+        $dataCollector->collectNormalization('traceIdTwo', ObjectNormalizer::class, 5.0, 'default');
+        $dataCollector->collectNormalization('traceIdTwo', ObjectNormalizer::class, 10.0, 'default');
 
         $dataCollector->lateCollect();
         $collectedData = $dataCollector->getData();
@@ -189,18 +195,18 @@ public function testCollectEncoding()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectEncode('traceIdOne', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectDecode('traceIdTwo', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
+        $dataCollector->collectEncode('traceIdOne', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectDecode('traceIdTwo', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
 
-        $dataCollector->collectEncoding('traceIdOne', JsonEncoder::class, 1.0);
-        $dataCollector->collectEncoding('traceIdOne', JsonEncoder::class, 2.0);
-        $dataCollector->collectEncoding('traceIdOne', CsvEncoder::class, 5.0);
-        $dataCollector->collectEncoding('traceIdOne', CsvEncoder::class, 10.0);
+        $dataCollector->collectEncoding('traceIdOne', JsonEncoder::class, 1.0, 'default');
+        $dataCollector->collectEncoding('traceIdOne', JsonEncoder::class, 2.0, 'default');
+        $dataCollector->collectEncoding('traceIdOne', CsvEncoder::class, 5.0, 'default');
+        $dataCollector->collectEncoding('traceIdOne', CsvEncoder::class, 10.0, 'default');
 
-        $dataCollector->collectDecoding('traceIdTwo', JsonEncoder::class, 1.0);
-        $dataCollector->collectDecoding('traceIdTwo', JsonEncoder::class, 2.0);
-        $dataCollector->collectDecoding('traceIdTwo', CsvEncoder::class, 5.0);
-        $dataCollector->collectDecoding('traceIdTwo', CsvEncoder::class, 10.0);
+        $dataCollector->collectDecoding('traceIdTwo', JsonEncoder::class, 1.0, 'default');
+        $dataCollector->collectDecoding('traceIdTwo', JsonEncoder::class, 2.0, 'default');
+        $dataCollector->collectDecoding('traceIdTwo', CsvEncoder::class, 5.0, 'default');
+        $dataCollector->collectDecoding('traceIdTwo', CsvEncoder::class, 10.0, 'default');
 
         $dataCollector->lateCollect();
         $collectedData = $dataCollector->getData();
@@ -245,13 +251,13 @@ public function testCountHandled()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectNormalize('traceIdThree', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectDenormalize('traceIdFour', 'data', 'type', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectEncode('traceIdFive', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectDecode('traceIdSix', 'data', 'format', ['foo' => 'bar'], 20.0, $caller);
-        $dataCollector->collectSerialize('traceIdSeven', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
+        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectNormalize('traceIdThree', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectDenormalize('traceIdFour', 'data', 'type', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectEncode('traceIdFive', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectDecode('traceIdSix', 'data', 'format', ['foo' => 'bar'], 20.0, $caller, 'default');
+        $dataCollector->collectSerialize('traceIdSeven', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
 
         $dataCollector->lateCollect();
 
@@ -264,13 +270,13 @@ public function testGetTotalTime()
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
 
-        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
-        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 2.0, $caller);
-        $dataCollector->collectNormalize('traceIdThree', 'data', 'format', ['foo' => 'bar'], 3.0, $caller);
-        $dataCollector->collectDenormalize('traceIdFour', 'data', 'type', 'format', ['foo' => 'bar'], 4.0, $caller);
-        $dataCollector->collectEncode('traceIdFive', 'data', 'format', ['foo' => 'bar'], 5.0, $caller);
-        $dataCollector->collectDecode('traceIdSix', 'data', 'format', ['foo' => 'bar'], 6.0, $caller);
-        $dataCollector->collectSerialize('traceIdSeven', 'data', 'format', ['foo' => 'bar'], 7.0, $caller);
+        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
+        $dataCollector->collectDeserialize('traceIdTwo', 'data', 'type', 'format', ['foo' => 'bar'], 2.0, $caller, 'default');
+        $dataCollector->collectNormalize('traceIdThree', 'data', 'format', ['foo' => 'bar'], 3.0, $caller, 'default');
+        $dataCollector->collectDenormalize('traceIdFour', 'data', 'type', 'format', ['foo' => 'bar'], 4.0, $caller, 'default');
+        $dataCollector->collectEncode('traceIdFive', 'data', 'format', ['foo' => 'bar'], 5.0, $caller, 'default');
+        $dataCollector->collectDecode('traceIdSix', 'data', 'format', ['foo' => 'bar'], 6.0, $caller, 'default');
+        $dataCollector->collectSerialize('traceIdSeven', 'data', 'format', ['foo' => 'bar'], 7.0, $caller, 'default');
 
         $dataCollector->lateCollect();
 
@@ -282,7 +288,7 @@ public function testReset()
         $dataCollector = new SerializerDataCollector();
 
         $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
-        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller);
+        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 1.0, $caller, 'default');
         $dataCollector->lateCollect();
 
         $this->assertNotSame([], $dataCollector->getData());
@@ -295,10 +301,10 @@ public function testDoNotCollectPartialTraces()
     {
         $dataCollector = new SerializerDataCollector();
 
-        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 1.0);
-        $dataCollector->collectDenormalization('traceIdTwo', DateTimeNormalizer::class, 1.0);
-        $dataCollector->collectEncoding('traceIdThree', CsvEncoder::class, 10.0);
-        $dataCollector->collectDecoding('traceIdFour', JsonEncoder::class, 1.0);
+        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 1.0, 'default');
+        $dataCollector->collectDenormalization('traceIdTwo', DateTimeNormalizer::class, 1.0, 'default');
+        $dataCollector->collectEncoding('traceIdThree', CsvEncoder::class, 10.0, 'default');
+        $dataCollector->collectDecoding('traceIdFour', JsonEncoder::class, 1.0, 'default');
 
         $dataCollector->lateCollect();
 
@@ -312,6 +318,84 @@ public function testDoNotCollectPartialTraces()
         $this->assertSame([], $data['decode']);
     }
 
+    public function testNamedSerializers()
+    {
+        $dataCollector = new SerializerDataCollector();
+
+        $caller = ['name' => 'Foo.php', 'file' => 'src/Foo.php', 'line' => 123];
+        $dataCollector->collectNormalization('traceIdOne', DateTimeNormalizer::class, 3.0, 'default');
+        $dataCollector->collectEncoding('traceIdOne', CsvEncoder::class, 4.0, 'default');
+        $dataCollector->collectSerialize('traceIdOne', 'data', 'format', ['foo' => 'bar'], 7.0, $caller, 'default');
+        $dataCollector->collectNormalization('traceIdTwo', ObjectNormalizer::class, 3.0, 'default');
+        $dataCollector->collectNormalize('traceIdTwo', 'data', 'format', ['foo' => 'bar'], 5.0, $caller, 'default');
+
+        $dataCollector->collectEncoding('traceIdThree', JsonEncoder::class, 4.0, 'api');
+        $dataCollector->collectEncode('traceIdThree', 'data', 'format', ['foo' => 'bar'], 5.0, $caller, 'api');
+        $dataCollector->collectDenormalization('traceIdFour', DateTimeNormalizer::class, 3.0, 'api');
+        $dataCollector->collectDecoding('traceIdFour', CsvEncoder::class, 4.0, 'api');
+        $dataCollector->collectDeserialize('traceIdFour', 'data', 'type', 'format', ['foo' => 'bar'], 7.0, $caller, 'api');
+        $dataCollector->collectDenormalization('traceIdFive', ObjectNormalizer::class, 3.0, 'api');
+        $dataCollector->collectDenormalize('traceIdFive', 'data', 'type', 'format', ['foo' => 'bar'], 5.0, $caller, 'api');
+        $dataCollector->collectDecoding('traceIdSix', JsonEncoder::class, 4.0, 'api');
+        $dataCollector->collectDecode('traceIdSix', 'data', 'format', ['foo' => 'bar'], 5.0, $caller, 'api');
+
+        $dataCollector->lateCollect();
+
+        $this->assertSame(6, $dataCollector->getHandledCount());
+
+        $collectedData = $dataCollector->getData();
+
+        $this->assertSame('default', $collectedData['serialize'][0]['name']);
+        $this->assertSame('DateTimeNormalizer', $collectedData['serialize'][0]['normalizer']['class']);
+        $this->assertSame('CsvEncoder', $collectedData['serialize'][0]['encoder']['class']);
+        $this->assertSame('default', $collectedData['normalize'][0]['name']);
+        $this->assertSame('ObjectNormalizer', $collectedData['normalize'][0]['normalizer']['class']);
+
+        $this->assertSame('api', $collectedData['encode'][0]['name']);
+        $this->assertSame('JsonEncoder', $collectedData['encode'][0]['encoder']['class']);
+        $this->assertSame('api', $collectedData['deserialize'][0]['name']);
+        $this->assertSame('DateTimeNormalizer', $collectedData['deserialize'][0]['normalizer']['class']);
+        $this->assertSame('CsvEncoder', $collectedData['deserialize'][0]['encoder']['class']);
+        $this->assertSame('api', $collectedData['denormalize'][0]['name']);
+        $this->assertSame('ObjectNormalizer', $collectedData['denormalize'][0]['normalizer']['class']);
+        $this->assertSame('api', $collectedData['decode'][0]['name']);
+        $this->assertSame('JsonEncoder', $collectedData['decode'][0]['encoder']['class']);
+
+        $this->assertSame(['default', 'api'], $dataCollector->getSerializerNames());
+
+        $this->assertSame(2, $dataCollector->getHandledCount('default'));
+
+        $collectedData = $dataCollector->getData('default');
+
+        $this->assertSame('default', $collectedData['serialize'][0]['name']);
+        $this->assertSame('DateTimeNormalizer', $collectedData['serialize'][0]['normalizer']['class']);
+        $this->assertSame('CsvEncoder', $collectedData['serialize'][0]['encoder']['class']);
+        $this->assertSame('default', $collectedData['normalize'][0]['name']);
+        $this->assertSame('ObjectNormalizer', $collectedData['normalize'][0]['normalizer']['class']);
+
+        $this->assertEmpty($collectedData['encode']);
+        $this->assertEmpty($collectedData['deserialize']);
+        $this->assertEmpty($collectedData['denormalize']);
+        $this->assertEmpty($collectedData['decode']);
+
+        $this->assertSame(4, $dataCollector->getHandledCount('api'));
+
+        $collectedData = $dataCollector->getData('api');
+
+        $this->assertEmpty($collectedData['serialize']);
+        $this->assertEmpty($collectedData['normalize']);
+
+        $this->assertSame('api', $collectedData['encode'][0]['name']);
+        $this->assertSame('JsonEncoder', $collectedData['encode'][0]['encoder']['class']);
+        $this->assertSame('api', $collectedData['deserialize'][0]['name']);
+        $this->assertSame('DateTimeNormalizer', $collectedData['deserialize'][0]['normalizer']['class']);
+        $this->assertSame('CsvEncoder', $collectedData['deserialize'][0]['encoder']['class']);
+        $this->assertSame('api', $collectedData['denormalize'][0]['name']);
+        $this->assertSame('ObjectNormalizer', $collectedData['denormalize'][0]['normalizer']['class']);
+        $this->assertSame('api', $collectedData['decode'][0]['name']);
+        $this->assertSame('JsonEncoder', $collectedData['decode'][0]['encoder']['class']);
+    }
+
     /**
      * Cast cloned vars to be able to test nested values.
      */
diff --git a/Tests/Debug/TraceableEncoderTest.php b/Tests/Debug/TraceableEncoderTest.php
index ec38c0ef5..2ac0b8f1f 100644
--- a/Tests/Debug/TraceableEncoderTest.php
+++ b/Tests/Debug/TraceableEncoderTest.php
@@ -36,12 +36,14 @@ public function testForwardsToEncoder()
             ->with('data', 'format', $this->isType('array'))
             ->willReturn('decoded');
 
-        $this->assertSame('encoded', (new TraceableEncoder($encoder, new SerializerDataCollector()))->encode('data', 'format'));
-        $this->assertSame('decoded', (new TraceableEncoder($decoder, new SerializerDataCollector()))->decode('data', 'format'));
+        $this->assertSame('encoded', (new TraceableEncoder($encoder, new SerializerDataCollector(), 'default'))->encode('data', 'format'));
+        $this->assertSame('decoded', (new TraceableEncoder($decoder, new SerializerDataCollector(), 'default'))->decode('data', 'format'));
     }
 
     public function testCollectEncodingData()
     {
+        $serializerName = uniqid('name', true);
+
         $encoder = $this->createMock(EncoderInterface::class);
         $decoder = $this->createMock(DecoderInterface::class);
 
@@ -49,14 +51,14 @@ public function testCollectEncodingData()
         $dataCollector
             ->expects($this->once())
             ->method('collectEncoding')
-            ->with($this->isType('string'), $encoder::class, $this->isType('float'));
+            ->with($this->isType('string'), $encoder::class, $this->isType('float'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectDecoding')
-            ->with($this->isType('string'), $decoder::class, $this->isType('float'));
+            ->with($this->isType('string'), $decoder::class, $this->isType('float'), $serializerName);
 
-        (new TraceableEncoder($encoder, $dataCollector))->encode('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
-        (new TraceableEncoder($decoder, $dataCollector))->decode('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
+        (new TraceableEncoder($encoder, $dataCollector, $serializerName))->encode('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
+        (new TraceableEncoder($decoder, $dataCollector, $serializerName))->decode('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
     }
 
     public function testNotCollectEncodingDataIfNoDebugTraceId()
@@ -68,22 +70,22 @@ public function testNotCollectEncodingDataIfNoDebugTraceId()
         $dataCollector->expects($this->never())->method('collectEncoding');
         $dataCollector->expects($this->never())->method('collectDecoding');
 
-        (new TraceableEncoder($encoder, $dataCollector))->encode('data', 'format');
-        (new TraceableEncoder($decoder, $dataCollector))->decode('data', 'format');
+        (new TraceableEncoder($encoder, $dataCollector, 'default'))->encode('data', 'format');
+        (new TraceableEncoder($decoder, $dataCollector, 'default'))->decode('data', 'format');
     }
 
     public function testCannotEncodeIfNotEncoder()
     {
         $this->expectException(\BadMethodCallException::class);
 
-        (new TraceableEncoder($this->createMock(DecoderInterface::class), new SerializerDataCollector()))->encode('data', 'format');
+        (new TraceableEncoder($this->createMock(DecoderInterface::class), new SerializerDataCollector(), 'default'))->encode('data', 'format');
     }
 
     public function testCannotDecodeIfNotDecoder()
     {
         $this->expectException(\BadMethodCallException::class);
 
-        (new TraceableEncoder($this->createMock(EncoderInterface::class), new SerializerDataCollector()))->decode('data', 'format');
+        (new TraceableEncoder($this->createMock(EncoderInterface::class), new SerializerDataCollector(), 'default'))->decode('data', 'format');
     }
 
     public function testSupports()
@@ -94,8 +96,8 @@ public function testSupports()
         $decoder = $this->createMock(DecoderInterface::class);
         $decoder->method('supportsDecoding')->willReturn(true);
 
-        $traceableEncoder = new TraceableEncoder($encoder, new SerializerDataCollector());
-        $traceableDecoder = new TraceableEncoder($decoder, new SerializerDataCollector());
+        $traceableEncoder = new TraceableEncoder($encoder, new SerializerDataCollector(), 'default');
+        $traceableDecoder = new TraceableEncoder($decoder, new SerializerDataCollector(), 'default');
 
         $this->assertTrue($traceableEncoder->supportsEncoding('data'));
         $this->assertTrue($traceableDecoder->supportsDecoding('data'));
diff --git a/Tests/Debug/TraceableNormalizerTest.php b/Tests/Debug/TraceableNormalizerTest.php
index 41e3441ed..56c161392 100644
--- a/Tests/Debug/TraceableNormalizerTest.php
+++ b/Tests/Debug/TraceableNormalizerTest.php
@@ -15,8 +15,8 @@
 use Symfony\Component\Serializer\DataCollector\SerializerDataCollector;
 use Symfony\Component\Serializer\Debug\TraceableNormalizer;
 use Symfony\Component\Serializer\Debug\TraceableSerializer;
-use Symfony\Component\Serializer\Tests\Fixtures\UpcomingDenormalizerInterface as DenormalizerInterface;
-use Symfony\Component\Serializer\Tests\Fixtures\UpcomingNormalizerInterface as NormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 
 class TraceableNormalizerTest extends TestCase
 {
@@ -38,12 +38,14 @@ public function testForwardsToNormalizer()
             ->with('data', 'type', 'format', $this->isType('array'))
             ->willReturn('denormalized');
 
-        $this->assertSame('normalized', (new TraceableNormalizer($normalizer, new SerializerDataCollector()))->normalize('data', 'format'));
-        $this->assertSame('denormalized', (new TraceableNormalizer($denormalizer, new SerializerDataCollector()))->denormalize('data', 'type', 'format'));
+        $this->assertSame('normalized', (new TraceableNormalizer($normalizer, new SerializerDataCollector(), 'default'))->normalize('data', 'format'));
+        $this->assertSame('denormalized', (new TraceableNormalizer($denormalizer, new SerializerDataCollector(), 'default'))->denormalize('data', 'type', 'format'));
     }
 
     public function testCollectNormalizationData()
     {
+        $serializerName = uniqid('name', true);
+
         $normalizer = $this->createMock(NormalizerInterface::class);
         $normalizer->method('getSupportedTypes')->willReturn(['*' => false]);
         $denormalizer = $this->createMock(DenormalizerInterface::class);
@@ -53,14 +55,14 @@ public function testCollectNormalizationData()
         $dataCollector
             ->expects($this->once())
             ->method('collectNormalization')
-            ->with($this->isType('string'), $normalizer::class, $this->isType('float'));
+            ->with($this->isType('string'), $normalizer::class, $this->isType('float'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectDenormalization')
-            ->with($this->isType('string'), $denormalizer::class, $this->isType('float'));
+            ->with($this->isType('string'), $denormalizer::class, $this->isType('float'), $serializerName);
 
-        (new TraceableNormalizer($normalizer, $dataCollector))->normalize('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
-        (new TraceableNormalizer($denormalizer, $dataCollector))->denormalize('data', 'type', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
+        (new TraceableNormalizer($normalizer, $dataCollector, $serializerName))->normalize('data', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
+        (new TraceableNormalizer($denormalizer, $dataCollector, $serializerName))->denormalize('data', 'type', 'format', [TraceableSerializer::DEBUG_TRACE_ID => 'debug']);
     }
 
     public function testNotCollectNormalizationDataIfNoDebugTraceId()
@@ -74,22 +76,22 @@ public function testNotCollectNormalizationDataIfNoDebugTraceId()
         $dataCollector->expects($this->never())->method('collectNormalization');
         $dataCollector->expects($this->never())->method('collectDenormalization');
 
-        (new TraceableNormalizer($normalizer, $dataCollector))->normalize('data', 'format');
-        (new TraceableNormalizer($denormalizer, $dataCollector))->denormalize('data', 'type', 'format');
+        (new TraceableNormalizer($normalizer, $dataCollector, 'default'))->normalize('data', 'format');
+        (new TraceableNormalizer($denormalizer, $dataCollector, 'default'))->denormalize('data', 'type', 'format');
     }
 
     public function testCannotNormalizeIfNotNormalizer()
     {
         $this->expectException(\BadMethodCallException::class);
 
-        (new TraceableNormalizer($this->createMock(DenormalizerInterface::class), new SerializerDataCollector()))->normalize('data');
+        (new TraceableNormalizer($this->createMock(DenormalizerInterface::class), new SerializerDataCollector(), 'default'))->normalize('data');
     }
 
     public function testCannotDenormalizeIfNotDenormalizer()
     {
         $this->expectException(\BadMethodCallException::class);
 
-        (new TraceableNormalizer($this->createMock(NormalizerInterface::class), new SerializerDataCollector()))->denormalize('data', 'type');
+        (new TraceableNormalizer($this->createMock(NormalizerInterface::class), new SerializerDataCollector(), 'default'))->denormalize('data', 'type');
     }
 
     public function testSupports()
@@ -102,8 +104,8 @@ public function testSupports()
         $denormalizer->method('getSupportedTypes')->willReturn(['*' => false]);
         $denormalizer->method('supportsDenormalization')->willReturn(true);
 
-        $traceableNormalizer = new TraceableNormalizer($normalizer, new SerializerDataCollector());
-        $traceableDenormalizer = new TraceableNormalizer($denormalizer, new SerializerDataCollector());
+        $traceableNormalizer = new TraceableNormalizer($normalizer, new SerializerDataCollector(), 'default');
+        $traceableDenormalizer = new TraceableNormalizer($denormalizer, new SerializerDataCollector(), 'default');
 
         $this->assertTrue($traceableNormalizer->supportsNormalization('data'));
         $this->assertTrue($traceableDenormalizer->supportsDenormalization('data', 'type'));
diff --git a/Tests/Debug/TraceableSerializerTest.php b/Tests/Debug/TraceableSerializerTest.php
index ea3c851c6..d697b270f 100644
--- a/Tests/Debug/TraceableSerializerTest.php
+++ b/Tests/Debug/TraceableSerializerTest.php
@@ -56,7 +56,7 @@ public function testForwardsToSerializer()
             ->with('data', 'format', $this->isType('array'))
             ->willReturn('decoded');
 
-        $traceableSerializer = new TraceableSerializer($serializer, new SerializerDataCollector());
+        $traceableSerializer = new TraceableSerializer($serializer, new SerializerDataCollector(), 'default');
 
         $this->assertSame('serialized', $traceableSerializer->serialize('data', 'format'));
         $this->assertSame('deserialized', $traceableSerializer->deserialize('data', 'type', 'format'));
@@ -68,33 +68,35 @@ public function testForwardsToSerializer()
 
     public function testCollectData()
     {
+        $serializerName = uniqid('name', true);
+
         $dataCollector = $this->createMock(SerializerDataCollector::class);
         $dataCollector
             ->expects($this->once())
             ->method('collectSerialize')
-            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectDeserialize')
-            ->with($this->isType('string'), 'data', 'type', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'type', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectNormalize')
-            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectDenormalize')
-            ->with($this->isType('string'), 'data', 'type', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'type', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectEncode')
-            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
         $dataCollector
             ->expects($this->once())
             ->method('collectDecode')
-            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'));
+            ->with($this->isType('string'), 'data', 'format', $this->isType('array'), $this->isType('float'), $this->isType('array'), $serializerName);
 
-        $traceableSerializer = new TraceableSerializer(new Serializer(), $dataCollector);
+        $traceableSerializer = new TraceableSerializer(new Serializer(), $dataCollector, $serializerName);
 
         $traceableSerializer->serialize('data', 'format');
         $traceableSerializer->deserialize('data', 'type', 'format');
@@ -117,7 +119,7 @@ public function testAddDebugTraceIdInContext()
             });
         }
 
-        $traceableSerializer = new TraceableSerializer($serializer, new SerializerDataCollector());
+        $traceableSerializer = new TraceableSerializer($serializer, new SerializerDataCollector(), 'default');
 
         $traceableSerializer->serialize('data', 'format');
         $traceableSerializer->deserialize('data', 'format', 'type');
diff --git a/Tests/DependencyInjection/SerializerPassTest.php b/Tests/DependencyInjection/SerializerPassTest.php
index b2f4fa7ad..88ec02b87 100644
--- a/Tests/DependencyInjection/SerializerPassTest.php
+++ b/Tests/DependencyInjection/SerializerPassTest.php
@@ -17,7 +17,10 @@
 use Symfony\Component\DependencyInjection\Reference;
 use Symfony\Component\Serializer\Debug\TraceableEncoder;
 use Symfony\Component\Serializer\Debug\TraceableNormalizer;
+use Symfony\Component\Serializer\Debug\TraceableSerializer;
 use Symfony\Component\Serializer\DependencyInjection\SerializerPass;
+use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
+use Symfony\Component\Serializer\SerializerInterface;
 
 /**
  * Tests for the SerializerPass class.
@@ -28,20 +31,20 @@ class SerializerPassTest extends TestCase
 {
     public function testThrowExceptionWhenNoNormalizers()
     {
-        $this->expectException(\RuntimeException::class);
-        $this->expectExceptionMessage('You must tag at least one service as "serializer.normalizer" to use the "serializer" service');
         $container = new ContainerBuilder();
         $container->setParameter('kernel.debug', false);
         $container->register('serializer');
 
         $serializerPass = new SerializerPass();
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('You must tag at least one service as "serializer.normalizer" to use the "serializer" service');
+
         $serializerPass->process($container);
     }
 
     public function testThrowExceptionWhenNoEncoders()
     {
-        $this->expectException(\RuntimeException::class);
-        $this->expectExceptionMessage('You must tag at least one service as "serializer.encoder" to use the "serializer" service');
         $container = new ContainerBuilder();
         $container->setParameter('kernel.debug', false);
         $container->register('serializer')
@@ -50,6 +53,10 @@ public function testThrowExceptionWhenNoEncoders()
         $container->register('normalizer')->addTag('serializer.normalizer');
 
         $serializerPass = new SerializerPass();
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('You must tag at least one service as "serializer.encoder" to use the "serializer" service');
+
         $serializerPass->process($container);
     }
 
@@ -93,7 +100,33 @@ public function testBindSerializerDefaultContext()
         $this->assertEquals($context, $container->getDefinition('serializer')->getArgument('$defaultContext'));
     }
 
-    public function testNormalizersAndEncodersAreDecoredAndOrderedWhenCollectingData()
+    /**
+     * @testWith [{}, {}]
+     *           [{"serializer.default_context": {"enable_max_depth": true}}, {"enable_max_depth": true}]
+     *           [{".serializer.circular_reference_handler": "foo"}, {"circular_reference_handler": "foo"}]
+     *           [{".serializer.max_depth_handler": "bar"}, {"max_depth_handler": "bar"}]
+     *           [{"serializer.default_context": {"enable_max_depth": true}, ".serializer.circular_reference_handler": "foo", ".serializer.max_depth_handler": "bar"}, {"enable_max_depth": true, "circular_reference_handler": "foo", "max_depth_handler": "bar"}]
+     */
+    public function testBindObjectNormalizerDefaultContext(array $parameters, array $context)
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->register('serializer')->setArguments([null, null, []]);
+        $container->getParameterBag()->add($parameters);
+        $definition = $container->register('serializer.normalizer.object')
+            ->setClass(ObjectNormalizer::class)
+            ->addTag('serializer.normalizer')
+            ->addTag('serializer.encoder')
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $bindings = $definition->getBindings();
+        $this->assertEquals($bindings['array $defaultContext'], new BoundArgument($context, false));
+    }
+
+    public function testNormalizersAndEncodersAreDecoratedAndOrderedWhenCollectingData()
     {
         $container = new ContainerBuilder();
 
@@ -113,9 +146,560 @@ public function testNormalizersAndEncodersAreDecoredAndOrderedWhenCollectingData
         $this->assertEquals(TraceableNormalizer::class, $traceableNormalizerDefinition->getClass());
         $this->assertEquals(new Reference('n'), $traceableNormalizerDefinition->getArgument(0));
         $this->assertEquals(new Reference('serializer.data_collector'), $traceableNormalizerDefinition->getArgument(1));
+        $this->assertSame('default', $traceableNormalizerDefinition->getArgument(2));
 
         $this->assertEquals(TraceableEncoder::class, $traceableEncoderDefinition->getClass());
         $this->assertEquals(new Reference('e'), $traceableEncoderDefinition->getArgument(0));
         $this->assertEquals(new Reference('serializer.data_collector'), $traceableEncoderDefinition->getArgument(1));
+        $this->assertSame('default', $traceableEncoderDefinition->getArgument(2));
+    }
+
+    /**
+     * @dataProvider provideDefaultSerializerTagsData
+     */
+    public function testDefaultSerializerTagsAreResolvedCorrectly(
+        array $normalizerTagAttributes,
+        array $encoderTagAttributes,
+        array $expectedNormalizerTags,
+        array $expectedEncoderTags,
+    ) {
+        $container = new ContainerBuilder();
+
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', []);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n0')->addTag('serializer.normalizer', ['serializer' => 'default']);
+        $container->register('e0')->addTag('serializer.encoder', ['serializer' => 'default']);
+
+        $normalizerDefinition = $container->register('n1')->addTag('serializer.normalizer', $normalizerTagAttributes);
+        $encoderDefinition = $container->register('e1')->addTag('serializer.encoder', $encoderTagAttributes);
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertSame($expectedNormalizerTags, $normalizerDefinition->getTag('serializer.normalizer.default'));
+        $this->assertSame($expectedEncoderTags, $encoderDefinition->getTag('serializer.encoder.default'));
+    }
+
+    public static function provideDefaultSerializerTagsData(): iterable
+    {
+        yield 'include no name' => [
+            [],
+            [],
+            [[]],
+            [[]],
+        ];
+
+        yield 'include name' => [
+            ['serializer' => 'default'],
+            ['serializer' => 'default'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'include built-in with different name' => [
+            ['built_in' => true, 'serializer' => 'api'],
+            ['built_in' => true, 'serializer' => 'api'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'include no name with priority' => [
+            ['priority' => 200],
+            ['priority' => 100],
+            [['priority' => 200]],
+            [['priority' => 100]],
+        ];
+
+        yield 'include name with priority' => [
+            ['serializer' => 'default', 'priority' => 200],
+            ['serializer' => 'default', 'priority' => 100],
+            [['priority' => 200]],
+            [['priority' => 100]],
+        ];
+
+        yield 'include wildcard' => [
+            ['serializer' => '*'],
+            ['serializer' => '*'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'is unique when built-in with name' => [
+            ['built_in' => true, 'serializer' => 'default'],
+            ['built_in' => true, 'serializer' => 'default'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'do not include different name' => [
+            ['serializer' => 'api'],
+            ['serializer' => 'api'],
+            [],
+            [],
+        ];
+    }
+
+    /**
+     * @dataProvider provideNamedSerializerTagsData
+     */
+    public function testNamedSerializerTagsAreResolvedCorrectly(
+        array $config,
+        array $normalizerTagAttributes,
+        array $encoderTagAttributes,
+        array $expectedNormalizerTags,
+        array $expectedEncoderTags,
+    ) {
+        $container = new ContainerBuilder();
+
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', ['api' => $config]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n0')->addTag('serializer.normalizer', ['serializer' => ['default', 'api']]);
+        $container->register('e0')->addTag('serializer.encoder', ['serializer' => ['default', 'api']]);
+
+        $normalizerDefinition = $container->register('n1')->addTag('serializer.normalizer', $normalizerTagAttributes);
+        $encoderDefinition = $container->register('e1')->addTag('serializer.encoder', $encoderTagAttributes);
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertSame($expectedNormalizerTags, $normalizerDefinition->getTag('serializer.normalizer.api'));
+        $this->assertSame($expectedEncoderTags, $encoderDefinition->getTag('serializer.encoder.api'));
+    }
+
+    public static function provideNamedSerializerTagsData(): iterable
+    {
+        yield 'include built-in' => [
+            ['include_built_in_normalizers' => true, 'include_built_in_encoders' => true],
+            ['built_in' => true],
+            ['built_in' => true],
+            [[]],
+            [[]],
+        ];
+
+        yield 'include built-in normalizers only' => [
+            ['include_built_in_normalizers' => true, 'include_built_in_encoders' => false],
+            ['built_in' => true],
+            ['built_in' => true],
+            [[]],
+            [],
+        ];
+
+        yield 'include built-in encoders only' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => true],
+            ['built_in' => true],
+            ['built_in' => true],
+            [],
+            [[]],
+        ];
+
+        yield 'include name' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => false],
+            ['serializer' => 'api'],
+            ['serializer' => 'api'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'include name with priority' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => false],
+            ['serializer' => 'api', 'priority' => 200],
+            ['serializer' => 'api', 'priority' => 100],
+            [['priority' => 200]],
+            [['priority' => 100]],
+        ];
+
+        yield 'include wildcard' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => false],
+            ['serializer' => '*'],
+            ['serializer' => '*'],
+            [[]],
+            [[]],
+        ];
+
+        yield 'do not include when include built-in not set' => [
+            [],
+            ['built_in' => true],
+            ['built_in' => true],
+            [],
+            [],
+        ];
+
+        yield 'do not include not built-in and no name' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => false],
+            [],
+            [],
+            [],
+            [],
+        ];
+
+        yield 'do not include different name' => [
+            ['include_built_in_normalizers' => false, 'include_built_in_encoders' => false],
+            ['serializer' => 'api2'],
+            ['serializer' => 'api2'],
+            [],
+            [],
+        ];
+    }
+
+    public function testMultipleNamedSerializerTagsAreResolvedCorrectly()
+    {
+        $container = new ContainerBuilder();
+
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => [],
+            'api2' => [],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n0')->addTag('serializer.normalizer', ['serializer' => 'default']);
+        $container->register('e0')->addTag('serializer.encoder', ['serializer' => 'default']);
+
+        $normalizerDefinition = $container->register('n1')->addTag('serializer.normalizer', ['serializer' => ['api', 'api2']]);
+        $encoderDefinition = $container->register('e1')
+            ->addTag('serializer.encoder', ['serializer' => ['api', 'api2']])
+            ->addTag('serializer.encoder', ['serializer' => ['api', 'api2'], 'priority' => 100])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertTrue($normalizerDefinition->hasTag('serializer.normalizer.api'));
+        $this->assertCount(1, $normalizerDefinition->getTag('serializer.normalizer.api'));
+        $this->assertTrue($normalizerDefinition->hasTag('serializer.normalizer.api2'));
+        $this->assertCount(1, $normalizerDefinition->getTag('serializer.normalizer.api2'));
+
+        $this->assertTrue($encoderDefinition->hasTag('serializer.encoder.api'));
+        $this->assertCount(2, $encoderDefinition->getTag('serializer.encoder.api'));
+        $this->assertTrue($encoderDefinition->hasTag('serializer.encoder.api2'));
+        $this->assertCount(2, $encoderDefinition->getTag('serializer.encoder.api2'));
+    }
+
+    public function testThrowExceptionWhenNoNormalizersForNamedSerializers()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => [],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n0')->addTag('serializer.normalizer');
+        $container->register('e0')->addTag('serializer.encoder', ['serializer' => '*']);
+
+        $serializerPass = new SerializerPass();
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('The named serializer "api" requires at least one registered normalizer. Tag the normalizers as "serializer.normalizer" with the "serializer" attribute set to "api".');
+
+        $serializerPass->process($container);
+    }
+
+    public function testThrowExceptionWhenNoEncodersForNamedSerializers()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => [],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n0')->addTag('serializer.normalizer', ['serializer' => '*']);
+        $container->register('e0')->addTag('serializer.encoder');
+
+        $serializerPass = new SerializerPass();
+
+        $this->expectException(\RuntimeException::class);
+        $this->expectExceptionMessage('The named serializer "api" requires at least one registered encoder. Tag the encoders as "serializer.encoder" with the "serializer" attribute set to "api".');
+
+        $serializerPass->process($container);
+    }
+
+    /**
+     * @testWith [null]
+     *           ["some.converter"]
+     */
+    public function testChildNameConverterIsNotBuiltWhenExpected(?string $nameConverter)
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.name_converter', $nameConverter);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => ['name_converter' => $nameConverter],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n')->addTag('serializer.normalizer', ['serializer' => '*']);
+        $container->register('e')->addTag('serializer.encoder', ['serializer' => '*']);
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertFalse($container->hasDefinition('serializer.name_converter.metadata_aware.'.ContainerBuilder::hash($nameConverter)));
+    }
+
+    /**
+     * @dataProvider provideChildNameConverterCases
+     */
+    public function testChildNameConverterIsBuiltWhenExpected(
+        ?string $defaultSerializerNameConverter,
+        ?string $namedSerializerNameConverter,
+        string $nameConverterIdExists,
+        string $nameConverterIdDoesNotExist,
+        array $nameConverterArguments,
+    ) {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.name_converter', $defaultSerializerNameConverter);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => ['name_converter' => $namedSerializerNameConverter],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n')->addTag('serializer.normalizer', ['serializer' => '*']);
+        $container->register('e')->addTag('serializer.encoder', ['serializer' => '*']);
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertFalse($container->hasDefinition($nameConverterIdExists));
+        $this->assertTrue($container->hasDefinition($nameConverterIdDoesNotExist));
+        $this->assertEquals($nameConverterArguments, $container->getDefinition($nameConverterIdDoesNotExist)->getArguments());
+    }
+
+    public static function provideChildNameConverterCases(): iterable
+    {
+        $withNull = 'serializer.name_converter.metadata_aware.'.ContainerBuilder::hash(null);
+        $withConverter = 'serializer.name_converter.metadata_aware.'.ContainerBuilder::hash('some.converter');
+
+        yield [null, 'some.converter', $withNull, $withConverter, [new Reference('some.converter')]];
+        yield ['some.converter', null, $withConverter, $withNull, []];
+    }
+
+    /**
+     * @dataProvider provideDifferentNamedSerializerConfigsCases
+     */
+    public function testNamedSerializersCreateNewServices(
+        array $defaultSerializerDefaultContext,
+        ?string $defaultSerializerNameConverter,
+        array $namedSerializerConfig,
+        string $nameConverterId,
+    ) {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('serializer.default_context', $defaultSerializerDefaultContext);
+        $container->setParameter('.serializer.name_converter', $defaultSerializerNameConverter);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => $namedSerializerConfig,
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n')
+            ->addArgument(new Reference('serializer.name_converter.metadata_aware'))
+            ->addTag('serializer.normalizer', ['serializer' => '*'])
+        ;
+        $container->register('e')
+            ->addArgument(new Reference('serializer.name_converter.metadata_aware'))
+            ->addTag('serializer.encoder', ['serializer' => '*'])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertEquals([new Reference('n.api')], $container->getDefinition('serializer.api')->getArgument(0));
+        $this->assertEquals(new Reference($nameConverterId), $container->getDefinition('n.api')->getArgument(0));
+        $this->assertEquals([new Reference('e.api')], $container->getDefinition('serializer.api')->getArgument(1));
+        $this->assertEquals(new Reference($nameConverterId), $container->getDefinition('e.api')->getArgument(0));
+    }
+
+    public static function provideDifferentNamedSerializerConfigsCases(): iterable
+    {
+        yield [
+            ['a' => true, 'b' => 3],
+            null,
+            ['default_context' => ['c' => 3, 'a' => true]],
+            'serializer.name_converter.metadata_aware',
+        ];
+        yield [
+            [],
+            'some.converter',
+            ['name_converter' => null],
+            'serializer.name_converter.metadata_aware.'.ContainerBuilder::hash(null),
+        ];
+        yield [
+            ['a' => true, 'b' => 3],
+            null,
+            ['default_context' => ['c' => 3, 'a' => true], 'name_converter' => 'some.converter'],
+            'serializer.name_converter.metadata_aware.'.ContainerBuilder::hash('some.converter'),
+        ];
+    }
+
+    public function testServicesAreOrderedAccordingToPriorityForNamedSerializers()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => [],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n2')
+            ->addTag('serializer.normalizer', ['serializer' => '*', 'priority' => 100])
+            ->addTag('serializer.encoder', ['serializer' => '*', 'priority' => 100])
+        ;
+        $container->register('n1')
+            ->addTag('serializer.normalizer', ['serializer' => 'api', 'priority' => 200])
+            ->addTag('serializer.encoder', ['serializer' => 'api', 'priority' => 200])
+        ;
+        $container->register('n3')
+            ->addTag('serializer.normalizer', ['serializer' => 'api'])
+            ->addTag('serializer.encoder', ['serializer' => 'api'])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertTrue($container->hasDefinition('serializer.api'));
+        $definition = $container->getDefinition('serializer.api');
+
+        $expected = [
+            new Reference('n1.api'),
+            new Reference('n2.api'),
+            new Reference('n3.api'),
+        ];
+        $this->assertEquals($expected, $definition->getArgument(0));
+        $this->assertEquals($expected, $definition->getArgument(1));
+    }
+
+    public function testBindSerializerDefaultContextToNamedSerializers()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => ['default_context' => $defaultContext = ['enable_max_depth' => true]],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null, []]);
+        $definition = $container->register('n1')
+            ->addTag('serializer.normalizer', ['serializer' => '*'])
+            ->addTag('serializer.encoder', ['serializer' => '*'])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $bindings = $definition->getBindings();
+        $this->assertArrayHasKey('array $defaultContext', $bindings);
+        $this->assertEquals($bindings['array $defaultContext'], new BoundArgument([], false));
+
+        $bindings = $container->getDefinition('n1.api')->getBindings();
+        $this->assertArrayHasKey('array $defaultContext', $bindings);
+        $this->assertEquals($bindings['array $defaultContext'], new BoundArgument($defaultContext, false));
+        $this->assertArrayNotHasKey('$defaultContext', $container->getDefinition('serializer')->getArguments());
+        $this->assertEquals($defaultContext, $container->getDefinition('serializer.api')->getArgument('$defaultContext'));
+    }
+
+    /**
+     * @testWith [{}, {}, {}]
+     *           [{"enable_max_depth": true}, {}, {"enable_max_depth": true}]
+     *           [{}, {".serializer.circular_reference_handler": "foo"}, {"circular_reference_handler": "foo"}]
+     *           [{}, {".serializer.max_depth_handler": "bar"}, {"max_depth_handler": "bar"}]
+     *           [{"enable_max_depth": true}, {".serializer.circular_reference_handler": "foo", ".serializer.max_depth_handler": "bar"}, {"enable_max_depth": true, "circular_reference_handler": "foo", "max_depth_handler": "bar"}]
+     */
+    public function testBindNamedSerializerObjectNormalizerDefaultContext(array $defaultContext, array $parameters, array $context)
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => ['default_context' => $defaultContext],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null, []]);
+        $container->getParameterBag()->add($parameters);
+        $container->register('serializer.normalizer.object')
+            ->setClass(ObjectNormalizer::class)
+            ->addTag('serializer.normalizer', ['serializer' => '*'])
+            ->addTag('serializer.encoder', ['serializer' => '*'])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $bindings = $container->getDefinition('serializer.normalizer.object.api')->getBindings();
+        $this->assertArrayHasKey('array $defaultContext', $bindings);
+        $this->assertEquals($bindings['array $defaultContext'], new BoundArgument($context, false));
+    }
+
+    public function testNamedSerializersAreRegistered()
+    {
+        $container = new ContainerBuilder();
+        $container->setParameter('kernel.debug', false);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => [],
+            'api2' => [],
+        ]);
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n')->addTag('serializer.normalizer', ['serializer' => '*']);
+        $container->register('e')->addTag('serializer.encoder', ['serializer' => '*']);
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $this->assertFalse($container->hasAlias(\sprintf('%s $defaultSerializer', SerializerInterface::class)));
+
+        $this->assertTrue($container->hasDefinition('serializer.api'));
+        $this->assertTrue($container->hasAlias(\sprintf('%s $apiSerializer', SerializerInterface::class)));
+        $this->assertTrue($container->hasDefinition('serializer.api2'));
+        $this->assertTrue($container->hasAlias(\sprintf('%s $api2Serializer', SerializerInterface::class)));
+    }
+
+    public function testNormalizersAndEncodersAreDecoratedAndOrderedWhenCollectingDataForNamedSerializers()
+    {
+        $container = new ContainerBuilder();
+
+        $container->setParameter('kernel.debug', true);
+        $container->setParameter('.serializer.named_serializers', [
+            'api' => ['default_context' => ['enable_max_depth' => true]],
+        ]);
+        $container->register('serializer.data_collector');
+
+        $container->register('serializer')->setArguments([null, null]);
+        $container->register('n')->addTag('serializer.normalizer', ['serializer' => '*']);
+        $container->register('e')->addTag('serializer.encoder', ['serializer' => '*']);
+
+        $container->register('debug.serializer', TraceableSerializer::class)
+            ->setDecoratedService('serializer')
+            ->setArguments([
+                new Reference('debug.serializer.inner'),
+                new Reference('serializer.data_collector'),
+                'default',
+            ])
+        ;
+
+        $serializerPass = new SerializerPass();
+        $serializerPass->process($container);
+
+        $traceableNormalizerDefinition = $container->getDefinition('.debug.serializer.normalizer.n.api');
+        $traceableEncoderDefinition = $container->getDefinition('.debug.serializer.encoder.e.api');
+
+        $traceableSerializerDefinition = $container->getDefinition('debug.serializer.api');
+        $this->assertSame('serializer.api', $traceableSerializerDefinition->getDecoratedService()[0]);
+        $this->assertEquals(new Reference('debug.serializer.api.inner'), $traceableSerializerDefinition->getArgument(0));
+        $this->assertSame('api', $traceableSerializerDefinition->getArgument(2));
+
+        $this->assertEquals(TraceableNormalizer::class, $traceableNormalizerDefinition->getClass());
+        $this->assertEquals(new Reference('n.api'), $traceableNormalizerDefinition->getArgument(0));
+        $this->assertEquals(new Reference('serializer.data_collector'), $traceableNormalizerDefinition->getArgument(1));
+        $this->assertSame('api', $traceableNormalizerDefinition->getArgument(2));
+
+        $this->assertEquals(TraceableEncoder::class, $traceableEncoderDefinition->getClass());
+        $this->assertEquals(new Reference('e.api'), $traceableEncoderDefinition->getArgument(0));
+        $this->assertEquals(new Reference('serializer.data_collector'), $traceableEncoderDefinition->getArgument(1));
+        $this->assertSame('api', $traceableEncoderDefinition->getArgument(2));
     }
 }
diff --git a/Tests/Dummy/DummyClassOne.php b/Tests/Dummy/DummyClassOne.php
index 2b3c94cb8..fc78db51c 100644
--- a/Tests/Dummy/DummyClassOne.php
+++ b/Tests/Dummy/DummyClassOne.php
@@ -16,6 +16,7 @@
 use Symfony\Component\Serializer\Attribute\Ignore;
 use Symfony\Component\Serializer\Attribute\MaxDepth;
 use Symfony\Component\Serializer\Attribute\SerializedName;
+use Symfony\Component\Serializer\Attribute\SerializedPath;
 
 class DummyClassOne
 {
@@ -29,5 +30,6 @@ class DummyClassOne
     )]
     public string $code;
 
+    #[SerializedPath('[data][name]')]
     public string $name;
 }
diff --git a/Tests/Encoder/CsvEncoderTest.php b/Tests/Encoder/CsvEncoderTest.php
index c0be73a8b..048d790b0 100644
--- a/Tests/Encoder/CsvEncoderTest.php
+++ b/Tests/Encoder/CsvEncoderTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Serializer\Tests\Encoder;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Bridge\PhpUnit\ExpectUserDeprecationMessageTrait;
 use Symfony\Component\Serializer\Encoder\CsvEncoder;
 use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 
@@ -20,6 +21,8 @@
  */
 class CsvEncoderTest extends TestCase
 {
+    use ExpectUserDeprecationMessageTrait;
+
     private CsvEncoder $encoder;
 
     protected function setUp(): void
@@ -149,7 +152,6 @@ public function testEncodeCustomSettings()
         $this->encoder = new CsvEncoder([
             CsvEncoder::DELIMITER_KEY => ';',
             CsvEncoder::ENCLOSURE_KEY => "'",
-            CsvEncoder::ESCAPE_CHAR_KEY => '',
             CsvEncoder::KEY_SEPARATOR_KEY => '-',
         ]);
 
@@ -175,7 +177,6 @@ public function testEncodeCustomSettingsPassedInContext()
             , $this->encoder->encode($value, 'csv', [
                 CsvEncoder::DELIMITER_KEY => ';',
                 CsvEncoder::ENCLOSURE_KEY => "'",
-                CsvEncoder::ESCAPE_CHAR_KEY => '',
                 CsvEncoder::KEY_SEPARATOR_KEY => '-',
             ]));
     }
@@ -185,7 +186,6 @@ public function testEncodeCustomSettingsPassedInConstructor()
         $encoder = new CsvEncoder([
             CsvEncoder::DELIMITER_KEY => ';',
             CsvEncoder::ENCLOSURE_KEY => "'",
-            CsvEncoder::ESCAPE_CHAR_KEY => '',
             CsvEncoder::KEY_SEPARATOR_KEY => '-',
         ]);
         $value = ['a' => 'he\'llo', 'c' => ['d' => 'foo']];
@@ -574,7 +574,6 @@ public function testDecodeCustomSettings()
         $this->encoder = new CsvEncoder([
             CsvEncoder::DELIMITER_KEY => ';',
             CsvEncoder::ENCLOSURE_KEY => "'",
-            CsvEncoder::ESCAPE_CHAR_KEY => '',
             CsvEncoder::KEY_SEPARATOR_KEY => '-',
         ]);
 
@@ -596,7 +595,6 @@ public function testDecodeCustomSettingsPassedInContext()
             , 'csv', [
                 CsvEncoder::DELIMITER_KEY => ';',
                 CsvEncoder::ENCLOSURE_KEY => "'",
-                CsvEncoder::ESCAPE_CHAR_KEY => '',
                 CsvEncoder::KEY_SEPARATOR_KEY => '-',
             ]));
     }
@@ -606,7 +604,6 @@ public function testDecodeCustomSettingsPassedInConstructor()
         $encoder = new CsvEncoder([
             CsvEncoder::DELIMITER_KEY => ';',
             CsvEncoder::ENCLOSURE_KEY => "'",
-            CsvEncoder::ESCAPE_CHAR_KEY => '',
             CsvEncoder::KEY_SEPARATOR_KEY => '-',
             CsvEncoder::AS_COLLECTION_KEY => true, // Can be removed in 5.0
         ]);
@@ -710,4 +707,26 @@ public function testEndOfLinePassedInConstructor()
         $encoder = new CsvEncoder([CsvEncoder::END_OF_LINE => "\r\n"]);
         $this->assertSame("foo,bar\r\nhello,test\r\n", $encoder->encode($value, 'csv'));
     }
+
+    /**
+     * @group legacy
+     */
+    public function testPassingNonEmptyEscapeCharIsDeprecated()
+    {
+        $this->expectUserDeprecationMessage('Since symfony/serializer 7.2: Setting the "csv_escape_char" option is deprecated. The option will be removed in 8.0.');
+        $encoder = new CsvEncoder(['csv_escape_char' => '@']);
+
+        $this->assertSame(
+            [[
+                'A, B@"' => 'D',
+                'C' => 'E',
+            ]],
+            $encoder->decode(<<<'CSV'
+                "A, B@"", "C"
+                "D", "E"
+                CSV,
+                'csv'
+            )
+        );
+    }
 }
diff --git a/Tests/Encoder/JsonDecodeTest.php b/Tests/Encoder/JsonDecodeTest.php
index 66cd10114..f336bcd42 100644
--- a/Tests/Encoder/JsonDecodeTest.php
+++ b/Tests/Encoder/JsonDecodeTest.php
@@ -47,11 +47,9 @@ public static function decodeProvider()
         $stdClass = new \stdClass();
         $stdClass->foo = 'bar';
 
-        $assoc = ['foo' => 'bar'];
-
         return [
             ['{"foo": "bar"}', $stdClass, []],
-            ['{"foo": "bar"}', $assoc, ['json_decode_associative' => true]],
+            ['{"foo": "bar"}', ['foo' => 'bar'], ['json_decode_associative' => true]],
         ];
     }
 
diff --git a/Tests/Encoder/JsonEncoderTest.php b/Tests/Encoder/JsonEncoderTest.php
index 1b47684ae..a34e82c6b 100644
--- a/Tests/Encoder/JsonEncoderTest.php
+++ b/Tests/Encoder/JsonEncoderTest.php
@@ -84,12 +84,13 @@ public function testWithDefaultContext()
 
     public function testEncodeNotUtf8WithoutPartialOnError()
     {
-        $this->expectException(UnexpectedValueException::class);
         $arr = [
             'utf8' => 'Hello World!',
             'notUtf8' => "\xb0\xd0\xb5\xd0",
         ];
 
+        $this->expectException(UnexpectedValueException::class);
+
         $this->encoder->encode($arr, 'json');
     }
 
diff --git a/Tests/Encoder/XmlEncoderTest.php b/Tests/Encoder/XmlEncoderTest.php
index 05abf9285..0eb332e80 100644
--- a/Tests/Encoder/XmlEncoderTest.php
+++ b/Tests/Encoder/XmlEncoderTest.php
@@ -39,46 +39,39 @@ protected function setUp(): void
         $this->encoder->setSerializer($serializer);
     }
 
-    public function testEncodeScalar()
+    /**
+     * @dataProvider validEncodeProvider
+     */
+    public function testEncode(string $expected, mixed $data, array $context = [])
     {
-        $obj = new ScalarDummy();
-        $obj->xmlFoo = 'foo';
-
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response>foo</response>'."\n";
-
-        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
+        $this->assertSame($expected, $this->encoder->encode($data, 'xml', $context));
     }
 
-    public function testEncodeArrayObject()
+    /**
+     * @return iterable<array{0: string, 1: mixed, 2?: array}>
+     */
+    public static function validEncodeProvider(): iterable
     {
-        $obj = new \ArrayObject(['foo' => 'bar']);
-
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><foo>bar</foo></response>'."\n";
-
-        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
-    }
-
-    public function testEncodeEmptyArrayObject()
-    {
-        $obj = new \ArrayObject();
+        $obj = new ScalarDummy();
+        $obj->xmlFoo = 'foo';
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response/>'."\n";
+        yield 'encode scalar' => [
+            '<?xml version="1.0"?>'."\n"
+            .'<response>foo</response>'."\n",
+            $obj,
+        ];
 
-        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
-    }
+        yield 'encode array object' => [
+            '<?xml version="1.0"?>'."\n"
+            .'<response><foo>bar</foo></response>'."\n",
+            new \ArrayObject(['foo' => 'bar']),
+        ];
 
-    public function testDocTypeIsNotAllowed()
-    {
-        $this->expectException(UnexpectedValueException::class);
-        $this->expectExceptionMessage('Document types are not allowed.');
-        $this->encoder->decode('<?xml version="1.0"?><!DOCTYPE foo><foo></foo>', 'foo');
-    }
+        yield 'encode empty array object' => [
+            '<?xml version="1.0"?>'."\n".'<response/>'."\n",
+            new \ArrayObject(),
+        ];
 
-    public function testAttributes()
-    {
         $obj = new ScalarDummy();
         $obj->xmlFoo = [
             'foo-bar' => [
@@ -100,7 +93,9 @@ public function testAttributes()
                 '@sring' => 'a',
             ],
         ];
-        $expected = '<?xml version="1.0"?>'."\n".
+
+        yield 'attributes' => [
+            '<?xml version="1.0"?>'."\n".
             '<response>'.
             '<foo-bar id="1" name="Bar"/>'.
             '<Foo Type="test"><Bar>Test</Bar></Foo>'.
@@ -110,12 +105,10 @@ public function testAttributes()
             '<Bar>3</Bar>'.
             '<a>b</a>'.
             '<scalars bool-true="1" bool-false="0" int="3" float="3.4" sring="a"/>'.
-            '</response>'."\n";
-        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
-    }
+            '</response>'."\n",
+            $obj,
+        ];
 
-    public function testElementNameValid()
-    {
         $obj = new ScalarDummy();
         $obj->xmlFoo = [
             'foo-bar' => 'a',
@@ -123,70 +116,54 @@ public function testElementNameValid()
             'föo_bär' => 'a',
         ];
 
-        $expected = '<?xml version="1.0"?>'."\n".
+        yield 'element name valid' => [
+            '<?xml version="1.0"?>'."\n".
             '<response>'.
             '<foo-bar>a</foo-bar>'.
             '<foo_bar>a</foo_bar>'.
             '<föo_bär>a</föo_bär>'.
-            '</response>'."\n";
-
-        $this->assertEquals($expected, $this->encoder->encode($obj, 'xml'));
-    }
+            '</response>'."\n",
+            $obj,
+        ];
 
-    public function testEncodeSimpleXML()
-    {
         $xml = simplexml_load_string('<firstname>Peter</firstname>');
         $array = ['person' => $xml];
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><person><firstname>Peter</firstname></person></response>'."\n";
-
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
-    }
+        yield 'encode SimpleXML' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n",
+            $array,
+        ];
 
-    public function testEncodeXmlAttributes()
-    {
         $xml = simplexml_load_string('<firstname>Peter</firstname>');
         $array = ['person' => $xml];
 
-        $expected = '<?xml version="1.1" encoding="utf-8" standalone="yes"?>'."\n".
-            '<response><person><firstname>Peter</firstname></person></response>'."\n";
-
-        $context = [
-            'xml_version' => '1.1',
-            'xml_encoding' => 'utf-8',
-            'xml_standalone' => true,
+        yield 'encode XML attributes' => [
+            '<?xml version="1.1" encoding="utf-8" standalone="yes"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n",
+            $array,
+            [
+                'xml_version' => '1.1',
+                'xml_encoding' => 'utf-8',
+                'xml_standalone' => true,
+            ],
         ];
 
-        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
-    }
-
-    public function testEncodeRemovingEmptyTags()
-    {
-        $array = ['person' => ['firstname' => 'Peter', 'lastname' => null]];
-
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><person><firstname>Peter</firstname></person></response>'."\n";
-
-        $context = ['remove_empty_tags' => true];
-
-        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
-    }
-
-    public function testEncodeNotRemovingEmptyTags()
-    {
-        $array = ['person' => ['firstname' => 'Peter', 'lastname' => null]];
-
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><person><firstname>Peter</firstname><lastname/></person></response>'."\n";
+        yield 'encode removing empty tags' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname></person></response>'."\n",
+            ['person' => ['firstname' => 'Peter', 'lastname' => null]],
+            ['remove_empty_tags' => true],
+        ];
 
-        $this->assertSame($expected, $this->encoder->encode($array, 'xml'));
-    }
+        yield 'encode not removing empty tags' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><person><firstname>Peter</firstname><lastname/></person></response>'."\n",
+            ['person' => ['firstname' => 'Peter', 'lastname' => null]],
+        ];
 
-    public function testContext()
-    {
-        $array = ['person' => ['name' => 'George Abitbol', 'age' => null]];
-        $expected = <<<'XML'
+        yield 'encode with context' => [
+            <<<'XML'
 <?xml version="1.0"?>
 <response>
   <person>
@@ -195,88 +172,139 @@ public function testContext()
   </person>
 </response>
 
-XML;
-
-        $context = [
-            'xml_format_output' => true,
-            'save_options' => \LIBXML_NOEMPTYTAG,
+XML,
+            ['person' => ['name' => 'George Abitbol', 'age' => null]],
+            [
+                'xml_format_output' => true,
+                'save_options' => \LIBXML_NOEMPTYTAG,
+            ],
         ];
 
-        $this->assertSame($expected, $this->encoder->encode($array, 'xml', $context));
-    }
+        yield 'encode scalar root attributes' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response eye-color="brown">Paul</response>'."\n",
+            [
+                '#' => 'Paul',
+                '@eye-color' => 'brown',
+            ],
+        ];
 
-    public function testEncodeScalarRootAttributes()
-    {
-        $array = [
-            '#' => 'Paul',
-            '@eye-color' => 'brown',
+        yield 'encode root attributes' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response eye-color="brown"><firstname>Paul</firstname></response>'."\n",
+            [
+                'firstname' => 'Paul',
+                '@eye-color' => 'brown',
+            ],
         ];
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response eye-color="brown">Paul</response>'."\n";
+        yield 'encode with CDATA wrapping with default pattern #1' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul & Martha <or Me>]]></firstname></response>'."\n",
+            ['firstname' => 'Paul & Martha <or Me>'],
+        ];
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
-    }
+        yield 'encode with CDATA wrapping with default pattern #2' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><lastname>O\'Donnel</lastname></response>'."\n",
+            ['lastname' => 'O\'Donnel'],
+        ];
 
-    public function testEncodeRootAttributes()
-    {
-        $array = [
-            'firstname' => 'Paul',
-            '@eye-color' => 'brown',
+        yield 'encode with CDATA wrapping with default pattern #3' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul & Martha]]></firstname></response>'."\n",
+            ['firstname' => 'Paul & Martha'],
         ];
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response eye-color="brown"><firstname>Paul</firstname></response>'."\n";
+        yield 'encode with CDATA wrapping with custom pattern #1' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul & Martha <or Me>]]></firstname></response>'."\n",
+            ['firstname' => 'Paul & Martha <or Me>'],
+            ['cdata_wrapping_pattern' => '/[<>&"\']/'],
+        ];
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
-    }
+        yield 'encode with CDATA wrapping with custom pattern #2' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><lastname><![CDATA[O\'Donnel]]></lastname></response>'."\n",
+            ['lastname' => 'O\'Donnel'],
+            ['cdata_wrapping_pattern' => '/[<>&"\']/'],
+        ];
 
-    public function testEncodeCdataWrapping()
-    {
-        $array = [
-            'firstname' => 'Paul & Martha <or Me>',
+        yield 'encode with CDATA wrapping with custom pattern #3' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname>Paul and Martha</firstname></response>'."\n",
+            ['firstname' => 'Paul and Martha'],
+            ['cdata_wrapping_pattern' => '/[<>&"\']/'],
         ];
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><firstname><![CDATA[Paul & Martha <or Me>]]></firstname></response>'."\n";
+        yield 'enable CDATA wrapping' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname><![CDATA[Paul & Martha <or Me>]]></firstname></response>'."\n",
+            ['firstname' => 'Paul & Martha <or Me>'],
+            ['cdata_wrapping' => true],
+        ];
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
-    }
+        yield 'disable CDATA wrapping' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><firstname>Paul &amp; Martha &lt;or Me&gt;</firstname></response>'."\n",
+            ['firstname' => 'Paul & Martha <or Me>'],
+            ['cdata_wrapping' => false],
+        ];
 
-    public function testEnableCdataWrapping()
-    {
-        $array = [
-            'firstname' => 'Paul & Martha <or Me>',
+        yield 'encode scalar with attribute' => [
+            '<?xml version="1.0"?>'."\n".
+            '<response><person eye-color="brown">Peter</person></response>'."\n",
+            ['person' => ['@eye-color' => 'brown', '#' => 'Peter']],
         ];
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><firstname><![CDATA[Paul & Martha <or Me>]]></firstname></response>'."\n";
+        yield 'encode' => [
+            self::getXmlSource(),
+            self::getObject(),
+        ];
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml', ['cdata_wrapping' => true]));
+        yield 'encode with namespace' => [
+            self::getNamespacedXmlSource(),
+            self::getNamespacedArray(),
+        ];
     }
 
-    public function testDisableCdataWrapping()
+    public function testEncodeSerializerXmlRootNodeNameOption()
     {
+        $options = ['xml_root_node_name' => 'test'];
+        $this->encoder = new XmlEncoder();
+        $serializer = new Serializer([], ['xml' => new XmlEncoder()]);
+        $this->encoder->setSerializer($serializer);
+
         $array = [
-            'firstname' => 'Paul & Martha <or Me>',
+            'person' => ['@eye-color' => 'brown', '#' => 'Peter'],
         ];
 
         $expected = '<?xml version="1.0"?>'."\n".
-            '<response><firstname>Paul &amp; Martha &lt;or Me&gt;</firstname></response>'."\n";
+            '<test><person eye-color="brown">Peter</person></test>'."\n";
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml', ['cdata_wrapping' => false]));
+        $this->assertSame($expected, $serializer->serialize($array, 'xml', $options));
     }
 
-    public function testEncodeScalarWithAttribute()
+    public function testEncodeTraversableWhenNormalizable()
     {
-        $array = [
-            'person' => ['@eye-color' => 'brown', '#' => 'Peter'],
-        ];
+        $this->encoder = new XmlEncoder();
+        $serializer = new Serializer([new CustomNormalizer()], ['xml' => new XmlEncoder()]);
+        $this->encoder->setSerializer($serializer);
 
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<response><person eye-color="brown">Peter</person></response>'."\n";
+        $expected = <<<'XML'
+<?xml version="1.0"?>
+<response><foo>normalizedFoo</foo><bar>normalizedBar</bar></response>
+
+XML;
 
-        $this->assertEquals($expected, $this->encoder->encode($array, 'xml'));
+        $this->assertSame($expected, $serializer->serialize(new NormalizableTraversableDummy(), 'xml'));
+    }
+
+    public function testDocTypeIsNotAllowed()
+    {
+        $this->expectException(UnexpectedValueException::class);
+        $this->expectExceptionMessage('Document types are not allowed.');
+        $this->encoder->decode('<?xml version="1.0"?><!DOCTYPE foo><foo></foo>', 'foo');
     }
 
     public function testDecodeScalar()
@@ -284,7 +312,7 @@ public function testDecodeScalar()
         $source = '<?xml version="1.0"?>'."\n".
             '<response>foo</response>'."\n";
 
-        $this->assertEquals('foo', $this->encoder->decode($source, 'xml'));
+        $this->assertSame('foo', $this->encoder->decode($source, 'xml'));
     }
 
     public function testDecodeBigDigitAttributes()
@@ -385,52 +413,10 @@ public function testDoesNotTypeCastStringsStartingWith0()
         $this->assertSame('018', $data['@a']);
     }
 
-    public function testEncode()
-    {
-        $source = $this->getXmlSource();
-        $obj = $this->getObject();
-
-        $this->assertEquals($source, $this->encoder->encode($obj, 'xml'));
-    }
-
-    public function testEncodeWithNamespace()
-    {
-        $source = $this->getNamespacedXmlSource();
-        $array = $this->getNamespacedArray();
-
-        $this->assertEquals($source, $this->encoder->encode($array, 'xml'));
-    }
-
-    public function testEncodeSerializerXmlRootNodeNameOption()
-    {
-        $options = ['xml_root_node_name' => 'test'];
-        $this->encoder = new XmlEncoder();
-        $serializer = new Serializer([], ['xml' => new XmlEncoder()]);
-        $this->encoder->setSerializer($serializer);
-
-        $array = [
-            'person' => ['@eye-color' => 'brown', '#' => 'Peter'],
-        ];
-
-        $expected = '<?xml version="1.0"?>'."\n".
-            '<test><person eye-color="brown">Peter</person></test>'."\n";
-
-        $this->assertEquals($expected, $serializer->serialize($array, 'xml', $options));
-    }
-
-    public function testEncodeTraversableWhenNormalizable()
+    public function testEncodeException()
     {
-        $this->encoder = new XmlEncoder();
-        $serializer = new Serializer([new CustomNormalizer()], ['xml' => new XmlEncoder()]);
-        $this->encoder->setSerializer($serializer);
-
-        $expected = <<<'XML'
-<?xml version="1.0"?>
-<response><foo>normalizedFoo</foo><bar>normalizedBar</bar></response>
-
-XML;
-
-        $this->assertEquals($expected, $serializer->serialize(new NormalizableTraversableDummy(), 'xml'));
+        $this->expectException(NotEncodableValueException::class);
+        $this->encoder->encode('Invalid character: '.\chr(7), 'xml');
     }
 
     public function testDecode()
@@ -625,8 +611,8 @@ public function testDecodeIgnoreComments()
 XML;
 
         $expected = ['person' => [
-          ['firstname' => 'Benjamin', 'lastname' => 'Alexandre'],
-          ['firstname' => 'Damien', 'lastname' => 'Clay'],
+            ['firstname' => 'Benjamin', 'lastname' => 'Alexandre'],
+            ['firstname' => 'Damien', 'lastname' => 'Clay'],
         ]];
 
         $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
@@ -649,8 +635,8 @@ public function testDecodeIgnoreDocumentType()
 </people>
 XML;
         $expected = ['person' => [
-          ['firstname' => 'Benjamin', 'lastname' => 'Alexandre'],
-          ['firstname' => 'Damien', 'lastname' => 'Clay'],
+            ['firstname' => 'Benjamin', 'lastname' => 'Alexandre'],
+            ['firstname' => 'Damien', 'lastname' => 'Clay'],
         ]];
         $this->assertEquals($expected, $this->encoder->decode(
             $source,
@@ -684,8 +670,8 @@ public function testDecodePreserveComments()
         $this->encoder->setSerializer($serializer);
 
         $expected = ['person' => [
-          ['firstname' => 'Benjamin', 'lastname' => 'Alexandre', '#comment' => ' This comment should be decoded. '],
-          ['firstname' => 'Damien', 'lastname' => 'Clay'],
+            ['firstname' => 'Benjamin', 'lastname' => 'Alexandre', '#comment' => ' This comment should be decoded. '],
+            ['firstname' => 'Damien', 'lastname' => 'Clay'],
         ]];
 
         $this->assertEquals($expected, $this->encoder->decode($source, 'xml'));
@@ -770,7 +756,7 @@ public function testDecodeEmptyXml()
         $this->encoder->decode(' ', 'xml');
     }
 
-    protected function getXmlSource()
+    protected static function getXmlSource(): string
     {
         return '<?xml version="1.0"?>'."\n".
             '<response>'.
@@ -783,7 +769,7 @@ protected function getXmlSource()
             '</response>'."\n";
     }
 
-    protected function getNamespacedXmlSource()
+    protected static function getNamespacedXmlSource(): string
     {
         return '<?xml version="1.0"?>'."\n".
             '<response xmlns="http://www.w3.org/2005/Atom" xmlns:app="http://www.w3.org/2007/app" xmlns:media="http://search.yahoo.com/mrss/" xmlns:gd="http://schemas.google.com/g/2005" xmlns:yt="http://gdata.youtube.com/schemas/2007">'.
@@ -796,7 +782,7 @@ protected function getNamespacedXmlSource()
             '</response>'."\n";
     }
 
-    protected function getNamespacedArray()
+    protected static function getNamespacedArray(): array
     {
         return [
             '@xmlns' => 'http://www.w3.org/2005/Atom',
@@ -830,7 +816,10 @@ protected function getNamespacedArray()
         ];
     }
 
-    protected function getObject()
+    /**
+     * @return Dummy
+     */
+    protected static function getObject(): object
     {
         $obj = new Dummy();
         $obj->foo = 'foo';
@@ -980,7 +969,7 @@ private function createXmlEncoderWithDateTimeNormalizer(): XmlEncoder
 
     private function createMockDateTimeNormalizer(): MockObject&NormalizerInterface
     {
-        $mock = $this->createMock(CustomNormalizer::class);
+        $mock = $this->createMock(NormalizerInterface::class);
 
         $mock
             ->expects($this->once())
@@ -1004,14 +993,14 @@ private function createMockDateTimeNormalizer(): MockObject&NormalizerInterface
 
     private function createXmlWithDateTime(): string
     {
-        return sprintf('<?xml version="1.0"?>
+        return \sprintf('<?xml version="1.0"?>
 <response><dateTime>%s</dateTime></response>
 ', $this->exampleDateTimeString);
     }
 
     private function createXmlWithDateTimeField(): string
     {
-        return sprintf('<?xml version="1.0"?>
+        return \sprintf('<?xml version="1.0"?>
 <response><foo dateTime="%s"/></response>
 ', $this->exampleDateTimeString);
     }
diff --git a/Tests/Fixtures/Annotations/AbstractDummy.php b/Tests/Fixtures/Annotations/AbstractDummy.php
deleted file mode 100644
index 96069b0db..000000000
--- a/Tests/Fixtures/Annotations/AbstractDummy.php
+++ /dev/null
@@ -1,31 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
-
-/**
- * @DiscriminatorMap(typeProperty="type", mapping={
- *    "first"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummyFirstChild",
- *    "second"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummySecondChild",
- *    "third"="Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummyThirdChild",
- * })
- */
-abstract class AbstractDummy
-{
-    public $foo;
-
-    public function __construct($foo = null)
-    {
-        $this->foo = $foo;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/AbstractDummyFirstChild.php b/Tests/Fixtures/Annotations/AbstractDummyFirstChild.php
deleted file mode 100644
index 81f15aaf0..000000000
--- a/Tests/Fixtures/Annotations/AbstractDummyFirstChild.php
+++ /dev/null
@@ -1,39 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Tests\Fixtures\DummyFirstChildQuux;
-
-class AbstractDummyFirstChild extends AbstractDummy
-{
-    public $bar;
-
-    /** @var DummyFirstChildQuux|null */
-    public $quux;
-
-    public function __construct($foo = null, $bar = null)
-    {
-        parent::__construct($foo);
-
-        $this->bar = $bar;
-    }
-
-    public function getQuux(): ?DummyFirstChildQuux
-    {
-        return $this->quux;
-    }
-
-    public function setQuux(DummyFirstChildQuux $quux): void
-    {
-        $this->quux = $quux;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/AbstractDummySecondChild.php b/Tests/Fixtures/Annotations/AbstractDummySecondChild.php
deleted file mode 100644
index 4d113066b..000000000
--- a/Tests/Fixtures/Annotations/AbstractDummySecondChild.php
+++ /dev/null
@@ -1,39 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Tests\Fixtures\DummySecondChildQuux;
-
-class AbstractDummySecondChild extends AbstractDummy
-{
-    public $baz;
-
-    /** @var DummySecondChildQuux|null */
-    public $quux;
-
-    public function __construct($foo = null, $baz = null)
-    {
-        parent::__construct($foo);
-
-        $this->baz = $baz;
-    }
-
-    public function getQuux(): ?DummySecondChildQuux
-    {
-        return $this->quux;
-    }
-
-    public function setQuux(DummySecondChildQuux $quux): void
-    {
-        $this->quux = $quux;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/BadMethodContextDummy.php b/Tests/Fixtures/Annotations/BadMethodContextDummy.php
deleted file mode 100644
index 758897b53..000000000
--- a/Tests/Fixtures/Annotations/BadMethodContextDummy.php
+++ /dev/null
@@ -1,28 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Context;
-
-/**
- * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
- */
-class BadMethodContextDummy extends ContextDummyParent
-{
-    /**
-     * @Context({ "foo" = "bar" })
-     */
-    public function badMethod()
-    {
-        return 'bad_method';
-    }
-}
diff --git a/Tests/Fixtures/Annotations/ContextDummy.php b/Tests/Fixtures/Annotations/ContextDummy.php
deleted file mode 100644
index 07fce9ebb..000000000
--- a/Tests/Fixtures/Annotations/ContextDummy.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Context;
-
-/**
- * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
- */
-class ContextDummy extends ContextDummyParent
-{
-    /**
-     * @Context({ "foo" = "value", "bar" = "value", "nested" = {
-     *   "nested_key" = "nested_value",
-     * }, "array": { "first", "second" } })
-     * @Context({ "bar" = "value_for_group_a" }, groups = "a")
-     */
-    public $foo;
-
-    /**
-     * @Context(
-     *     normalizationContext = { "format" = "d/m/Y" },
-     *     denormalizationContext = { "format" = "m-d-Y H:i" },
-     *     groups = {"a", "b"}
-     * )
-     */
-    public $bar;
-
-    /**
-     * @Context(normalizationContext={ "prop" = "dummy_value" })
-     */
-    public $overriddenParentProperty;
-
-    /**
-     * @Context({ "method" = "method_with_context" })
-     */
-    public function getMethodWithContext()
-    {
-        return 'method_with_context';
-    }
-}
diff --git a/Tests/Fixtures/Annotations/ContextDummyParent.php b/Tests/Fixtures/Annotations/ContextDummyParent.php
deleted file mode 100644
index cdb81a778..000000000
--- a/Tests/Fixtures/Annotations/ContextDummyParent.php
+++ /dev/null
@@ -1,30 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Context;
-
-/**
- * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
- */
-class ContextDummyParent
-{
-    /**
-     * @Context(normalizationContext={ "prop" = "dummy_parent_value" })
-     */
-    public $parentProperty;
-
-    /**
-     * @Context(normalizationContext={ "prop" = "dummy_parent_value" })
-     */
-    public $overriddenParentProperty;
-}
diff --git a/Tests/Fixtures/Annotations/ContextDummyPromotedProperties.php b/Tests/Fixtures/Annotations/ContextDummyPromotedProperties.php
deleted file mode 100644
index e42985280..000000000
--- a/Tests/Fixtures/Annotations/ContextDummyPromotedProperties.php
+++ /dev/null
@@ -1,53 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Context;
-
-/**
- * @author Maxime Steinhausser <maxime.steinhausser@gmail.com>
- */
-class ContextDummyPromotedProperties extends ContextDummyParent
-{
-    public function __construct(
-        /**
-         * @Context({ "foo" = "value", "bar" = "value", "nested" = {
-         *   "nested_key" = "nested_value",
-         * }, "array": { "first", "second" } })
-         * @Context({ "bar" = "value_for_group_a" }, groups = "a")
-         */
-        public $foo,
-
-        /**
-         * @Context(
-         *     normalizationContext = { "format" = "d/m/Y" },
-         *     denormalizationContext = { "format" = "m-d-Y H:i" },
-         *     groups = {"a", "b"}
-         * )
-         */
-        public $bar,
-
-        /**
-         * @Context(normalizationContext={ "prop" = "dummy_value" })
-         */
-        public $overriddenParentProperty,
-    ) {
-    }
-
-    /**
-     * @Context({ "method" = "method_with_context" })
-     */
-    public function getMethodWithContext()
-    {
-        return 'method_with_context';
-    }
-}
diff --git a/Tests/Fixtures/Annotations/Entity45016.php b/Tests/Fixtures/Annotations/Entity45016.php
deleted file mode 100644
index 686331e58..000000000
--- a/Tests/Fixtures/Annotations/Entity45016.php
+++ /dev/null
@@ -1,26 +0,0 @@
-<?php
-
-namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Ignore;
-
-class Entity45016
-{
-    /**
-     * @var int
-     */
-    private $id = 1234;
-
-    public function getId(): int
-    {
-        return $this->id;
-    }
-
-    /**
-     * @Ignore()
-     */
-    public function badIgnore(): bool
-    {
-        return true;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/GroupClassDummy.php b/Tests/Fixtures/Annotations/GroupClassDummy.php
deleted file mode 100644
index bbdcfc8a7..000000000
--- a/Tests/Fixtures/Annotations/GroupClassDummy.php
+++ /dev/null
@@ -1,62 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Groups;
-
-/**
- * @Groups({"a"})
- */
-class GroupClassDummy
-{
-    /**
-     * @Groups({"b"})
-     */
-    private $foo;
-
-    /**
-     * @Groups({"c", "d"})
-     */
-    private $bar;
-
-    private $baz;
-
-    public function getFoo()
-    {
-        return $this->foo;
-    }
-
-    public function setFoo($foo): void
-    {
-        $this->foo = $foo;
-    }
-
-    public function getBar()
-    {
-        return $this->bar;
-    }
-
-    public function setBar($bar): void
-    {
-        $this->bar = $bar;
-    }
-
-    public function getBaz()
-    {
-        return $this->baz;
-    }
-
-    public function setBaz($baz): void
-    {
-        $this->baz = $baz;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/GroupDummy.php b/Tests/Fixtures/Annotations/GroupDummy.php
deleted file mode 100644
index 6081511fa..000000000
--- a/Tests/Fixtures/Annotations/GroupDummy.php
+++ /dev/null
@@ -1,97 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Groups;
-use Symfony\Component\Serializer\Tests\Fixtures\ChildOfGroupsAnnotationDummy;
-use Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummyInterface;
-
-/**
- * @author Kévin Dunglas <dunglas@gmail.com>
- */
-class GroupDummy extends GroupDummyParent implements GroupDummyInterface
-{
-    /**
-     * @Groups({"a"})
-     */
-    private $foo;
-    /**
-     * @Groups({"b", "c", "name_converter"})
-     */
-    protected $bar;
-    /**
-     * @ChildOfGroupsAnnotationDummy
-     */
-    protected $quux;
-
-    private $fooBar;
-    private $symfony;
-
-    /**
-     * @Groups({"b"})
-     */
-    public function setBar($bar)
-    {
-        $this->bar = $bar;
-    }
-
-    /**
-     * @Groups({"c"})
-     */
-    public function getBar()
-    {
-        return $this->bar;
-    }
-
-    public function setFoo($foo)
-    {
-        $this->foo = $foo;
-    }
-
-    public function getFoo()
-    {
-        return $this->foo;
-    }
-
-    public function setFooBar($fooBar)
-    {
-        $this->fooBar = $fooBar;
-    }
-
-    /**
-     * @Groups({"a", "b", "name_converter"})
-     */
-    public function isFooBar()
-    {
-        return $this->fooBar;
-    }
-
-    public function setSymfony($symfony)
-    {
-        $this->symfony = $symfony;
-    }
-
-    public function getSymfony()
-    {
-        return $this->symfony;
-    }
-
-    public function getQuux()
-    {
-        return $this->quux;
-    }
-
-    public function setQuux($quux): void
-    {
-        $this->quux = $quux;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/GroupDummyInterface.php b/Tests/Fixtures/Annotations/GroupDummyInterface.php
deleted file mode 100644
index 4341b1385..000000000
--- a/Tests/Fixtures/Annotations/GroupDummyInterface.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Groups;
-
-/**
- * @author Kévin Dunglas <dunglas@gmail.com>
- */
-interface GroupDummyInterface
-{
-    /**
-     * @Groups({"a", "name_converter"})
-     */
-    public function getSymfony();
-}
diff --git a/Tests/Fixtures/Annotations/GroupDummyParent.php b/Tests/Fixtures/Annotations/GroupDummyParent.php
deleted file mode 100644
index ad94c87f3..000000000
--- a/Tests/Fixtures/Annotations/GroupDummyParent.php
+++ /dev/null
@@ -1,49 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Groups;
-
-/**
- * @author Kévin Dunglas <dunglas@gmail.com>
- */
-class GroupDummyParent
-{
-    /**
-     * @Groups({"a"})
-     */
-    private $kevin;
-    private $coopTilleuls;
-
-    public function setKevin($kevin)
-    {
-        $this->kevin = $kevin;
-    }
-
-    public function getKevin()
-    {
-        return $this->kevin;
-    }
-
-    public function setCoopTilleuls($coopTilleuls)
-    {
-        $this->coopTilleuls = $coopTilleuls;
-    }
-
-    /**
-     * @Groups({"a", "b"})
-     */
-    public function getCoopTilleuls()
-    {
-        return $this->coopTilleuls;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/IgnoreDummy.php b/Tests/Fixtures/Annotations/IgnoreDummy.php
deleted file mode 100644
index fe81d0f76..000000000
--- a/Tests/Fixtures/Annotations/IgnoreDummy.php
+++ /dev/null
@@ -1,35 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Ignore;
-
-/**
- * @author Kévin Dunglas <dunglas@gmail.com>
- */
-class IgnoreDummy
-{
-    public $notIgnored;
-    /**
-     * @Ignore()
-     */
-    public $ignored1;
-    private $ignored2;
-
-    /**
-     * @Ignore()
-     */
-    public function getIgnored2()
-    {
-        return $this->ignored2;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetter.php b/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetter.php
deleted file mode 100644
index 257803dfc..000000000
--- a/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetter.php
+++ /dev/null
@@ -1,27 +0,0 @@
-<?php
-
-namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\Ignore;
-
-class IgnoreDummyAdditionalGetter
-{
-    private $myValue;
-
-    /**
-     * @Ignore()
-     */
-    public function getMyValue()
-    {
-        return $this->myValue;
-    }
-
-    public function getExtraValue(string $parameter)
-    {
-        return $parameter;
-    }
-
-    public function setExtraValue2(string $parameter)
-    {
-    }
-}
diff --git a/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php b/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php
deleted file mode 100644
index 2b717c93a..000000000
--- a/Tests/Fixtures/Annotations/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?php
-
-namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
-
-class IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations
-{
-    private $myValue;
-
-    public function getMyValue()
-    {
-        return $this->myValue;
-    }
-
-    public function getExtraValue(string $parameter)
-    {
-        return $parameter;
-    }
-
-    public function setExtraValue2(string $parameter)
-    {
-    }
-}
diff --git a/Tests/Fixtures/Annotations/MaxDepthDummy.php b/Tests/Fixtures/Annotations/MaxDepthDummy.php
deleted file mode 100644
index 4f3044036..000000000
--- a/Tests/Fixtures/Annotations/MaxDepthDummy.php
+++ /dev/null
@@ -1,50 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\MaxDepth;
-
-/**
- * @author Kévin Dunglas <dunglas@gmail.com>
- */
-class MaxDepthDummy
-{
-    /**
-     * @MaxDepth(2)
-     */
-    public $foo;
-
-    public $bar;
-
-    /**
-     * @var self
-     */
-    public $child;
-
-    /**
-     * @MaxDepth(3)
-     */
-    public function getBar()
-    {
-        return $this->bar;
-    }
-
-    public function getChild()
-    {
-        return $this->child;
-    }
-
-    public function getFoo()
-    {
-        return $this->foo;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/SerializedNameDummy.php b/Tests/Fixtures/Annotations/SerializedNameDummy.php
deleted file mode 100644
index b7c6055bc..000000000
--- a/Tests/Fixtures/Annotations/SerializedNameDummy.php
+++ /dev/null
@@ -1,47 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\SerializedName;
-
-/**
- * @author Fabien Bourigault <bourigaultfabien@gmail.com>
- */
-class SerializedNameDummy
-{
-    /**
-     * @SerializedName("baz")
-     */
-    public $foo;
-
-    public $bar;
-
-    public $quux;
-
-    /**
-     * @var self
-     */
-    public $child;
-
-    /**
-     * @SerializedName("qux")
-     */
-    public function getBar()
-    {
-        return $this->bar;
-    }
-
-    public function getChild()
-    {
-        return $this->child;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/SerializedPathDummy.php b/Tests/Fixtures/Annotations/SerializedPathDummy.php
deleted file mode 100644
index 76ee6bfda..000000000
--- a/Tests/Fixtures/Annotations/SerializedPathDummy.php
+++ /dev/null
@@ -1,35 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\SerializedPath;
-
-/**
- * @author Tobias Bönner <tobi@boenner.family>
- */
-class SerializedPathDummy
-{
-    /**
-     * @SerializedPath("[one][two]")
-     */
-    public $three;
-
-    public $seven;
-
-    /**
-     * @SerializedPath("[three][four]")
-     */
-    public function getSeven()
-    {
-        return $this->seven;
-    }
-}
diff --git a/Tests/Fixtures/Annotations/SerializedPathInConstructorDummy.php b/Tests/Fixtures/Annotations/SerializedPathInConstructorDummy.php
deleted file mode 100644
index ebbe2b46e..000000000
--- a/Tests/Fixtures/Annotations/SerializedPathInConstructorDummy.php
+++ /dev/null
@@ -1,25 +0,0 @@
-<?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\Tests\Fixtures\Annotations;
-
-use Symfony\Component\Serializer\Attribute\SerializedPath;
-
-class SerializedPathInConstructorDummy
-{
-    public function __construct(
-        /**
-         * @SerializedPath("[one][two]")
-         */
-        public $three,
-    ) {
-    }
-}
diff --git a/Tests/Fixtures/Attributes/GroupDummy.php b/Tests/Fixtures/Attributes/GroupDummy.php
index 749e841a5..41457d796 100644
--- a/Tests/Fixtures/Attributes/GroupDummy.php
+++ b/Tests/Fixtures/Attributes/GroupDummy.php
@@ -12,7 +12,7 @@
 namespace Symfony\Component\Serializer\Tests\Fixtures\Attributes;
 
 use Symfony\Component\Serializer\Attribute\Groups;
-use Symfony\Component\Serializer\Tests\Fixtures\ChildOfGroupsAnnotationDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\ChildOfGroupsAttributeDummy;
 
 /**
  * @author Kévin Dunglas <dunglas@gmail.com>
@@ -23,7 +23,7 @@ class GroupDummy extends GroupDummyParent implements GroupDummyInterface
     private $foo;
     #[Groups(['b', 'c', 'name_converter'])]
     protected $bar;
-    #[ChildOfGroupsAnnotationDummy]
+    #[ChildOfGroupsAttributeDummy]
     protected $quux;
     private $fooBar;
     private $symfony;
diff --git a/Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php b/Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAttributes.php
similarity index 85%
rename from Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php
rename to Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAttributes.php
index 21abb870b..5d3e8f47f 100644
--- a/Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations.php
+++ b/Tests/Fixtures/Attributes/IgnoreDummyAdditionalGetterWithoutIgnoreAttributes.php
@@ -2,7 +2,7 @@
 
 namespace Symfony\Component\Serializer\Tests\Fixtures\Attributes;
 
-class IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations
+class IgnoreDummyAdditionalGetterWithoutIgnoreAttributes
 {
     private $myValue;
 
diff --git a/Tests/Fixtures/ChildOfGroupsAnnotationDummy.php b/Tests/Fixtures/ChildOfGroupsAttributeDummy.php
similarity index 70%
rename from Tests/Fixtures/ChildOfGroupsAnnotationDummy.php
rename to Tests/Fixtures/ChildOfGroupsAttributeDummy.php
index 210256eed..4fc81fa9d 100644
--- a/Tests/Fixtures/ChildOfGroupsAnnotationDummy.php
+++ b/Tests/Fixtures/ChildOfGroupsAttributeDummy.php
@@ -4,12 +4,8 @@
 
 use Symfony\Component\Serializer\Attribute\Groups;
 
-/**
- * @Annotation
- * @Target({"PROPERTY", "METHOD"})
- */
 #[\Attribute(\Attribute::TARGET_METHOD | \Attribute::TARGET_PROPERTY)]
-final class ChildOfGroupsAnnotationDummy extends Groups
+final class ChildOfGroupsAttributeDummy extends Groups
 {
     public function __construct()
     {
diff --git a/Tests/Fixtures/DummyObjectWithEnumProperty.php b/Tests/Fixtures/DummyObjectWithEnumProperty.php
index f2677195f..70c6cff7b 100644
--- a/Tests/Fixtures/DummyObjectWithEnumProperty.php
+++ b/Tests/Fixtures/DummyObjectWithEnumProperty.php
@@ -2,8 +2,6 @@
 
 namespace Symfony\Component\Serializer\Tests\Fixtures;
 
-use Symfony\Component\Serializer\Tests\Fixtures\StringBackedEnumDummy;
-
 class DummyObjectWithEnumProperty
 {
     public StringBackedEnumDummy $get;
diff --git a/Tests/Fixtures/FormatAndContextAwareNormalizer.php b/Tests/Fixtures/FormatAndContextAwareNormalizer.php
deleted file mode 100644
index 428c618a9..000000000
--- a/Tests/Fixtures/FormatAndContextAwareNormalizer.php
+++ /dev/null
@@ -1,22 +0,0 @@
-<?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\Tests\Fixtures;
-
-use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
-
-class FormatAndContextAwareNormalizer extends ObjectNormalizer
-{
-    protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
-    {
-        return \in_array($attribute, ['foo', 'bar']) && 'foo_and_bar_included' === $format;
-    }
-}
diff --git a/Tests/Fixtures/UpcomingDenormalizerInterface.php b/Tests/Fixtures/UpcomingDenormalizerInterface.php
deleted file mode 100644
index 2efc12bb6..000000000
--- a/Tests/Fixtures/UpcomingDenormalizerInterface.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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\Tests\Fixtures;
-
-use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
-
-// @deprecated remove in 7.0 in favor of direct use of the DenormalizerInterface
-interface UpcomingDenormalizerInterface extends DenormalizerInterface
-{
-    public function getSupportedTypes(?string $format): array;
-}
diff --git a/Tests/Fixtures/UpcomingNormalizerInterface.php b/Tests/Fixtures/UpcomingNormalizerInterface.php
deleted file mode 100644
index 59972bb5e..000000000
--- a/Tests/Fixtures/UpcomingNormalizerInterface.php
+++ /dev/null
@@ -1,20 +0,0 @@
-<?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\Tests\Fixtures;
-
-use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
-
-// @deprecated remove in 7.0 in favor of direct use of the NormalizerInterface
-interface UpcomingNormalizerInterface extends NormalizerInterface
-{
-    public function getSupportedTypes(?string $format): array;
-}
diff --git a/Tests/Mapping/Factory/CacheMetadataFactoryTest.php b/Tests/Mapping/Factory/CacheMetadataFactoryTest.php
index 9525ca605..e18dd707f 100644
--- a/Tests/Mapping/Factory/CacheMetadataFactoryTest.php
+++ b/Tests/Mapping/Factory/CacheMetadataFactoryTest.php
@@ -58,16 +58,17 @@ public function testHasMetadataFor()
 
     public function testInvalidClassThrowsException()
     {
-        $this->expectException(InvalidArgumentException::class);
         $decorated = $this->createMock(ClassMetadataFactoryInterface::class);
         $factory = new CacheClassMetadataFactory($decorated, new ArrayAdapter());
 
+        $this->expectException(InvalidArgumentException::class);
+
         $factory->getMetadataFor('Not\Exist');
     }
 
     public function testAnonymousClass()
     {
-        $anonymousObject = new class() {
+        $anonymousObject = new class {
         };
 
         $metadata = new ClassMetadata($anonymousObject::class);
diff --git a/Tests/Mapping/Factory/ClassMetadataFactoryCompilerTest.php b/Tests/Mapping/Factory/ClassMetadataFactoryCompilerTest.php
index 20b057211..40dcb5015 100644
--- a/Tests/Mapping/Factory/ClassMetadataFactoryCompilerTest.php
+++ b/Tests/Mapping/Factory/ClassMetadataFactoryCompilerTest.php
@@ -27,7 +27,7 @@ final class ClassMetadataFactoryCompilerTest extends TestCase
 
     protected function setUp(): void
     {
-        $this->dumpPath = sys_get_temp_dir().\DIRECTORY_SEPARATOR.'php_serializer_metadata.'.uniqid('CompiledClassMetadataFactory', true).'.php';
+        $this->dumpPath = tempnam(sys_get_temp_dir(), 'sf_serializer_metadata_');
     }
 
     protected function tearDown(): void
diff --git a/Tests/Mapping/Factory/CompiledClassMetadataFactoryTest.php b/Tests/Mapping/Factory/CompiledClassMetadataFactoryTest.php
index 683f445df..ff54fb96b 100644
--- a/Tests/Mapping/Factory/CompiledClassMetadataFactoryTest.php
+++ b/Tests/Mapping/Factory/CompiledClassMetadataFactoryTest.php
@@ -34,19 +34,21 @@ public function testItImplementsClassMetadataFactoryInterface()
 
     public function testItThrowAnExceptionWhenCacheFileIsNotFound()
     {
+        $classMetadataFactory = $this->createMock(ClassMetadataFactoryInterface::class);
+
         $this->expectException(\RuntimeException::class);
         $this->expectExceptionMessageMatches('#File ".*/Fixtures/not-found-serializer.class.metadata.php" could not be found.#');
 
-        $classMetadataFactory = $this->createMock(ClassMetadataFactoryInterface::class);
         new CompiledClassMetadataFactory(__DIR__.'/../../Fixtures/not-found-serializer.class.metadata.php', $classMetadataFactory);
     }
 
     public function testItThrowAnExceptionWhenMetadataIsNotOfTypeArray()
     {
+        $classMetadataFactory = $this->createMock(ClassMetadataFactoryInterface::class);
+
         $this->expectException(\RuntimeException::class);
         $this->expectExceptionMessage('Compiled metadata must be of the type array, object given.');
 
-        $classMetadataFactory = $this->createMock(ClassMetadataFactoryInterface::class);
         new CompiledClassMetadataFactory(__DIR__.'/../../Fixtures/object-metadata.php', $classMetadataFactory);
     }
 
diff --git a/Tests/Mapping/Loader/AnnotationLoaderWithDoctrineAnnotationsTest.php b/Tests/Mapping/Loader/AnnotationLoaderWithDoctrineAnnotationsTest.php
deleted file mode 100644
index 9d786bde5..000000000
--- a/Tests/Mapping/Loader/AnnotationLoaderWithDoctrineAnnotationsTest.php
+++ /dev/null
@@ -1,171 +0,0 @@
-<?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\Tests\Mapping\Loader;
-
-use Doctrine\Common\Annotations\AnnotationReader;
-use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
-use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
-use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
-
-/**
- * @group legacy
- */
-class AnnotationLoaderWithDoctrineAnnotationsTest extends AttributeLoaderTestCase
-{
-    use ExpectDeprecationTrait;
-
-    protected function setUp(): void
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Passing a "Doctrine\Common\Annotations\AnnotationReader" instance as argument 1 to "Symfony\Component\Serializer\Mapping\Loader\AttributeLoader::__construct()" is deprecated, pass null or omit the parameter instead.');
-
-        parent::setUp();
-    }
-
-    public function testLoadClassMetadataReturnsTrueIfSuccessful()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$bar" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$quux" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::setBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::getBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::isFooBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadClassMetadataReturnsTrueIfSuccessful();
-    }
-
-    public function testLoadGroups()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$bar" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$quux" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::setBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::getBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::isFooBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadGroups();
-    }
-
-    public function testLoadDiscriminatorMap()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Class "Symfony\Component\Serializer\Tests\Fixtures\Annotations\AbstractDummy" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadDiscriminatorMap();
-    }
-
-    public function testLoadMaxDepth()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\MaxDepthDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\MaxDepthDummy::getBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadMaxDepth();
-    }
-
-    public function testLoadSerializedName()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\SerializedNameDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\SerializedNameDummy::getBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadSerializedName();
-    }
-
-    public function testLoadSerializedPath()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\SerializedPathDummy::$three" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\SerializedPathDummy::getSeven()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadSerializedPath();
-    }
-
-    public function testLoadSerializedPathInConstructor()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\SerializedPathInConstructorDummy::$three" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadSerializedPathInConstructor();
-    }
-
-    public function testLoadClassMetadataAndMerge()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummyParent::$kevin" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummyParent::getCoopTilleuls()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$bar" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::$quux" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::setBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::getBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\GroupDummy::isFooBar()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadClassMetadataAndMerge();
-    }
-
-    public function testLoadIgnore()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\IgnoreDummy::$ignored1" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\IgnoreDummy::getIgnored2()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadIgnore();
-    }
-
-    public function testLoadContexts()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyParent::$parentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyParent::$overriddenParentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummy::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummy::$bar" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummy::$overriddenParentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummy::getMethodWithContext()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadContexts();
-    }
-
-    public function testLoadContextsPropertiesPromoted()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyParent::$parentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyParent::$overriddenParentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyPromotedProperties::$foo" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyPromotedProperties::$bar" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Property "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyPromotedProperties::$overriddenParentProperty" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\ContextDummyPromotedProperties::getMethodWithContext()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testLoadContextsPropertiesPromoted();
-    }
-
-    public function testThrowsOnContextOnInvalidMethod()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\BadMethodContextDummy::badMethod()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testThrowsOnContextOnInvalidMethod();
-    }
-
-    public function testCanHandleUnrelatedIgnoredMethods()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\Entity45016::badIgnore()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testCanHandleUnrelatedIgnoredMethods();
-    }
-
-    public function testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsUsed()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Tests\Fixtures\Annotations\IgnoreDummyAdditionalGetter::getMyValue()" uses Doctrine Annotations to configure serialization, which is deprecated. Use PHP attributes instead.');
-
-        parent::testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsUsed();
-    }
-
-    protected function createLoader(): AttributeLoader
-    {
-        return new AnnotationLoader(new AnnotationReader());
-    }
-
-    protected function getNamespace(): string
-    {
-        return 'Symfony\Component\Serializer\Tests\Fixtures\Annotations';
-    }
-}
diff --git a/Tests/Mapping/Loader/AttributeLoaderTestCase.php b/Tests/Mapping/Loader/AttributeLoaderTest.php
similarity index 62%
rename from Tests/Mapping/Loader/AttributeLoaderTestCase.php
rename to Tests/Mapping/Loader/AttributeLoaderTest.php
index 73cb674c2..2af244a6f 100644
--- a/Tests/Mapping/Loader/AttributeLoaderTestCase.php
+++ b/Tests/Mapping/Loader/AttributeLoaderTest.php
@@ -12,32 +12,48 @@
 namespace Symfony\Component\Serializer\Tests\Mapping\Loader;
 
 use PHPUnit\Framework\TestCase;
-use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
 use Symfony\Component\PropertyAccess\PropertyPath;
 use Symfony\Component\Serializer\Exception\MappingException;
 use Symfony\Component\Serializer\Mapping\AttributeMetadata;
 use Symfony\Component\Serializer\Mapping\ClassDiscriminatorMapping;
 use Symfony\Component\Serializer\Mapping\ClassMetadata;
-use Symfony\Component\Serializer\Mapping\Loader\AnnotationLoader;
 use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
 use Symfony\Component\Serializer\Mapping\Loader\LoaderInterface;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\AbstractDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\AbstractDummyFirstChild;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\AbstractDummySecondChild;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\AbstractDummyThirdChild;
 use Symfony\Component\Serializer\Tests\Fixtures\Attributes\AccessorishGetters;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\BadAttributeDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\BadMethodContextDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\ContextDummyParent;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\ContextDummyPromotedProperties;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\Entity45016;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\GroupClassDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\GroupDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\GroupDummyParent;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\IgnoreDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\IgnoreDummyAdditionalGetter;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\IgnoreDummyAdditionalGetterWithoutIgnoreAttributes;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\MaxDepthDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\SerializedNameDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\SerializedPathDummy;
+use Symfony\Component\Serializer\Tests\Fixtures\Attributes\SerializedPathInConstructorDummy;
 use Symfony\Component\Serializer\Tests\Mapping\Loader\Features\ContextMappingTestTrait;
 use Symfony\Component\Serializer\Tests\Mapping\TestClassMetadataFactory;
 
 /**
  * @author Kévin Dunglas <dunglas@gmail.com>
  */
-abstract class AttributeLoaderTestCase extends TestCase
+class AttributeLoaderTest extends TestCase
 {
     use ContextMappingTestTrait;
-    use ExpectDeprecationTrait;
 
-    protected AnnotationLoader $loader;
+    protected AttributeLoader $loader;
 
     protected function setUp(): void
     {
-        $this->loader = $this->createLoader();
+        $this->loader = new AttributeLoader();
     }
 
     public function testInterface()
@@ -47,28 +63,28 @@ public function testInterface()
 
     public function testLoadClassMetadataReturnsTrueIfSuccessful()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\GroupDummy');
+        $classMetadata = new ClassMetadata(GroupDummy::class);
 
         $this->assertTrue($this->loader->loadClassMetadata($classMetadata));
     }
 
     public function testLoadGroups()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\GroupDummy');
+        $classMetadata = new ClassMetadata(GroupDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
-        $this->assertEquals(TestClassMetadataFactory::createClassMetadata($this->getNamespace()), $classMetadata);
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\Attributes'), $classMetadata);
     }
 
     public function testLoadDiscriminatorMap()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\AbstractDummy');
+        $classMetadata = new ClassMetadata(AbstractDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
-        $expected = new ClassMetadata($this->getNamespace().'\AbstractDummy', new ClassDiscriminatorMapping('type', [
-            'first' => $this->getNamespace().'\AbstractDummyFirstChild',
-            'second' => $this->getNamespace().'\AbstractDummySecondChild',
-            'third' => $this->getNamespace().'\AbstractDummyThirdChild',
+        $expected = new ClassMetadata(AbstractDummy::class, new ClassDiscriminatorMapping('type', [
+            'first' => AbstractDummyFirstChild::class,
+            'second' => AbstractDummySecondChild::class,
+            'third' => AbstractDummyThirdChild::class,
         ]));
 
         $expected->addAttributeMetadata(new AttributeMetadata('foo'));
@@ -79,7 +95,7 @@ public function testLoadDiscriminatorMap()
 
     public function testLoadMaxDepth()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\MaxDepthDummy');
+        $classMetadata = new ClassMetadata(MaxDepthDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -89,7 +105,7 @@ public function testLoadMaxDepth()
 
     public function testLoadSerializedName()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\SerializedNameDummy');
+        $classMetadata = new ClassMetadata(SerializedNameDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -99,7 +115,7 @@ public function testLoadSerializedName()
 
     public function testLoadSerializedPath()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\SerializedPathDummy');
+        $classMetadata = new ClassMetadata(SerializedPathDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -109,7 +125,7 @@ public function testLoadSerializedPath()
 
     public function testLoadSerializedPathInConstructor()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\SerializedPathInConstructorDummy');
+        $classMetadata = new ClassMetadata(SerializedPathInConstructorDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -118,20 +134,20 @@ public function testLoadSerializedPathInConstructor()
 
     public function testLoadClassMetadataAndMerge()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\GroupDummy');
-        $parentClassMetadata = new ClassMetadata($this->getNamespace().'\GroupDummyParent');
+        $classMetadata = new ClassMetadata(GroupDummy::class);
+        $parentClassMetadata = new ClassMetadata(GroupDummyParent::class);
 
         $this->loader->loadClassMetadata($parentClassMetadata);
         $classMetadata->merge($parentClassMetadata);
 
         $this->loader->loadClassMetadata($classMetadata);
 
-        $this->assertEquals(TestClassMetadataFactory::createClassMetadata($this->getNamespace(), true), $classMetadata);
+        $this->assertEquals(TestClassMetadataFactory::createClassMetadata('Symfony\Component\Serializer\Tests\Fixtures\Attributes', true), $classMetadata);
     }
 
     public function testLoadIgnore()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\IgnoreDummy');
+        $classMetadata = new ClassMetadata(IgnoreDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -139,35 +155,26 @@ public function testLoadIgnore()
         $this->assertTrue($attributesMetadata['ignored2']->isIgnored());
     }
 
-    public function testLoadContexts()
-    {
-        $this->assertLoadedContexts($this->getNamespace().'\ContextDummy', $this->getNamespace().'\ContextDummyParent');
-    }
-
     public function testLoadContextsPropertiesPromoted()
     {
-        $this->assertLoadedContexts($this->getNamespace().'\ContextDummyPromotedProperties', $this->getNamespace().'\ContextDummyParent');
+        $this->assertLoadedContexts(ContextDummyPromotedProperties::class, ContextDummyParent::class);
     }
 
     public function testThrowsOnContextOnInvalidMethod()
     {
-        $class = $this->getNamespace().'\BadMethodContextDummy';
-
         $this->expectException(MappingException::class);
-        $this->expectExceptionMessage(sprintf('Context on "%s::badMethod()" cannot be added', $class));
+        $this->expectExceptionMessage(\sprintf('Context on "%s::badMethod()" cannot be added', BadMethodContextDummy::class));
 
         $loader = $this->getLoaderForContextMapping();
 
-        $classMetadata = new ClassMetadata($class);
+        $classMetadata = new ClassMetadata(BadMethodContextDummy::class);
 
         $loader->loadClassMetadata($classMetadata);
     }
 
     public function testCanHandleUnrelatedIgnoredMethods()
     {
-        $class = $this->getNamespace().'\Entity45016';
-
-        $metadata = new ClassMetadata($class);
+        $metadata = new ClassMetadata(Entity45016::class);
         $loader = $this->getLoaderForContextMapping();
 
         $loader->loadClassMetadata($metadata);
@@ -175,9 +182,9 @@ public function testCanHandleUnrelatedIgnoredMethods()
         $this->assertSame(['id'], array_keys($metadata->getAttributesMetadata()));
     }
 
-    public function testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsUsed()
+    public function testIgnoreGetterWithRequiredParameterIfIgnoreAttributeIsUsed()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\IgnoreDummyAdditionalGetter');
+        $classMetadata = new ClassMetadata(IgnoreDummyAdditionalGetter::class);
         $this->getLoaderForContextMapping()->loadClassMetadata($classMetadata);
 
         $attributes = $classMetadata->getAttributesMetadata();
@@ -185,9 +192,9 @@ public function testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsUsed()
         self::assertArrayHasKey('extraValue2', $attributes);
     }
 
-    public function testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsNotUsed()
+    public function testIgnoreGetterWithRequiredParameterIfIgnoreAttributeIsNotUsed()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\IgnoreDummyAdditionalGetterWithoutIgnoreAnnotations');
+        $classMetadata = new ClassMetadata(IgnoreDummyAdditionalGetterWithoutIgnoreAttributes::class);
         $this->getLoaderForContextMapping()->loadClassMetadata($classMetadata);
 
         $attributes = $classMetadata->getAttributesMetadata();
@@ -197,7 +204,7 @@ public function testIgnoreGetterWithRequiredParameterIfIgnoreAnnotationIsNotUsed
 
     public function testLoadGroupsOnClass()
     {
-        $classMetadata = new ClassMetadata($this->getNamespace().'\GroupClassDummy');
+        $classMetadata = new ClassMetadata(GroupClassDummy::class);
         $this->loader->loadClassMetadata($classMetadata);
 
         $attributesMetadata = $classMetadata->getAttributesMetadata();
@@ -213,6 +220,16 @@ public function testLoadGroupsOnClass()
         self::assertSame(['a'], $attributesMetadata['baz']->getGroups());
     }
 
+    public function testLoadWithInvalidAttribute()
+    {
+        $this->expectException(MappingException::class);
+        $this->expectExceptionMessage('Could not instantiate attribute "Symfony\Component\Serializer\Attribute\Groups" on "Symfony\Component\Serializer\Tests\Fixtures\Attributes\BadAttributeDummy::myMethod()".');
+
+        $classMetadata = new ClassMetadata(BadAttributeDummy::class);
+
+        $this->loader->loadClassMetadata($classMetadata);
+    }
+
     public function testIgnoresAccessorishGetters()
     {
         $classMetadata = new ClassMetadata(AccessorishGetters::class);
@@ -229,20 +246,7 @@ public function testIgnoresAccessorishGetters()
         self::assertArrayNotHasKey('h', $attributesMetadata);
     }
 
-    /**
-     * @group legacy
-     */
-    public function testExpectedDeprecationOnLoadAnnotationsCall()
-    {
-        $this->expectDeprecation('Since symfony/serializer 6.4: Method "Symfony\Component\Serializer\Mapping\Loader\AttributeLoader::loadAnnotations()" is deprecated without replacement.');
-        $this->loader->loadAnnotations(new \ReflectionClass(\stdClass::class));
-    }
-
-    abstract protected function createLoader(): AttributeLoader;
-
-    abstract protected function getNamespace(): string;
-
-    protected function getLoaderForContextMapping(): LoaderInterface
+    protected function getLoaderForContextMapping(): AttributeLoader
     {
         return $this->loader;
     }
diff --git a/Tests/Mapping/Loader/AttributeLoaderWithAttributesTest.php b/Tests/Mapping/Loader/AttributeLoaderWithAttributesTest.php
deleted file mode 100644
index 6f14d2fc0..000000000
--- a/Tests/Mapping/Loader/AttributeLoaderWithAttributesTest.php
+++ /dev/null
@@ -1,39 +0,0 @@
-<?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\Tests\Mapping\Loader;
-
-use Symfony\Component\Serializer\Exception\MappingException;
-use Symfony\Component\Serializer\Mapping\ClassMetadata;
-use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
-
-class AttributeLoaderWithAttributesTest extends AttributeLoaderTestCase
-{
-    protected function createLoader(): AttributeLoader
-    {
-        return new AttributeLoader();
-    }
-
-    protected function getNamespace(): string
-    {
-        return 'Symfony\Component\Serializer\Tests\Fixtures\Attributes';
-    }
-
-    public function testLoadWithInvalidAttribute()
-    {
-        $this->expectException(MappingException::class);
-        $this->expectExceptionMessage('Could not instantiate attribute "Symfony\Component\Serializer\Attribute\Groups" on "Symfony\Component\Serializer\Tests\Fixtures\Attributes\BadAttributeDummy::myMethod()".');
-
-        $classMetadata = new ClassMetadata($this->getNamespace().'\BadAttributeDummy');
-
-        $this->loader->loadClassMetadata($classMetadata);
-    }
-}
diff --git a/Tests/Mapping/Loader/YamlFileLoaderTest.php b/Tests/Mapping/Loader/YamlFileLoaderTest.php
index ea81a9d8a..48e95aecd 100644
--- a/Tests/Mapping/Loader/YamlFileLoaderTest.php
+++ b/Tests/Mapping/Loader/YamlFileLoaderTest.php
@@ -65,8 +65,10 @@ public function testLoadClassMetadataReturnsFalseWhenEmpty()
 
     public function testLoadClassMetadataReturnsThrowsInvalidMapping()
     {
-        $this->expectException(MappingException::class);
         $loader = new YamlFileLoader(__DIR__.'/../../Fixtures/invalid-mapping.yml');
+
+        $this->expectException(MappingException::class);
+
         $loader->loadClassMetadata($this->metadata);
     }
 
diff --git a/Tests/NameConverter/CamelCaseToSnakeCaseNameConverterTest.php b/Tests/NameConverter/CamelCaseToSnakeCaseNameConverterTest.php
index e4d419e45..d1edc2325 100644
--- a/Tests/NameConverter/CamelCaseToSnakeCaseNameConverterTest.php
+++ b/Tests/NameConverter/CamelCaseToSnakeCaseNameConverterTest.php
@@ -12,11 +12,13 @@
 namespace Symfony\Component\Serializer\Tests\NameConverter;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Exception\UnexpectedPropertyException;
 use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
 use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
 
 /**
  * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Aurélien Pillevesse <aurelienpillevesse@hotmail.fr>
  */
 class CamelCaseToSnakeCaseNameConverterTest extends TestCase
 {
@@ -55,4 +57,20 @@ public static function attributeProvider()
             ['this_is_a_test', 'ThisIsATest', false],
         ];
     }
+
+    public function testDenormalizeWithContext()
+    {
+        $nameConverter = new CamelCaseToSnakeCaseNameConverter(null, true);
+        $denormalizedValue = $nameConverter->denormalize('last_name', null, null, [CamelCaseToSnakeCaseNameConverter::REQUIRE_SNAKE_CASE_PROPERTIES => true]);
+
+        $this->assertSame('lastName', $denormalizedValue);
+    }
+
+    public function testErrorDenormalizeWithContext()
+    {
+        $nameConverter = new CamelCaseToSnakeCaseNameConverter(null, true);
+
+        $this->expectException(UnexpectedPropertyException::class);
+        $nameConverter->denormalize('lastName', null, null, [CamelCaseToSnakeCaseNameConverter::REQUIRE_SNAKE_CASE_PROPERTIES => true]);
+    }
 }
diff --git a/Tests/NameConverter/SnakeCaseToCamelCaseNameConverterTest.php b/Tests/NameConverter/SnakeCaseToCamelCaseNameConverterTest.php
new file mode 100644
index 000000000..2d2799e2c
--- /dev/null
+++ b/Tests/NameConverter/SnakeCaseToCamelCaseNameConverterTest.php
@@ -0,0 +1,64 @@
+<?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\Tests\NameConverter;
+
+use PHPUnit\Framework\TestCase;
+use Symfony\Component\Serializer\Exception\UnexpectedPropertyException;
+use Symfony\Component\Serializer\NameConverter\NameConverterInterface;
+use Symfony\Component\Serializer\NameConverter\SnakeCaseToCamelCaseNameConverter;
+
+/**
+ * @author Kévin Dunglas <dunglas@gmail.com>
+ * @author Aurélien Pillevesse <aurelienpillevesse@hotmail.fr>
+ */
+class SnakeCaseToCamelCaseNameConverterTest extends TestCase
+{
+    public function testInterface()
+    {
+        $attributeMetadata = new SnakeCaseToCamelCaseNameConverter();
+        $this->assertInstanceOf(NameConverterInterface::class, $attributeMetadata);
+    }
+
+    /**
+     * @dataProvider Symfony\Component\Serializer\Tests\NameConverter\CamelCaseToSnakeCaseNameConverterTest::attributeProvider
+     */
+    public function testNormalize($underscored, $camelCased, $useLowerCamelCase)
+    {
+        $nameConverter = new SnakeCaseToCamelCaseNameConverter(null, $useLowerCamelCase);
+        $this->assertEquals($camelCased, $nameConverter->normalize($underscored));
+    }
+
+    /**
+     * @dataProvider Symfony\Component\Serializer\Tests\NameConverter\CamelCaseToSnakeCaseNameConverterTest::attributeProvider
+     */
+    public function testDenormalize($underscored, $camelCased, $useLowerCamelCase)
+    {
+        $nameConverter = new SnakeCaseToCamelCaseNameConverter(null, $useLowerCamelCase);
+        $this->assertEquals($underscored, $nameConverter->denormalize($camelCased));
+    }
+
+    public function testDenormalizeWithContext()
+    {
+        $nameConverter = new SnakeCaseToCamelCaseNameConverter(null, true);
+        $denormalizedValue = $nameConverter->denormalize('lastName', null, null, [SnakeCaseToCamelCaseNameConverter::REQUIRE_CAMEL_CASE_PROPERTIES => true]);
+
+        $this->assertSame('last_name', $denormalizedValue);
+    }
+
+    public function testErrorDenormalizeWithContext()
+    {
+        $nameConverter = new SnakeCaseToCamelCaseNameConverter(null, true);
+
+        $this->expectException(UnexpectedPropertyException::class);
+        $nameConverter->denormalize('last_name', null, null, [SnakeCaseToCamelCaseNameConverter::REQUIRE_CAMEL_CASE_PROPERTIES => true]);
+    }
+}
diff --git a/Tests/Normalizer/AbstractNormalizerTest.php b/Tests/Normalizer/AbstractNormalizerTest.php
index 4c1e76d86..74ca3d6d6 100644
--- a/Tests/Normalizer/AbstractNormalizerTest.php
+++ b/Tests/Normalizer/AbstractNormalizerTest.php
@@ -271,13 +271,13 @@ public function testVariadicConstructorDenormalization()
     public static function getNormalizerWithCustomNameConverter()
     {
         $extractor = new PhpDocExtractor();
-        $nameConverter = new class() implements NameConverterInterface {
-            public function normalize(string $propertyName): string
+        $nameConverter = new class implements NameConverterInterface {
+            public function normalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
             {
                 return ucfirst($propertyName);
             }
 
-            public function denormalize(string $propertyName): string
+            public function denormalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
             {
                 return lcfirst($propertyName);
             }
@@ -303,9 +303,6 @@ public function testIgnore()
         $this->assertSame([], $normalizer->normalize($dummy));
     }
 
-    /**
-     * @requires PHP 8.1.2
-     */
     public function testDenormalizeWhenObjectNotInstantiable()
     {
         $this->expectException(NotNormalizableValueException::class);
diff --git a/Tests/Normalizer/AbstractObjectNormalizerTest.php b/Tests/Normalizer/AbstractObjectNormalizerTest.php
index 0cca05db3..270b65f33 100644
--- a/Tests/Normalizer/AbstractObjectNormalizerTest.php
+++ b/Tests/Normalizer/AbstractObjectNormalizerTest.php
@@ -13,9 +13,11 @@
 
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
+use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
+use Symfony\Component\PropertyInfo\PropertyDocBlockExtractorInterface;
 use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
-use Symfony\Component\PropertyInfo\Type;
+use Symfony\Component\PropertyInfo\Type as LegacyType;
 use Symfony\Component\Serializer\Attribute\Context;
 use Symfony\Component\Serializer\Attribute\DiscriminatorMap;
 use Symfony\Component\Serializer\Attribute\SerializedName;
@@ -37,6 +39,7 @@
 use Symfony\Component\Serializer\NameConverter\MetadataAwareNameConverter;
 use Symfony\Component\Serializer\Normalizer\AbstractNormalizer;
 use Symfony\Component\Serializer\Normalizer\AbstractObjectNormalizer;
+use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
 use Symfony\Component\Serializer\Normalizer\BackedEnumNormalizer;
 use Symfony\Component\Serializer\Normalizer\CustomNormalizer;
 use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
@@ -56,6 +59,7 @@
 use Symfony\Component\Serializer\Tests\Fixtures\DummyWithObjectOrNull;
 use Symfony\Component\Serializer\Tests\Fixtures\DummyWithStringObject;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\ObjectDummyWithContextAttribute;
+use Symfony\Component\TypeInfo\Type;
 
 class AbstractObjectNormalizerTest extends TestCase
 {
@@ -82,10 +86,12 @@ public function testInstantiateObjectDenormalizer()
 
     public function testDenormalizeWithExtraAttribute()
     {
-        $this->expectException(ExtraAttributesException::class);
-        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo" is unknown).');
         $factory = new ClassMetadataFactory(new AttributeLoader());
         $normalizer = new AbstractObjectNormalizerDummy($factory);
+
+        $this->expectException(ExtraAttributesException::class);
+        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo" is unknown).');
+
         $normalizer->denormalize(
             ['fooFoo' => 'foo'],
             Dummy::class,
@@ -96,10 +102,12 @@ public function testDenormalizeWithExtraAttribute()
 
     public function testDenormalizeWithExtraAttributes()
     {
-        $this->expectException(ExtraAttributesException::class);
-        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).');
         $factory = new ClassMetadataFactory(new AttributeLoader());
         $normalizer = new AbstractObjectNormalizerDummy($factory);
+
+        $this->expectException(ExtraAttributesException::class);
+        $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).');
+
         $normalizer->denormalize(
             ['fooFoo' => 'foo', 'fooBar' => 'bar'],
             Dummy::class,
@@ -110,9 +118,11 @@ public function testDenormalizeWithExtraAttributes()
 
     public function testDenormalizeWithExtraAttributesAndNoGroupsWithMetadataFactory()
     {
+        $normalizer = new AbstractObjectNormalizerWithMetadata();
+
         $this->expectException(ExtraAttributesException::class);
         $this->expectExceptionMessage('Extra attributes are not allowed ("fooFoo", "fooBar" are unknown).');
-        $normalizer = new AbstractObjectNormalizerWithMetadata();
+
         $normalizer->denormalize(
             ['fooFoo' => 'foo', 'fooBar' => 'bar', 'bar' => 'bar'],
             Dummy::class,
@@ -134,9 +144,11 @@ public function testDenormalizePlainObject()
 
     public function testDenormalizeWithDuplicateNestedAttributes()
     {
+        $normalizer = new AbstractObjectNormalizerWithMetadata();
+
         $this->expectException(LogicException::class);
         $this->expectExceptionMessage('Duplicate serialized path: "one,two,three" used for properties "foo" and "bar".');
-        $normalizer = new AbstractObjectNormalizerWithMetadata();
+
         $normalizer->denormalize([], DuplicateValueNestedDummy::class, 'any');
     }
 
@@ -204,8 +216,6 @@ public function testDenormalizeWithNestedAttributes()
 
     public function testDenormalizeWithNestedAttributesDuplicateKeys()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('Duplicate values for key "quux" found. One value is set via the SerializedPath attribute: "one->four", the other one is set via the SerializedName attribute: "notquux".');
         $normalizer = new AbstractObjectNormalizerWithMetadata();
         $data = [
             'one' => [
@@ -213,6 +223,10 @@ public function testDenormalizeWithNestedAttributesDuplicateKeys()
             ],
             'quux' => 'notquux',
         ];
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Duplicate values for key "quux" found. One value is set via the SerializedPath attribute: "one->four", the other one is set via the SerializedName attribute: "notquux".');
+
         $normalizer->denormalize($data, DuplicateKeyNestedDummy::class, 'any');
     }
 
@@ -265,25 +279,29 @@ public function testDenormalizeWithNestedAttributesInConstructorAndDiscriminator
 
     public function testNormalizeWithNestedAttributesMixingArrayTypes()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('The element you are trying to set is already populated: "[one][two]"');
         $foobar = new AlreadyPopulatedNestedDummy();
         $foobar->foo = 'foo';
         $foobar->bar = 'bar';
         $classMetadataFactory = new ClassMetadataFactory(new AttributeLoader());
         $normalizer = new ObjectNormalizer($classMetadataFactory, new MetadataAwareNameConverter($classMetadataFactory));
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('The element you are trying to set is already populated: "[one][two]"');
+
         $normalizer->normalize($foobar, 'any');
     }
 
     public function testNormalizeWithNestedAttributesElementAlreadySet()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('The element you are trying to set is already populated: "[one][two][three]"');
         $foobar = new DuplicateValueNestedDummy();
         $foobar->foo = 'foo';
         $foobar->bar = 'bar';
         $classMetadataFactory = new ClassMetadataFactory(new AttributeLoader());
         $normalizer = new ObjectNormalizer($classMetadataFactory, new MetadataAwareNameConverter($classMetadataFactory));
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('The element you are trying to set is already populated: "[one][two][three]"');
+
         $normalizer->normalize($foobar, 'any');
     }
 
@@ -419,11 +437,20 @@ public function testDenormalizeCollectionDecodedFromXmlWithTwoChildren()
     private function getDenormalizerForDummyCollection()
     {
         $extractor = $this->createMock(PhpDocExtractor::class);
-        $extractor->method('getTypes')
-            ->willReturn(
-                [new Type('array', false, null, true, new Type('int'), new Type('object', false, DummyChild::class))],
-                null
-            );
+
+        if (method_exists(PhpDocExtractor::class, 'getType')) {
+            $extractor->method('getType')
+                ->willReturn(
+                    Type::list(Type::object(DummyChild::class)),
+                    null,
+                );
+        } else {
+            $extractor->method('getTypes')
+                ->willReturn(
+                    [new LegacyType('array', false, null, true, new LegacyType('int'), new LegacyType('object', false, DummyChild::class))],
+                    null
+                );
+        }
 
         $denormalizer = new AbstractObjectNormalizerCollectionDummy(null, null, $extractor);
         $arrayDenormalizer = new ArrayDenormalizerDummy();
@@ -474,11 +501,20 @@ public function testDenormalizeNotSerializableObjectToPopulate()
     private function getDenormalizerForStringCollection()
     {
         $extractor = $this->createMock(PhpDocExtractor::class);
-        $extractor->method('getTypes')
-            ->willReturn(
-                [new Type('array', false, null, true, new Type('int'), new Type('string'))],
-                null
-            );
+
+        if (method_exists(PhpDocExtractor::class, 'getType')) {
+            $extractor->method('getType')
+                ->willReturn(
+                    Type::list(Type::string()),
+                    null,
+                );
+        } else {
+            $extractor->method('getTypes')
+                ->willReturn(
+                    [new LegacyType('array', false, null, true, new LegacyType('int'), new LegacyType('string'))],
+                    null
+                );
+        }
 
         $denormalizer = new AbstractObjectNormalizerCollectionDummy(null, null, $extractor);
         $arrayDenormalizer = new ArrayDenormalizerDummy();
@@ -493,7 +529,7 @@ public function testDenormalizeWithDiscriminatorMapUsesCorrectClassname()
     {
         $factory = new ClassMetadataFactory(new AttributeLoader());
 
-        $loaderMock = new class() implements ClassMetadataFactoryInterface {
+        $loaderMock = new class implements ClassMetadataFactoryInterface {
             public function getMetadataFor($value): ClassMetadataInterface
             {
                 if (AbstractDummy::class === $value) {
@@ -528,7 +564,7 @@ public function testDenormalizeWithDiscriminatorMapAndObjectToPopulateUsesCorrec
     {
         $factory = new ClassMetadataFactory(new AttributeLoader());
 
-        $loaderMock = new class() implements ClassMetadataFactoryInterface {
+        $loaderMock = new class implements ClassMetadataFactoryInterface {
             public function getMetadataFor($value): ClassMetadataInterface
             {
                 if (AbstractDummy::class === $value) {
@@ -581,7 +617,7 @@ public function hasMetadataFor($value): bool
 
     public function testDenormalizeWithNestedDiscriminatorMap()
     {
-        $classDiscriminatorResolver = new class() implements ClassDiscriminatorResolverInterface {
+        $classDiscriminatorResolver = new class implements ClassDiscriminatorResolverInterface {
             public function getMappingForClass(string $class): ?ClassDiscriminatorMapping
             {
                 return match ($class) {
@@ -661,21 +697,40 @@ public function testDenormalizeBasicTypePropertiesFromXml()
     private function getDenormalizerForObjectWithBasicProperties()
     {
         $extractor = $this->createMock(PhpDocExtractor::class);
-        $extractor->method('getTypes')
-            ->willReturn(
-                [new Type('bool')],
-                [new Type('bool')],
-                [new Type('bool')],
-                [new Type('bool')],
-                [new Type('int')],
-                [new Type('int')],
-                [new Type('float')],
-                [new Type('float')],
-                [new Type('float')],
-                [new Type('float')],
-                [new Type('float')],
-                [new Type('float')]
-            );
+
+        if (method_exists(PhpDocExtractor::class, 'getType')) {
+            $extractor->method('getType')
+                ->willReturn(
+                    Type::bool(),
+                    Type::bool(),
+                    Type::bool(),
+                    Type::bool(),
+                    Type::int(),
+                    Type::int(),
+                    Type::float(),
+                    Type::float(),
+                    Type::float(),
+                    Type::float(),
+                    Type::float(),
+                    Type::float(),
+                );
+        } else {
+            $extractor->method('getTypes')
+                ->willReturn(
+                    [new LegacyType('bool')],
+                    [new LegacyType('bool')],
+                    [new LegacyType('bool')],
+                    [new LegacyType('bool')],
+                    [new LegacyType('int')],
+                    [new LegacyType('int')],
+                    [new LegacyType('float')],
+                    [new LegacyType('float')],
+                    [new LegacyType('float')],
+                    [new LegacyType('float')],
+                    [new LegacyType('float')],
+                    [new LegacyType('float')]
+                );
+        }
 
         $denormalizer = new AbstractObjectNormalizerCollectionDummy(null, null, $extractor);
         $arrayDenormalizer = new ArrayDenormalizerDummy();
@@ -691,9 +746,10 @@ private function getDenormalizerForObjectWithBasicProperties()
      */
     public function testExtraAttributesException()
     {
+        $normalizer = new ObjectNormalizer();
+
         $this->expectException(LogicException::class);
         $this->expectExceptionMessage('A class metadata factory must be provided in the constructor when setting "allow_extra_attributes" to false.');
-        $normalizer = new ObjectNormalizer();
 
         $normalizer->denormalize([], \stdClass::class, 'xml', [
             'allow_extra_attributes' => false,
@@ -814,7 +870,7 @@ public function testDenormalizeWithNumberAsSerializedNameAndNoArrayReindex()
             '99' => 'baz',
         ];
 
-        $obj = new class() {
+        $obj = new class {
             #[SerializedName('1')]
             public $foo;
 
@@ -838,7 +894,7 @@ public function testDenormalizeWithCorrectOrderOfAttributeAndProperty()
             ],
         ];
 
-        $obj = new class() {
+        $obj = new class {
             #[SerializedPath('[data][id]')]
             public $id;
         };
@@ -849,7 +905,12 @@ public function testDenormalizeWithCorrectOrderOfAttributeAndProperty()
 
     public function testNormalizeBasedOnAllowedAttributes()
     {
-        $normalizer = new class() extends AbstractObjectNormalizer {
+        $normalizer = new class extends AbstractObjectNormalizer {
+            public function getSupportedTypes(?string $format): array
+            {
+                return ['*' => false];
+            }
+
             protected function getAllowedAttributes($classOrObject, array $context, bool $attributesAsString = false): array
             {
                 return ['foo'];
@@ -924,7 +985,7 @@ public function testProvidingContextCacheKeyGeneratesSameChildContextCacheKey()
         $foobar->bar = 'bar';
         $foobar->baz = 'baz';
 
-        $normalizer = new class() extends AbstractObjectNormalizerDummy {
+        $normalizer = new class extends AbstractObjectNormalizerDummy {
             public $childContextCacheKey;
 
             protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
@@ -964,7 +1025,7 @@ public function testChildContextKeepsOriginalContextCacheKey()
         $foobar->bar = 'bar';
         $foobar->baz = 'baz';
 
-        $normalizer = new class() extends AbstractObjectNormalizerDummy {
+        $normalizer = new class extends AbstractObjectNormalizerDummy {
             public $childContextCacheKey;
 
             protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
@@ -999,7 +1060,7 @@ public function testChildContextCacheKeyStaysFalseWhenOriginalCacheKeyIsFalse()
         $foobar->bar = 'bar';
         $foobar->baz = 'baz';
 
-        $normalizer = new class() extends AbstractObjectNormalizerDummy {
+        $normalizer = new class extends AbstractObjectNormalizerDummy {
             public $childContextCacheKey;
 
             protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
@@ -1029,7 +1090,7 @@ protected function createChildContext(array $parentContext, string $attribute, ?
 
     public function testDenormalizeXmlScalar()
     {
-        $normalizer = new class() extends AbstractObjectNormalizer {
+        $normalizer = new class extends AbstractObjectNormalizer {
             public function __construct()
             {
                 parent::__construct(null, new MetadataAwareNameConverter(new ClassMetadataFactory(new AttributeLoader())));
@@ -1049,6 +1110,11 @@ protected function setAttributeValue(object $object, string $attribute, $value,
             {
                 $object->$attribute = $value;
             }
+
+            public function getSupportedTypes(?string $format): array
+            {
+                return ['*' => false];
+            }
         };
 
         $this->assertSame('scalar', $normalizer->denormalize('scalar', XmlScalarDummy::class, 'xml')->value);
@@ -1068,6 +1134,52 @@ public function testNormalizationWithMaxDepthOnStdclassObjectDoesNotThrowWarning
         $this->assertSame(['string' => 'yes'], $normalized);
     }
 
+    public function testDenormalizeCollectionOfScalarTypesPropertyWithPhpDocExtractor()
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
+        $data = [
+            'type' => 'foo',
+            'values' => [
+                ['1'],
+                ['2'],
+                ['3'],
+                ['4'],
+                ['5'],
+            ],
+        ];
+        $expected = new ScalarCollectionDocBlockDummy([[1], [2], [3], [4], [5]]);
+
+        $this->assertEquals($expected, $normalizer->denormalize($data, ScalarCollectionDocBlockDummy::class));
+    }
+
+    public function testDenormalizeCollectionOfUnionTypesPropertyWithPhpDocExtractor()
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
+        $data = [
+            'values1' => [
+                'foo' => 'foo',
+                'bar' => 222,
+            ],
+            'values2' => [
+                'baz' => 'baz',
+                'qux' => 333,
+            ],
+        ];
+        $expected = new UnionCollectionDocBlockDummy($data['values1']);
+        $expected->values2 = $data['values2'];
+
+        $this->assertEquals($expected, $normalizer->denormalize($data, UnionCollectionDocBlockDummy::class));
+    }
+
+    public function testDenormalizeMixedProperty()
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
+        $expected = new MixedPropertyDummy();
+        $expected->foo = 'bar';
+
+        $this->assertEquals($expected, $normalizer->denormalize(['foo' => 'bar'], MixedPropertyDummy::class));
+    }
+
     /**
      * @dataProvider provideBooleanTypesData
      */
@@ -1087,6 +1199,120 @@ public static function provideBooleanTypesData()
             [['foo' => false], TruePropertyDummy::class],
         ];
     }
+
+    /**
+     * @dataProvider provideDenormalizeWithFilterBoolData
+     */
+    public function testDenormalizeBooleanTypeWithFilterBool(array $data, ?bool $expectedFoo)
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
+
+        $dummy = $normalizer->denormalize($data, BoolPropertyDummy::class, null, [AbstractNormalizer::FILTER_BOOL => true]);
+
+        $this->assertSame($expectedFoo, $dummy->foo);
+    }
+
+    public static function provideDenormalizeWithFilterBoolData(): array
+    {
+        return [
+            [['foo' => 'true'], true],
+            [['foo' => 'True'], true],
+            [['foo' => 'TRUE'], true],
+            [['foo' => '1'], true],
+            [['foo' => 1], true],
+            [['foo' => 'yes'], true],
+            [['foo' => 'Yes'], true],
+            [['foo' => 'YES'], true],
+            [['foo' => 'on'], true],
+            [['foo' => 'On'], true],
+            [['foo' => 'ON'], true],
+            [['foo' => 'false'], false],
+            [['foo' => 'False'], false],
+            [['foo' => 'FALSE'], false],
+            [['foo' => '0'], false],
+            [['foo' => 0], false],
+            [['foo' => 'no'], false],
+            [['foo' => 'No'], false],
+            [['foo' => 'NO'], false],
+            [['foo' => 'off'], false],
+            [['foo' => 'Off'], false],
+            [['foo' => 'OFF'], false],
+            [['foo' => ''], false],
+            [['foo' => null], null],
+            [['foo' => 'null'], null],
+            [['foo' => 'something'], null],
+            [['foo' => 'foo'], null],
+            [['foo' => 1234567890], null],
+            [['foo' => -1234567890], null],
+        ];
+    }
+
+    public function testDenormalizeArrayObject()
+    {
+        $normalizer = new class extends AbstractObjectNormalizerDummy {
+            public function __construct()
+            {
+                parent::__construct(null, null, new PhpDocExtractor());
+            }
+
+            protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
+            {
+                return true;
+            }
+        };
+        $serializer = new Serializer([$normalizer]);
+        $normalizer->setSerializer($serializer);
+
+        $actual = $normalizer->denormalize(['foo' => ['array' => ['key' => 'value']]], DummyWithArrayObject::class);
+
+        $this->assertInstanceOf(DummyWithArrayObject::class, $actual);
+        $this->assertInstanceOf(\ArrayObject::class, $actual->foo);
+        $this->assertSame(1, $actual->foo->count());
+    }
+
+    public function testTemplateTypeWhenAnObjectIsPassedToDenormalize()
+    {
+        $normalizer = new class(classMetadataFactory: new ClassMetadataFactory(new AttributeLoader()), propertyTypeExtractor: new PropertyInfoExtractor(typeExtractors: [new PhpStanExtractor(), new ReflectionExtractor()])) extends AbstractObjectNormalizerDummy {
+            protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
+            {
+                return true;
+            }
+        };
+        $serializer = new Serializer([$normalizer]);
+        $normalizer->setSerializer($serializer);
+
+        $denormalizedData = $normalizer->denormalize(['value' => new DummyGenericsValue()], DummyGenericsValueWrapper::class);
+
+        $this->assertInstanceOf(DummyGenericsValueWrapper::class, $denormalizedData);
+        $this->assertInstanceOf(DummyGenericsValue::class, $denormalizedData->value);
+
+        $this->assertSame('dummy', $denormalizedData->value->type);
+    }
+
+    public function testDenormalizeTemplateType()
+    {
+        if (!interface_exists(PropertyDocBlockExtractorInterface::class)) {
+            $this->markTestSkipped('The PropertyInfo component before Symfony 7.1 does not support template types.');
+        }
+
+        $normalizer = new class(classMetadataFactory: new ClassMetadataFactory(new AttributeLoader()), propertyTypeExtractor: new PropertyInfoExtractor(typeExtractors: [new PhpStanExtractor(), new ReflectionExtractor()])) extends AbstractObjectNormalizerDummy {
+            protected function isAllowedAttribute($classOrObject, string $attribute, ?string $format = null, array $context = []): bool
+            {
+                return true;
+            }
+        };
+        $serializer = new Serializer([new ArrayDenormalizer(), $normalizer]);
+        $normalizer->setSerializer($serializer);
+
+        $denormalizedData = $normalizer->denormalize(['value' => ['type' => 'dummy'], 'values' => [['type' => 'dummy']]], DummyGenericsValueWrapper::class);
+
+        $this->assertInstanceOf(DummyGenericsValueWrapper::class, $denormalizedData);
+        $this->assertInstanceOf(DummyGenericsValue::class, $denormalizedData->value);
+        $this->assertContainsOnlyInstancesOf(DummyGenericsValue::class, $denormalizedData->values);
+        $this->assertCount(1, $denormalizedData->values);
+        $this->assertSame('dummy', $denormalizedData->value->type);
+        $this->assertSame('dummy', $denormalizedData->values[0]->type);
+    }
 }
 
 class AbstractObjectNormalizerDummy extends AbstractObjectNormalizer
@@ -1189,6 +1415,11 @@ class SnakeCaseNestedDummy
     public $fooBar;
 }
 
+class MixedPropertyDummy
+{
+    public mixed $foo;
+}
+
 #[DiscriminatorMap(typeProperty: 'type', mapping: [
     'first' => FirstNestedDummyWithConstructorAndDiscriminator::class,
     'second' => SecondNestedDummyWithConstructorAndDiscriminator::class,
@@ -1367,6 +1598,18 @@ class TruePropertyDummy
     public $foo;
 }
 
+class BoolPropertyDummy
+{
+    /** @var bool|null */
+    public $foo;
+}
+
+class DummyWithArrayObject
+{
+    /** @var \ArrayObject<string, mixed> */
+    public $foo;
+}
+
 class SerializerCollectionDummy implements SerializerInterface, DenormalizerInterface
 {
     private array $normalizers;
@@ -1511,16 +1754,45 @@ public function __construct(
     }
 }
 
-class AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors extends AbstractObjectNormalizer
+#[DiscriminatorMap('type', ['foo' => ScalarCollectionDocBlockDummy::class])]
+class ScalarCollectionDocBlockDummy
 {
-    public function __construct()
+    /**
+     * @param array<int, array<int, string>>|null $values
+     */
+    public function __construct(
+        private readonly ?array $values = null,
+    ) {
+    }
+
+    /** @return array<int, array<int, string>>|null */
+    public function getValues(): ?array
     {
-        parent::__construct(new ClassMetadataFactory(new AttributeLoader()), null, new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]));
+        return $this->values;
     }
+}
 
-    public function getSupportedTypes(?string $format): array
+class UnionCollectionDocBlockDummy
+{
+    /**
+     * @param array<string, string|int> $values1
+     */
+    public function __construct(
+        public array $values1,
+    ) {
+    }
+
+    /**
+     * @var array<string, string|int>
+     */
+    public array $values2;
+}
+
+class AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors extends AbstractObjectNormalizer
+{
+    public function __construct()
     {
-        return ['*' => false];
+        parent::__construct(new ClassMetadataFactory(new AttributeLoader()), null, new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]));
     }
 
     protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
@@ -1533,10 +1805,45 @@ protected function getAttributeValue(object $object, string $attribute, ?string
         return null;
     }
 
-    protected function setAttributeValue(object $object, string $attribute, $value, ?string $format = null, array $context = []): void
+    protected function setAttributeValue(object $object, string $attribute, mixed $value, ?string $format = null, array $context = []): void
     {
         if (property_exists($object, $attribute)) {
             $object->$attribute = $value;
         }
     }
+
+    public function getSupportedTypes(?string $format): array
+    {
+        return [
+            '*' => false,
+        ];
+    }
+}
+
+#[DiscriminatorMap('type', ['dummy' => DummyGenericsValue::class])]
+abstract class AbstractDummyGenericsValue
+{
+    public function __construct(
+        public string $type,
+    ) {
+    }
+}
+
+class DummyGenericsValue extends AbstractDummyGenericsValue
+{
+    public function __construct()
+    {
+        parent::__construct('dummy');
+    }
+}
+
+/**
+ * @template T of AbstractDummyGenericsValue
+ */
+class DummyGenericsValueWrapper
+{
+    /** @var T */
+    public mixed $value;
+    /** @var T[] */
+    public array $values;
 }
diff --git a/Tests/Normalizer/ArrayDenormalizerTest.php b/Tests/Normalizer/ArrayDenormalizerTest.php
index 8f7a75b11..b60f57bac 100644
--- a/Tests/Normalizer/ArrayDenormalizerTest.php
+++ b/Tests/Normalizer/ArrayDenormalizerTest.php
@@ -14,7 +14,7 @@
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
 use Symfony\Component\Serializer\Normalizer\ArrayDenormalizer;
-use Symfony\Component\Serializer\Tests\Fixtures\UpcomingDenormalizerInterface as DenormalizerInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 
 class ArrayDenormalizerTest extends TestCase
 {
@@ -108,6 +108,22 @@ public function testSupportsNoArray()
             )
         );
     }
+
+    public function testDenormalizeWithoutDenormalizer()
+    {
+        $arrayDenormalizer = new ArrayDenormalizer();
+
+        $this->expectException(\BadMethodCallException::class);
+        $arrayDenormalizer->denormalize([], 'string[]');
+    }
+
+    public function testSupportsDenormalizationWithoutDenormalizer()
+    {
+        $arrayDenormalizer = new ArrayDenormalizer();
+
+        $this->expectException(\BadMethodCallException::class);
+        $arrayDenormalizer->supportsDenormalization([], 'string[]');
+    }
 }
 
 class ArrayDummy
diff --git a/Tests/Normalizer/ConstraintViolationListNormalizerTest.php b/Tests/Normalizer/ConstraintViolationListNormalizerTest.php
index bb69392f5..1d0afb3cb 100644
--- a/Tests/Normalizer/ConstraintViolationListNormalizerTest.php
+++ b/Tests/Normalizer/ConstraintViolationListNormalizerTest.php
@@ -50,23 +50,23 @@ public function testNormalize()
             'detail' => 'd: a
 4: 1',
             'violations' => [
-                    [
-                        'propertyPath' => 'd',
-                        'title' => 'a',
-                        'template' => 'b',
-                        'type' => 'urn:uuid:f',
-                        'parameters' => [
-                            'value' => 'foo',
-                        ],
-                    ],
-                    [
-                        'propertyPath' => '4',
-                        'title' => '1',
-                        'template' => '2',
-                        'type' => 'urn:uuid:6',
-                        'parameters' => [],
+                [
+                    'propertyPath' => 'd',
+                    'title' => 'a',
+                    'template' => 'b',
+                    'type' => 'urn:uuid:f',
+                    'parameters' => [
+                        'value' => 'foo',
                     ],
                 ],
+                [
+                    'propertyPath' => '4',
+                    'title' => '1',
+                    'template' => '2',
+                    'type' => 'urn:uuid:6',
+                    'parameters' => [],
+                ],
+            ],
         ];
 
         $this->assertEquals($expected, $this->normalizer->normalize($list));
diff --git a/Tests/Normalizer/DataUriNormalizerTest.php b/Tests/Normalizer/DataUriNormalizerTest.php
index 92e173fe0..7e9af4360 100644
--- a/Tests/Normalizer/DataUriNormalizerTest.php
+++ b/Tests/Normalizer/DataUriNormalizerTest.php
@@ -121,7 +121,7 @@ public function testGiveNotAccessToLocalFiles()
     /**
      * @dataProvider invalidUriProvider
      */
-    public function testInvalidData($uri)
+    public function testInvalidData(?string $uri)
     {
         $this->expectException(UnexpectedValueException::class);
         $this->normalizer->denormalize($uri, 'SplFileObject');
@@ -148,7 +148,7 @@ public static function invalidUriProvider()
     /**
      * @dataProvider validUriProvider
      */
-    public function testValidData($uri)
+    public function testValidData(string $uri)
     {
         $this->assertInstanceOf(\SplFileObject::class, $this->normalizer->denormalize($uri, 'SplFileObject'));
     }
diff --git a/Tests/Normalizer/DateTimeNormalizerTest.php b/Tests/Normalizer/DateTimeNormalizerTest.php
index e65b6f67d..81219652b 100644
--- a/Tests/Normalizer/DateTimeNormalizerTest.php
+++ b/Tests/Normalizer/DateTimeNormalizerTest.php
@@ -154,6 +154,72 @@ public static function normalizeUsingTimeZonePassedInContextAndExpectedFormatWit
         ];
     }
 
+    /**
+     * @dataProvider provideNormalizeUsingCastCases
+     */
+    public function testNormalizeUsingCastPassedInConstructor(\DateTimeInterface $value, string $format, ?string $cast, string|int|float $expectedResult)
+    {
+        $normalizer = new DateTimeNormalizer([DateTimeNormalizer::CAST_KEY => $cast]);
+
+        $this->assertSame($normalizer->normalize($value, null, [DateTimeNormalizer::FORMAT_KEY => $format]), $expectedResult);
+    }
+
+    /**
+     * @dataProvider provideNormalizeUsingCastCases
+     */
+    public function testNormalizeUsingCastPassedInContext(\DateTimeInterface $value, string $format, ?string $cast, string|int|float $expectedResult)
+    {
+        $this->assertSame($this->normalizer->normalize($value, null, [DateTimeNormalizer::FORMAT_KEY => $format, DateTimeNormalizer::CAST_KEY => $cast]), $expectedResult);
+    }
+
+    /**
+     * @return iterable<array{0: \DateTimeImmutable, 1: non-empty-string, 2: 'int'|'float'|null, 3: 'int'|'float'|'string'}>
+     */
+    public static function provideNormalizeUsingCastCases(): iterable
+    {
+        yield [
+            \DateTimeImmutable::createFromFormat('U', '1703071202'),
+            'Y',
+            null,
+            '2023',
+        ];
+
+        yield [
+            \DateTimeImmutable::createFromFormat('U', '1703071202'),
+            'Y',
+            'int',
+            2023,
+        ];
+
+        yield [
+            \DateTimeImmutable::createFromFormat('U', '1703071202'),
+            'Ymd',
+            'int',
+            20231220,
+        ];
+
+        yield [
+            \DateTimeImmutable::createFromFormat('U', '1703071202'),
+            'Y',
+            'int',
+            2023,
+        ];
+
+        yield [
+            \DateTimeImmutable::createFromFormat('U.v', '1703071202.388'),
+            'U.v',
+            'float',
+            1703071202.388,
+        ];
+
+        yield [
+            \DateTimeImmutable::createFromFormat('U.u', '1703071202.388811'),
+            'U.u',
+            'float',
+            1703071202.388811,
+        ];
+    }
+
     public function testNormalizeInvalidObjectThrowsException()
     {
         $this->expectException(InvalidArgumentException::class);
@@ -166,6 +232,8 @@ public function testSupportsDenormalization()
         $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTimeInterface::class));
         $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTime::class));
         $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', \DateTimeImmutable::class));
+        $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', DateTimeImmutableChild::class));
+        $this->assertTrue($this->normalizer->supportsDenormalization('2016-01-01T00:00:00+00:00', DateTimeChild::class));
         $this->assertFalse($this->normalizer->supportsDenormalization('foo', 'Bar'));
     }
 
@@ -175,6 +243,10 @@ public function testDenormalize()
         $this->assertEquals(new \DateTimeImmutable('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeImmutable::class));
         $this->assertEquals(new \DateTime('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTime::class));
         $this->assertEquals(new \DateTime('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('  2016-01-01T00:00:00+00:00  ', \DateTime::class));
+        $this->assertEquals(new DateTimeImmutableChild('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', DateTimeImmutableChild::class));
+        $this->assertEquals(new DateTimeImmutableChild('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', DateTimeImmutableChild::class));
+        $this->assertEquals(new DateTimeChild('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', DateTimeChild::class));
+        $this->assertEquals(new DateTimeChild('2016/01/01', new \DateTimeZone('UTC')), $this->normalizer->denormalize('  2016-01-01T00:00:00+00:00  ', DateTimeChild::class));
         $this->assertEquals(new \DateTimeImmutable('2023-05-06T17:35:34.000000+0000', new \DateTimeZone('UTC')), $this->normalizer->denormalize(1683394534, \DateTimeImmutable::class, null, [DateTimeNormalizer::FORMAT_KEY => 'U']));
         $this->assertEquals(new \DateTimeImmutable('2023-05-06T17:35:34.123400+0000', new \DateTimeZone('UTC')), $this->normalizer->denormalize(1683394534.1234, \DateTimeImmutable::class, null, [DateTimeNormalizer::FORMAT_KEY => 'U.u']));
     }
@@ -321,3 +393,11 @@ public function testDenormalizeFormatMismatchThrowsException()
         $this->normalizer->denormalize('2016-01-01T00:00:00+00:00', \DateTimeInterface::class, null, [DateTimeNormalizer::FORMAT_KEY => 'Y-m-d|']);
     }
 }
+
+class DateTimeChild extends \DateTime
+{
+}
+
+class DateTimeImmutableChild extends \DateTimeImmutable
+{
+}
diff --git a/Tests/Normalizer/Features/CallbacksTestTrait.php b/Tests/Normalizer/Features/CallbacksTestTrait.php
index 09e2f8867..3a9191ae8 100644
--- a/Tests/Normalizer/Features/CallbacksTestTrait.php
+++ b/Tests/Normalizer/Features/CallbacksTestTrait.php
@@ -59,7 +59,7 @@ public function testNormalizeCallbacksWithNoConstructorArgument($callbacks, $val
     {
         $normalizer = $this->getNormalizerForCallbacksWithPropertyTypeExtractor();
 
-        $obj = new class() extends CallbacksObject {
+        $obj = new class extends CallbacksObject {
             public function __construct()
             {
             }
@@ -101,7 +101,7 @@ public function testDenormalizeCallbacksWithNoConstructorArgument($callbacks, $v
     {
         $normalizer = $this->getNormalizerForCallbacksWithPropertyTypeExtractor();
 
-        $objWithNoConstructorArgument = new class() extends CallbacksObject {
+        $objWithNoConstructorArgument = new class extends CallbacksObject {
             public function __construct()
             {
             }
diff --git a/Tests/Normalizer/Features/CircularReferenceTestTrait.php b/Tests/Normalizer/Features/CircularReferenceTestTrait.php
index d02e245f7..85720bcfe 100644
--- a/Tests/Normalizer/Features/CircularReferenceTestTrait.php
+++ b/Tests/Normalizer/Features/CircularReferenceTestTrait.php
@@ -42,7 +42,7 @@ public function testUnableToNormalizeCircularReference(array $defaultContext, ar
         $obj = $this->getSelfReferencingModel();
 
         $this->expectException(CircularReferenceException::class);
-        $this->expectExceptionMessage(sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', $obj::class, $expectedLimit));
+        $this->expectExceptionMessage(\sprintf('A circular reference has been detected when serializing the object of class "%s" (configured limit: %d).', $obj::class, $expectedLimit));
         $normalizer->normalize($obj, null, $context);
     }
 
diff --git a/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php b/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php
index 72652f340..0a5f6f249 100644
--- a/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php
+++ b/Tests/Normalizer/Features/ConstructorArgumentsTestTrait.php
@@ -64,10 +64,10 @@ public function testConstructorWithMissingData()
         $normalizer = $this->getDenormalizerForConstructArguments();
         try {
             $normalizer->denormalize($data, ConstructorArgumentsObject::class);
-            self::fail(sprintf('Failed asserting that exception of type "%s" is thrown.', MissingConstructorArgumentsException::class));
+            self::fail(\sprintf('Failed asserting that exception of type "%s" is thrown.', MissingConstructorArgumentsException::class));
         } catch (MissingConstructorArgumentsException $e) {
             self::assertSame(ConstructorArgumentsObject::class, $e->getClass());
-            self::assertSame(sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$foo", "$baz".', ConstructorArgumentsObject::class), $e->getMessage());
+            self::assertSame(\sprintf('Cannot create an instance of "%s" from serialized data because its constructor requires the following parameters to be present : "$foo", "$baz".', ConstructorArgumentsObject::class), $e->getMessage());
             self::assertSame(['foo', 'baz'], $e->getMissingConstructorArguments());
         }
     }
diff --git a/Tests/Fixtures/Annotations/AbstractDummyThirdChild.php b/Tests/Normalizer/Features/FilterBoolObject.php
similarity index 61%
rename from Tests/Fixtures/Annotations/AbstractDummyThirdChild.php
rename to Tests/Normalizer/Features/FilterBoolObject.php
index 2df26c332..2d9828b91 100644
--- a/Tests/Fixtures/Annotations/AbstractDummyThirdChild.php
+++ b/Tests/Normalizer/Features/FilterBoolObject.php
@@ -9,8 +9,11 @@
  * file that was distributed with this source code.
  */
 
-namespace Symfony\Component\Serializer\Tests\Fixtures\Annotations;
+namespace Symfony\Component\Serializer\Tests\Normalizer\Features;
 
-final class AbstractDummyThirdChild extends AbstractDummyFirstChild
+class FilterBoolObject
 {
+    public function __construct(public ?bool $value)
+    {
+    }
 }
diff --git a/Tests/Normalizer/Features/FilterBoolTestTrait.php b/Tests/Normalizer/Features/FilterBoolTestTrait.php
new file mode 100644
index 000000000..ceb80dc3b
--- /dev/null
+++ b/Tests/Normalizer/Features/FilterBoolTestTrait.php
@@ -0,0 +1,47 @@
+<?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\Tests\Normalizer\Features;
+
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
+
+/**
+ * Test AbstractNormalizer::FILTER_BOOL.
+ */
+trait FilterBoolTestTrait
+{
+    abstract protected function getNormalizerForFilterBool(): DenormalizerInterface;
+
+    /**
+     * @dataProvider provideObjectWithBoolArguments
+     */
+    public function testObjectWithBoolArguments(?bool $expectedValue, ?string $parameterValue)
+    {
+        $normalizer = $this->getNormalizerForFilterBool();
+
+        $dummy = $normalizer->denormalize(['value' => $parameterValue], FilterBoolObject::class, context: ['filter_bool' => true]);
+
+        $this->assertSame($expectedValue, $dummy->value);
+    }
+
+    public static function provideObjectWithBoolArguments()
+    {
+        yield 'default value' => [null, null];
+        yield '0' => [false, '0'];
+        yield 'false' => [false, 'false'];
+        yield 'no' => [false, 'no'];
+        yield 'off' => [false, 'off'];
+        yield '1' => [true, '1'];
+        yield 'true' => [true, 'true'];
+        yield 'yes' => [true, 'yes'];
+        yield 'on' => [true, 'on'];
+    }
+}
diff --git a/Tests/Normalizer/Features/GroupsTestTrait.php b/Tests/Normalizer/Features/GroupsTestTrait.php
index 08d5e065a..621ceec41 100644
--- a/Tests/Normalizer/Features/GroupsTestTrait.php
+++ b/Tests/Normalizer/Features/GroupsTestTrait.php
@@ -31,6 +31,7 @@ public function testGroupsNormalize()
         $obj = new GroupDummy();
         $obj->setFoo('foo');
         $obj->setBar('bar');
+        $obj->setQuux('quux');
         $obj->setFooBar('fooBar');
         $obj->setSymfony('symfony');
         $obj->setKevin('kevin');
@@ -59,23 +60,23 @@ public function testGroupsDenormalize()
 
         $data = ['foo' => 'foo', 'bar' => 'bar'];
 
-        $normalized = $normalizer->denormalize(
+        $denormalized = $normalizer->denormalize(
             $data,
             GroupDummy::class,
             null,
             ['groups' => ['a']]
         );
-        $this->assertEquals($obj, $normalized);
+        $this->assertEquals($obj, $denormalized);
 
         $obj->setBar('bar');
 
-        $normalized = $normalizer->denormalize(
+        $denormalized = $normalizer->denormalize(
             $data,
             GroupDummy::class,
             null,
             ['groups' => ['a', 'b']]
         );
-        $this->assertEquals($obj, $normalized);
+        $this->assertEquals($obj, $denormalized);
     }
 
     public function testNormalizeNoPropertyInGroup()
diff --git a/Tests/Normalizer/GetSetMethodNormalizerTest.php b/Tests/Normalizer/GetSetMethodNormalizerTest.php
index 4398fbdab..80788a0d2 100644
--- a/Tests/Normalizer/GetSetMethodNormalizerTest.php
+++ b/Tests/Normalizer/GetSetMethodNormalizerTest.php
@@ -39,6 +39,7 @@
 use Symfony\Component\Serializer\Tests\Normalizer\Features\CallbacksTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\CircularReferenceTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\ConstructorArgumentsTestTrait;
+use Symfony\Component\Serializer\Tests\Normalizer\Features\FilterBoolTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\GroupsTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\IgnoredAttributesTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\MaxDepthTestTrait;
@@ -53,6 +54,7 @@ class GetSetMethodNormalizerTest extends TestCase
     use CallbacksTestTrait;
     use CircularReferenceTestTrait;
     use ConstructorArgumentsTestTrait;
+    use FilterBoolTestTrait;
     use GroupsTestTrait;
     use IgnoredAttributesTestTrait;
     use MaxDepthTestTrait;
@@ -279,6 +281,11 @@ protected function getDenormalizerForGroups(): GetSetMethodNormalizer
         return new GetSetMethodNormalizer($classMetadataFactory);
     }
 
+    protected function getNormalizerForFilterBool(): GetSetMethodNormalizer
+    {
+        return new GetSetMethodNormalizer();
+    }
+
     public function testGroupsNormalizeWithNameConverter()
     {
         $classMetadataFactory = new ClassMetadataFactory(new AttributeLoader());
@@ -375,8 +382,6 @@ protected function getDenormalizerForIgnoredAttributes(): GetSetMethodNormalizer
 
     public function testUnableToNormalizeObjectAttribute()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('Cannot normalize attribute "object" because the injected serializer is not a normalizer');
         $serializer = $this->createMock(SerializerInterface::class);
         $this->normalizer->setSerializer($serializer);
 
@@ -384,6 +389,9 @@ public function testUnableToNormalizeObjectAttribute()
         $object = new \stdClass();
         $obj->setObject($object);
 
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Cannot normalize attribute "object" because the injected serializer is not a normalizer');
+
         $this->normalizer->normalize($obj, 'any');
     }
 
@@ -392,14 +400,12 @@ public function testSiblingReference()
         $serializer = new Serializer([$this->normalizer]);
         $this->normalizer->setSerializer($serializer);
 
-        $siblingHolder = new SiblingHolder();
-
         $expected = [
             'sibling0' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
             'sibling1' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
             'sibling2' => ['coopTilleuls' => 'Les-Tilleuls.coop'],
         ];
-        $this->assertEquals($expected, $this->normalizer->normalize($siblingHolder));
+        $this->assertEquals($expected, $this->normalizer->normalize(new SiblingHolder()));
     }
 
     public function testDenormalizeNonExistingAttribute()
diff --git a/Tests/Normalizer/JsonSerializableNormalizerTest.php b/Tests/Normalizer/JsonSerializableNormalizerTest.php
index 54a977f55..f8f8546d7 100644
--- a/Tests/Normalizer/JsonSerializableNormalizerTest.php
+++ b/Tests/Normalizer/JsonSerializableNormalizerTest.php
@@ -68,9 +68,10 @@ public function testNormalize()
 
     public function testCircularNormalize()
     {
-        $this->expectException(CircularReferenceException::class);
         $this->createNormalizer([JsonSerializableNormalizer::CIRCULAR_REFERENCE_LIMIT => 1]);
 
+        $this->expectException(CircularReferenceException::class);
+
         $this->serializer
             ->expects($this->once())
             ->method('normalize')
diff --git a/Tests/Normalizer/MapDenormalizationTest.php b/Tests/Normalizer/MapDenormalizationTest.php
index ea4515955..75ecbccb9 100644
--- a/Tests/Normalizer/MapDenormalizationTest.php
+++ b/Tests/Normalizer/MapDenormalizationTest.php
@@ -187,7 +187,7 @@ public function testNullableAbstractObject()
 
     private function getSerializer()
     {
-        $loaderMock = new class() implements ClassMetadataFactoryInterface {
+        $loaderMock = new class implements ClassMetadataFactoryInterface {
             public function getMetadataFor($value): ClassMetadataInterface
             {
                 if (AbstractDummyValue::class === $value) {
diff --git a/Tests/Normalizer/ObjectNormalizerTest.php b/Tests/Normalizer/ObjectNormalizerTest.php
index 822c0016e..d45586b44 100644
--- a/Tests/Normalizer/ObjectNormalizerTest.php
+++ b/Tests/Normalizer/ObjectNormalizerTest.php
@@ -14,12 +14,14 @@
 use PHPStan\PhpDocParser\Parser\PhpDocParser;
 use PHPUnit\Framework\MockObject\MockObject;
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\PropertyAccess\Exception\InvalidTypeException;
 use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
 use Symfony\Component\PropertyInfo\Extractor\PhpStanExtractor;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
 use Symfony\Component\PropertyInfo\PropertyInfoExtractor;
 use Symfony\Component\Serializer\Attribute\Ignore;
 use Symfony\Component\Serializer\Exception\LogicException;
+use Symfony\Component\Serializer\Exception\NotNormalizableValueException;
 use Symfony\Component\Serializer\Exception\RuntimeException;
 use Symfony\Component\Serializer\Exception\UnexpectedValueException;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
@@ -39,7 +41,6 @@
 use Symfony\Component\Serializer\Tests\Fixtures\Attributes\GroupDummy;
 use Symfony\Component\Serializer\Tests\Fixtures\CircularReferenceDummy;
 use Symfony\Component\Serializer\Tests\Fixtures\DummyPrivatePropertyWithoutGetter;
-use Symfony\Component\Serializer\Tests\Fixtures\FormatAndContextAwareNormalizer;
 use Symfony\Component\Serializer\Tests\Fixtures\OtherSerializedNameDummy;
 use Symfony\Component\Serializer\Tests\Fixtures\Php74Dummy;
 use Symfony\Component\Serializer\Tests\Fixtures\Php74DummyPrivate;
@@ -51,6 +52,7 @@
 use Symfony\Component\Serializer\Tests\Normalizer\Features\CircularReferenceTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\ConstructorArgumentsTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\ContextMetadataTestTrait;
+use Symfony\Component\Serializer\Tests\Normalizer\Features\FilterBoolTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\GroupsTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\IgnoredAttributesTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\MaxDepthTestTrait;
@@ -73,6 +75,7 @@ class ObjectNormalizerTest extends TestCase
     use CircularReferenceTestTrait;
     use ConstructorArgumentsTestTrait;
     use ContextMetadataTestTrait;
+    use FilterBoolTestTrait;
     use GroupsTestTrait;
     use IgnoredAttributesTestTrait;
     use MaxDepthTestTrait;
@@ -324,8 +327,6 @@ public function testConstructorWithUnconstructableNullableObjectTypeHintDenormal
 
     public function testConstructorWithUnknownObjectTypeHintDenormalize()
     {
-        $this->expectException(RuntimeException::class);
-        $this->expectExceptionMessage('Could not determine the class of the parameter "unknown".');
         $data = [
             'id' => 10,
             'unknown' => [
@@ -338,6 +339,9 @@ public function testConstructorWithUnknownObjectTypeHintDenormalize()
         $serializer = new Serializer([$normalizer]);
         $normalizer->setSerializer($serializer);
 
+        $this->expectException(RuntimeException::class);
+        $this->expectExceptionMessage('Could not determine the class of the parameter "unknown".');
+
         $normalizer->denormalize($data, DummyWithConstructorInexistingObject::class);
     }
 
@@ -361,6 +365,11 @@ protected function getDenormalizerForAttributes(): ObjectNormalizer
         return $normalizer;
     }
 
+    protected function getNormalizerForFilterBool(): ObjectNormalizer
+    {
+        return new ObjectNormalizer();
+    }
+
     public function testAttributesContextDenormalizeConstructor()
     {
         $normalizer = new ObjectNormalizer(null, null, null, new ReflectionExtractor());
@@ -640,8 +649,6 @@ protected function getDenormalizerForTypeEnforcement(): ObjectNormalizer
 
     public function testUnableToNormalizeObjectAttribute()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('Cannot normalize attribute "object" because the injected serializer is not a normalizer');
         $serializer = $this->createMock(SerializerInterface::class);
         $this->normalizer->setSerializer($serializer);
 
@@ -649,6 +656,9 @@ public function testUnableToNormalizeObjectAttribute()
         $object = new \stdClass();
         $obj->setObject($object);
 
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Cannot normalize attribute "object" because the injected serializer is not a normalizer');
+
         $this->normalizer->normalize($obj, 'any');
     }
 
@@ -737,26 +747,12 @@ public function testDoesntHaveIssuesWithUnionConstTypes()
         $normalizer = new ObjectNormalizer(null, null, null, $extractor);
         $serializer = new Serializer([new ArrayDenormalizer(), new DateTimeNormalizer(), $normalizer]);
 
-        $this->assertSame('bar', $serializer->denormalize(['foo' => 'bar'], (new class() {
+        $this->assertSame('bar', $serializer->denormalize(['foo' => 'bar'], (new class {
             /** @var self::*|null */
             public $foo;
         })::class)->foo);
     }
 
-    /**
-     * @group legacy
-     */
-    public function testExtractAttributesRespectsFormat()
-    {
-        $normalizer = new FormatAndContextAwareNormalizer();
-
-        $data = new ObjectDummy();
-        $data->setFoo('bar');
-        $data->bar = 'foo';
-
-        $this->assertSame(['foo' => 'bar', 'bar' => 'foo'], $normalizer->normalize($data, 'foo_and_bar_included'));
-    }
-
     public function testExtractAttributesRespectsContext()
     {
         $normalizer = new ObjectNormalizer();
@@ -786,15 +782,15 @@ public function testDenormalizeFalsePseudoType()
 
     public function testAdvancedNameConverter()
     {
-        $nameConverter = new class() implements AdvancedNameConverterInterface {
+        $nameConverter = new class implements AdvancedNameConverterInterface {
             public function normalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
             {
-                return sprintf('%s-%s-%s-%s', $propertyName, $class, $format, $context['foo']);
+                return \sprintf('%s-%s-%s-%s', $propertyName, $class, $format, $context['foo']);
             }
 
             public function denormalize(string $propertyName, ?string $class = null, ?string $format = null, array $context = []): string
             {
-                return sprintf('%s-%s-%s-%s', $propertyName, $class, $format, $context['foo']);
+                return \sprintf('%s-%s-%s-%s', $propertyName, $class, $format, $context['foo']);
             }
         };
 
@@ -869,6 +865,34 @@ public function testNormalizeStdClass()
         $this->assertSame(['baz' => 'baz'], $this->normalizer->normalize($o2));
     }
 
+    public function testNotNormalizableValueInvalidType()
+    {
+        if (!class_exists(InvalidTypeException::class)) {
+            $this->markTestSkipped('Skipping test as the improvements on PropertyAccess are required.');
+        }
+
+        $this->expectException(NotNormalizableValueException::class);
+        $this->expectExceptionMessage('Expected argument of type "string", "array" given at property path "initialized"');
+
+        try {
+            $this->normalizer->denormalize(['initialized' => ['not a string']], TypedPropertiesObject::class, 'array');
+        } catch (NotNormalizableValueException $e) {
+            $this->assertSame(['string'], $e->getExpectedTypes());
+
+            throw $e;
+        }
+    }
+
+    public function testNormalizeWithoutSerializerSet()
+    {
+        $normalizer = new ObjectNormalizer(new ClassMetadataFactory(new AttributeLoader()));
+
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Cannot normalize attribute "foo" because the injected serializer is not a normalizer.');
+
+        $normalizer->normalize(new ObjectConstructorDummy([], [], []));
+    }
+
     public function testNormalizeWithIgnoreAttributeAndPrivateProperties()
     {
         $classMetadataFactory = new ClassMetadataFactory(new AttributeLoader());
@@ -952,7 +976,7 @@ public function testNormalizeWithMethodNamesSimilarToAccessors()
             'tell' => true,
             'class' => true,
             'responsibility' => true,
-            123 => 321
+            123 => 321,
         ], $normalized);
     }
 }
diff --git a/Tests/Normalizer/PropertyNormalizerTest.php b/Tests/Normalizer/PropertyNormalizerTest.php
index 0601a2d60..ecdae436e 100644
--- a/Tests/Normalizer/PropertyNormalizerTest.php
+++ b/Tests/Normalizer/PropertyNormalizerTest.php
@@ -38,6 +38,7 @@
 use Symfony\Component\Serializer\Tests\Normalizer\Features\CallbacksTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\CircularReferenceTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\ConstructorArgumentsTestTrait;
+use Symfony\Component\Serializer\Tests\Normalizer\Features\FilterBoolTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\GroupsTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\IgnoredAttributesTestTrait;
 use Symfony\Component\Serializer\Tests\Normalizer\Features\MaxDepthTestTrait;
@@ -52,6 +53,7 @@ class PropertyNormalizerTest extends TestCase
     use CallbacksTestTrait;
     use CircularReferenceTestTrait;
     use ConstructorArgumentsTestTrait;
+    use FilterBoolTestTrait;
     use GroupsTestTrait;
     use IgnoredAttributesTestTrait;
     use MaxDepthTestTrait;
@@ -184,7 +186,16 @@ public function testNormalizeWithParentClass()
         $group->setKevin('Kevin');
         $group->setCoopTilleuls('coop');
         $this->assertEquals(
-            ['foo' => 'foo', 'bar' => 'bar', 'quux' => 'quux', 'kevin' => 'Kevin', 'coopTilleuls' => 'coop', 'fooBar' => null, 'symfony' => null, 'baz' => 'baz'],
+            [
+                'foo' => 'foo',
+                'bar' => 'bar',
+                'quux' => 'quux',
+                'kevin' => 'Kevin',
+                'coopTilleuls' => 'coop',
+                'fooBar' => null,
+                'symfony' => null,
+                'baz' => 'baz',
+            ],
             $this->normalizer->normalize($group, 'any')
         );
     }
@@ -248,6 +259,11 @@ protected function getSelfReferencingModel()
         return new PropertyCircularReferenceDummy();
     }
 
+    protected function getNormalizerForFilterBool(): PropertyNormalizer
+    {
+        return new PropertyNormalizer();
+    }
+
     public function testSiblingReference()
     {
         $serializer = new Serializer([$this->normalizer]);
@@ -320,12 +336,16 @@ public function testGroupsDenormalizeWithNameConverter()
 
         $this->assertEquals(
             $obj,
-            $this->normalizer->denormalize([
-                'bar' => null,
-                'foo_bar' => '@dunglas',
-                'symfony' => '@coopTilleuls',
-                'coop_tilleuls' => 'les-tilleuls.coop',
-            ], GroupDummy::class, null, [PropertyNormalizer::GROUPS => ['name_converter']])
+            $this->normalizer->denormalize(
+                [
+                    'bar' => null,
+                    'foo_bar' => '@dunglas',
+                    'symfony' => '@coopTilleuls',
+                    'coop_tilleuls' => 'les-tilleuls.coop',
+                ],
+                GroupDummy::class, null,
+                [PropertyNormalizer::GROUPS => ['name_converter']]
+            )
         );
     }
 
@@ -385,13 +405,19 @@ public function testDenormalizeNonExistingAttribute()
     {
         $this->assertEquals(
             new PropertyDummy(),
-            $this->normalizer->denormalize(['non_existing' => true], PropertyDummy::class)
+            $this->normalizer->denormalize(
+                ['non_existing' => true],
+                PropertyDummy::class
+            )
         );
     }
 
     public function testDenormalizeShouldIgnoreStaticProperty()
     {
-        $obj = $this->normalizer->denormalize(['outOfScope' => true], PropertyDummy::class);
+        $obj = $this->normalizer->denormalize(
+            ['outOfScope' => true],
+            PropertyDummy::class
+        );
 
         $this->assertEquals(new PropertyDummy(), $obj);
         $this->assertEquals('out_of_scope', PropertyDummy::$outOfScope);
@@ -399,8 +425,6 @@ public function testDenormalizeShouldIgnoreStaticProperty()
 
     public function testUnableToNormalizeObjectAttribute()
     {
-        $this->expectException(LogicException::class);
-        $this->expectExceptionMessage('Cannot normalize attribute "bar" because the injected serializer is not a normalizer');
         $serializer = $this->createMock(SerializerInterface::class);
         $this->normalizer->setSerializer($serializer);
 
@@ -408,6 +432,9 @@ public function testUnableToNormalizeObjectAttribute()
         $object = new \stdClass();
         $obj->setBar($object);
 
+        $this->expectException(LogicException::class);
+        $this->expectExceptionMessage('Cannot normalize attribute "bar" because the injected serializer is not a normalizer');
+
         $this->normalizer->normalize($obj, 'any');
     }
 
@@ -429,7 +456,8 @@ public function testInheritedPropertiesSupport()
     public function testMultiDimensionObject()
     {
         $normalizer = $this->getDenormalizerForTypeEnforcement();
-        $root = $normalizer->denormalize([
+        $root = $normalizer->denormalize(
+            [
                 'children' => [[
                     ['foo' => 'one', 'bar' => 'two'],
                     ['foo' => 'three', 'bar' => 'four'],
@@ -446,7 +474,7 @@ public function testMultiDimensionObject()
             RootDummy::class,
             'any'
         );
-        $this->assertEquals($root::class, RootDummy::class);
+        $this->assertSame(RootDummy::class, $root::class);
 
         // children (two dimension array)
         $this->assertCount(1, $root->children);
@@ -514,7 +542,13 @@ public function testDenormalizeWithDiscriminator()
         $denormalized = new PropertyDiscriminatedDummyTwo();
         $denormalized->url = 'url';
 
-        $this->assertEquals($denormalized, $normalizer->denormalize(['type' => 'two', 'url' => 'url'], PropertyDummyInterface::class));
+        $this->assertEquals(
+            $denormalized,
+            $normalizer->denormalize(
+                ['type' => 'two', 'url' => 'url'],
+                PropertyDummyInterface::class
+            )
+        );
     }
 }
 
diff --git a/Tests/Normalizer/UidNormalizerTest.php b/Tests/Normalizer/UidNormalizerTest.php
index 9797e2b1d..734b15b48 100644
--- a/Tests/Normalizer/UidNormalizerTest.php
+++ b/Tests/Normalizer/UidNormalizerTest.php
@@ -12,7 +12,6 @@
 namespace Symfony\Component\Serializer\Tests\Normalizer;
 
 use PHPUnit\Framework\TestCase;
-use Symfony\Bridge\PhpUnit\ExpectDeprecationTrait;
 use Symfony\Component\Serializer\Exception\LogicException;
 use Symfony\Component\Serializer\Normalizer\UidNormalizer;
 use Symfony\Component\Uid\AbstractUid;
@@ -26,8 +25,6 @@
 
 class UidNormalizerTest extends TestCase
 {
-    use ExpectDeprecationTrait;
-
     private UidNormalizer $normalizer;
 
     protected function setUp(): void
@@ -50,8 +47,8 @@ public static function normalizeProvider()
     {
         $uidFormats = [null, 'canonical', 'base58', 'base32', 'rfc4122'];
         $data = [
-             [
-                 UuidV1::fromString('9b7541de-6f87-11ea-ab3c-9da9a81562fc'),
+            [
+                UuidV1::fromString('9b7541de-6f87-11ea-ab3c-9da9a81562fc'),
                 '9b7541de-6f87-11ea-ab3c-9da9a81562fc',
                 '9b7541de-6f87-11ea-ab3c-9da9a81562fc',
                 'LCQS8f2p5SDSiAt9V7ZYnF',
@@ -143,14 +140,9 @@ public function testSupportsDenormalizationForNonUid()
         $this->assertFalse($this->normalizer->supportsDenormalization('foo', \stdClass::class));
     }
 
-    /**
-     * @group legacy
-     */
     public function testSupportOurAbstractUid()
     {
-        $this->expectDeprecation('Since symfony/serializer 6.1: Supporting denormalization for the "Symfony\Component\Uid\AbstractUid" type in "Symfony\Component\Serializer\Normalizer\UidNormalizer" is deprecated, use one of "Symfony\Component\Uid\AbstractUid" child class instead.');
-
-        $this->assertTrue($this->normalizer->supportsDenormalization('1ea6ecef-eb9a-66fe-b62b-957b45f17e43', AbstractUid::class));
+        $this->assertFalse($this->normalizer->supportsDenormalization('1ea6ecef-eb9a-66fe-b62b-957b45f17e43', AbstractUid::class));
     }
 
     public function testSupportCustomAbstractUid()
@@ -166,22 +158,18 @@ public function testDenormalize($uuidString, $class)
         $this->assertEquals($class::fromString($uuidString), $this->normalizer->denormalize($uuidString, $class));
     }
 
-    /**
-     * @group legacy
-     */
     public function testDenormalizeOurAbstractUid()
     {
-        $this->expectDeprecation('Since symfony/serializer 6.1: Denormalizing to an abstract class in "Symfony\Component\Serializer\Normalizer\UidNormalizer" is deprecated.');
+        $this->expectException(\Error::class);
+        $this->expectExceptionMessage('Cannot call abstract method Symfony\Component\Uid\AbstractUid::fromString()');
 
         $this->assertEquals(Uuid::fromString($uuidString = '1ea6ecef-eb9a-66fe-b62b-957b45f17e43'), $this->normalizer->denormalize($uuidString, AbstractUid::class));
     }
 
-    /**
-     * @group legacy
-     */
     public function testDenormalizeCustomAbstractUid()
     {
-        $this->expectDeprecation('Since symfony/serializer 6.1: Denormalizing to an abstract class in "Symfony\Component\Serializer\Normalizer\UidNormalizer" is deprecated.');
+        $this->expectException(\Error::class);
+        $this->expectExceptionMessage('Cannot instantiate abstract class Symfony\Component\Serializer\Tests\Normalizer\TestAbstractCustomUid');
 
         $this->assertEquals(Uuid::fromString($uuidString = '1ea6ecef-eb9a-66fe-b62b-957b45f17e43'), $this->normalizer->denormalize($uuidString, TestAbstractCustomUid::class));
     }
diff --git a/Tests/SerializerTest.php b/Tests/SerializerTest.php
index da5ccc15e..8fd0ff885 100644
--- a/Tests/SerializerTest.php
+++ b/Tests/SerializerTest.php
@@ -12,6 +12,7 @@
 namespace Symfony\Component\Serializer\Tests;
 
 use PHPUnit\Framework\TestCase;
+use Symfony\Component\PropertyAccess\Exception\InvalidTypeException;
 use Symfony\Component\PropertyAccess\PropertyAccessor;
 use Symfony\Component\PropertyInfo\Extractor\PhpDocExtractor;
 use Symfony\Component\PropertyInfo\Extractor\ReflectionExtractor;
@@ -41,8 +42,10 @@
 use Symfony\Component\Serializer\Normalizer\DateTimeNormalizer;
 use Symfony\Component\Serializer\Normalizer\DateTimeZoneNormalizer;
 use Symfony\Component\Serializer\Normalizer\DenormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\DenormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\GetSetMethodNormalizer;
 use Symfony\Component\Serializer\Normalizer\NormalizerAwareInterface;
+use Symfony\Component\Serializer\Normalizer\NormalizerInterface;
 use Symfony\Component\Serializer\Normalizer\ObjectNormalizer;
 use Symfony\Component\Serializer\Normalizer\PropertyNormalizer;
 use Symfony\Component\Serializer\Normalizer\UidNormalizer;
@@ -72,8 +75,6 @@
 use Symfony\Component\Serializer\Tests\Fixtures\Php80WithPromotedTypedConstructor;
 use Symfony\Component\Serializer\Tests\Fixtures\TraversableDummy;
 use Symfony\Component\Serializer\Tests\Fixtures\TrueBuiltInDummy;
-use Symfony\Component\Serializer\Tests\Fixtures\UpcomingDenormalizerInterface as DenormalizerInterface;
-use Symfony\Component\Serializer\Tests\Fixtures\UpcomingNormalizerInterface as NormalizerInterface;
 use Symfony\Component\Serializer\Tests\Fixtures\WithTypedConstructor;
 use Symfony\Component\Serializer\Tests\Normalizer\TestDenormalizer;
 use Symfony\Component\Serializer\Tests\Normalizer\TestNormalizer;
@@ -98,8 +99,10 @@ public function testItThrowsExceptionOnInvalidEncoder()
 
     public function testNormalizeNoMatch()
     {
+        $serializer = new Serializer([$this->createMock(NormalizerInterface::class)]);
+
         $this->expectException(UnexpectedValueException::class);
-        $serializer = new Serializer([$this->createMock(CustomNormalizer::class)]);
+
         $serializer->normalize(new \stdClass(), 'xml');
     }
 
@@ -119,15 +122,19 @@ public function testNormalizeGivesPriorityToInterfaceOverTraversable()
 
     public function testNormalizeOnDenormalizer()
     {
-        $this->expectException(UnexpectedValueException::class);
         $serializer = new Serializer([new TestDenormalizer()], []);
+
+        $this->expectException(UnexpectedValueException::class);
+
         $this->assertTrue($serializer->normalize(new \stdClass(), 'json'));
     }
 
     public function testDenormalizeNoMatch()
     {
+        $serializer = new Serializer([$this->createMock(NormalizerInterface::class)]);
+
         $this->expectException(UnexpectedValueException::class);
-        $serializer = new Serializer([$this->createMock(CustomNormalizer::class)]);
+
         $serializer->denormalize('foo', 'stdClass');
     }
 
@@ -141,9 +148,11 @@ public function testDenormalizeOnObjectThatOnlySupportsDenormalization()
 
     public function testDenormalizeOnNormalizer()
     {
-        $this->expectException(UnexpectedValueException::class);
         $serializer = new Serializer([new TestNormalizer()], []);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(UnexpectedValueException::class);
+
         $this->assertTrue($serializer->denormalize(json_encode($data), 'stdClass', 'json'));
     }
 
@@ -238,17 +247,21 @@ public function testSerializeEmpty()
 
     public function testSerializeNoEncoder()
     {
-        $this->expectException(UnexpectedValueException::class);
         $serializer = new Serializer([], []);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(UnexpectedValueException::class);
+
         $serializer->serialize($data, 'json');
     }
 
     public function testSerializeNoNormalizer()
     {
-        $this->expectException(LogicException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(LogicException::class);
+
         $serializer->serialize(Model::fromArray($data), 'json');
     }
 
@@ -272,25 +285,31 @@ public function testDeserializeUseCache()
 
     public function testDeserializeNoNormalizer()
     {
-        $this->expectException(LogicException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(LogicException::class);
+
         $serializer->deserialize(json_encode($data), Model::class, 'json');
     }
 
     public function testDeserializeWrongNormalizer()
     {
-        $this->expectException(UnexpectedValueException::class);
         $serializer = new Serializer([new CustomNormalizer()], ['json' => new JsonEncoder()]);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(UnexpectedValueException::class);
+
         $serializer->deserialize(json_encode($data), Model::class, 'json');
     }
 
     public function testDeserializeNoEncoder()
     {
-        $this->expectException(UnexpectedValueException::class);
         $serializer = new Serializer([], []);
         $data = ['title' => 'foo', 'numbers' => [5, 3]];
+
+        $this->expectException(UnexpectedValueException::class);
+
         $serializer->deserialize(json_encode($data), Model::class, 'json');
     }
 
@@ -408,7 +427,7 @@ public function testDeserializeAndSerializeAbstractObjectsWithTheClassMetadataDi
         $example = new AbstractDummyFirstChild('foo-value', 'bar-value');
         $example->setQuux(new DummyFirstChildQuux('quux'));
 
-        $loaderMock = new class() implements ClassMetadataFactoryInterface {
+        $loaderMock = new class implements ClassMetadataFactoryInterface {
             public function getMetadataFor($value): ClassMetadataInterface
             {
                 if (AbstractDummy::class === $value) {
@@ -589,10 +608,10 @@ public static function provideObjectOrCollectionTests()
         $data['c2'] = new \ArrayObject(['nested' => new \ArrayObject(['k' => 'v'])]);
         $data['d1'] = new \ArrayObject(['nested' => []]);
         $data['d2'] = new \ArrayObject(['nested' => ['k' => 'v']]);
-        $data['e1'] = new class() {
+        $data['e1'] = new class {
             public $map = [];
         };
-        $data['e2'] = new class() {
+        $data['e2'] = new class {
             public $map = ['k' => 'v'];
         };
         $data['f1'] = new class(new \ArrayObject()) {
@@ -690,29 +709,37 @@ public function testDeserializeScalar()
 
     public function testDeserializeLegacyScalarType()
     {
-        $this->expectException(LogicException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
+
+        $this->expectException(LogicException::class);
+
         $serializer->deserialize('42', 'integer', 'json');
     }
 
     public function testDeserializeScalarTypeToCustomType()
     {
-        $this->expectException(LogicException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
+
+        $this->expectException(LogicException::class);
+
         $serializer->deserialize('"something"', Foo::class, 'json');
     }
 
     public function testDeserializeNonscalarTypeToScalar()
     {
-        $this->expectException(NotNormalizableValueException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
+
+        $this->expectException(NotNormalizableValueException::class);
+
         $serializer->deserialize('{"foo":true}', 'string', 'json');
     }
 
     public function testDeserializeInconsistentScalarType()
     {
-        $this->expectException(NotNormalizableValueException::class);
         $serializer = new Serializer([], ['json' => new JsonEncoder()]);
+
+        $this->expectException(NotNormalizableValueException::class);
+
         $serializer->deserialize('"42"', 'int', 'json');
     }
 
@@ -728,8 +755,10 @@ public function testDeserializeScalarArray()
 
     public function testDeserializeInconsistentScalarArray()
     {
-        $this->expectException(NotNormalizableValueException::class);
         $serializer = new Serializer([new ArrayDenormalizer()], ['json' => new JsonEncoder()]);
+
+        $this->expectException(NotNormalizableValueException::class);
+
         $serializer->deserialize('["42"]', 'int[]', 'json');
     }
 
@@ -832,9 +861,6 @@ public function testUnionTypeDeserializableWithoutAllowedExtraAttributes()
         ]);
     }
 
-    /**
-     * @requires PHP 8.2
-     */
     public function testFalseBuiltInTypes()
     {
         $extractor = new PropertyInfoExtractor([], [new ReflectionExtractor()]);
@@ -845,9 +871,6 @@ public function testFalseBuiltInTypes()
         $this->assertEquals(new FalseBuiltInDummy(), $actual);
     }
 
-    /**
-     * @requires PHP 8.2
-     */
     public function testTrueBuiltInTypes()
     {
         $extractor = new PropertyInfoExtractor([], [new ReflectionExtractor()]);
@@ -1192,7 +1215,7 @@ public function testCollectDenormalizationErrors2(?ClassMetadataFactory $classMe
                 'useMessageForUser' => false,
                 'message' => 'The type of the "string" attribute for class "Symfony\\Component\\Serializer\\Tests\\Fixtures\\Php74Full" must be one of "string" ("null" given).',
             ],
-            ];
+        ];
 
         $this->assertSame($expected, $exceptionsAsArray);
     }
@@ -1232,7 +1255,7 @@ public function testCollectDenormalizationErrorsWithoutTypeExtractor()
             [
                 'currentType' => 'array',
                 'expectedTypes' => [
-                    'unknown',
+                    class_exists(InvalidTypeException::class) ? 'string' : 'unknown',
                 ],
                 'path' => 'string',
                 'useMessageForUser' => false,
@@ -1241,7 +1264,7 @@ public function testCollectDenormalizationErrorsWithoutTypeExtractor()
             [
                 'currentType' => 'array',
                 'expectedTypes' => [
-                    'unknown',
+                    class_exists(InvalidTypeException::class) ? 'int' : 'unknown',
                 ],
                 'path' => 'int',
                 'useMessageForUser' => false,
@@ -1250,7 +1273,7 @@ public function testCollectDenormalizationErrorsWithoutTypeExtractor()
             [
                 'currentType' => 'array',
                 'expectedTypes' => [
-                    'unknown',
+                    class_exists(InvalidTypeException::class) ? 'float' : 'unknown',
                 ],
                 'path' => 'float',
                 'useMessageForUser' => false,
@@ -1442,8 +1465,8 @@ public function testCollectDenormalizationErrorsWithWrongPropertyWithoutConstruc
 
         try {
             $serializer->deserialize('{"get": "POST"}', DummyObjectWithEnumProperty::class, 'json', [
-                 DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS => true,
-             ]);
+                DenormalizerInterface::COLLECT_DENORMALIZATION_ERRORS => true,
+            ]);
         } catch (\Throwable $e) {
             $this->assertInstanceOf(PartialDenormalizationException::class, $e);
         }
diff --git a/composer.json b/composer.json
index a46393778..d8809fa07 100644
--- a/composer.json
+++ b/composer.json
@@ -16,44 +16,44 @@
         }
     ],
     "require": {
-        "php": ">=8.1",
+        "php": ">=8.2",
         "symfony/deprecation-contracts": "^2.5|^3",
         "symfony/polyfill-ctype": "~1.8"
     },
     "require-dev": {
-        "doctrine/annotations": "^1.12|^2",
-        "seld/jsonlint": "^1.10",
         "phpdocumentor/reflection-docblock": "^3.2|^4.0|^5.0",
-        "symfony/cache": "^5.4|^6.0|^7.0",
-        "symfony/config": "^5.4|^6.0|^7.0",
-        "symfony/console": "^5.4|^6.0|^7.0",
-        "symfony/dependency-injection": "^5.4|^6.0|^7.0",
-        "symfony/error-handler": "^5.4|^6.0|^7.0",
-        "symfony/filesystem": "^5.4|^6.0|^7.0",
-        "symfony/form": "^5.4|^6.0|^7.0",
-        "symfony/http-foundation": "^5.4|^6.0|^7.0",
-        "symfony/http-kernel": "^5.4|^6.0|^7.0",
-        "symfony/messenger": "^5.4|^6.0|^7.0",
-        "symfony/mime": "^5.4|^6.0|^7.0",
-        "symfony/property-access": "^5.4.26|^6.3|^7.0",
-        "symfony/property-info": "^5.4.24|^6.2.11|^7.0",
+        "phpstan/phpdoc-parser": "^1.0|^2.0",
+        "seld/jsonlint": "^1.10",
+        "symfony/cache": "^6.4|^7.0",
+        "symfony/config": "^6.4|^7.0",
+        "symfony/console": "^6.4|^7.0",
+        "symfony/dependency-injection": "^7.2",
+        "symfony/error-handler": "^6.4|^7.0",
+        "symfony/filesystem": "^6.4|^7.0",
+        "symfony/form": "^6.4|^7.0",
+        "symfony/http-foundation": "^6.4|^7.0",
+        "symfony/http-kernel": "^6.4|^7.0",
+        "symfony/messenger": "^6.4|^7.0",
+        "symfony/mime": "^6.4|^7.0",
+        "symfony/property-access": "^6.4|^7.0",
+        "symfony/property-info": "^6.4|^7.0",
         "symfony/translation-contracts": "^2.5|^3",
-        "symfony/uid": "^5.4|^6.0|^7.0",
+        "symfony/type-info": "^7.1",
+        "symfony/uid": "^6.4|^7.0",
         "symfony/validator": "^6.4|^7.0",
-        "symfony/var-dumper": "^5.4|^6.0|^7.0",
-        "symfony/var-exporter": "^5.4|^6.0|^7.0",
-        "symfony/yaml": "^5.4|^6.0|^7.0"
+        "symfony/var-dumper": "^6.4|^7.0",
+        "symfony/var-exporter": "^6.4|^7.0",
+        "symfony/yaml": "^6.4|^7.0"
     },
     "conflict": {
-        "doctrine/annotations": "<1.12",
         "phpdocumentor/reflection-docblock": "<3.2.2",
         "phpdocumentor/type-resolver": "<1.4.0",
-        "symfony/dependency-injection": "<5.4",
-        "symfony/property-access": "<5.4",
-        "symfony/property-info": "<5.4.24|>=6,<6.2.11",
+        "symfony/dependency-injection": "<6.4",
+        "symfony/property-access": "<6.4",
+        "symfony/property-info": "<6.4",
+        "symfony/uid": "<6.4",
         "symfony/validator": "<6.4",
-        "symfony/uid": "<5.4",
-        "symfony/yaml": "<5.4"
+        "symfony/yaml": "<6.4"
     },
     "autoload": {
         "psr-4": { "Symfony\\Component\\Serializer\\": "" },