Merge pull request #3401 from lbargaoanu/constructors

Matching source values should override constructor parameters default…

Author: jbogard

src/AutoMapper/AttributeExclusions.txt

@@ -0,0 +1,2 @@
+T:System.Runtime.CompilerServices.CompilerGeneratedAttribute
+T:System.Runtime.CompilerServices.IteratorStateMachineAttribute

src/AutoMapper/AutoMapper.csproj

@@ -18,6 +18,7 @@
     <PublishRepositoryUrl>true</PublishRepositoryUrl>
     <AllowedOutputExtensionsInPackageBuildOutputFolder>$(AllowedOutputExtensionsInPackageBuildOutputFolder);.pdb</AllowedOutputExtensionsInPackageBuildOutputFolder>
     <BaselineAllAPICompatError>true</BaselineAllAPICompatError>
+    <ApiCompatExcludeAttributeList>AttributeExclusions.txt</ApiCompatExcludeAttributeList>
   </PropertyGroup>
 
   <ItemGroup>

src/AutoMapper/Configuration/CtorParamConfigurationExpression.cs

@@ -5,7 +5,7 @@
 
 namespace AutoMapper.Configuration
 {
-    public class CtorParamConfigurationExpression<TSource> : ICtorParamConfigurationExpression<TSource>, ICtorParameterConfiguration
+    public class CtorParamConfigurationExpression<TSource, TDestination> : ICtorParamConfigurationExpression<TSource>, ICtorParameterConfiguration
     {
         public string CtorParamName { get; }
         public Type SourceType { get; }
@@ -23,14 +23,14 @@ public void MapFrom<TMember>(Expression<Func<TSource, TMember>> sourceMember) =>
 
         public void MapFrom<TMember>(Func<TSource, ResolutionContext, TMember> resolver)
         {
-            Expression<Func<TSource, ResolutionContext, TMember>> resolverExpression = (src, ctxt) => resolver(src, ctxt);
+            Expression<Func<TSource, TDestination, TMember, ResolutionContext, TMember>> resolverExpression = (src, dest, destMember, ctxt) => resolver(src, ctxt);
             _ctorParamActions.Add(cpm => cpm.CustomMapFunction = resolverExpression);
         }
 
         public void MapFrom(string sourceMemberName)
         {
             SourceType.GetFieldOrProperty(sourceMemberName);
-            _ctorParamActions.Add(cpm => cpm.SourceMemberName = sourceMemberName);
+            _ctorParamActions.Add(cpm => cpm.MapFrom(sourceMemberName));
         }
 
         public void Configure(TypeMap typeMap)

src/AutoMapper/Configuration/MappingExpressionBase.cs

@@ -415,7 +415,7 @@ public void ConvertUsing<TTypeConverter>() where TTypeConverter : ITypeConverter
 
         public TMappingExpression ForCtorParam(string ctorParamName, Action<ICtorParamConfigurationExpression<TSource>> paramOptions)
         {
-            var ctorParamExpression = new CtorParamConfigurationExpression<TSource>(ctorParamName, SourceType);
+            var ctorParamExpression = new CtorParamConfigurationExpression<TSource, TDestination>(ctorParamName, SourceType);
 
             paramOptions(ctorParamExpression);
 

src/AutoMapper/ConstructorParameterMap.cs

@@ -41,6 +41,7 @@ public ConstructorParameterMap(TypeMap typeMap, ParameterInfo parameter, IEnumer
         public override bool CanResolveValue { get; set; }
 
         public override bool Inline { get; set; }
-        public string SourceMemberName { get; set; }
+
+        public Expression DefaultValue() => Expression.Constant(Parameter.GetDefaultValue());
     }
 }

src/AutoMapper/DefaultMemberMap.cs

@@ -1,3 +1,4 @@
+using AutoMapper.Internal;
 using System;
 using System.Collections.Generic;
 using System.Linq;
@@ -6,6 +7,8 @@
 
 namespace AutoMapper
 {
+    using static Expression;
+
     /// <summary>
     /// Member maps with default values. Used in dynamic/dictionary scenarios when source/destination members do not exist.
     /// </summary>
@@ -49,5 +52,20 @@ public MemberInfo SourceMember
                 return SourceMembers.LastOrDefault();
             }
         }
+  
+        public void MapFrom(LambdaExpression sourceMember)
+        {
+            CustomMapExpression = sourceMember;
+            Ignored = false;
+        }
+
+        public void MapFrom(string propertyOrField)
+        {
+            var mapExpression = TypeMap.SourceType.IsGenericTypeDefinition ?
+                                                // just a placeholder so the member is mapped
+                                                Lambda(Constant(null)) :
+                                                ExpressionFactory.MemberAccessLambda(TypeMap.SourceType, propertyOrField);
+            MapFrom(mapExpression);
+        }
     }
 }

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -320,25 +320,9 @@ private Expression CreateNewDestinationExpression(ConstructorMap constructorMap)
             return Block(variables, body);
         }
 
-        private Expression ResolveSource(ConstructorParameterMap ctorParamMap)
-        {
-            if(ctorParamMap.CustomMapExpression != null)
-                return ctorParamMap.CustomMapExpression.ConvertReplaceParameters(Source)
-                    .NullCheck(ctorParamMap.DestinationType);
-            if(ctorParamMap.CustomMapFunction != null)
-                return ctorParamMap.CustomMapFunction.ConvertReplaceParameters(Source, Context);
-            if (ctorParamMap.SourceMemberName != null)
-            {
-                return MemberAccesses(ctorParamMap.SourceMemberName, Source);
-            }
-            if (ctorParamMap.HasDefaultValue)
-                return Constant(ctorParamMap.Parameter.GetDefaultValue());
-            return Chain(ctorParamMap.SourceMembers, ctorParamMap.DestinationType);
-        }
-
         private Expression CreateConstructorParameterExpression(ConstructorParameterMap ctorParamMap)
         {
-            var resolvedExpression = ResolveSource(ctorParamMap);
+            var resolvedExpression = BuildValueResolverFunc(ctorParamMap, _destination, ctorParamMap.DefaultValue());
             var resolvedValue = Variable(resolvedExpression.Type, "resolvedValue");
             var tryMap = Block(new[] {resolvedValue},
                 Assign(resolvedValue, resolvedExpression),
@@ -469,7 +453,7 @@ private Expression CreatePropertyMapFunc(IMemberMap memberMap, Expression destin
             return Block(new[] {resolvedValue, propertyValue}.Distinct(), mapperExpr);
         }
 
-        private Expression BuildValueResolverFunc(IMemberMap memberMap, Expression destValueExpr)
+        private Expression BuildValueResolverFunc(IMemberMap memberMap, Expression destValueExpr, Expression defaultValue = null)
         {
             Expression valueResolverFunc;
             var destinationPropertyType = memberMap.DestinationType;
@@ -517,7 +501,7 @@ private Expression BuildValueResolverFunc(IMemberMap memberMap, Expression destV
             }
             else
             {
-                valueResolverFunc = Throw(Constant(new Exception("I done blowed up")));
+                valueResolverFunc = defaultValue ?? Throw(Constant(new Exception("I done blowed up")));
             }
 
             if (memberMap.NullSubstitute != null)

src/AutoMapper/PropertyMap.cs

@@ -105,21 +105,6 @@ public void ApplyInheritedPropertyMap(PropertyMap inheritedMappedProperty)
         public bool IsResolveConfigured => ValueResolverConfig != null || CustomMapFunction != null ||
                                          CustomMapExpression != null || ValueConverterConfig != null;
 
-        public void MapFrom(LambdaExpression sourceMember)
-        {
-            CustomMapExpression = sourceMember;
-            Ignored = false;
-        }
-
-        public void MapFrom(string propertyOrField)
-        {
-            var mapExpression = TypeMap.SourceType.IsGenericTypeDefinition ?
-                                                // just a placeholder so the member is mapped
-                                                Lambda(Constant(null)) :
-                                                MemberAccessLambda(TypeMap.SourceType, propertyOrField);
-            MapFrom(mapExpression);
-        }
-
         public void AddValueTransformation(ValueTransformerConfiguration valueTransformerConfiguration) =>
             _valueTransformerConfigs.Add(valueTransformerConfiguration);
     }

src/UnitTests/Constructors.cs

@@ -1308,7 +1308,6 @@ public void Should_resolve_constructor_arguments_using_mapping_engine()
             var config = new MapperConfiguration(cfg =>
             {
                 cfg.CreateMap<SourceBar, DestinationBar>();
-
                 cfg.CreateMap<SourceFoo, DestinationFoo>();
             });
 
@@ -1383,15 +1382,18 @@ public class When_mapping_to_an_object_with_a_constructor_with_multiple_optional
         [Fact]
         public void Should_resolve_constructor_when_args_are_optional()
         {
-
-            var config = new MapperConfiguration(cfg => cfg.CreateMap<SourceFoo, DestinationFoo>());
+            var config = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<SourceBar, DestinationBar>();
+                cfg.CreateMap<SourceFoo, DestinationFoo>();
+            });
 
             var sourceBar = new SourceBar("fooBar");
             var sourceFoo = new SourceFoo(sourceBar);
 
             var destinationFoo = config.CreateMapper().Map<DestinationFoo>(sourceFoo);
 
-            destinationFoo.Bar.ShouldBeNull();
+            destinationFoo.Bar.FooBar.ShouldBe("fooBar");
             destinationFoo.Str.ShouldBe("hello");
         }
 
@@ -1460,14 +1462,18 @@ public class When_mapping_to_an_object_with_a_constructor_with_single_optional_a
         [Fact]
         public void Should_resolve_constructor_when_arg_is_optional()
         {
-            var config = new MapperConfiguration(cfg => cfg.CreateMap<SourceFoo, DestinationFoo>());
+            var config = new MapperConfiguration(cfg =>
+            {
+                cfg.CreateMap<SourceBar, DestinationBar>();
+                cfg.CreateMap<SourceFoo, DestinationFoo>();
+            });
 
             var sourceBar = new SourceBar("fooBar");
             var sourceFoo = new SourceFoo(sourceBar);
 
             var destinationFoo = config.CreateMapper().Map<DestinationFoo>(sourceFoo);
 
-            destinationFoo.Bar.ShouldBeNull();
+            destinationFoo.Bar.FooBar.ShouldBe("fooBar");
         }