Add MapFromAttribute for explicit property mapping

Theme: Enhanced DTO mapping and source generator support
  -- Introduced MapFromAttribute to allow explicit mapping of DTO/detail properties from source entity properties, supporting both string literals and nameof expressions.
  -- Updated source generator logic to recognize and process MapFromAttribute, including robust extraction of property names via constructor, named arguments, and syntax parsing.
  -- Added CustomProductDetails partial class using AutoSelect and MapFrom attributes, with generated projection and conversion methods for Product entities.
  -- Added unit tests to verify MapFrom-based mapping, covering both code generation and runtime behavior.
  -- Updated documentation to describe MapFromAttribute usage.
  -- Updated project configuration and references to support new attribute and generator features.

These changes improve clarity and flexibility when mapping between types with differing property names.

Author: eglauko

src/Directory.Build.props

@@ -5,7 +5,7 @@
 		<GenFrwkVer>netstandard2.0</GenFrwkVer>
 	</PropertyGroup>
 	<PropertyGroup>
-		<ExtSrcGenVer>0.1.12</ExtSrcGenVer>
+		<ExtSrcGenVer>0.1.13</ExtSrcGenVer>
 	</PropertyGroup>
 	<PropertyGroup>
 		<Ver>0.4.0</Ver>

src/RoyalCode.SmartSelector.Demo/Details/ProductDetails.cs

@@ -11,3 +11,14 @@ public partial class ProductDetails
     public DateTime? CreatedAt { get; set; }
     public DateTime? UpdatedAt { get; set; }
 }
+
+[AutoSelect<Product>]
+public partial class CustomProductDetails
+{
+    [MapFrom("Id")]
+    public int CustomId { get; set; }
+    [MapFrom(nameof(Product.Name))]
+    public string CustomName { get; set; } = default!;
+    [MapFrom(nameof(Product.IsActive))]
+    public bool CustomIsActive { get; set; }
+}

src/RoyalCode.SmartSelector.Demo/Generated/RoyalCode.SmartSelector.Generators/RoyalCode.SmartSelector.Generators.IncrementalGenerator/CustomProductDetails.g.cs

@@ -0,0 +1,18 @@
+using RoyalCode.SmartSelector.Demo.Entities;
+using System.Linq.Expressions;
+
+namespace RoyalCode.SmartSelector.Demo.Details;
+
+public partial class CustomProductDetails
+{
+    private static Func<Product, CustomProductDetails> selectProductFunc;
+
+    public static Expression<Func<Product, CustomProductDetails>> SelectProductExpression { get; } = a => new CustomProductDetails
+    {
+        CustomId = a.Id,
+        CustomName = a.Name,
+        CustomIsActive = a.IsActive
+    };
+
+    public static CustomProductDetails From(Product product) => (selectProductFunc ??= SelectProductExpression.Compile())(product);
+}

src/RoyalCode.SmartSelector.Demo/Generated/RoyalCode.SmartSelector.Generators/RoyalCode.SmartSelector.Generators.IncrementalGenerator/CustomProductDetails_Extensions.g.cs

@@ -0,0 +1,18 @@
+using RoyalCode.SmartSelector.Demo.Entities;
+
+namespace RoyalCode.SmartSelector.Demo.Details;
+
+public static class CustomProductDetails_Extensions
+{
+    public static IQueryable<CustomProductDetails> SelectCustomProductDetails(this IQueryable<Product> query)
+    {
+        return query.Select(CustomProductDetails.SelectProductExpression);
+    }
+
+    public static IEnumerable<CustomProductDetails> SelectCustomProductDetails(this IEnumerable<Product> enumerable)
+    {
+        return enumerable.Select(CustomProductDetails.From);
+    }
+
+    public static CustomProductDetails ToCustomProductDetails(this Product product) => CustomProductDetails.From(product);
+}

src/RoyalCode.SmartSelector.Demo/Tests/ProductDemoTests.cs

@@ -94,4 +94,20 @@ public void Select_ProductDetails_From_List()
         Assert.Contains(details, d => d.Name == "Hot dog 2");
         Assert.Contains(details, d => d.Name == "Hot dog 3");
     }
+
+    [Fact]
+    public void Create_CustomProductDetails_From_Product()
+    {
+        // arrange
+        var product = new Product("Hot dog 1");
+
+        // act
+        var details = CustomProductDetails.From(product);
+
+        // assert
+        Assert.NotNull(details);
+        Assert.Equal(product.Id, details.CustomId);
+        Assert.Equal(product.Name, details.CustomName);
+        Assert.Equal(product.IsActive, details.CustomIsActive);
+    }
 }

src/RoyalCode.SmartSelector.Generators/Generators/AutoPropertiesGenerator.cs

@@ -10,11 +10,13 @@ internal static class AutoPropertiesGenerator
 
     private const string AutoPropertiesAttributeName = "AutoProperties";              // non generic form
     private const string AutoPropertiesGenericAttributeName = "AutoProperties";       // generic form base identifier
+    internal const string MapFromAttributeName = "MapFromAttribute";
 
     internal static MatchOptions MatchOptions { get; } = new()
     {
         OriginPropertiesRetriever = new AutoPropertyOriginPropertiesRetriever(),
         AdditionalAssignDescriptorResolvers = [new AutoDetailsAssignDescriptorResolver()],
+        PropertyNameResolvers = [new MapFromPropertyNameResolver()],
     };
 
     internal static bool Predicate(SyntaxNode node, CancellationToken token)
@@ -486,4 +488,108 @@ public bool TryCreateAssignDescriptor(
 
         return true;
     }
+}
+
+internal class MapFromPropertyNameResolver : IPropertyNameResolver
+{
+    public bool TryResolvePropertyName(IPropertySymbol symbol, out string? propertyName)
+    {
+        propertyName = null;
+
+        // check if the symbol has the MapFrom attribute
+        var attr = symbol.GetAttributes()
+            .FirstOrDefault(attr => attr.AttributeClass?.Name == AutoPropertiesGenerator.MapFromAttributeName);
+
+        if (attr is not null)
+        {
+            // First, try constructor argument (preferred usage)
+            if (attr.ConstructorArguments.Length == 1)
+            {
+                propertyName = attr.ConstructorArguments[0].Value as string;
+                if (!string.IsNullOrEmpty(propertyName))
+                    return true;
+            }
+
+            // Fallback: try named argument on the attribute (PropertyName setter)
+            if (attr.NamedArguments.Length > 0)
+            {
+                var named = attr.NamedArguments.FirstOrDefault(a => a.Key == "PropertyName");
+                if (named.Value.Value is string s && !string.IsNullOrEmpty(s))
+                {
+                    propertyName = s;
+                    return true;
+                }
+            }
+
+            // Last resort: inspect declaration syntax to extract literal or nameof
+            // This handles cases where Roslyn didn't materialize ConstructorArguments in this pipeline
+            foreach (var decl in symbol.DeclaringSyntaxReferences)
+            {
+                var syntax = decl.GetSyntax();
+                if (syntax is not PropertyDeclarationSyntax pds)
+                    continue;
+
+                foreach (var al in pds.AttributeLists)
+                {
+                    foreach (var a in al.Attributes)
+                    {
+                        var nameText = a.Name switch
+                        {
+                            IdentifierNameSyntax id => id.Identifier.Text,
+                            GenericNameSyntax gn => gn.Identifier.Text,
+                            _ => a.Name.ToString()
+                        };
+
+                        if (!string.Equals(nameText, "MapFrom", StringComparison.Ordinal))
+                            continue;
+
+                        if (a.ArgumentList is { Arguments.Count: > 0 })
+                        {
+                            var expr = a.ArgumentList.Arguments[0].Expression;
+                            switch (expr)
+                            {
+                                case LiteralExpressionSyntax les:
+                                    var text = les.Token.ValueText;
+                                    if (!string.IsNullOrEmpty(text))
+                                    {
+                                        propertyName = text;
+                                        return true;
+                                    }
+                                    break;
+                                case InvocationExpressionSyntax ies:
+                                    // Handle nameof(Member) -> get last identifier as property name
+                                    if (ies.Expression is Microsoft.CodeAnalysis.CSharp.Syntax.IdentifierNameSyntax ident
+                                        && string.Equals(ident.Identifier.Text, "nameof", StringComparison.Ordinal)
+                                        && ies.ArgumentList.Arguments.Count == 1)
+                                    {
+                                        var argExpr = ies.ArgumentList.Arguments[0].Expression;
+                                        if (argExpr is IdentifierNameSyntax idArg)
+                                        {
+                                            propertyName = idArg.Identifier.Text;
+                                            if (!string.IsNullOrEmpty(propertyName))
+                                                return true;
+                                        }
+                                        else if (argExpr is MemberAccessExpressionSyntax mae)
+                                        {
+                                            propertyName = mae.Name.Identifier.Text;
+                                            if (!string.IsNullOrEmpty(propertyName))
+                                                return true;
+                                        }
+                                    }
+                                    break;
+                                case MemberAccessExpressionSyntax maeExpr:
+                                    // If provided directly as something like Product.Name (rare), take the right side
+                                    propertyName = maeExpr.Name.Identifier.Text;
+                                    if (!string.IsNullOrEmpty(propertyName))
+                                        return true;
+                                    break;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        return false;
+    }
 }

src/RoyalCode.SmartSelector.Tests/Tests/MapFromTests.cs

@@ -0,0 +1,106 @@
+using FluentAssertions;
+using Microsoft.CodeAnalysis;
+
+namespace RoyalCode.SmartSelector.Tests.Tests;
+
+public partial class MapFromTests
+{
+    [Fact]
+    public void Select_ProductDetails_With_MapFromAttribute()
+    {
+        Util.Compile(Code.Types, out var output, out var diagnostics);
+
+        diagnostics.Where(d => d.Severity == DiagnosticSeverity.Error).Should().BeEmpty();
+
+        var generatedInterface = output.SyntaxTrees.Skip(1).FirstOrDefault()?.ToString();
+        generatedInterface.Should().Be(Code.ExpectedPartial);
+
+        var generatedHandler = output.SyntaxTrees.Skip(2).FirstOrDefault()?.ToString();
+        generatedHandler.Should().Be(Code.ExpectedExtension);
+    }
+}
+
+file static class Code
+{
+    public const string Types =
+"""
+using RoyalCode.SmartSelector;
+
+namespace Tests.SmartSelector.Models;
+
+#nullable disable // poco
+
+public abstract class Entity<TId>
+{
+    public TId Id { get; protected set; }
+}
+
+public class Product : Entity<Guid>
+{
+    public Product(string name)
+    {
+        Name = name;
+        Active = true;
+    }
+    public string Name { get; set; }
+    public bool Active { get; set; }
+}
+
+[AutoSelect<Product>]
+public partial class ProductDetails
+{
+    [MapFrom("Id")]
+    public Guid CustomId { get; set; }
+    
+    [MapFrom(nameof(Product.Name))]
+    public string CustomName { get; set; }
+
+    [MapFrom(nameof(Product.Active))]
+    public bool CustomActive { get; set; }
+}
+""";
+
+    public const string ExpectedPartial =
+"""
+using System.Linq.Expressions;
+
+namespace Tests.SmartSelector.Models;
+
+public partial class ProductDetails
+{
+    private static Func<Product, ProductDetails> selectProductFunc;
+
+    public static Expression<Func<Product, ProductDetails>> SelectProductExpression { get; } = a => new ProductDetails
+    {
+        CustomId = a.Id,
+        CustomName = a.Name,
+        CustomActive = a.Active
+    };
+
+    public static ProductDetails From(Product product) => (selectProductFunc ??= SelectProductExpression.Compile())(product);
+}
+
+""";
+
+    public const string ExpectedExtension =
+"""
+
+namespace Tests.SmartSelector.Models;
+
+public static class ProductDetails_Extensions
+{
+    public static IQueryable<ProductDetails> SelectProductDetails(this IQueryable<Product> query)
+    {
+        return query.Select(ProductDetails.SelectProductExpression);
+    }
+
+    public static IEnumerable<ProductDetails> SelectProductDetails(this IEnumerable<Product> enumerable)
+    {
+        return enumerable.Select(ProductDetails.From);
+    }
+
+    public static ProductDetails ToProductDetails(this Product product) => ProductDetails.From(product);
+}
+
+""";
+}

src/RoyalCode.SmartSelector.Tests/Util.cs

@@ -30,6 +30,7 @@ internal static void Compile(
             MetadataReference.CreateFromFile(typeof(Task).Assembly.Location),
             MetadataReference.CreateFromFile(typeof(CancellationToken).Assembly.Location),
             MetadataReference.CreateFromFile(typeof(AutoSelectAttribute<>).Assembly.Location),
+            MetadataReference.CreateFromFile(typeof(MapFromAttribute).Assembly.Location),
         };
 
         // create a compilation for the source code.

src/RoyalCode.SmartSelector/.publish/RoyalCode.SmartSelector/RoyalCode.SmartSelector.xml

@@ -0,0 +1,24 @@
+namespace RoyalCode.SmartSelector;
+
+#pragma warning disable CS9113 // PropertyName not used
+
+/// <summary>
+/// Indicates that the decorated property should map its value from another property with the specified name.
+/// </summary>
+[AttributeUsage(AttributeTargets.Property, Inherited = false, AllowMultiple = false)] 
+public sealed class MapFromAttribute : Attribute
+{
+    /// <summary>
+    /// Initializes a new instance of the MapFromAttribute class, specifying the source property name to map from.
+    /// </summary>
+    /// <param name="propertyName">The name of the source property to be mapped. Cannot be null or empty.</param>
+    public MapFromAttribute(string propertyName)
+    { 
+        PropertyName = propertyName;
+    }
+
+    /// <summary>
+    /// Gets or sets the name of the source property to map from.
+    /// </summary>
+    public string PropertyName { get; set; }
+}