feat: add support for nested properties

src/Riok.Mapperly.Abstractions/MapperNestedPropertiesAttribute.cs

@@ -0,0 +1,37 @@
+namespace Riok.Mapperly.Abstractions;
+
+/// <summary>
+/// Maps all properties from a nested path to the root destination.
+/// </summary>
+[AttributeUsage(AttributeTargets.Method, AllowMultiple = true)]
+public class MapperNestedPropertiesAttribute : Attribute
+{
+    private const string PropertyAccessSeparatorStr = ".";
+    private const char PropertyAccessSeparator = '.';
+
+    /// <summary>
+    /// Maps a specified source property to the specified target property.
+    /// </summary>
+    /// <param name="source">The name of the source property. The use of `nameof()` is encouraged. A path can be specified by joining property names with a '.'.</param>
+    public MapperNestedPropertiesAttribute(string source)
+        : this(source.Split(PropertyAccessSeparator)) { }
+
+    /// <summary>
+    /// Maps a specified source property to the specified target property.
+    /// </summary>
+    /// <param name="source">The path of the source property. The use of `nameof()` is encouraged.</param>
+    public MapperNestedPropertiesAttribute(string[] source)
+    {
+        Source = source;
+    }
+
+    /// <summary>
+    /// Gets the name of the source property.
+    /// </summary>
+    public IReadOnlyCollection<string> Source { get; }
+
+    /// <summary>
+    /// Gets the full name of the source property path.
+    /// </summary>
+    public string SourceFullName => string.Join(PropertyAccessSeparatorStr, Source);
+}

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

@@ -105,3 +105,8 @@ Riok.Mapperly.Abstractions.MapperIgnoreTargetValueAttribute
 Riok.Mapperly.Abstractions.MapperIgnoreTargetValueAttribute.MapperIgnoreTargetValueAttribute(object! target) -> void
 Riok.Mapperly.Abstractions.MapperIgnoreSourceValueAttribute.SourceValue.get -> System.Enum?
 Riok.Mapperly.Abstractions.MapperIgnoreTargetValueAttribute.TargetValue.get -> System.Enum?
+Riok.Mapperly.Abstractions.MapperNestedPropertiesAttribute
+Riok.Mapperly.Abstractions.MapperNestedPropertiesAttribute.MapperNestedPropertiesAttribute(string! source) -> void
+Riok.Mapperly.Abstractions.MapperNestedPropertiesAttribute.MapperNestedPropertiesAttribute(string![]! source) -> void
+Riok.Mapperly.Abstractions.MapperNestedPropertiesAttribute.Source.get -> System.Collections.Generic.IReadOnlyCollection<string!>!
+Riok.Mapperly.Abstractions.MapperNestedPropertiesAttribute.SourceFullName.get -> string!

src/Riok.Mapperly/Configuration/MapperConfiguration.cs

@@ -27,6 +27,7 @@ public MapperConfiguration(SymbolAccessor symbolAccessor, ISymbol mapperSymbol)
                 Array.Empty<string>(),
                 Array.Empty<string>(),
                 Array.Empty<PropertyMappingConfiguration>(),
+                Array.Empty<NestedPropertyMappingConfiguration>(),
                 Mapper.IgnoreObsoleteMembersStrategy
             ),
             Array.Empty<DerivedTypeMappingConfiguration>()
@@ -74,8 +75,14 @@ private PropertiesMappingConfiguration BuildPropertiesConfig(IMethodSymbol metho
         var ignoreObsolete = _dataAccessor.Access<MapperIgnoreObsoleteMembersAttribute>(method).FirstOrDefault() is not { } methodIgnore
             ? _defaultConfiguration.Properties.IgnoreObsoleteMembersStrategy
             : methodIgnore.IgnoreObsoleteStrategy;
-
-        return new PropertiesMappingConfiguration(ignoredSourceProperties, ignoredTargetProperties, explicitMappings, ignoreObsolete);
+        var nestedMappings = _dataAccessor.Access<MapperNestedPropertiesAttribute, NestedPropertyMappingConfiguration>(method).ToList();
+        return new PropertiesMappingConfiguration(
+            ignoredSourceProperties,
+            ignoredTargetProperties,
+            explicitMappings,
+            nestedMappings,
+            ignoreObsolete
+        );
     }
 
     private EnumMappingConfiguration BuildEnumConfig(MappingConfigurationReference configRef)

src/Riok.Mapperly/Configuration/NestedPropertyMappingConfiguration.cs

@@ -0,0 +1,3 @@
+namespace Riok.Mapperly.Configuration;
+
+public record NestedPropertyMappingConfiguration(StringMemberPath Source);

src/Riok.Mapperly/Configuration/PropertiesMappingConfiguration.cs

@@ -6,5 +6,6 @@ public record PropertiesMappingConfiguration(
     IReadOnlyCollection<string> IgnoredSources,
     IReadOnlyCollection<string> IgnoredTargets,
     IReadOnlyCollection<PropertyMappingConfiguration> ExplicitMappings,
+    IReadOnlyCollection<NestedPropertyMappingConfiguration> NestedMappings,
     IgnoreObsoleteMembersStrategy IgnoreObsoleteMembersStrategy
 );

src/Riok.Mapperly/Descriptors/MappingBodyBuilders/BuilderContext/MembersMappingBuilderContext.cs

@@ -42,8 +42,6 @@ protected MembersMappingBuilderContext(MappingBuilderContext builderContext, T m
 
         _unmappedSourceMemberNames.ExceptWith(IgnoredSourceMemberNames);
 
-        MemberConfigsByRootTargetName = GetMemberConfigurations();
-
         // remove explicitly mapped ignored targets from ignoredTargetMemberNames
         // then remove all ignored targets from TargetMembers, leaving unignored and explicitly mapped ignored members
         ignoredTargetMemberNames.ExceptWith(MemberConfigsByRootTargetName.Keys);
@@ -117,9 +115,25 @@ private Dictionary<string, IMappableMember> GetTargetMembers()
 
     private Dictionary<string, List<PropertyMappingConfiguration>> GetMemberConfigurations()
     {
-        return BuilderContext.Configuration.Properties.ExplicitMappings
-            .GroupBy(x => x.Target.Path.First())
-            .ToDictionary(x => x.Key, x => x.ToList());
+        var simpleMappings = BuilderContext.Configuration.Properties.ExplicitMappings.GroupBy(x => x.Target.Path.First());
+
+        var wildcardMappings = BuilderContext.Configuration.Properties.NestedMappings
+            .SelectMany(x =>
+            {
+                return BuilderContext.SymbolAccessor
+                    .GetAllAccessibleMappableMembers(Mapping.SourceType)
+                    .Where(i => i.Name == x.Source.Path.Last())
+                    .SelectMany(i => BuilderContext.SymbolAccessor.GetAllAccessibleMappableMembers(i.Type))
+                    .Select(i =>
+                    {
+                        var list = x.Source.Path.ToList();
+                        list.Add(i.Name);
+                        return new PropertyMappingConfiguration(new StringMemberPath(list), new StringMemberPath(new[] { i.Name }));
+                    });
+            })
+            .GroupBy(x => x.Target.Path.Last());
+
+        return simpleMappings.Union(wildcardMappings).ToDictionary(x => x.Key, x => x.ToList());
     }
 
     private void AddUnmatchedIgnoredTargetMembersDiagnostics()

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

@@ -208,6 +208,19 @@ public Task WithPropertyNameMappingStrategyCaseSensitive()
         return TestHelper.VerifyGenerator(source);
     }
 
+    [Fact]
+    public Task WithPropertyNameMappingStrategyCaseSensitiveAndManualMappedProperty()
+    {
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            "[MapProperty(nameof(A.stringvalue), nameof(B.StringValue2)] partial B Map(A source);",
+            new TestSourceBuilderOptions { PropertyNameMappingStrategy = PropertyNameMappingStrategy.CaseSensitive },
+            "class A { public string stringvalue { get; set; } }",
+            "class B { public string StringValue2 { get; set; } }"
+        );
+
+        return TestHelper.VerifyGenerator(source);
+    }
+
     [Fact]
     public Task WithManualMappedNotFoundTargetPropertyShouldDiagnostic()
     {
@@ -443,4 +456,33 @@ public void ShouldIgnoreStaticConstructorAndDiagnostic()
             .HaveDiagnostic(DiagnosticDescriptors.CouldNotCreateMapping)
             .HaveAssertedAllDiagnostics();
     }
+
+    [Fact]
+    public void ShouldFlattedNestedToTargetRootMapping()
+    {
+        var mapperBody = """
+            [MapperNestedProperties(nameof(A.NestedValue)]
+            public partial C Map(A source);
+            """;
+
+        var source = TestSourceBuilder.MapperWithBodyAndTypes(
+            mapperBody,
+            "class A { public B NestedValue { get; set; } public string DummyValue { get; set; } }",
+            "class B { public string GoodProp1 { get; set; } public string GoodProp2 { get; set; } }",
+            "class C { public string GoodProp1 { get; set; } public string GoodProp2 { get; set; } public string DummyValue { get; set; } }"
+        );
+
+        TestHelper
+            .GenerateMapper(source)
+            .Should()
+            .HaveMapMethodBody(
+                """
+                var target = new global::C();
+                target.GoodProp1 = source.NestedValue.GoodProp1;
+                target.GoodProp2 = source.NestedValue.GoodProp2;
+                target.DummyValue = source.DummyValue;
+                return target;
+                """
+            );
+    }
 }

test/Riok.Mapperly.Tests/_snapshots/ObjectPropertyTest.WithPropertyNameMappingStrategyCaseSensitiveAndManualMappedProperty#Mapper.g.verified.cs

@@ -0,0 +1,12 @@
+//HintName: Mapper.g.cs
+// <auto-generated />
+#nullable enable
+public partial class Mapper
+{
+    private partial global::B Map(global::A source)
+    {
+        var target = new global::B();
+        target.StringValue2 = source.stringvalue;
+        return target;
+    }
+}