feat: v1.11.0 — reverse mapping (Reverse = true on [Map] and [MapFrom])

Swevo · Copilot · Swevo · commit 79d0160a9d6a · 2026-06-25T19:03:02.000+01:00
Co-authored-by: Copilot &lt;223556219+Copilot@users.noreply.github.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,16 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.0.0/); version
 
 ---
 
+## [1.11.0] — 2026-06-25
+
+### Added
+
+- **Reverse mapping generation** — set `Reverse = true` on `[Map]` or `[MapFrom]` to emit a second mapping method in the opposite direction (for example `dto.ToOrder()` alongside `order.ToOrderDto()`).
+- **Reverse-aware property rules** — reverse generation now respects `[MapIgnore]`, `[MapProperty]`, constructor-mapped destinations, and only reverses nested/collection members when a matching reverse mapping exists.
+- **AM007 diagnostic** — warns when `Reverse = true` is requested but no reverse properties can be generated.
+
+---
+
 ## [1.9.0] — 2026-06-25
 
 ### Added
diff --git a/src/AutoMap/AutoMap.csproj b/src/AutoMap/AutoMap.csproj
@@ -11,7 +11,7 @@
     <NoWarn>$(NoWarn);NU5017;NU5128;RS2008;RS1035;RS1038;RS1019</NoWarn>
 
     <PackageId>AutoMap.Generator</PackageId>
-    <Version>1.10.0</Version>
+    <Version>1.11.0</Version>
     <Authors>Justin Bannister</Authors>
     <Copyright>Copyright (c) 2026 Justin Bannister</Copyright>
     <Description>Compile-time object mapping for .NET using Roslyn source generators. Add [Map(typeof(Dto))] to your domain class — AutoMap generates strongly-typed ToDto() extension methods at build time. Zero runtime overhead, no reflection, no AutoMapper dependency. Supports [MapFrom], [MapIgnore], [MapProperty], records, and structs.</Description>
@@ -27,7 +27,7 @@
     <IncludeSymbols>false</IncludeSymbols>
     <Deterministic>true</Deterministic>
     <ContinuousIntegrationBuild Condition="'$(CI)' == 'true'">true</ContinuousIntegrationBuild>
-    <PackageReleaseNotes>1.10.0: AM004 code-fix provider (Add [MapIgnore] lightbulb). 1.9.0: Collection-level extension methods (orders.ToOrderDtos()). 1.8.0: [TrimStrings], [MapFormat], IMapFrom&lt;T&gt; convention, partial On{Method} hooks, Strict mode. 1.7.0: [MapWhen] conditional mapping. 1.6.0: Cross-enum mapping + [MapEnum]. 1.5.0: Flattening + [MapDefault]. 1.4.0: [MapWith]. 1.3.0: Constructor mapping. 1.2.0: Reverse + IAutoMapper. 1.1.0: Nested + collections. 1.0.0: Initial.</PackageReleaseNotes>
+    <PackageReleaseNotes>1.11.0: Reverse = true on [Map] and [MapFrom], including reverse nested/collection resolution and AM007 warnings. 1.10.0: AM004 code-fix provider (Add [MapIgnore] lightbulb). 1.9.0: Collection-level extension methods (orders.ToOrderDtos()). 1.8.0: [TrimStrings], [MapFormat], IMapFrom&lt;T&gt; convention, partial On{Method} hooks, Strict mode. 1.7.0: [MapWhen] conditional mapping. 1.6.0: Cross-enum mapping + [MapEnum]. 1.5.0: Flattening + [MapDefault]. 1.4.0: [MapWith]. 1.3.0: Constructor mapping. 1.2.0: Reverse + IAutoMapper. 1.1.0: Nested + collections. 1.0.0: Initial.</PackageReleaseNotes>
   </PropertyGroup>
   <ItemGroup>
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.*" PrivateAssets="all" />
diff --git a/src/AutoMap/AutoMapGenerator.cs b/src/AutoMap/AutoMapGenerator.cs
@@ -222,6 +222,15 @@ public interface IAutoMapper<in TSource, out TResult>
         isEnabledByDefault: true,
         helpLinkUri: "https://github.com/Swevo/AutoMap.Generator#am006");
 
+    private static readonly DiagnosticDescriptor AM007 = new DiagnosticDescriptor(
+        "AM007",
+        "Reverse mapping could not be generated",
+        "Reverse = true specified for mapping from '{0}' to '{1}', but no reverse properties could be generated",
+        "AutoMap",
+        DiagnosticSeverity.Warning,
+        isEnabledByDefault: true,
+        helpLinkUri: "https://github.com/Swevo/AutoMap.Generator#am007");
+
     // Strict-mode variants (same codes, Error severity — used when [Map(Strict = true)])
     private static readonly DiagnosticDescriptor AM001_Strict = new DiagnosticDescriptor(
         "AM001", "No properties mapped",
@@ -327,7 +336,7 @@ private static ImmutableArray<MappingInfo> TransformAttributes(
 
             // When Reverse = true, also generate the opposite direction
             if (reverse)
-                builder.Add(BuildMappingInfo(destSymbol, sourceSymbol, null, ctx.SemanticModel.Compilation, strict));
+                builder.Add(BuildReverseMappingInfo(sourceSymbol, destSymbol, ctx.SemanticModel.Compilation, strict));
         }
 
         return builder.ToImmutable();
@@ -365,7 +374,8 @@ private static MappingInfo BuildMappingInfo(
         INamedTypeSymbol destSymbol,
         string? methodName,
         Compilation compilation,
-        bool isStrict = false)
+        bool isStrict = false,
+        bool reverse = false)
     {
         var sourceFqn = sourceSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
         var destFqn   = destSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
@@ -589,6 +599,8 @@ private static MappingInfo BuildMappingInfo(
         }
 
         // AM001 moved to GenerateSource (needs all mappings to know if deferred props resolve)
+        var matchedMembers = mappings.Count + ctorParams.Count(p => p.SourcePropertyName != null);
+
         return new MappingInfo(
             sourceFqn, destFqn, effectiveMethod,
             mappings.ToImmutable(),
@@ -597,7 +609,176 @@ private static MappingInfo BuildMappingInfo(
             sourceSymbol.IsValueType,
             ctorParams,
             trimStrings,
-            isStrict);
+            isStrict,
+            reverse,
+            matchedMembers);
+    }
+
+    private static MappingInfo BuildReverseMappingInfo(
+        INamedTypeSymbol originalSourceSymbol,
+        INamedTypeSymbol originalDestSymbol,
+        Compilation compilation,
+        bool isStrict = false)
+    {
+        var reverseSourceSymbol = originalDestSymbol;
+        var reverseDestSymbol = originalSourceSymbol;
+
+        var sourceFqn = reverseSourceSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+        var destFqn = reverseDestSymbol.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat);
+        var methodName = "To" + originalSourceSymbol.Name;
+
+        bool trimStrings = HasAttribute(reverseSourceSymbol, "AutoMap.TrimStringsAttribute")
+                        || HasAttribute(reverseDestSymbol, "AutoMap.TrimStringsAttribute");
+
+        var sourceProps = BuildReadablePropLookup(reverseSourceSymbol);
+        var reverseLookup = new Dictionary<string, (string SourcePropertyName, bool SkipReverse)>(StringComparer.OrdinalIgnoreCase);
+
+        foreach (var forwardDestProp in GetAllProperties(originalDestSymbol))
+        {
+            if (forwardDestProp.IsStatic || forwardDestProp.IsIndexer) continue;
+            if (forwardDestProp.GetMethod?.DeclaredAccessibility != Accessibility.Public) continue;
+
+            string lookupName = forwardDestProp.Name;
+            bool skipReverse = false;
+
+            foreach (var a in forwardDestProp.GetAttributes())
+            {
+                var fqn = a.AttributeClass?.ToDisplayString();
+                if (fqn == "AutoMap.MapIgnoreAttribute" || fqn == "AutoMap.MapWithAttribute")
+                    skipReverse = true;
+                else if (fqn == "AutoMap.MapPropertyAttribute" && a.ConstructorArguments.Length > 0)
+                    lookupName = a.ConstructorArguments[0].Value as string ?? lookupName;
+            }
+
+            if (!reverseLookup.ContainsKey(lookupName))
+                reverseLookup[lookupName] = (forwardDestProp.Name, skipReverse);
+        }
+
+        var mappings = ImmutableArray.CreateBuilder<PropertyMapping>();
+        var unresolvedProperties = ImmutableArray.CreateBuilder<UnresolvedProperty>();
+        var diagnostics = ImmutableArray.CreateBuilder<DiagnosticInfo>();
+
+        foreach (var destProp in GetAllProperties(reverseDestSymbol))
+        {
+            if (destProp.IsStatic || destProp.IsIndexer) continue;
+
+            var setter = destProp.SetMethod;
+            if (setter == null || setter.DeclaredAccessibility != Accessibility.Public) continue;
+
+            if (!reverseLookup.TryGetValue(destProp.Name, out var reverseInfo) || reverseInfo.SkipReverse) continue;
+            if (!sourceProps.TryGetValue(reverseInfo.SourcePropertyName, out var srcProp)) continue;
+
+            var csharp = compilation as Microsoft.CodeAnalysis.CSharp.CSharpCompilation;
+            bool typeCompatible;
+            if (csharp != null)
+            {
+                var conv = csharp.ClassifyConversion(srcProp.Type, destProp.Type);
+                typeCompatible = conv.IsIdentity || conv.IsImplicit;
+            }
+            else
+            {
+                var srcTypeFqn = srcProp.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).TrimEnd('?');
+                var destTypeFqn = destProp.Type.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat).TrimEnd('?');
+                typeCompatible = srcTypeFqn == destTypeFqn;
+            }
+
+            if (typeCompatible)
+            {
+                var finalExpr = trimStrings && IsStringType(destProp.Type)
+                    ? $"src.{srcProp.Name}?.Trim()"
+                    : null;
+                mappings.Add(new PropertyMapping(destProp.Name, srcProp.Name, finalExpr));
+            }
+            else if (srcProp.Type.TypeKind == TypeKind.Enum
+                  && destProp.Type.TypeKind == TypeKind.Enum
+                  && srcProp.Type is INamedTypeSymbol srcEnum
+                  && destProp.Type is INamedTypeSymbol destEnum)
+            {
+                var switchExpr = BuildEnumSwitchExpression(
+                    $"src.{srcProp.Name}", srcEnum, destEnum,
+                    destEnum.ToDisplayString(SymbolDisplayFormat.FullyQualifiedFormat),
+                    diagnostics);
+                mappings.Add(new PropertyMapping(destProp.Name, srcProp.Name, switchExpr));
+            }
+            else
+            {
+                var unresolved = BuildUnresolvedProperty(destProp.Name, srcProp.Name, srcProp.Type, destProp.Type);
+                if (unresolved != null)
+                    unresolvedProperties.Add(unresolved);
+            }
+        }
+
+        bool hasParamlessCtor = false;
+        foreach (var ctor in reverseDestSymbol.Constructors)
+        {
+            if (!ctor.IsStatic && ctor.DeclaredAccessibility == Accessibility.Public
+                && ctor.Parameters.Length == 0)
+            { hasParamlessCtor = true; break; }
+        }
+
+        bool hasMapConstructorAttr = HasAttribute(reverseDestSymbol, "AutoMap.MapConstructorAttribute");
+        var ctorParams = ImmutableArray<CtorParamMapping>.Empty;
+
+        if (!hasParamlessCtor || hasMapConstructorAttr)
+        {
+            IMethodSymbol? bestCtor = null;
+            foreach (var ctor in reverseDestSymbol.Constructors)
+            {
+                if (ctor.IsStatic || ctor.DeclaredAccessibility != Accessibility.Public) continue;
+                if (bestCtor == null || ctor.Parameters.Length > bestCtor.Parameters.Length)
+                    bestCtor = ctor;
+            }
+
+            if (bestCtor != null)
+            {
+                var ctorBuilder = ImmutableArray.CreateBuilder<CtorParamMapping>(bestCtor.Parameters.Length);
+                var ctorParamNames = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+                foreach (var param in bestCtor.Parameters)
+                {
+                    IPropertySymbol? matchedProp = null;
+                    if (reverseLookup.TryGetValue(param.Name, out var reverseInfo)
+                        && !reverseInfo.SkipReverse)
+                    {
+                        sourceProps.TryGetValue(reverseInfo.SourcePropertyName, out matchedProp);
+                    }
+
+                    if (matchedProp == null)
+                    {
+                        diagnostics.Add(new DiagnosticInfo("AM005",
+                            ImmutableArray.Create(param.Name, reverseDestSymbol.Name, reverseSourceSymbol.Name)));
+                        ctorBuilder.Add(new CtorParamMapping(param.Name, null));
+                    }
+                    else
+                    {
+                        ctorBuilder.Add(new CtorParamMapping(param.Name, matchedProp.Name));
+                        ctorParamNames.Add(matchedProp.Name);
+                    }
+                }
+
+                ctorParams = ctorBuilder.ToImmutable();
+
+                var filtered = ImmutableArray.CreateBuilder<PropertyMapping>();
+                foreach (var pm in mappings)
+                    if (!ctorParamNames.Contains(pm.SourcePropertyName))
+                        filtered.Add(pm);
+                mappings = filtered;
+            }
+        }
+
+        var matchedMembers = mappings.Count + ctorParams.Count(p => p.SourcePropertyName != null);
+
+        return new MappingInfo(
+            sourceFqn, destFqn, methodName,
+            mappings.ToImmutable(),
+            unresolvedProperties.ToImmutable(),
+            diagnostics.ToImmutable(),
+            reverseSourceSymbol.IsValueType,
+            ctorParams,
+            trimStrings,
+            isStrict,
+            reverse: true,
+            matchedMembers: matchedMembers);
     }
 
     // ── Helpers ───────────────────────────────────────────────────────────────
@@ -700,6 +881,7 @@ private static void GenerateSource(
         foreach (var m in mappings)
         {
             if (string.IsNullOrEmpty(m.SourceFqn)) continue;
+            if (m.Mappings.Length == 0 && m.CtorParams.Length == 0 && m.UnresolvedProperties.Length == 0) continue;
             if (!knownMappings.TryGetValue(m.SourceFqn, out var destMap))
                 knownMappings[m.SourceFqn] = destMap = new Dictionary<string, string>(StringComparer.Ordinal);
             destMap[m.DestFqn] = m.MethodName;
@@ -752,20 +934,29 @@ private static void GenerateSource(
             resolvedExtras[m] = extras;
         }
 
+        foreach (var m in mappings)
+        {
+            if (!m.Reverse || string.IsNullOrEmpty(m.SourceFqn)) continue;
+            var extras = resolvedExtras.TryGetValue(m, out var ex) ? ex : null;
+            if (m.MatchedMembers == 0 && (extras == null || extras.Count == 0))
+                spc.ReportDiagnostic(Diagnostic.Create(AM007, null,
+                    SimpleName(m.SourceFqn), SimpleName(m.DestFqn)));
+        }
+
         // Report stored diagnostics (AM002, AM003, AM005)
         foreach (var m in mappings)
         {
             foreach (var d in m.Diagnostics)
             {
-                var descriptor = d.Id switch { "AM002" => AM002, "AM003" => AM003, "AM005" => AM005, "AM006" => AM006, _ => AM001 };
+                var descriptor = d.Id switch { "AM002" => AM002, "AM003" => AM003, "AM005" => AM005, "AM006" => AM006, "AM007" => AM007, _ => AM001 };
                 spc.ReportDiagnostic(Diagnostic.Create(descriptor, null, d.Args.ToArray<object>()));
             }
         }
 
         // AM001 — no properties at all (direct or resolved)
         foreach (var m in mappings)
         {
-            if (string.IsNullOrEmpty(m.SourceFqn) || m.Diagnostics.Length > 0) continue;
+            if (m.Reverse || string.IsNullOrEmpty(m.SourceFqn) || m.Diagnostics.Length > 0) continue;
             var extras = resolvedExtras.TryGetValue(m, out var ex) ? ex : null;
             if (m.Mappings.Length == 0 && m.CtorParams.Length == 0 && (extras == null || extras.Count == 0))
             {
@@ -1019,6 +1210,8 @@ internal sealed class MappingInfo
     public ImmutableArray<CtorParamMapping> CtorParams { get; }
     public bool TrimStrings { get; }
     public bool IsStrict { get; }
+    public bool Reverse { get; }
+    public int MatchedMembers { get; }
 
     public bool UseConstructor => CtorParams.Length > 0;
 
@@ -1029,14 +1222,18 @@ public MappingInfo(string sourceFqn, string destFqn, string methodName,
         bool isSourceValueType,
         ImmutableArray<CtorParamMapping> ctorParams = default,
         bool trimStrings = false,
-        bool isStrict = false)
+        bool isStrict = false,
+        bool reverse = false,
+        int matchedMembers = 0)
     {
         SourceFqn = sourceFqn; DestFqn = destFqn; MethodName = methodName;
         Mappings = mappings; UnresolvedProperties = unresolvedProperties;
         Diagnostics = diagnostics; IsSourceValueType = isSourceValueType;
         CtorParams = ctorParams.IsDefault ? ImmutableArray<CtorParamMapping>.Empty : ctorParams;
         TrimStrings = trimStrings;
         IsStrict = isStrict;
+        Reverse = reverse;
+        MatchedMembers = matchedMembers;
     }
 }
 
diff --git a/tests/AutoMap.Tests/MappingTests.cs b/tests/AutoMap.Tests/MappingTests.cs
