consider member value resolvers and value converters for source validation

Author: lbargaoanu

src/AutoMapper/MemberMap.cs

@@ -39,7 +39,9 @@ public class MemberMap
         public virtual ValueResolverConfiguration ValueResolverConfig { get => default; set { } }
         public virtual ValueResolverConfiguration ValueConverterConfig { get => default; set { } }
         public virtual IReadOnlyCollection<ValueTransformerConfiguration> ValueTransformers => Array.Empty<ValueTransformerConfiguration>();
-        public MemberInfo SourceMember => CustomMapExpression.GetMember() ?? SourceMembers.LastOrDefault();
+        public MemberInfo SourceMember => CustomMapExpression.GetMember() ?? SourceMembers.FirstOrDefault();
+        public string GetSourceMemberName() =>
+            ValueConverterConfig?.GetSourceMemberName() ?? ValueResolverConfig?.GetSourceMemberName() ?? SourceMember?.Name;
         public bool MustUseDestination => UseDestinationValue is true || !CanBeSet;
         public void MapFrom(LambdaExpression sourceMember)
         {
@@ -92,6 +94,7 @@ public ValueResolverConfiguration(object instance, Type interfaceType)
             InterfaceType = interfaceType;
         }
         public Type ResolvedType => InterfaceType.GenericTypeArguments.Last();
+        public string GetSourceMemberName() => SourceMember == null ? SourceMemberName : SourceMember.GetMember()?.Name;
     }
     public readonly struct ValueTransformerConfiguration
     {

src/AutoMapper/TypeMap.cs

@@ -176,41 +176,28 @@ private void AddPropertyMap(PropertyMap propertyMap)
         }
         public string[] GetUnmappedPropertyNames()
         {
-            var autoMappedProperties = GetPropertyNames(PropertyMaps);
             IEnumerable<string> properties;
             if (ConfiguredMemberList == MemberList.Destination)
             {
                 properties = Profile.CreateTypeDetails(DestinationType).WriteAccessors
                     .Select(p => p.Name)
                     .Where(p => !ConstructorParameterMatches(p))
-                    .Except(autoMappedProperties)
+                    .Except(MappedMembers().Select(m => m.DestinationName))
                     .Except(PathMaps.Select(p => p.MemberPath.First.Name));
             }
             else
             {
-                var redirectedSourceMembers = MemberMaps
-                     .Where(pm => pm.IsMapped && pm.SourceMember != null && pm.SourceMember.Name != pm.DestinationName)
-                     .Select(pm => pm.SourceMember.Name);
-
                 var ignoredSourceMembers = _sourceMemberConfigs?.Values
                     .Where(smc => smc.IsIgnored())
                     .Select(pm => pm.SourceMember.Name);
-
                 properties = Profile.CreateTypeDetails(SourceType).ReadAccessors
                     .Select(p => p.Name)
-                    .Except(autoMappedProperties)
-                    .Except(redirectedSourceMembers)
+                    .Except(MappedMembers().Select(m => m.GetSourceMemberName()))
                     .Except(ignoredSourceMembers ?? Array.Empty<string>());
             }
             return properties.Where(memberName => !Profile.GlobalIgnores.Any(memberName.StartsWith)).ToArray();
-            string GetPropertyName(PropertyMap pm) => ConfiguredMemberList == MemberList.Destination
-                ? pm.DestinationName
-                : pm.SourceMembers.Length > 1
-                    ? pm.SourceMembers[0].Name
-                    : pm.SourceMember?.Name ?? pm.DestinationName;
-            string[] GetPropertyNames(IEnumerable<PropertyMap> propertyMaps) => propertyMaps.Where(pm => pm.IsMapped).Select(GetPropertyName).ToArray();
+            IEnumerable<MemberMap> MappedMembers() => MemberMaps.Where(pm => pm.IsMapped);
         }
-
         public PropertyMap FindOrCreatePropertyMapFor(MemberInfo destinationProperty, Type destinationPropertyType)
         {
             var propertyMap = GetPropertyMap(destinationProperty.Name);

src/UnitTests/BasicFlattening.cs

@@ -2,7 +2,8 @@
 using System.Collections.Generic;
 using Xunit;
 using Shouldly;
-
+using System.Linq;
+
 namespace AutoMapper.UnitTests
 {
     public class BasicFlattening : AutoMapperSpecBase
@@ -232,6 +233,6 @@ public class CustomerDTO
         protected override MapperConfiguration CreateConfiguration() => new(cfg => cfg.CreateMap<Customer, CustomerDTO>(MemberList.Source).ForMember(d=>d.Id, o=>o.MapFrom(s=>s.AnotherId)));
         [Fact]
         public void Should_validate() =>
-            new Action(AssertConfigurationIsValid).ShouldThrowException<AutoMapperConfigurationException>(ex => ex.Errors[0].UnmappedPropertyNames[0].ShouldBe(nameof(Address.Id)));
+            new Action(AssertConfigurationIsValid).ShouldThrow<AutoMapperConfigurationException>().Errors.Single().UnmappedPropertyNames.Single().ShouldBe(nameof(Address.Id));
     }
 }

src/UnitTests/ConfigurationValidation.cs

@@ -283,6 +283,49 @@ public void Should_fail_a_configuration_check()
         {
             typeof(AutoMapperConfigurationException).ShouldBeThrownBy(AssertConfigurationIsValid);
         }
+    }
+
+    public class ResolversWithSourceValidation : AutoMapperSpecBase
+    {
+        class Source
+        {
+            public int Resolved { get; set; }
+            public int TypedResolved { get; set; }
+            public int Converted { get; set; }
+            public int TypedConverted { get; set; }
+        }
+        class Destination
+        {
+            public int ResolvedDest { get; set; }
+            public int TypedResolvedDest { get; set; }
+            public int ConvertedDest { get; set; }
+            public int TypedConvertedDest { get; set; }
+        }
+        class MemberResolver : IMemberValueResolver<Source, Destination, int, int>
+        {
+            public int Resolve(Source source, Destination destination, int sourceMember, int destinationMember, ResolutionContext context) => sourceMember + 5;
+        }
+        class ValueConverter : IValueConverter<int, int>
+        {
+            public int Convert(int sourceMember, ResolutionContext context) => sourceMember + 5;
+        }
+        protected override MapperConfiguration CreateConfiguration() => new(cfg =>
+        {
+            cfg.CreateMap<Source, Destination>(MemberList.Source)
+                .ForMember(d => d.ResolvedDest, o => o.MapFrom<MemberResolver, int>("Resolved"))
+                .ForMember(d=>d.TypedResolvedDest, o => o.MapFrom<MemberResolver, int>(s => s.TypedResolved))
+                .ForMember(d => d.ConvertedDest, o => o.ConvertUsing<ValueConverter, int>("Converted"))
+                .ForMember(d => d.TypedConvertedDest, o => o.ConvertUsing<ValueConverter, int>(s => s.TypedConverted));
+        });
+        [Fact]
+        public void Should_work()
+        {
+            var result = Mapper.Map<Source, Destination>(new Source { Resolved = 5, TypedResolved =  5, Converted = 5, TypedConverted = 5});
+            result.ResolvedDest.ShouldBe(10);
+            result.TypedResolvedDest.ShouldBe(10);
+            result.ConvertedDest.ShouldBe(10);
+            result.TypedConvertedDest.ShouldBe(10);
+        }
     }
 
     public class NonMemberExpressionWithSourceValidation : NonValidatingSpecBase