Any progress on this PR?

Just putting my 2c into this issue (I made the original suggestion a while back). I believe it would be prudent to generate a single mapping method per permutation. You would then use the @SubclassMapping as the source of truth, only falling back to the most specific common declared ancestor if an exact match was not found.

In the case of second-generation ancestors, we would add a new annotation to specify the common ancestor of each defined subclass mapping. So if I created an inheritance tree as seen below:

@Mapper
public interface CustomMapper {

    @SubclassMapping(source =CarDTO.class, target=Car.class)
    @SubclassMapping(source =BikeDTO.class, target=Bike.class)
    @SubclassMapping(source =F150.class, target=F150DTO.class)
    @SubclassMapping(source =Corvette.class, target=CorvetteDTO.class)
    @SubclassParent(source=Supercar.class, target=SupercarDTO.class)
    void update(@MappingTarget Vehicle target, VehicleDto source);

}

This would build the tree of:

In this case, the F150 and Bike would be downcast to a Vehicle if no exact type-matched mapper was found (because Car was not declared as a @SubclassParent). If the Corvette was similarly downcast, it would match Supercar before it matched Vehicle because of the provided @SubclassParent.

This would mean we would not generate a mapping method that allows the Corvette to be upgraded using a SupercarDTO because the user did not ask us to explicitly create that relation.

In this case, I think its okay to omit non-explicit downcasts of 2nd-generation-onward ancestors, because otherwise you get the whole problem of generating a mapper for the cross product of every class and every DTO that is an ancestor of the @SubclassMapping. If we allow the craziness to unfold, we are going to get people asking why they cannot provide a Corvette to the F150 mapping because they both can be downcast to Car.

Without the @SubparentMapping you would get this:

Imagine a heirarchy like A -> B -> C

You would have to generate:

Adto -> A
Bdto -> B
Bdto -> A
Cdto -> C
Cdto -> B
Cdto -> A

etc. etc.
Now add C -> D and C -> E

Instead of it being linear, you now have to add:
Ddto -> D
Ddto -> C
Ddto -> B
Ddto -> A
Edto -> E
Edto -> C
Edto -> B
Edto -> A

With the @SubparentMapping(source=Cdto.class, target=C.class)

Ddto -> D
Ddto -> C
Edto -> E
Edto -> C

Finally, I am willing to work on this in my spare time if needed. I would just need to learn the mapstruct ecosystem first.