feat: add user implemented existing target mapping

riok · Aug 1, 2023 · 1cff8e3 · 1cff8e3
1 parent e8fc876
commit 1cff8e3
Show file tree

Hide file tree

Showing 33 changed files with 367 additions and 13 deletions.
diff --git a/src/Riok.Mapperly/Descriptors/MappingBodyBuilders/RuntimeTargetTypeMappingBodyBuilder.cs b/src/Riok.Mapperly/Descriptors/MappingBodyBuilders/RuntimeTargetTypeMappingBodyBuilder.cs
@@ -45,8 +45,8 @@ private static IEnumerable<ITypeMapping> GetUserMappingCandidates(MappingBuilder
     {
         foreach (var userMapping in ctx.UserMappings)
         {
-            // exclude runtime target type mappings
-            if (userMapping is UserDefinedNewInstanceRuntimeTargetTypeMapping)
+            // exclude runtime target type and user implemented existing type mappings
+            if (userMapping is UserDefinedNewInstanceRuntimeTargetTypeMapping or UserImplementedExistingTargetMethodMapping)
                 continue;
 
             if (userMapping.CallableByOtherMappings)

diff --git a/src/Riok.Mapperly/Descriptors/MappingCollection.cs b/src/Riok.Mapperly/Descriptors/MappingCollection.cs
@@ -66,6 +66,15 @@ public void Add(ITypeMapping mapping)
             _methodMappings.Add(methodMapping);
         }
 
+        if (mapping.CallableByOtherMappings && mapping is UserImplementedExistingTargetMethodMapping existingMapping)
+        {
+            if (FindExistingInstanceMapping(mapping.SourceType, mapping.TargetType) is null)
+            {
+                _existingTargetMappings.Add(new TypeMappingKey(mapping), existingMapping);
+            }
+            return;
+        }
+
         if (mapping.CallableByOtherMappings && Find(mapping.SourceType, mapping.TargetType) is null)
         {
             _mappings.Add(new TypeMappingKey(mapping), mapping);

diff --git a/....Mapperly/Descriptors/Mappings/UserMappings/UserImplementedExistingTargetMethodMapping.cs b/....Mapperly/Descriptors/Mappings/UserMappings/UserImplementedExistingTargetMethodMapping.cs
@@ -0,0 +1,75 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Riok.Mapperly.Descriptors.Mappings.ExistingTarget;
+using Riok.Mapperly.Emit;
+using Riok.Mapperly.Helpers;
+using Riok.Mapperly.Symbols;
+
+namespace Riok.Mapperly.Descriptors.Mappings.UserMappings;
+
+/// <summary>
+/// Represents an existing target type mapper which is implemented by the user.
+/// </summary>
+public class UserImplementedExistingTargetMethodMapping : ExistingTargetMapping, IUserMapping
+{
+    private readonly MethodParameter _sourceParameter;
+    private readonly MethodParameter _targetParameter;
+    private readonly MethodParameter? _referenceHandlerParameter;
+
+    public UserImplementedExistingTargetMethodMapping(
+        IMethodSymbol method,
+        MethodParameter sourceParameter,
+        MethodParameter targetParameter,
+        MethodParameter? referenceHandlerParameter
+    )
+        : base(method.Parameters[0].Type.UpgradeNullable(), targetParameter.Type.UpgradeNullable())
+    {
+        Method = method;
+        _sourceParameter = sourceParameter;
+        _targetParameter = targetParameter;
+        _referenceHandlerParameter = referenceHandlerParameter;
+    }
+
+    public IMethodSymbol Method { get; }
+
+    public bool CallableByOtherMappings => true;
+    public bool IsSynthetic => false;
+
+    public ExpressionSyntax Build(TypeMappingBuildContext ctx) =>
+        throw new InvalidOperationException(
+            $"{nameof(UserImplementedExistingTargetMethodMapping)} {ctx.Source}, {ctx.ReferenceHandler} does not support {nameof(Build)}"
+        );
+
+    public override IEnumerable<StatementSyntax> Build(TypeMappingBuildContext ctx, ExpressionSyntax target)
+    {
+        // if the user implemented method is on an interface,
+        // we explicitly cast to be able to use the default interface implementation or explicit implementations
+        if (Method.ReceiverType?.TypeKind != TypeKind.Interface)
+        {
+            yield return SyntaxFactory.ExpressionStatement(
+                SyntaxFactoryHelper.Invocation(
+                    Method.Name,
+                    _sourceParameter.WithArgument(ctx.Source),
+                    _targetParameter.WithArgument(target),
+                    _referenceHandlerParameter?.WithArgument(ctx.ReferenceHandler)
+                )
+            );
+            yield break;
+        }
+
+        var castedThis = SyntaxFactory.CastExpression(
+            SyntaxFactoryHelper.FullyQualifiedIdentifier(Method.ReceiverType!),
+            SyntaxFactory.ThisExpression()
+        );
+        var method = SyntaxFactoryHelper.MemberAccess(SyntaxFactory.ParenthesizedExpression(castedThis), Method.Name);
+        yield return SyntaxFactory.ExpressionStatement(
+            SyntaxFactoryHelper.Invocation(
+                method,
+                _sourceParameter.WithArgument(ctx.Source),
+                _targetParameter.WithArgument(target),
+                _referenceHandlerParameter?.WithArgument(ctx.ReferenceHandler)
+            )
+        );
+    }
+}
diff --git a/src/Riok.Mapperly/Descriptors/UserMethodMappingExtractor.cs b/src/Riok.Mapperly/Descriptors/UserMethodMappingExtractor.cs
@@ -66,13 +66,21 @@ private static IEnumerable<IMethodSymbol> ExtractBaseMethods(SimpleMappingBuilde
         bool isStatic
     )
     {
-        var valid =
-            method is { ReturnsVoid: false, IsGenericMethod: false }
-            && (allowPartial || !method.IsPartialDefinition)
-            && (!isStatic || method.IsStatic);
-        return valid && BuildParameters(ctx, method, out var parameters)
-            ? new UserImplementedMethodMapping(method, parameters.Source, parameters.ReferenceHandler)
-            : null;
+        var valid = !method.IsGenericMethod && (allowPartial || !method.IsPartialDefinition) && (!isStatic || method.IsStatic);
+
+        if (!valid || !BuildParameters(ctx, method, out var parameters))
+        {
+            return null;
+        }
+
+        return method.ReturnsVoid
+            ? new UserImplementedExistingTargetMethodMapping(
+                method,
+                parameters.Source,
+                parameters.Target!.Value,
+                parameters.ReferenceHandler
+            )
+            : new UserImplementedMethodMapping(method, parameters.Source, parameters.ReferenceHandler);
     }
 
     private static IUserMapping? BuilderUserDefinedMapping(SimpleMappingBuilderContext ctx, IMethodSymbol methodSymbol, bool isStatic)

diff --git a/test/Riok.Mapperly.IntegrationTests/BaseMapperTest.cs b/test/Riok.Mapperly.IntegrationTests/BaseMapperTest.cs
@@ -110,6 +110,7 @@ public static TestObject NewTestObj()
                 ExistingISet = { "1", "2", "3", },
                 ExistingHashSet = { "1", "2", "3", },
                 ExistingSortedSet = { "1", "2", "3", },
+                ExistingList = { "1", "2", "3", },
                 ISet = new HashSet<string> { "1", "2", "3", },
 #if NET5_0_OR_GREATER
                 IReadOnlySet = new HashSet<string> { "1", "2", "3", },

diff --git a/test/Riok.Mapperly.IntegrationTests/Dto/TestObjectDto.cs b/test/Riok.Mapperly.IntegrationTests/Dto/TestObjectDto.cs
@@ -81,9 +81,11 @@ public TestObjectDto(int ctorValue, int unknownValue = 10, int ctorValue2 = 100)
 
         public ISet<int> ExistingISet { get; } = new HashSet<int>();
 
-        public HashSet<int> ExistingHashSet { get; } = new HashSet<int>();
+        public HashSet<int> ExistingHashSet { get; } = new();
 
-        public SortedSet<int> ExistingSortedSet { get; } = new SortedSet<int>();
+        public SortedSet<int> ExistingSortedSet { get; } = new();
+
+        public List<int> ExistingList { get; } = new();
 
         public ISet<int> ISet { get; set; } = new HashSet<int>();
 

diff --git a/test/Riok.Mapperly.IntegrationTests/Mapper/StaticTestMapper.cs b/test/Riok.Mapperly.IntegrationTests/Mapper/StaticTestMapper.cs
@@ -39,6 +39,14 @@ public static TestObjectDto MapToDto(TestObject src)
             return target;
         }
 
+        public static void MapExistingList(List<string> src, List<int> dst)
+        {
+            foreach (var item in src)
+            {
+                dst.Add(int.Parse(item));
+            }
+        }
+
         // disable obsolete warning, as the obsolete attribute should still be tested.
 #pragma warning disable CS0618
         [MapperIgnore(nameof(TestObjectDto.IgnoredStringValue))]

diff --git a/test/Riok.Mapperly.IntegrationTests/Models/TestObject.cs b/test/Riok.Mapperly.IntegrationTests/Models/TestObject.cs
@@ -79,9 +79,11 @@ public TestObject(int ctorValue, int unknownValue = 10, int ctorValue2 = 100)
 
         public ISet<string> ExistingISet { get; } = new HashSet<string>();
 
-        public HashSet<string> ExistingHashSet { get; } = new HashSet<string>();
+        public HashSet<string> ExistingHashSet { get; } = new();
 
-        public SortedSet<string> ExistingSortedSet { get; } = new SortedSet<string>();
+        public SortedSet<string> ExistingSortedSet { get; } = new();
+
+        public List<string> ExistingList { get; } = new();
 
         public ISet<string> ISet { get; set; } = new HashSet<string>();
 

diff --git a/...ntegrationTests/_snapshots/NET_48/DeepCloningMapperTest.RunMappingShouldWork.verified.txt b/...ntegrationTests/_snapshots/NET_48/DeepCloningMapperTest.RunMappingShouldWork.verified.txt
@@ -128,6 +128,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/...egrationTests/_snapshots/NET_48/DeepCloningMapperTest.SnapshotGeneratedSource.verified.cs b/...egrationTests/_snapshots/NET_48/DeepCloningMapperTest.SnapshotGeneratedSource.verified.cs
@@ -90,6 +90,11 @@ public static partial class DeepCloningMapper
                 target.ExistingSortedSet.Add(item2);
             }
 
+            foreach (var item3 in src.ExistingList)
+            {
+                target.ExistingList.Add(item3);
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(src.ISet);
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(src.HashSet);
             target.SortedSet = new global::System.Collections.Generic.SortedSet<string>(src.SortedSet);

diff --git a/....Mapperly.IntegrationTests/_snapshots/NET_48/MapperTest.RunMappingShouldWork.verified.txt b/....Mapperly.IntegrationTests/_snapshots/NET_48/MapperTest.RunMappingShouldWork.verified.txt
@@ -144,6 +144,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/...apperly.IntegrationTests/_snapshots/NET_48/MapperTest.SnapshotGeneratedSource.verified.cs b/...apperly.IntegrationTests/_snapshots/NET_48/MapperTest.SnapshotGeneratedSource.verified.cs
@@ -131,6 +131,11 @@ public partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            foreach (var item3 in testObject.ExistingList)
+            {
+                target.ExistingList.Add(ParseableInt(item3));
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.ISet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.HashSet, x => ParseableInt(x)));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<int>(global::System.Linq.Enumerable.Select(testObject.SortedSet, x => ParseableInt(x)));
@@ -214,6 +219,11 @@ public partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(item2.ToString());
             }
 
+            foreach (var item3 in dto.ExistingList)
+            {
+                target.ExistingList.Add(item3.ToString());
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.ISet, x => x.ToString()));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.HashSet, x => x.ToString()));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<string>(global::System.Linq.Enumerable.Select(dto.SortedSet, x => x.ToString()));
@@ -302,6 +312,11 @@ public partial void UpdateDto(global::Riok.Mapperly.IntegrationTests.Models.Test
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            foreach (var item3 in source.ExistingList)
+            {
+                target.ExistingList.Add(ParseableInt(item3));
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.ISet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.HashSet, x => ParseableInt(x)));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<int>(global::System.Linq.Enumerable.Select(source.SortedSet, x => ParseableInt(x)));

diff --git a/...rationTests/_snapshots/NET_48/StaticMapperTest.RunExtensionMappingShouldWork.verified.txt b/...rationTests/_snapshots/NET_48/StaticMapperTest.RunExtensionMappingShouldWork.verified.txt
@@ -139,6 +139,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/...rly.IntegrationTests/_snapshots/NET_48/StaticMapperTest.RunMappingShouldWork.verified.txt b/...rly.IntegrationTests/_snapshots/NET_48/StaticMapperTest.RunMappingShouldWork.verified.txt
@@ -144,6 +144,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/...y.IntegrationTests/_snapshots/NET_48/StaticMapperTest.SnapshotGeneratedSource.verified.cs b/...y.IntegrationTests/_snapshots/NET_48/StaticMapperTest.SnapshotGeneratedSource.verified.cs
@@ -128,6 +128,7 @@ public static partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            MapExistingList(src.ExistingList, target.ExistingList);
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(src.ISet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(src.HashSet, x => ParseableInt(x)));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<int>(global::System.Linq.Enumerable.Select(src.SortedSet, x => ParseableInt(x)));
@@ -229,6 +230,7 @@ public static partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            MapExistingList(testObject.ExistingList, target.ExistingList);
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.ISet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.HashSet, x => ParseableInt(x)));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<int>(global::System.Linq.Enumerable.Select(testObject.SortedSet, x => ParseableInt(x)));
@@ -312,6 +314,11 @@ public static partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(item2.ToString());
             }
 
+            foreach (var item3 in dto.ExistingList)
+            {
+                target.ExistingList.Add(item3.ToString());
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.ISet, x => x.ToString()));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.HashSet, x => x.ToString()));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<string>(global::System.Linq.Enumerable.Select(dto.SortedSet, x => x.ToString()));
@@ -400,6 +407,7 @@ public static partial void UpdateDto(global::Riok.Mapperly.IntegrationTests.Mode
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            MapExistingList(source.ExistingList, target.ExistingList);
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.ISet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.HashSet, x => ParseableInt(x)));
             target.SortedSet = new global::System.Collections.Generic.SortedSet<int>(global::System.Linq.Enumerable.Select(source.SortedSet, x => ParseableInt(x)));

diff --git a/...ts/_snapshots/Roslyn_4_4_OR_LOWER/DeepCloningMapperTest.RunMappingShouldWork.verified.txt b/...ts/_snapshots/Roslyn_4_4_OR_LOWER/DeepCloningMapperTest.RunMappingShouldWork.verified.txt
@@ -128,6 +128,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/.../_snapshots/Roslyn_4_4_OR_LOWER/DeepCloningMapperTest.SnapshotGeneratedSource.verified.cs b/.../_snapshots/Roslyn_4_4_OR_LOWER/DeepCloningMapperTest.SnapshotGeneratedSource.verified.cs
@@ -88,6 +88,12 @@ public static partial class DeepCloningMapper
                 target.ExistingSortedSet.Add(item2);
             }
 
+            target.ExistingList.EnsureCapacity(src.ExistingList.Count + target.ExistingList.Count);
+            foreach (var item3 in src.ExistingList)
+            {
+                target.ExistingList.Add(item3);
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(src.ISet);
             target.IReadOnlySet = global::System.Linq.Enumerable.ToHashSet(src.IReadOnlySet);
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(src.HashSet);

diff --git a/...egrationTests/_snapshots/Roslyn_4_4_OR_LOWER/MapperTest.RunMappingShouldWork.verified.txt b/...egrationTests/_snapshots/Roslyn_4_4_OR_LOWER/MapperTest.RunMappingShouldWork.verified.txt
@@ -144,6 +144,11 @@
     2,
     3
   ],
+  ExistingList: [
+    1,
+    2,
+    3
+  ],
   ISet: [
     1,
     2,

diff --git a/...rationTests/_snapshots/Roslyn_4_4_OR_LOWER/MapperTest.SnapshotGeneratedSource.verified.cs b/...rationTests/_snapshots/Roslyn_4_4_OR_LOWER/MapperTest.SnapshotGeneratedSource.verified.cs
@@ -129,6 +129,12 @@ public partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            target.ExistingList.EnsureCapacity(testObject.ExistingList.Count + target.ExistingList.Count);
+            foreach (var item3 in testObject.ExistingList)
+            {
+                target.ExistingList.Add(ParseableInt(item3));
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.ISet, x => ParseableInt(x)));
             target.IReadOnlySet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.IReadOnlySet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(testObject.HashSet, x => ParseableInt(x)));
@@ -211,6 +217,12 @@ public partial int ParseableInt(string value)
                 target.ExistingSortedSet.Add(item2.ToString());
             }
 
+            target.ExistingList.EnsureCapacity(dto.ExistingList.Count + target.ExistingList.Count);
+            foreach (var item3 in dto.ExistingList)
+            {
+                target.ExistingList.Add(item3.ToString());
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.ISet, x => x.ToString()));
             target.IReadOnlySet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.IReadOnlySet, x => x.ToString()));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(dto.HashSet, x => x.ToString()));
@@ -301,6 +313,12 @@ public partial void UpdateDto(global::Riok.Mapperly.IntegrationTests.Models.Test
                 target.ExistingSortedSet.Add(ParseableInt(item2));
             }
 
+            target.ExistingList.EnsureCapacity(source.ExistingList.Count + target.ExistingList.Count);
+            foreach (var item3 in source.ExistingList)
+            {
+                target.ExistingList.Add(ParseableInt(item3));
+            }
+
             target.ISet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.ISet, x => ParseableInt(x)));
             target.IReadOnlySet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.IReadOnlySet, x => ParseableInt(x)));
             target.HashSet = global::System.Linq.Enumerable.ToHashSet(global::System.Linq.Enumerable.Select(source.HashSet, x => ParseableInt(x)));