Nested target properties uses same method for different mappings

[filiphr]

It comes from this Stack Overflow question.

In a nutshell:

@Mapper
public interface MyMapper {

@Mappings({
        @Mapping(source = "senderId", target = "sender.id"),
        @Mapping(source = "recipientId", target = "recipient.id")
    })
    Entity toEntity(Dto dto);
}

Generates:

public class MyMapperImpl implements MyMapper {

    @Override
    public Entity toEntity(Dto dto) {
        if ( dto == null ) {
            return null;
        }

        Entity entity = new Entity();

        entity.setRecipient( dtoToClient( dto ) );
        entity.setSender( dtoToClient( dto ) );

        return entity;
    }

    protected Client dtoToClient(Dto dto) {
        if ( dto == null ) {
            return null;
        }

        Client client = new Client();

        client.setId( dto.getRecipientId() );

        return client;
    }
}

It should generate 2 dtoToClient methods instead of one. We most probably need to extend the the PropertyMapping to have the nested name as well and use that somehow in the equals

[filiphr]

Until the bug is resolved one can use a mapper like:

@Mapper
public interface MyMapper {

    @Mappings({
        @Mapping(source = "dto", target = "sender", qualifiedByName = "sender"),
        @Mapping(source = "dto", target = "recipient", qualifiedByName = "recipient")
    })
    Entity toEntity(Dto dto);


    @Named("sender")
    @Mapping(source = "senderId", target = "id")
    Client toClient(Dto dto);

    @Named("recipient")
    @Mapping(source = "recipientId", target = "id")
    Client toClientRecipient(Dto dto);
}

@sjaakd, @agudian, @gunnarmorling this looks a bit complex to fix (if we want to reuse methods). We do this recursively ans when we reach the second level we have lost everything until there... Do you have some suggestion.

[sjaakd]

We do this recursively ans when we reach the second level we have lost everything until there... Do you have some suggestion.

I thought a mapping method is characterized by its signature (excluding the name) and its mappings. Mapping getRecipient is something different than a mapping getSender.. Right? So does the equals work correctly?

[filiphr]

If by mappings you mean the PropertyMapping(s) then yes it is characterized by them. However, currently a PropertyMapping is the same if they have the same name and type. We didn't had access to the source property entries for it.

I think that I found a way for this, we just have to pass the SourceReference.getPropertyEntries() to the PropertyMapping and use them to see if they are same. I am running the suite locally and if everything is OK, I'll make a PR.

[filiphr]

@sjaakd thanks for the comment, it inspired me for the solution :)

[filiphr]

A workaround for going live with 1.2.0.CR1 would be to raise a compile error if something like this can occur, so not to generate a wrong code