feat: add configuration whether to deep clone objects (#10)

Add a configuration whether objects are directly assigned if possible or need to be deeply cloned By default direct assignments are allowed
riok · Feb 15, 2022 · baf98fd · baf98fd
1 parent 89f96c4
commit baf98fd
Show file tree

Hide file tree

Showing 12 changed files with 108 additions and 12 deletions.
diff --git a/README.md b/README.md
@@ -43,6 +43,13 @@ The attributes defined in `Riok.Mapperly.Abstractions` can be used to customize
 The `MapperAttribute` provides options to customize the generated mapper class.
 The generated class name, the instance field name and the default enum mapping strategy is adjustable.
 
+### Copy behaviour
+
+By default, Mapperly does not create deep copies of objects to improve performance.
+If an object can be directly assigned to the target, it will do so
+(eg. if the source and target type are both `Car[]`, the array and its entries will not be cloned).
+To create deep copies, set the `UseDeepCloning` property on the `MapperAttribute` to `true`.
+
 #### Properties
 
 On each mapping method declaration property mappings can be customized.

diff --git a/src/Riok.Mapperly.Abstractions/MapperAttribute.cs b/src/Riok.Mapperly.Abstractions/MapperAttribute.cs
@@ -22,4 +22,12 @@ public sealed class MapperAttribute : Attribute
     /// Can be overwritten on specific enums via mapping method configurations.
     /// </summary>
     public EnumMappingStrategy EnumMappingStrategy { get; set; } = EnumMappingStrategy.ByValue;
+
+    /// <summary>
+    /// Whether to always deep copy objects.
+    /// Eg. when the type <c>Person[]</c> should be mapped to the same type <c>Person[]</c>,
+    /// with <c><see cref="UseDeepCloning"/>=true</c>, the same array is reused.
+    /// With <c><see cref="UseDeepCloning"/>=false</c>, the array and each person is cloned.
+    /// </summary>
+    public bool UseDeepCloning { get; set; }
 }
diff --git a/src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs b/src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs
@@ -15,7 +15,7 @@ public class DescriptorBuilder
     private static readonly IReadOnlyCollection<MappingBuilder> _mappingBuilders = new MappingBuilder[]
     {
         SpecialTypeMappingBuilder.TryBuildMapping,
-        ImmutableTypeMappingBuilder.TryBuildMapping,
+        DirectAssignmentMappingBuilder.TryBuildMapping,
         DictionaryMappingBuilder.TryBuildMapping,
         EnumerableMappingBuilder.TryBuildMapping,
         ImplicitCastMappingBuilder.TryBuildMapping,
@@ -56,14 +56,16 @@ public class DescriptorBuilder
         _context = sourceContext;
         Compilation = compilation;
         _mapperDescriptor = new MapperDescriptor(mapperSymbol.Name);
-        Configure();
+        MapperConfiguration = Configure();
     }
 
     internal IReadOnlyDictionary<Type, Attribute> DefaultConfigurations => _defaultConfigurations;
 
     internal Compilation Compilation { get; }
 
-    private void Configure()
+    public MapperAttribute MapperConfiguration { get; }
+
+    private MapperAttribute Configure()
     {
         var mapperAttribute = AttributeDataAccessor.AccessFirstOrDefault<MapperAttribute>(Compilation, _mapperSymbol) ?? new();
         if (!_mapperSymbol.ContainingNamespace.IsGlobalNamespace)
@@ -77,6 +79,7 @@ private void Configure()
         _mapperDescriptor.InstanceName = mapperAttribute.InstanceName;
 
         _defaultConfigurations.Add(typeof(MapEnumAttribute), new MapEnumAttribute(mapperAttribute.EnumMappingStrategy));
+        return mapperAttribute;
     }
 
     private string BuildName()

diff --git a/...ingBuilder/ImmutableTypeMappingBuilder.cs → ...Builder/DirectAssignmentMappingBuilder.cs b/...ingBuilder/ImmutableTypeMappingBuilder.cs → ...Builder/DirectAssignmentMappingBuilder.cs
@@ -4,11 +4,12 @@
 
 namespace Riok.Mapperly.Descriptors.MappingBuilder;
 
-public static class ImmutableTypeMappingBuilder
+public static class DirectAssignmentMappingBuilder
 {
     public static TypeMapping? TryBuildMapping(MappingBuilderContext ctx)
     {
-        return SymbolEqualityComparer.IncludeNullability.Equals(ctx.Source, ctx.Target) && ctx.Source.IsImmutable()
+        return SymbolEqualityComparer.IncludeNullability.Equals(ctx.Source, ctx.Target)
+            && (!ctx.MapperConfiguration.UseDeepCloning || ctx.Source.IsImmutable())
             ? new DirectAssignmentMapping(ctx.Source)
             : null;
     }

diff --git a/src/Riok.Mapperly/Descriptors/MappingBuilder/ExplicitCastMappingBuilder.cs b/src/Riok.Mapperly/Descriptors/MappingBuilder/ExplicitCastMappingBuilder.cs
@@ -8,7 +8,7 @@ public static class ExplicitCastMappingBuilder
 {
     public static CastMapping? TryBuildMapping(MappingBuilderContext ctx)
     {
-        if (!ctx.Source.IsImmutable() && !ctx.Target.IsImmutable())
+        if (ctx.MapperConfiguration.UseDeepCloning && !ctx.Source.IsImmutable() && !ctx.Target.IsImmutable())
             return null;
 
         var conversion = ctx.Compilation.ClassifyConversion(ctx.Source, ctx.Target);

diff --git a/src/Riok.Mapperly/Descriptors/MappingBuilder/ImplicitCastMappingBuilder.cs b/src/Riok.Mapperly/Descriptors/MappingBuilder/ImplicitCastMappingBuilder.cs
@@ -8,7 +8,7 @@ public static class ImplicitCastMappingBuilder
 {
     public static CastMapping? TryBuildMapping(MappingBuilderContext ctx)
     {
-        if (!ctx.Source.IsImmutable() && !ctx.Target.IsImmutable())
+        if (ctx.MapperConfiguration.UseDeepCloning && !ctx.Source.IsImmutable() && !ctx.Target.IsImmutable())
             return null;
 
         var conversion = ctx.Compilation.ClassifyConversion(ctx.Source, ctx.Target);

diff --git a/src/Riok.Mapperly/Descriptors/SimpleMappingBuilderContext.cs b/src/Riok.Mapperly/Descriptors/SimpleMappingBuilderContext.cs
@@ -1,4 +1,5 @@
 using Microsoft.CodeAnalysis;
+using Riok.Mapperly.Abstractions;
 
 namespace Riok.Mapperly.Descriptors;
 
@@ -13,6 +14,8 @@ public SimpleMappingBuilderContext(DescriptorBuilder builder)
 
     public Compilation Compilation => _builder.Compilation;
 
+    public MapperAttribute MapperConfiguration => _builder.MapperConfiguration;
+
     public void ReportDiagnostic(DiagnosticDescriptor descriptor, ISymbol? location, params object[] messageArgs)
         => ReportDiagnostic(descriptor, location?.DeclaringSyntaxReferences.FirstOrDefault()?.GetSyntax(), messageArgs);
 

diff --git a/...k.Mapperly.Tests/Mapping/ValueTypeTest.cs → ...rly.Tests/Mapping/DirectAssignmentTest.cs b/...k.Mapperly.Tests/Mapping/ValueTypeTest.cs → ...rly.Tests/Mapping/DirectAssignmentTest.cs
@@ -1,6 +1,6 @@
 namespace Riok.Mapperly.Tests.Mapping;
 
-public class ValueTypeTest
+public class DirectAssignmentTest
 {
     [Fact]
     public void CustomReadOnlyStructToSameCustomReadOnlyStruct()

diff --git a/test/Riok.Mapperly.Tests/Mapping/EnumerableTest.cs b/test/Riok.Mapperly.Tests/Mapping/EnumerableTest.cs
@@ -8,6 +8,18 @@ public void ArrayToArrayOfPrimitiveTypes()
         var source = TestSourceBuilder.Mapping(
             "int[]",
             "int[]");
+        TestHelper.GenerateSingleMapperMethodBody(source)
+            .Should()
+            .Be("return source;");
+    }
+
+    [Fact]
+    public void ArrayToArrayOfPrimitiveTypesDeepCloning()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "int[]",
+            "int[]",
+            TestSourceBuilderOptions.Default with { UseDeepCloning = true });
         TestHelper.GenerateSingleMapperMethodBody(source)
             .Should()
             .Be("return (int[])source.Clone();");
@@ -20,6 +32,19 @@ public void ArrayCustomClassToArrayCustomClass()
             "B[]",
             "B[]",
             "class B { public int Value {get; set; }}");
+        TestHelper.GenerateSingleMapperMethodBody(source)
+            .Should()
+            .Be("return source;");
+    }
+
+    [Fact]
+    public void ArrayCustomClassToArrayCustomClassDeepCloning()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "B[]",
+            "B[]",
+            TestSourceBuilderOptions.Default with { UseDeepCloning = true },
+            "class B { public int Value { get; set; }}");
         TestHelper.GenerateMapperMethodBody(source)
             .Should()
             .Be("return System.Linq.Enumerable.ToArray(System.Linq.Enumerable.Select(source, x => MapToB(x)));");
@@ -31,6 +56,18 @@ public void ArrayToArrayOfString()
         var source = TestSourceBuilder.Mapping(
             "string[]",
             "string[]");
+        TestHelper.GenerateSingleMapperMethodBody(source)
+            .Should()
+            .Be("return source;");
+    }
+
+    [Fact]
+    public void ArrayToArrayOfStringDeepCloning()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "string[]",
+            "string[]",
+            TestSourceBuilderOptions.Default with { UseDeepCloning = true });
         TestHelper.GenerateSingleMapperMethodBody(source)
             .Should()
             .Be("return (string[])source.Clone();");
@@ -66,7 +103,7 @@ public void EnumerableToEnumerableOfPrimitiveTypes()
             "IEnumerable<int>");
         TestHelper.GenerateSingleMapperMethodBody(source)
             .Should()
-            .Be("return (System.Collections.Generic.IEnumerable<int>)source;");
+            .Be("return source;");
     }
 
     [Fact]

diff --git a/test/Riok.Mapperly.Tests/Mapping/ObjectPropertyTest.cs b/test/Riok.Mapperly.Tests/Mapping/ObjectPropertyTest.cs
@@ -27,6 +27,20 @@ public void SameType()
             "A",
             "class A { public string StringValue { get; set; } }");
 
+        TestHelper.GenerateSingleMapperMethodBody(source)
+            .Should()
+            .Be("return source;");
+    }
+
+    [Fact]
+    public void SameTypeDeepCopies()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "A",
+            TestSourceBuilderOptions.Default with { UseDeepCloning = true },
+            "class A { public string StringValue { get; set; } }");
+
         TestHelper.GenerateSingleMapperMethodBody(source)
             .Should()
             .Be(@"var target = new A();
@@ -41,10 +55,23 @@ public void CustomRefStructToSameCustomStruct()
             "A",
             "A",
             "ref struct A {}");
+        TestHelper.GenerateSingleMapperMethodBody(source)
+            .Should()
+            .Be("return source;");
+    }
+
+    [Fact]
+    public void CustomRefStructToSameCustomStructDeepCloning()
+    {
+        var source = TestSourceBuilder.Mapping(
+            "A",
+            "A",
+            TestSourceBuilderOptions.Default with { UseDeepCloning = true },
+            "ref struct A {}");
         TestHelper.GenerateSingleMapperMethodBody(source)
             .Should()
             .Be(@"var target = new A();
-    return target;");
+    return target;".ReplaceLineEndings());
     }
 
     [Fact]

diff --git a/test/Riok.Mapperly.Tests/TestSourceBuilder.cs b/test/Riok.Mapperly.Tests/TestSourceBuilder.cs
@@ -26,14 +26,21 @@ public static string MapperWithBody(string body, TestSourceBuilderOptions? optio
 
 {(options.Namespace != null ? $"namespace {options.Namespace};" : string.Empty)}
 
-[Mapper]
+{BuildAttribute(options)}
 public {(options.AsInterface ? "interface I" : "abstract class ")}Mapper
 {{
     {body}
 }}
 ";
     }
 
+    private static string BuildAttribute(TestSourceBuilderOptions options)
+    {
+        return options.UseDeepCloning
+            ? "[Mapper(UseDeepCloning = true)]"
+            : "[Mapper]";
+    }
+
     public static string MapperWithBodyAndTypes(string body, params string[] types)
         => MapperWithBodyAndTypes(body, null, types);
 

diff --git a/test/Riok.Mapperly.Tests/TestSourceBuilderOptions.cs b/test/Riok.Mapperly.Tests/TestSourceBuilderOptions.cs
@@ -1,6 +1,9 @@
 namespace Riok.Mapperly.Tests;
 
-public record TestSourceBuilderOptions(bool AsInterface = true, string? Namespace = null)
+public record TestSourceBuilderOptions(
+    bool AsInterface = true,
+    string? Namespace = null,
+    bool UseDeepCloning = false)
 {
     public static readonly TestSourceBuilderOptions Default = new();
 }