SAVEPOINT

Src/FluentAssertions/Common/MemberPath.cs

@@ -20,7 +20,7 @@ internal class MemberPath
     private static readonly MemberPathSegmentEqualityComparer MemberPathSegmentEqualityComparer = new();
 
     public MemberPath(IMember member, string parentPath)
-        : this(member.ReflectedType, member.DeclaringType, parentPath.Combine(member.Name))
+        : this(member.ReflectedType, member.DeclaringType, parentPath.Combine(member.OriginalName ?? member.Name))
     {
     }
 

Src/FluentAssertions/Equivalency/Field.cs

@@ -24,6 +24,7 @@ public Field(Type reflectedType, FieldInfo fieldInfo, INode parent)
         DeclaringType = fieldInfo.DeclaringType;
         ReflectedType = reflectedType;
         Path = parent.PathAndName;
+        OriginalPath = parent.OriginalPathAndName;
         GetSubjectId = parent.GetSubjectId;
         Name = fieldInfo.Name;
         Type = fieldInfo.FieldType;

Src/FluentAssertions/Equivalency/INode.cs

@@ -79,4 +79,24 @@ public interface INode
     /// Gets a value indicating if the root of this graph is a collection.
     /// </summary>
     bool RootIsCollection { get; }
+
+    [CanBeNull]
+    string OriginalPath { get; set; }
+
+    /// <summary>
+    /// Gets the original name of this node before <see cref="Name"/> was updated, for example
+    /// when the expectation is mapped to a different member of the subject.
+    /// </summary>
+    [CanBeNull]
+    string OriginalName { get; set; }
+
+    /// <summary>
+    /// Gets the full path from the root object up to and including the name of the node as it was originally defined, for example
+    /// when the expectation is mapped to a different member of the subject.
+    /// </summary>
+    /// <example>
+    /// "Parent[0]"
+    /// </example>
+    [CanBeNull]
+    string OriginalPathAndName { get; }
 }

Src/FluentAssertions/Equivalency/Node.cs

@@ -93,6 +93,7 @@ public static INode FromCollectionItem<T>(string index, INode parent)
             ParentType = parent.Type,
             Name = "[" + index + "]",
             Path = parent.PathAndName,
+            OriginalPath = parent.OriginalPath,
             GetSubjectId = parent.GetSubjectId,
             RootIsCollection = parent.RootIsCollection
         };
@@ -106,11 +107,29 @@ public static INode FromDictionaryItem<T>(object key, INode parent)
             ParentType = parent.Type,
             Name = "[" + key + "]",
             Path = parent.PathAndName,
+            OriginalPath = parent.OriginalPath,
             GetSubjectId = parent.GetSubjectId,
             RootIsCollection = parent.RootIsCollection
         };
     }
 
+    public string OriginalPath { get; set; }
+
+    public string OriginalName { get; set; }
+
+    public string OriginalPathAndName
+    {
+        get
+        {
+            if (OriginalPath is not null || OriginalName is not null)
+            {
+                return (OriginalPath ?? string.Empty).Combine(OriginalName ?? Name);
+            }
+
+            return null;
+        }
+    }
+
     public override bool Equals(object obj)
     {
         if (obj is null)

Src/FluentAssertions/Equivalency/Property.cs

@@ -28,6 +28,7 @@ public Property(Type reflectedType, PropertyInfo propertyInfo, INode parent)
         Type = propertyInfo.PropertyType;
         ParentType = propertyInfo.DeclaringType;
         Path = parent.PathAndName;
+        OriginalPath = parent.OriginalPathAndName;
         GetSubjectId = parent.GetSubjectId;
         RootIsCollection = parent.RootIsCollection;
     }

Src/FluentAssertions/Equivalency/Steps/StructuralEqualityEquivalencyStep.cs

@@ -70,6 +70,7 @@ private static void AssertMemberEquality(Comparands comparands, IEquivalencyVali
             {
                 // In case the matching process selected a different member on the subject,
                 // adjust the current member so that assertion failures report the proper name.
+                selectedMember.OriginalName = selectedMember.Name;
                 selectedMember.Name = matchingMember.Name;
             }
 

Tests/FluentAssertions.Equivalency.Specs/MemberMatchingSpecs.cs

@@ -87,7 +87,8 @@ public void Nested_properties_can_be_mapped_using_a_nested_type_and_property_nam
     public void Nested_explicitly_implemented_properties_can_be_mapped_using_a_nested_type_and_property_names()
     {
         // Arrange
-        var subject = new ParentOfSubjectWithExplicitlyImplementedProperty(new[] { new SubjectWithExplicitImplementedProperty() });
+        var subject =
+            new ParentOfSubjectWithExplicitlyImplementedProperty(new[] { new SubjectWithExplicitImplementedProperty() });
 
         ((IProperty)subject.Children[0]).Property = "Hello";
 
@@ -135,6 +136,56 @@ public void Nested_properties_can_be_mapped_using_a_nested_type_and_a_property_e
                     e => e.Property2, s => s.Property1));
     }
 
+    private class Customer
+    {
+        public Residence Address { get; set; }
+
+        public class Residence
+        {
+            public string Address { get; set; }
+        }
+    }
+
+    private class CustomerDto
+    {
+        public ResidenceDto AddressInformation { get; set; }
+
+        public class ResidenceDto
+        {
+            public string Address { get; set; }
+
+            public bool IsValidated { get; set; }
+        }
+    }
+
+    [Fact]
+    public void CustomerDto_To_Customer_ShouldBeEquivalent()
+    {
+        //Arrange
+        var expectation = new CustomerDto
+        {
+            AddressInformation = new CustomerDto.ResidenceDto
+            {
+                Address = "123 Main St",
+                IsValidated = true,
+            },
+        };
+
+        //Act
+        var subject = new Customer
+        {
+            Address = new Customer.Residence
+            {
+                Address = "123 Main St",
+            },
+        };
+
+        //Assert
+        subject.Should().BeEquivalentTo(expectation, o => o
+            .Excluding(r => r.AddressInformation.IsValidated)
+            .WithMapping<CustomerDto, Customer>(s => s.AddressInformation, d => d.Address));
+    }
+
     [Fact]
     public void Nested_properties_on_a_collection_can_be_mapped_using_a_dotted_path()
     {