fix: unique method names

src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs

@@ -49,6 +49,8 @@ public class DescriptorBuilder
     // queue of mappings which don't have the body built yet
     private readonly Queue<(TypeMapping, MappingBuilderContext)> _mappingsToBuildBody = new();
 
+    private readonly MethodNameBuilder _methodNameBuilder = new();
+
     public DescriptorBuilder(
         SourceProductionContext sourceContext,
         Compilation compilation,
@@ -95,6 +97,7 @@ private string BuildName()
             : _mapperSymbol.Name + MapperDescriptor.ImplClassNameSuffix;
     }
 
+
     public MapperDescriptor Build()
     {
         // extract mappings from declarations
@@ -107,7 +110,7 @@ public MapperDescriptor Build()
                 this,
                 userMapping.SourceType,
                 userMapping.TargetType,
-                (userMapping as IHasUserSymbolMapping)?.Method);
+                (userMapping as IUserMapping)?.Method);
             _mappingsToBuildBody.Enqueue((userMapping, ctx));
         }
 
@@ -169,6 +172,11 @@ internal void ReportDiagnostic(DiagnosticDescriptor descriptor, Location? locati
 
     private void BuildMappingBody(MappingBuilderContext ctx, TypeMapping typeMapping)
     {
+        if (typeMapping is not MethodMapping methodMapping)
+            return;
+
+        methodMapping.SetMethodNameIfNeeded(_methodNameBuilder.Build);
+
         switch (typeMapping)
         {
             case ObjectPropertyMapping mapping:
@@ -185,6 +193,7 @@ private void AddMapping(TypeMapping mapping)
 
     private void AddUserMapping(TypeMapping mapping)
     {
+        _methodNameBuilder.Add(((IUserMapping)mapping).Method.Name);
         if (mapping.CallableByOtherMappings && FindMapping(mapping.SourceType, mapping.TargetType) is null)
         {
             AddMapping(mapping);

src/Riok.Mapperly/Descriptors/MethodNameBuilder.cs

@@ -0,0 +1,27 @@
+using Riok.Mapperly.Descriptors.TypeMappings;
+using Riok.Mapperly.Helpers;
+
+namespace Riok.Mapperly.Descriptors;
+
+internal class MethodNameBuilder
+{
+    private const string MethodNamePrefix = "MapTo";
+    private readonly HashSet<string> _usedNames = new();
+
+    internal void Add(string name)
+        => _usedNames.Add(name);
+
+    internal string Build(MethodMapping mapping)
+    {
+        var i = 0;
+        var prefix = MethodNamePrefix + mapping.TargetType.NonNullable().Name;
+        var name = prefix;
+        while (!_usedNames.Add(name))
+        {
+            i++;
+            name = prefix + i;
+        }
+
+        return name;
+    }
+}

src/Riok.Mapperly/Descriptors/TypeMappings/IHasUserSymbolMapping.cs → src/Riok.Mapperly/Descriptors/TypeMappings/IUserMapping.cs

@@ -5,7 +5,7 @@ namespace Riok.Mapperly.Descriptors.TypeMappings;
 /// <summary>
 /// A user defined / implemented mapping.
 /// </summary>
-public interface IHasUserSymbolMapping
+public interface IUserMapping
 {
     IMethodSymbol Method { get; }
 }

src/Riok.Mapperly/Descriptors/TypeMappings/MethodMapping.cs

@@ -1,7 +1,6 @@
 using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.CSharp;
 using Microsoft.CodeAnalysis.CSharp.Syntax;
-using Riok.Mapperly.Helpers;
 using static Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 using static Riok.Mapperly.Emit.SyntaxFactoryHelper;
 
@@ -13,7 +12,7 @@ namespace Riok.Mapperly.Descriptors.TypeMappings;
 public abstract class MethodMapping : TypeMapping
 {
     private const string SourceParamName = "source";
-    private const string MappingMethodNamePrefix = "MapTo";
+    private string? _methodName;
 
     protected MethodMapping(ITypeSymbol sourceType, ITypeSymbol targetType) : base(sourceType, targetType)
     {
@@ -23,7 +22,11 @@ protected MethodMapping(ITypeSymbol sourceType, ITypeSymbol targetType) : base(s
 
     protected bool Override { get; set; }
 
-    protected virtual string MethodName => MappingMethodNamePrefix + TargetType.NonNullable().Name;
+    protected string MethodName
+    {
+        get => _methodName ?? throw new InvalidOperationException();
+        set => _methodName = value;
+    }
 
     public override ExpressionSyntax Build(ExpressionSyntax source)
         => Invocation(MethodName, source);
@@ -43,6 +46,11 @@ public MethodDeclarationSyntax BuildMethod()
 
     public abstract IEnumerable<StatementSyntax> BuildBody(ExpressionSyntax source);
 
+    internal void SetMethodNameIfNeeded(Func<MethodMapping, string> methodNameBuilder)
+    {
+        _methodName ??= methodNameBuilder(this);
+    }
+
     protected virtual ITypeSymbol? ReturnType => TargetType;
 
     protected virtual IEnumerable<ParameterSyntax> BuildParameters()

src/Riok.Mapperly/Descriptors/TypeMappings/UserDefinedExistingInstanceMethodMapping.cs

@@ -10,7 +10,7 @@ namespace Riok.Mapperly.Descriptors.TypeMappings;
 /// Represents a mapping method declared but not implemented by the user which reuses an existing target object instance.
 /// Is implicitly an <see cref="ObjectPropertyMapping"/>, since no other mappings work with an existing target object instance.
 /// </summary>
-public class UserDefinedExistingInstanceMethodMapping : ObjectPropertyMapping, IHasUserSymbolMapping
+public class UserDefinedExistingInstanceMethodMapping : ObjectPropertyMapping, IUserMapping
 {
     public UserDefinedExistingInstanceMethodMapping(
         IMethodSymbol method,
@@ -20,14 +20,13 @@ public UserDefinedExistingInstanceMethodMapping(
         Override = isAbstractMapperDefinition;
         Accessibility = Accessibility.Public;
         Method = method;
+        MethodName = method.Name;
     }
 
     public IMethodSymbol Method { get; }
 
     private IParameterSymbol TargetParameter => Method.Parameters[1];
 
-    protected override string MethodName => Method.Name;
-
     public override bool CallableByOtherMappings => false;
 
     public override ExpressionSyntax Build(ExpressionSyntax source)

src/Riok.Mapperly/Descriptors/TypeMappings/UserDefinedNewInstanceMethodMapping.cs

@@ -8,7 +8,7 @@ namespace Riok.Mapperly.Descriptors.TypeMappings;
 /// <summary>
 /// Represents a mapping method declared but not implemented by the user which results in a new target object instance.
 /// </summary>
-public class UserDefinedNewInstanceMethodMapping : MethodMapping, IHasUserSymbolMapping
+public class UserDefinedNewInstanceMethodMapping : MethodMapping, IUserMapping
 {
     private const string NoMappingComment = "// Could not generate mapping";
 
@@ -18,14 +18,13 @@ public UserDefinedNewInstanceMethodMapping(IMethodSymbol method, bool isAbstract
         Override = isAbstractMapperDefinition;
         Accessibility = Accessibility.Public;
         Method = method;
+        MethodName = method.Name;
     }
 
     public IMethodSymbol Method { get; }
 
     public TypeMapping? DelegateMapping { get; set; }
 
-    protected override string MethodName => Method.Name;
-
     public override IEnumerable<StatementSyntax> BuildBody(ExpressionSyntax source)
     {
         if (DelegateMapping == null)

src/Riok.Mapperly/Descriptors/TypeMappings/UserImplementedMethodMapping.cs

@@ -8,7 +8,7 @@ namespace Riok.Mapperly.Descriptors.TypeMappings;
 /// <summary>
 /// Represents a mapping method on the mapper which is implemented by the user.
 /// </summary>
-public class UserImplementedMethodMapping : TypeMapping, IHasUserSymbolMapping
+public class UserImplementedMethodMapping : TypeMapping, IUserMapping
 {
     public UserImplementedMethodMapping(IMethodSymbol method)
         : base(method.Parameters.Single().Type, method.ReturnType)

test/Directory.Build.props

@@ -25,5 +25,6 @@
     </PackageReference>
     <PackageReference Include="Meziantou.Xunit.ParallelTestFramework" Version="1.0.0"/>
     <PackageReference Include="Verify.XUnit" Version="16.0.0" />
+    <PackageReference Include="Moq" Version="4.16.1" />
   </ItemGroup>
 </Project>

test/Riok.Mapperly.Tests/Descriptors/MethodNameBuilderTest.cs

@@ -0,0 +1,48 @@
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp.Syntax;
+using Moq;
+using Riok.Mapperly.Descriptors;
+using Riok.Mapperly.Descriptors.TypeMappings;
+
+namespace Riok.Mapperly.Tests.Descriptors;
+
+public class MethodNameBuilderTest
+{
+    [Fact]
+    public void ShouldGenerateUniqueMethodNames()
+    {
+        var builder = new MethodNameBuilder();
+        builder.Add("MapToA");
+        builder.Build(NewMethodMappingMock("A"))
+            .Should()
+            .BeEquivalentTo("MapToA1");
+        builder.Build(NewMethodMappingMock("A"))
+            .Should()
+            .BeEquivalentTo("MapToA2");
+        builder.Build(NewMethodMappingMock("B"))
+            .Should()
+            .BeEquivalentTo("MapToB");
+        builder.Build(NewMethodMappingMock("B"))
+            .Should()
+            .BeEquivalentTo("MapToB1");
+    }
+
+    private MethodMapping NewMethodMappingMock(string targetTypeName)
+    {
+        var targetTypeMock = new Mock<ITypeSymbol>();
+        targetTypeMock.Setup(x => x.Name).Returns(targetTypeName);
+        targetTypeMock.Setup(x => x.NullableAnnotation).Returns(NullableAnnotation.NotAnnotated);
+
+        return new MockedMethodMapping(targetTypeMock.Object);
+    }
+
+    private class MockedMethodMapping : MethodMapping
+    {
+        public MockedMethodMapping(ITypeSymbol t) : base(t, t)
+        {
+        }
+
+        public override IEnumerable<StatementSyntax> BuildBody(ExpressionSyntax source)
+            => Enumerable.Empty<StatementSyntax>();
+    }
+}

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

@@ -121,6 +121,21 @@ public void WithMultipleUserDefinedMethodDifferentConfigShouldWork()
     return target;".ReplaceLineEndings());
     }
 
+    [Fact]
+    public void WithSameNamesShouldGenerateUniqueMethodNames()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "B MapToB(A source);",
+            TestSourceBuilderOptions.WithDeepCloning,
+            "class A { public B? Value { get; set; } }",
+            "class B { public B? Value { get; set; } }");
+
+        TestHelper.GenerateMapperMethodBodies(source)
+            .Select(x => x.Name)
+            .Should()
+            .BeEquivalentTo("MapToB", "MapToB2");
+    }
+
     [Fact]
     public Task WithInvalidSignatureShouldDiagnostic()
     {