Improve null handling

[latonz]

Currently, Mapperly upgrades non-nullable reference types to annotated nullable reference types early in the mapping pipeline. Additionally, when nullables are involved, Mapperly incorporates null handling into the mapping process and continues the pipeline with non-nullable types. This approach centralizes null handling, making it simple and consistent.

However, this design has led to several bugs, indicating the need for a more robust solution. We need to define a clear concept to address these issues and improve the handling of nullable reference types without compromising simplicity or maintainability.

Related Bugs:

• Invalid mapping for nullable arrays #1611
• Unexpected IQueryable mapping when project's Nullable flag is set to "disable" #1293
• UseDeepCloning generate Dictionary<string?, xxx> when mapping from nullable disable class file #1615

See also #1117 (comment).

[TonEnfer]

I think that when doing this task, you should also take into account similar conversions from #1117:

Source	Is nullable	Target	Is nullable	Expected result
class A {}	true	class B { static B Create(A source) }	false	target = global::B.Create(source ?? throw new ArgumentNullException(nameof(source)));
class A {}	false	class B { static B? Create(A source) }	false	target = global::B.Create(source) ?? throw new ArgumentNullException();
class A {}	false	struct B { static B? Create(A source) }	false	target = global::B.Create(source) ?? throw new ArgumentNullException(); or target = global::B.Create(source).GetValueOrDefault();

Also pay attention to the results of these two tests:

mapperly/test/Riok.Mapperly.Tests/Mapping/StaticMethodConversionTest.cs

Lines 135 to 146 in 39376fa

	public void MapNonNullableValueTypeToNullableValueType()
	{
	var source = TestSourceBuilder.Mapping("B", "A?", "struct A { public static A FromB(B source) => new(); }; struct B {}");
	TestHelper.GenerateMapper(source).Should().HaveSingleMethodBody("return (global::A?)global::A.FromB(source);");
	}
	[Fact]
	public void MapNonNullableValueTypeToNullableValueTypeWithNullableMethodParameter()
	{
	var source = TestSourceBuilder.Mapping("B", "A?", "struct A { public static A FromB(B? source) => new(); }; struct B {}");
	TestHelper.GenerateMapper(source).Should().HaveSingleMethodBody("return global::A.FromB(source);");
	}

[CoreDX9]

Can null value assignments be configured separately for each property?
Like this:

[AllowNullPropertyAssignment(false, Include = ["ArrayProp1", "ListProp2"])]
public static partial void UpdateEntity(this UpdateDto dto, MyEntity entity);

This way, null values can be used in the collection navigation properties to indicate that the collection navigation properties are not modified when update entity using EF Core.

[latonz]

This is not yet possible.

[johnnyelwailer]

Greetings. I have a related use case.
Consider this code:

    public class SourceItem
    {
        public required string Name { get; set; }
    }

    public class DestinationItem
    {
        public required string Name { get; set; }
    }

    public class Source
    {
        public SourceItem[]? Items { get; set; }
    }
    
    public class Destination
    {
        public required DestinationItem[] Items { get; set; }
    }
    
    [Mapper(ThrowOnPropertyMappingNullMismatch = false, ThrowOnMappingNullMismatch = false)]
    public partial class TestMapper
    {
        public partial Destination Map(Source source);
    }

It generates the following method

        [global::System.CodeDom.Compiler.GeneratedCode("Riok.Mapperly", "4.2.0.0")]
        public partial global::<Api.Destination Map(global::Api.Mapping.Source source)
        {
            var target = new global::Api.Mapping.Destination()
            {
                Items = source.Items != null ? MapToDestinationItemArray(source.Items) : throw new System.ArgumentNullException(nameof(source.Items)),
            };
            return target;
        }

BUT, at the same time, it emits a compilation error:
RMG002: Api.Mapping.DestinationItem[] has no accessible parameterless constructor

I guess the best solution to just try to use a empty collection initalizer?
Like

Items = source.Items != null ? MapToDestinationItemArray(source.Items) : []

Currently I can workaround this problem by manually adding the following code:

        public partial DestinationItem Map(SourceItem sourceItem);
        public DestinationItem[] Map(SourceItem[]? sourceItems)
        {
            return sourceItems?.Select(this.Map).ToArray() ?? [];
        }

Thanks for considering.