Fix inconsistent handling of mixed nullable contexts

Allow using non-null returning mapping methods when target type does allow nulls

src/Riok.Mapperly/Descriptors/MappingBuilderContext.cs

@@ -154,7 +154,9 @@ bool ignoreDerivedTypes
         Location? diagnosticLocation = null
     )
     {
-        return FindMapping(mappingKey) ?? BuildMapping(mappingKey, options, diagnosticLocation);
+        return FindMapping(mappingKey)
+            ?? FindMapping(mappingKey.TargetNonNullable())
+            ?? BuildMapping(mappingKey, options, diagnosticLocation);
     }
 
     /// <summary>

src/Riok.Mapperly/Descriptors/TypeMappingKey.cs

@@ -26,6 +26,8 @@ public TypeMappingKey(ITypeMapping mapping, TypeMappingConfiguration? config = n
 
     public TypeMappingKey NonNullable() => new(Source.NonNullable(), Target.NonNullable(), Configuration);
 
+    public TypeMappingKey TargetNonNullable() => new(Source, Target.NonNullable(), Configuration);
+
     public override bool Equals(object? obj) =>
         obj is TypeMappingKey other
         && _comparer.Equals(Source, other.Source)

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

@@ -899,4 +899,33 @@ private A(C value)
                 """
             );
     }
+
+    [Fact]
+    public Task MixedNullableContextsWithDerivedTypesShouldWork()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            """
+            [MapDerivedType<A, B>]
+            public partial BBase Map(ABase src);
+            """,
+            """
+            #nullable disable
+            public abstract record BBase
+            {
+                public List<BBase> Objects { get; init; } = [];
+            }
+
+            public record B : BBase;
+
+            #nullable enable
+            public abstract record ABase
+            {
+                public List<ABase> Objects { get; init; } = [];
+            }
+
+            public record A: ABase;
+            """
+        );
+        return TestHelper.VerifyGenerator(source);
+    }
 }

test/Riok.Mapperly.Tests/_snapshots/ObjectPropertyNullableTest.MixedNullableContextsWithDerivedTypesShouldWork#Mapper.g.verified.cs

@@ -0,0 +1,36 @@
+//HintName: Mapper.g.cs
+// <auto-generated />
+#nullable enable
+public partial class Mapper
+{
+    [global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "0.0.1.0")]
+    public partial global::BBase Map(global::ABase src)
+    {
+        return src switch
+        {
+            global::A x => MapToB(x),
+            _ => throw new System.ArgumentException($"Cannot map {src.GetType()} to BBase as there is no known derived type mapping", nameof(src)),
+        };
+    }
+
+    [global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "0.0.1.0")]
+    private global::B MapToB(global::A source)
+    {
+        var target = new global::B()
+        {
+            Objects = MapToListOfBBase(source.Objects),
+        };
+        return target;
+    }
+
+    [global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "0.0.1.0")]
+    private global::System.Collections.Generic.List<global::BBase?> MapToListOfBBase(global::System.Collections.Generic.IReadOnlyCollection<global::ABase> source)
+    {
+        var target = new global::System.Collections.Generic.List<global::BBase?>(source.Count);
+        foreach (var item in source)
+        {
+            target.Add(Map(item));
+        }
+        return target;
+    }
+}