MapProperty.Use: Default + non-default user mappings generate wrong (chained) mapping code

[InspiringCode]

Consider the following classes:

public class Model
{
    public Length Length { get; set; }

    public Length Thickness { get; set; }
}

public class ModelDto
{
    public double LengthInMeter { get; set; }

    public double ThicknessInMillimeter { get; set; }
}

And the following mapper:

[Mapper]
public partial class DemoMapper
{
    [MapProperty("Length", "LengthInMeter", Use = nameof(ToMeters))]
    [MapProperty("Thickness", "ThicknessInMillimeter")]
    public partial ModelDto ToDto(Model source);

    // Here we just copied the attributes from 'ToDto' but accidentally
    // forget to change the mapping method from 'ToMeters' to its
    // inverse ('FromMeters'), which could easily happen in practice...
    [MapProperty("LengthInMeter", "Length", Use = nameof(ToMeters))]
    [MapProperty("ThicknessInMillimeter", "Thickness")]
    public partial Model ToModelWrong(ModelDto source);

    [MapProperty("LengthInMeter", "Length", Use = nameof(FromMeters))]
    [MapProperty("ThicknessInMillimeter", "Thickness")]
    public partial Model ToModelCorrect(ModelDto source);


    // 95% of all Length properties are in millimeters, so we use this as default
    public double ToMillimeters(Length length) => length.Millimeters;
    public Length FromMillimeters(double valueInMm) => Length.FromMillimeters(valueInMm);

    [UserMapping(Default = false)]
    public double ToMeters(Length length) => length.Meters;
    [UserMapping(Default = false)]
    public Length FromMeters(double length) => Length.FromMeters(length);
}

In ToModelWrong we want to convert a double to Length, but we explicitly specify a mapping method that converts from Length to double (ToMeters). Since we also have a default mapping method that converts double to Length (FromMillimeters), Mapperly generates the following mapping (double -> Length, Length -> double, double -> Length):

target.Length = FromMillimeters(ToMeters(FromMillimeters(source.LengthInMeter)));

But this is obviously very wrong and unexpected. In this case I would expect an error from Mapperly because I explicitly specified a mapping method that has an incompatible signature.

[latonz]

Mapperly tries to map these types to compatible types. As this behaviour is already released in a stable version and may also be useful in some scenarios we cannot remove it completely anymore. I still understand your point. I think we should introduce a compile time warning whenever a MapPropertyAttribute.Use mapping has incompatible types.

[InspiringCode]

@latonz Sounds reasonable. Users can then change the Analyzer Rule ID severity to Error or none, depending on their preference.

[github-actions]

🎉 This issue has been resolved in version 3.6.0-next.1 🎉

The release is available on:

• GitHub release
• v3.6.0-next.1

Your semantic-release bot 📦🚀

[github-actions]

🎉 This issue has been resolved in version 3.6.0 🎉

The release is available on:

• GitHub release
• v3.6.0

Your semantic-release bot 📦🚀