[ObjectMapper] Why is an explicit #[Map(source: '...')] only applied as a fallback when the same-named property isn't readable on the source? #64861

What I'm trying to understand

I'm mapping an object that has no ObjectMapper metadata (a Doctrine entity) to a target DTO. A target property declares an explicit nested path, e.g. #[Map(source: 'category.label')], while the source also exposes a property named category (a related object, readable through a public getter).

I noticed that whether the explicit source path is used depends on whether the same-named property is readable on the source, and I'd like to understand the intended semantics here.

Where I see it

In ObjectMapper::doMap() (branch 8.1):

$sourcePropertyName = $propertyName;
if ($mapping->source && !$this->isReadable($source, $propertyName)) {
    $sourcePropertyName = $mapping->source;
}
// ...
$value = $this->getRawValue($source, $sourcePropertyName);

So the explicit $mapping->source is applied only when the target property name is not readable on the source; otherwise the same-named source property is read directly.

I also noticed the effective behavior differs between two releases:

• v8.1.0, the guard was !$refl->hasProperty($propertyName) || !isset($source->$propertyName). For a private source property with a public getter, isset($source->$name) is false, so the explicit source path was taken.
• v8.1.1 (after [ObjectMapper] Fix mapping of private properties from parent classes #63791), isReadable() goes through the PropertyAccessor and returns true for a property exposed via a public getter, so the same-named property is read directly instead of the explicit source path.

That difference is what prompted me to ask: v8.1.1 seems consistent (a property with a public getter genuinely is readable), so I assume the fallback semantics are deliberate — I just want to understand the design and the recommended usage.

Small example

use Symfony\Component\ObjectMapper\Attribute\Map;
use Symfony\Component\ObjectMapper\Metadata\ReflectionObjectMapperMetadataFactory;
use Symfony\Component\ObjectMapper\ObjectMapper;
use Symfony\Component\PropertyAccess\PropertyAccess;

class Inner
{
    public function __construct(public string $label) {}
}

class Source
{
    public function __construct(private Inner $category) {}

    public function getCategory(): Inner
    {
        return $this->category;
    }
}

class Target
{
    #[Map(source: 'category.label')]
    public string $category = '';
}

$mapper = new ObjectMapper(
    new ReflectionObjectMapperMetadataFactory(),
    PropertyAccess::createPropertyAccessor(),
);

$result = $mapper->map(new Source(new Inner('hello')), Target::class);

var_dump($result->category);

• On v8.1.0, $result->category is "hello" (the category.label path is followed).
• On v8.1.1, the raw Inner from getCategory() is read instead of the category.label path.

My questions

1. Is it intended that an explicit #[Map(source: '...')] acts as a fallback, applied only when the same-named property is not readable on the source? What's the reasoning behind keying it on readability of the target-property name?
2. When the target property shares its name with a readable source property, what is the recommended way to populate it from a nested value — a transform (e.g. #[Map(source: 'category', transform: ...)]), or giving the target property a different name (keeping the serialized key via #[SerializedName])?

Thanks a lot for the guidance!