feat: Add option to use other mappers (#661)

docs/docs/configuration/analyzer-diagnostics.mdx

@@ -17,7 +17,6 @@ You won't see the updated mapper code or mapper diagnostics until you perform a
 
 This is done for performance reasons,
 otherwise the IDE could become laggy.
-Improvements are tracked in [#72](https://github.com/riok/mapperly/issues/72).
 :::
 
 ## Editorconfig

docs/docs/configuration/generated-source.mdx

@@ -62,5 +62,4 @@ You won't see the updated mapper code or mapper diagnostics until you perform a
 
 This is done for performance reasons,
 otherwise the IDE could become laggy.
-Improvements are tracked in [#72](https://github.com/riok/mapperly/issues/72).
 :::

docs/docs/configuration/user-implemented-methods.mdx

@@ -0,0 +1,88 @@
+---
+sidebar_position: 5
+description: Manually implement mappings
+---
+
+import Tabs from '@theme/Tabs';
+
+# User implemented mapping methods
+
+If Mapperly cannot generate a mapping, one can implement it manually simply by providing a method body in the mapper declaration:
+
+```csharp
+[Mapper]
+public partial class CarMapper
+{
+    public partial CarDto CarToCarDto(Car car);
+
+    private int TimeSpanToHours(TimeSpan t) => t.Hours;
+}
+```
+
+Whenever Mapperly needs a mapping from `TimeSpan` to `int` inside the `CarMapper` implementation, it will use the provided implementation.
+
+## Use external mappings
+
+Mapperly can also consider mappings implemented in other classes.
+In order for Mapperly to find the mappings, they must be made known with `UseMapper` / `UseStaticMapper`.
+
+<!-- do not indent this, it won't work, https://stackoverflow.com/a/67579641/3302887 -->
+
+<Tabs>
+<TabItem value="static" label="Static">
+
+For static mappings, `UseStaticMapper` can be used:
+
+```csharp
+[Mapper]
+// highlight-start
+[UseStaticMapper<BananaMapper>] // for c# language level ≥ 11
+[UseStaticMapper(typeof(BananaMapper))] // for c# language level < 11
+// highlight-end
+public static partial class BoxMapper
+{
+  public static partial BananaBox MapBananaBox(BananaBoxDto dto);
+}
+
+public static class BananaMapper
+{
+  public static Banana MapBanana(BananaDto dto)
+    => new Banana(dto.Weigth);
+}
+```
+
+</TabItem>
+<TabItem value="instance" label="Instance">
+
+To use the mappings of an object instance `UseMapper` can be used:
+
+```csharp
+[Mapper]
+public static partial class BoxMapper
+{
+    // highlight-start
+    [UseMapper]
+    private readonly BananaMapper _bananaMapper = new();
+    // highlight-end
+
+    public static partial BananaBox MapBananaBox(BananaBoxDto dto);
+}
+
+public static class BananaMapper
+{
+    public static Banana MapBanana(BananaDto dto)
+        => new Banana(dto.Weigth);
+}
+```
+
+:::info
+The initialization of fields and properties annotated with `UseMapper` needs to be done by the user.
+:::
+
+</TabItem>
+</Tabs>
+
+Whenever Mapperly needs a mapping from `BananaBox` to `BananaBoxDto` inside the `BoxMapper` implementation,
+it will use the provided implementation by the `BananaMapper`.
+
+Used mappers themselves can be Mapperly backed classes.

docs/docs/getting-started/faq.md

@@ -24,4 +24,4 @@ Try to rebuild the solution or restart the IDE. This is a bug of the IDE.
 
 ## My advanced use case isn't supported by Mapperly or needs lots of configuration. What should I do?
 
-Write the mapping for that class manually. You can mix automatically generated mappings and [user implemented mappings](../configuration/user-implemented-methods.md) without problems.
+Write the mapping for that class manually. You can mix automatically generated mappings and [user implemented mappings](../configuration/user-implemented-methods.mdx) without problems.

src/Riok.Mapperly.Abstractions/PublicAPI.Shipped.txt

@@ -105,3 +105,9 @@ Riok.Mapperly.Abstractions.MapperIgnoreSourceValueAttribute.SourceValue.get -> S
 Riok.Mapperly.Abstractions.MapperIgnoreTargetValueAttribute.TargetValue.get -> System.Enum?
 Riok.Mapperly.Abstractions.MapperAttribute.AllowNullPropertyAssignment.get -> bool
 Riok.Mapperly.Abstractions.MapperAttribute.AllowNullPropertyAssignment.set -> void
+Riok.Mapperly.Abstractions.UseMapperAttribute
+Riok.Mapperly.Abstractions.UseMapperAttribute.UseMapperAttribute() -> void
+Riok.Mapperly.Abstractions.UseStaticMapperAttribute
+Riok.Mapperly.Abstractions.UseStaticMapperAttribute.UseStaticMapperAttribute(System.Type! mapperType) -> void
+Riok.Mapperly.Abstractions.UseStaticMapperAttribute<T>
+Riok.Mapperly.Abstractions.UseStaticMapperAttribute<T>.UseStaticMapperAttribute() -> void

src/Riok.Mapperly.Abstractions/UseMapperAttribute.cs

@@ -0,0 +1,8 @@
+namespace Riok.Mapperly.Abstractions;
+
+/// <summary>
+/// Considers all accessible mapping methods provided by the type of this member.
+/// Includes static and instance methods.
+/// </summary>
+[AttributeUsage(AttributeTargets.Field | AttributeTargets.Property)]
+public sealed class UseMapperAttribute : Attribute { }

src/Riok.Mapperly.Abstractions/UseStaticMapperAttribute.cs

@@ -0,0 +1,21 @@
+namespace Riok.Mapperly.Abstractions;
+
+/// <summary>
+/// Considers all static mapping methods provided by the type.
+/// </summary>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public sealed class UseStaticMapperAttribute : Attribute
+{
+    /// <summary>
+    /// Considers all static mapping methods provided by the <paramref name="mapperType"/>.
+    /// </summary>
+    /// <param name="mapperType">The type of which mapping methods will be included.</param>
+    public UseStaticMapperAttribute(Type mapperType) { }
+}
+
+/// <summary>
+/// Considers all static mapping methods provided by the generic type.
+/// </summary>
+/// <typeparam name="T">The type of which mapping methods will be included.</typeparam>
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = true)]
+public sealed class UseStaticMapperAttribute<T> : Attribute { }

src/Riok.Mapperly/AnalyzerReleases.Shipped.md

@@ -106,3 +106,11 @@ RMG044  | Mapper   | Warning  | An ignored enum member can not be found on the s
 RMG045  | Mapper   | Warning  | An ignored enum member can not be found on the target enum
 RMG046  | Mapper   | Error    | The used C# language version is not supported by Mapperly, Mapperly requires at least C# 9.0
 RMG047  | Mapper   | Error    | Cannot map to member path due to modifying a temporary value, see CS1612
+
+## Release 3.2
+
+### New Rules
+
+Rule ID | Category | Severity | Notes
+--------|----------|----------|-------
+RMG048 | Mapper | Error | Used mapper members cannot be nullable

src/Riok.Mapperly/Configuration/AttributeDataAccessor.cs

@@ -8,7 +8,7 @@ namespace Riok.Mapperly.Configuration;
 /// <summary>
 /// Creates <see cref="Attribute"/> instances by resolving attribute data from provided symbols.
 /// </summary>
-internal class AttributeDataAccessor
+public class AttributeDataAccessor
 {
     private const string NameOfOperatorName = "nameof";
     private const char FullNameOfPrefix = '@';
@@ -27,6 +27,9 @@ public T AccessSingle<T>(ISymbol symbol)
         where TAttribute : Attribute
         where TData : notnull => Access<TAttribute, TData>(symbol).FirstOrDefault();
 
+    public bool HasAttribute<TAttribute>(ISymbol symbol)
+        where TAttribute : Attribute => _symbolAccessor.GetAttributes<TAttribute>(symbol).Any();
+
     public IEnumerable<TAttribute> Access<TAttribute>(ISymbol symbol)
         where TAttribute : Attribute => Access<TAttribute, TAttribute>(symbol);
 
@@ -60,13 +63,14 @@ public IEnumerable<TData> Access<TAttribute, TData>(ISymbol symbol)
             var attr = Create<TData>(typeArguments, attrData.ConstructorArguments, syntaxArguments);
 
             var syntaxIndex = attrData.ConstructorArguments.Length;
+            var propertiesByName = dataType.GetProperties().GroupBy(x => x.Name).ToDictionary(x => x.Key, x => x.First());
             foreach (var namedArgument in attrData.NamedArguments)
             {
-                var prop = dataType.GetProperty(namedArgument.Key);
-                if (prop == null)
+                if (!propertiesByName.TryGetValue(namedArgument.Key, out var prop))
                     throw new InvalidOperationException($"Could not get property {namedArgument.Key} of attribute {attrType.FullName}");
 
-                prop.SetValue(attr, BuildArgumentValue(namedArgument.Value, prop.PropertyType, syntaxArguments[syntaxIndex]));
+                var value = BuildArgumentValue(namedArgument.Value, prop.PropertyType, syntaxArguments[syntaxIndex]);
+                prop.SetValue(attr, value);
                 syntaxIndex++;
             }
 

src/Riok.Mapperly/Configuration/MapperConfiguration.cs

@@ -1,6 +1,5 @@
 using Microsoft.CodeAnalysis;
 using Riok.Mapperly.Abstractions;
-using Riok.Mapperly.Descriptors;
 using Riok.Mapperly.Helpers;
 
 namespace Riok.Mapperly.Configuration;
@@ -10,9 +9,9 @@ public class MapperConfiguration
     private readonly MappingConfiguration _defaultConfiguration;
     private readonly AttributeDataAccessor _dataAccessor;
 
-    public MapperConfiguration(SymbolAccessor symbolAccessor, ISymbol mapperSymbol)
+    public MapperConfiguration(AttributeDataAccessor dataAccessor, ISymbol mapperSymbol)
     {
-        _dataAccessor = new AttributeDataAccessor(symbolAccessor);
+        _dataAccessor = dataAccessor;
         Mapper = _dataAccessor.AccessSingle<MapperAttribute>(mapperSymbol);
         _defaultConfiguration = new MappingConfiguration(
             new EnumMappingConfiguration(

src/Riok.Mapperly/Configuration/UseStaticMapperConfiguration.cs

@@ -0,0 +1,5 @@
+using Microsoft.CodeAnalysis;
+
+namespace Riok.Mapperly.Configuration;
+
+public record UseStaticMapperConfiguration(ITypeSymbol MapperType);

src/Riok.Mapperly/Descriptors/DescriptorBuilder.cs

@@ -2,6 +2,7 @@
 using Microsoft.CodeAnalysis.CSharp.Syntax;
 using Riok.Mapperly.Abstractions.ReferenceHandling;
 using Riok.Mapperly.Configuration;
+using Riok.Mapperly.Descriptors.ExternalMappings;
 using Riok.Mapperly.Descriptors.MappingBodyBuilders;
 using Riok.Mapperly.Descriptors.MappingBuilders;
 using Riok.Mapperly.Descriptors.ObjectFactories;
@@ -33,11 +34,14 @@ SymbolAccessor symbolAccessor
         _mapperDescriptor = new MapperDescriptor(mapperSyntax, mapperSymbol, _methodNameBuilder);
         _symbolAccessor = symbolAccessor;
         _mappingBodyBuilder = new MappingBodyBuilder(_mappings);
+
+        var attributeAccessor = new AttributeDataAccessor(symbolAccessor);
         _builderContext = new SimpleMappingBuilderContext(
             compilation,
-            new MapperConfiguration(symbolAccessor, mapperSymbol),
+            new MapperConfiguration(attributeAccessor, mapperSymbol),
             wellKnownTypes,
             _symbolAccessor,
+            attributeAccessor,
             _mapperDescriptor,
             _diagnostics,
             new MappingBuilder(_mappings),
@@ -50,6 +54,7 @@ SymbolAccessor symbolAccessor
         ReserveMethodNames();
         ExtractObjectFactories();
         ExtractUserMappings();
+        ExtractExternalMappings();
         _mappingBodyBuilder.BuildMappingBodies();
         BuildMappingMethodNames();
         BuildReferenceHandlingParameters();
@@ -79,6 +84,14 @@ private void ExtractUserMappings()
         }
     }
 
+    private void ExtractExternalMappings()
+    {
+        foreach (var externalMapping in ExternalMappingsExtractor.ExtractExternalMappings(_builderContext, _mapperDescriptor.Symbol))
+        {
+            _mappings.Add(externalMapping);
+        }
+    }
+
     private void ReserveMethodNames()
     {
         foreach (var methodSymbol in _symbolAccessor.GetAllMembers(_mapperDescriptor.Symbol))

src/Riok.Mapperly/Descriptors/ExternalMappings/ExternalMappingsExtractor.cs

@@ -0,0 +1,53 @@
+using Microsoft.CodeAnalysis;
+using Riok.Mapperly.Abstractions;
+using Riok.Mapperly.Configuration;
+using Riok.Mapperly.Descriptors.Mappings.UserMappings;
+using Riok.Mapperly.Diagnostics;
+using Riok.Mapperly.Helpers;
+
+namespace Riok.Mapperly.Descriptors.ExternalMappings;
+
+internal static class ExternalMappingsExtractor
+{
+    public static IEnumerable<IUserMapping> ExtractExternalMappings(SimpleMappingBuilderContext ctx, INamedTypeSymbol mapperSymbol)
+    {
+        var staticExternalMappers = ctx.AttributeAccessor
+            .Access<UseStaticMapperAttribute, UseStaticMapperConfiguration>(mapperSymbol)
+            .Concat(ctx.AttributeAccessor.Access<UseStaticMapperAttribute<object>, UseStaticMapperConfiguration>(mapperSymbol))
+            .SelectMany(
+                x =>
+                    UserMethodMappingExtractor.ExtractUserImplementedMappings(
+                        ctx,
+                        x.MapperType,
+                        x.MapperType.FullyQualifiedIdentifierName(),
+                        true
+                    )
+            );
+
+        var externalInstanceMappers = ctx.SymbolAccessor
+            .GetAllMembers(mapperSymbol)
+            .Where(x => ctx.AttributeAccessor.HasAttribute<UseMapperAttribute>(x))
+            .SelectMany(x => ValidateAndExtractExternalInstanceMappings(ctx, x));
+
+        return staticExternalMappers.Concat(externalInstanceMappers);
+    }
+
+    private static IEnumerable<IUserMapping> ValidateAndExtractExternalInstanceMappings(SimpleMappingBuilderContext ctx, ISymbol symbol)
+    {
+        var (name, type, nullableAnnotation) = symbol switch
+        {
+            IFieldSymbol field => (field.Name, field.Type, field.NullableAnnotation),
+            IPropertySymbol prop => (prop.Name, prop.Type, prop.NullableAnnotation),
+            _ => (string.Empty, null, NullableAnnotation.None),
+        };
+
+        if (type == null)
+            return Enumerable.Empty<IUserMapping>();
+
+        if (nullableAnnotation != NullableAnnotation.Annotated)
+            return UserMethodMappingExtractor.ExtractUserImplementedMappings(ctx, type, name, false);
+
+        ctx.ReportDiagnostic(DiagnosticDescriptors.ExternalMapperMemberCannotBeNullable, symbol, symbol.ToDisplayString());
+        return Enumerable.Empty<IUserMapping>();
+    }
+}

src/Riok.Mapperly/Descriptors/Mappings/Enums/EnumFromStringSwitchMapping.cs

@@ -60,7 +60,7 @@ private SwitchExpressionArmSyntax BuildArmIgnoreCase(string ignoreCaseSwitchDesi
             .WithDesignation(SingleVariableDesignation(Identifier(ignoreCaseSwitchDesignatedVariableName)));
 
         // source.Value1
-        var typeMemberAccess = MemberAccess(FullyQualifiedIdentifierName(field.ContainingType.NonNullable()), field.Name);
+        var typeMemberAccess = MemberAccess(field.ContainingType.NonNullable().FullyQualifiedIdentifierName(), field.Name);
 
         // when s.Equals(nameof(source.Value1), StringComparison.OrdinalIgnoreCase)
         var whenClause = WhenClause(