diff --git a/Normalizer/AbstractObjectNormalizer.php b/Normalizer/AbstractObjectNormalizer.php
index df3d693f21f..3275d976a10 100644
--- a/Normalizer/AbstractObjectNormalizer.php
+++ b/Normalizer/AbstractObjectNormalizer.php
@@ -566,12 +566,30 @@ private function validateAndDenormalizeLegacy(array $types, string $currentClass
                     return (float) $data;
                 }
 
+                if (LegacyType::BUILTIN_TYPE_BOOL === $builtinType && \is_string($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;
                 }
 
-                if (('is_'.$builtinType)($data)) {
-                    return $data;
+                switch ($builtinType) {
+                    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;
+                        }
+
+                        break;
                 }
             } catch (NotNormalizableValueException|InvalidArgumentException $e) {
                 if (!$isUnionType && !$isNullable) {
@@ -626,8 +644,11 @@ private function validateAndDenormalizeLegacy(array $types, string $currentClass
     private function validateAndDenormalize(Type $type, string $currentClass, string $attribute, mixed $data, ?string $format, array $context): mixed
     {
         $expectedTypes = [];
+        $isUnionType = $type->asNonNullable() instanceof UnionType;
+        $e = null;
         $extraAttributesException = null;
         $missingConstructorArgumentsException = null;
+        $isNullable = false;
 
         $types = match (true) {
             $type instanceof IntersectionType => throw new LogicException('Unable to handle intersection type.'),
@@ -665,12 +686,19 @@ private function validateAndDenormalize(Type $type, string $currentClass, string
                 // 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 '';
+                        }
+
+                        $isNullable = $isNullable ?: $type->isNullable();
+                    }
+
                     switch ($typeIdentifier) {
-                        case TypeIdentifier::ARRAY:
-                            if ('' === $data) {
-                                return [];
-                            }
-                            break;
                         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) {
@@ -773,25 +801,42 @@ private function validateAndDenormalize(Type $type, string $currentClass, string
                     return (float) $data;
                 }
 
-                if ((TypeIdentifier::FALSE === $typeIdentifier && false === $data) || (TypeIdentifier::TRUE === $typeIdentifier && true === $data)) {
-                    return $data;
+                if (TypeIdentifier::BOOL === $typeIdentifier && \is_string($data) && ($context[self::FILTER_BOOL] ?? false)) {
+                    return filter_var($data, \FILTER_VALIDATE_BOOL, \FILTER_NULL_ON_FAILURE);
                 }
 
-                if (('is_'.$typeIdentifier->value)($data)) {
+                $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) {
+                if (!$isUnionType && !$isNullable) {
                     throw $e;
                 }
             } catch (ExtraAttributesException $e) {
-                if (!$type instanceof UnionType) {
+                if (!$isUnionType && !$isNullable) {
                     throw $e;
                 }
 
                 $extraAttributesException ??= $e;
             } catch (MissingConstructorArgumentsException $e) {
-                if (!$type instanceof UnionType) {
+                if (!$isUnionType && !$isNullable) {
                     throw $e;
                 }
 
@@ -811,6 +856,10 @@ private function validateAndDenormalize(Type $type, string $currentClass, string
             throw $missingConstructorArgumentsException;
         }
 
+        if (!$isUnionType && $e) {
+            throw $e;
+        }
+
         if ($context[self::DISABLE_TYPE_ENFORCEMENT] ?? $this->defaultContext[self::DISABLE_TYPE_ENFORCEMENT] ?? false) {
             return $data;
         }
diff --git a/Normalizer/ObjectNormalizer.php b/Normalizer/ObjectNormalizer.php
index 1b51b729c66..1f19bd9d865 100644
--- a/Normalizer/ObjectNormalizer.php
+++ b/Normalizer/ObjectNormalizer.php
@@ -177,15 +177,19 @@ protected function isAllowedAttribute($classOrObject, string $attribute, ?string
 
         if ($context['_read_attributes'] ?? true) {
             if (!isset(self::$isReadableCache[$class.$attribute])) {
-                self::$isReadableCache[$class.$attribute] = $this->propertyInfoExtractor->isReadable($class, $attribute) || $this->hasAttributeAccessorMethod($class, $attribute);
+                self::$isReadableCache[$class.$attribute] = (\is_object($classOrObject) && $this->propertyAccessor->isReadable($classOrObject, $attribute)) || $this->propertyInfoExtractor->isReadable($class, $attribute) || $this->hasAttributeAccessorMethod($class, $attribute);
             }
 
             return self::$isReadableCache[$class.$attribute];
         }
 
         if (!isset(self::$isWritableCache[$class.$attribute])) {
-            self::$isWritableCache[$class.$attribute] = $this->propertyInfoExtractor->isWritable($class, $attribute)
-                || (($writeInfo = $this->writeInfoExtractor->getWriteInfo($class, $attribute)) && PropertyWriteInfo::TYPE_NONE !== $writeInfo->getType());
+            if (str_contains($attribute, '.')) {
+                self::$isWritableCache[$class.$attribute] = true;
+            } else {
+                self::$isWritableCache[$class.$attribute] = $this->propertyInfoExtractor->isWritable($class, $attribute)
+                    || (($writeInfo = $this->writeInfoExtractor->getWriteInfo($class, $attribute)) && PropertyWriteInfo::TYPE_NONE !== $writeInfo->getType());
+            }
         }
 
         return self::$isWritableCache[$class.$attribute];
diff --git a/Tests/DeserializeNestedArrayOfObjectsTest.php b/Tests/DeserializeNestedArrayOfObjectsTest.php
index 8da1b471bd5..57f2b568ef4 100644
--- a/Tests/DeserializeNestedArrayOfObjectsTest.php
+++ b/Tests/DeserializeNestedArrayOfObjectsTest.php
@@ -156,7 +156,7 @@ class ZooWithKeyTypes
     public $animalsString = [];
     /** @var array<int|string, Animal> */
     public $animalsUnion = [];
-    /** @var \stdClass<Animal> */
+    /** @var \Traversable<Animal> */
     public $animalsGenerics = [];
 }
 
diff --git a/Tests/Fixtures/NotNormalizableDummy.php b/Tests/Fixtures/NotNormalizableDummy.php
index 41da0eac8a9..ef7a8c906dc 100644
--- a/Tests/Fixtures/NotNormalizableDummy.php
+++ b/Tests/Fixtures/NotNormalizableDummy.php
@@ -26,6 +26,6 @@ public function __construct()
 
     public function denormalize(DenormalizerInterface $denormalizer, $data, ?string $format = null, array $context = []): void
     {
-        throw new NotNormalizableValueException();
+        throw new NotNormalizableValueException('Custom exception message');
     }
 }
diff --git a/Tests/Fixtures/property-path-mapping.yaml b/Tests/Fixtures/property-path-mapping.yaml
new file mode 100644
index 00000000000..834b39150fe
--- /dev/null
+++ b/Tests/Fixtures/property-path-mapping.yaml
@@ -0,0 +1,5 @@
+Symfony\Component\Serializer\Tests\Normalizer\ObjectOuter:
+    attributes:
+        inner.foo:
+            serialized_name: inner_foo
+            groups: [ 'read' ]
diff --git a/Tests/Normalizer/AbstractObjectNormalizerTest.php b/Tests/Normalizer/AbstractObjectNormalizerTest.php
index f41c0fdf395..e1b1031dabe 100644
--- a/Tests/Normalizer/AbstractObjectNormalizerTest.php
+++ b/Tests/Normalizer/AbstractObjectNormalizerTest.php
@@ -946,6 +946,7 @@ public function testDenormalizeUntypedFormat()
     public function testDenormalizeUntypedFormatNotNormalizable()
     {
         $this->expectException(NotNormalizableValueException::class);
+        $this->expectExceptionMessage('Custom exception message');
         $serializer = new Serializer([new CustomNormalizer(), new ObjectNormalizer(null, null, null, new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]))]);
         $serializer->denormalize(['value' => 'test'], DummyWithNotNormalizable::class, 'xml');
     }
@@ -1132,7 +1133,7 @@ public function testNormalizationWithMaxDepthOnStdclassObjectDoesNotThrowWarning
 
     public function testDenormalizeCollectionOfScalarTypesPropertyWithPhpDocExtractor()
     {
-        $normalizer = new AbstractObjectNormalizerWithMetadataAndPhpDocExtractor();
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
         $data = [
             'type' => 'foo',
             'values' => [
@@ -1150,7 +1151,7 @@ public function testDenormalizeCollectionOfScalarTypesPropertyWithPhpDocExtracto
 
     public function testDenormalizeCollectionOfUnionTypesPropertyWithPhpDocExtractor()
     {
-        $normalizer = new AbstractObjectNormalizerWithMetadataAndPhpDocExtractor();
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
         $data = [
             'values1' => [
                 'foo' => 'foo',
@@ -1166,6 +1167,63 @@ public function testDenormalizeCollectionOfUnionTypesPropertyWithPhpDocExtractor
 
         $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
+     */
+    public function testDenormalizeBooleanTypesWithNotMatchingData(array $data, string $type)
+    {
+        $normalizer = new AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors();
+
+        $this->expectException(NotNormalizableValueException::class);
+
+        $normalizer->denormalize($data, $type);
+    }
+
+    public function provideBooleanTypesData()
+    {
+        return [
+            [['foo' => true], FalsePropertyDummy::class],
+            [['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 function provideDenormalizeWithFilterBoolData(): array
+    {
+        return [
+            [['foo' => 'true'], true],
+            [['foo' => '1'], true],
+            [['foo' => 'yes'], true],
+            [['foo' => 'false'], false],
+            [['foo' => '0'], false],
+            [['foo' => 'no'], false],
+            [['foo' => ''], false],
+            [['foo' => null], null],
+            [['foo' => 'null'], null],
+            [['foo' => 'something'], null],
+        ];
+    }
 }
 
 class AbstractObjectNormalizerDummy extends AbstractObjectNormalizer
@@ -1268,6 +1326,11 @@ class SnakeCaseNestedDummy
     public $fooBar;
 }
 
+class MixedPropertyDummy
+{
+    public mixed $foo;
+}
+
 #[DiscriminatorMap(typeProperty: 'type', mapping: [
     'first' => FirstNestedDummyWithConstructorAndDiscriminator::class,
     'second' => SecondNestedDummyWithConstructorAndDiscriminator::class,
@@ -1434,6 +1497,24 @@ class XmlScalarDummy
     public $value;
 }
 
+class FalsePropertyDummy
+{
+    /** @var false */
+    public $foo;
+}
+
+class TruePropertyDummy
+{
+    /** @var true */
+    public $foo;
+}
+
+class BoolPropertyDummy
+{
+    /** @var null|bool */
+    public $foo;
+}
+
 class SerializerCollectionDummy implements SerializerInterface, DenormalizerInterface
 {
     private array $normalizers;
@@ -1612,11 +1693,11 @@ public function __construct(
     public array $values2;
 }
 
-class AbstractObjectNormalizerWithMetadataAndPhpDocExtractor extends AbstractObjectNormalizer
+class AbstractObjectNormalizerWithMetadataAndPropertyTypeExtractors extends AbstractObjectNormalizer
 {
     public function __construct()
     {
-        parent::__construct(new ClassMetadataFactory(new AttributeLoader()), null, new PropertyInfoExtractor([], [new PhpDocExtractor()]));
+        parent::__construct(new ClassMetadataFactory(new AttributeLoader()), null, new PropertyInfoExtractor([], [new PhpDocExtractor(), new ReflectionExtractor()]));
     }
 
     protected function extractAttributes(object $object, ?string $format = null, array $context = []): array
diff --git a/Tests/Normalizer/ObjectNormalizerTest.php b/Tests/Normalizer/ObjectNormalizerTest.php
index 19bbcde2c71..c5f86939e02 100644
--- a/Tests/Normalizer/ObjectNormalizerTest.php
+++ b/Tests/Normalizer/ObjectNormalizerTest.php
@@ -27,6 +27,7 @@
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactory;
 use Symfony\Component\Serializer\Mapping\Factory\ClassMetadataFactoryInterface;
 use Symfony\Component\Serializer\Mapping\Loader\AttributeLoader;
+use Symfony\Component\Serializer\Mapping\Loader\YamlFileLoader;
 use Symfony\Component\Serializer\NameConverter\AdvancedNameConverterInterface;
 use Symfony\Component\Serializer\NameConverter\CamelCaseToSnakeCaseNameConverter;
 use Symfony\Component\Serializer\NameConverter\MetadataAwareNameConverter;
@@ -918,6 +919,40 @@ public function testDenormalizeWithIgnoreAttributeAndPrivateProperties()
 
         $this->assertEquals($expected, $obj);
     }
+
+    public function testNormalizeWithPropertyPath()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new YamlFileLoader(__DIR__.'/../Fixtures/property-path-mapping.yaml'));
+        $normalizer = new ObjectNormalizer($classMetadataFactory, new MetadataAwareNameConverter($classMetadataFactory));
+
+        $dummyInner = new ObjectInner();
+        $dummyInner->foo = 'foo';
+        $dummy = new ObjectOuter();
+        $dummy->setInner($dummyInner);
+
+        $this->assertSame(['inner_foo' => 'foo'], $normalizer->normalize($dummy, 'json', ['groups' => 'read']));
+    }
+
+    public function testDenormalizeWithPropertyPath()
+    {
+        $classMetadataFactory = new ClassMetadataFactory(new YamlFileLoader(__DIR__.'/../Fixtures/property-path-mapping.yaml'));
+        $normalizer = new ObjectNormalizer($classMetadataFactory, new MetadataAwareNameConverter($classMetadataFactory));
+
+        $dummy = new ObjectOuter();
+        $dummy->setInner(new ObjectInner());
+
+        $obj = $normalizer->denormalize(['inner_foo' => 'foo'], ObjectOuter::class, 'json', [
+            'object_to_populate' => $dummy,
+            'groups' => 'read',
+        ]);
+
+        $expectedInner = new ObjectInner();
+        $expectedInner->foo = 'foo';
+        $expected = new ObjectOuter();
+        $expected->setInner($expectedInner);
+
+        $this->assertEquals($expected, $obj);
+    }
 }
 
 class ProxyObjectDummy extends ObjectDummy