fix: generate generic mapping only for matching source / target types…

… if non-generic (#1000)

docs/docs/configuration/generic-mapping.md

@@ -7,22 +7,23 @@ description: Create a generic mapping method
 
 Mapperly supports generic user defined mapping methods.
 Mapperly implements this mapping method
-using all mappings the user defined in the mapper.
+using all mappings the user defined in the mapper that satisfy the source and target type constraints.
 
 ```csharp
 [Mapper]
 public static partial class ModelMapper
 {
     // highlight-start
-    public static partial TTarget Map<TTarget>(object source);
+    public static partial TTarget MapFruit<TTarget>(Fruit source);
     // highlight-end
 
     private static partial BananaDto MapBanana(Banana source);
     private static partial AppleDto MapApple(Apple source);
 }
 
-class Banana {}
-class Apple {}
+class Fruit {}
+class Banana : Fruit {}
+class Apple : Fruit {}
 
 class BananaDto {}
 class AppleDto {}

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/RuntimeTargetTypeMappingBodyBuilder.cs

@@ -1,3 +1,4 @@
+using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Descriptors.MappingBuilders;
 using Riok.Mapperly.Descriptors.Mappings;
 using Riok.Mapperly.Descriptors.Mappings.UserMappings;
@@ -16,14 +17,24 @@ public static void BuildMappingBody(MappingBuilderContext ctx, UserDefinedNewIns
         var mappings = GetUserMappingCandidates(ctx)
             .Where(
                 x =>
-                    mapping
+                    DoesTypesSatisfySubstitutionPrinciples(mapping, ctx.SymbolAccessor, x.SourceType.NonNullable(), x.TargetType)
+                    && mapping
                         .TypeParameters
                         .DoesTypesSatisfyTypeParameterConstraints(ctx.SymbolAccessor, x.SourceType.NonNullable(), x.TargetType)
             );
 
         BuildMappingBody(ctx, mapping, mappings);
     }
 
+    private static bool DoesTypesSatisfySubstitutionPrinciples(
+        IMapping mapping,
+        SymbolAccessor symbolAccessor,
+        ITypeSymbol sourceType,
+        ITypeSymbol targetType
+    ) =>
+        (mapping.SourceType.TypeKind == TypeKind.TypeParameter || symbolAccessor.HasImplicitConversion(sourceType, mapping.SourceType))
+        && (mapping.TargetType.TypeKind == TypeKind.TypeParameter || symbolAccessor.HasImplicitConversion(targetType, mapping.TargetType));
+
     public static void BuildMappingBody(MappingBuilderContext ctx, UserDefinedNewInstanceRuntimeTargetTypeMapping mapping)
     {
         // source nulls are filtered out by the type switch arms,

test/Riok.Mapperly.Tests/Mapping/GenericTest.cs

@@ -303,6 +303,41 @@ public void WithGenericSourceAndTargetTypeNullableReferenceTypeConstraint()
             );
     }
 
+    [Fact]
+    public void WithGenericSourceSpecificTarget()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            """
+            partial BaseDto Map<TSource>(TSource source);
+
+            partial C MapToC(A source);
+            partial D MapToD(B source);
+            partial MyEnum MapToMyEnum(DtoEnum source);
+            """,
+            "record A(string BaseValue);",
+            "record B(string BaseValue);",
+            "abstract record BaseDto(string BaseValue);",
+            "record C(string BaseValue) : BaseDto(BaseValue);",
+            "record D(string BaseValue) : BaseDto(BaseValue);",
+            "enum DtoEnum;",
+            "enum MyEnum;"
+        );
+        TestHelper
+            .GenerateMapper(source)
+            .Should()
+            .HaveMapMethodBody(
+                """
+                return source switch
+                {
+                    global::A x => MapToC(x),
+                    global::B x => MapToD(x),
+                    null => throw new System.ArgumentNullException(nameof(source)),
+                    _ => throw new System.ArgumentException($"Cannot map {source.GetType()} to {typeof(global::BaseDto)} as there is no known type mapping", nameof(source)),
+                };
+                """
+            );
+    }
+
     [Fact]
     public void WithGenericTarget()
     {
@@ -365,6 +400,41 @@ public void WithGenericTargetTypeConstraints()
             );
     }
 
+    [Fact]
+    public void WithGenericTargetSpecificSource()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            """
+            partial TTarget Map<TTarget>(BaseDto source);
+
+            partial C MapToC(A source);
+            partial D MapToD(B source);
+            partial MyEnum MapToMyEnum(DtoEnum source);
+            """,
+            "abstract record BaseDto(string BaseValue);",
+            "record A(string BaseValue) : BaseDto(BaseValue);",
+            "record B(string BaseValue) : BaseDto(BaseValue);",
+            "record C(string BaseValue);",
+            "record D(string BaseValue);",
+            "enum DtoEnum;",
+            "enum MyEnum;"
+        );
+        TestHelper
+            .GenerateMapper(source)
+            .Should()
+            .HaveMapMethodBody(
+                """
+                return source switch
+                {
+                    global::A x when typeof(TTarget).IsAssignableFrom(typeof(global::C)) => (TTarget)(object)MapToC(x),
+                    global::B x when typeof(TTarget).IsAssignableFrom(typeof(global::D)) => (TTarget)(object)MapToD(x),
+                    null => throw new System.ArgumentNullException(nameof(source)),
+                    _ => throw new System.ArgumentException($"Cannot map {source.GetType()} to {typeof(TTarget)} as there is no known type mapping", nameof(source)),
+                };
+                """
+            );
+    }
+
     [Fact]
     public void WithGenericSourceAndTargetTypeConstraints()
     {