Skipping 'do nothing' mapping of complex type child members with no mapped members or constructor parameters

Author: SteveWilkes

AgileMapper.UnitTests/WhenViewingMappingPlans.cs

@@ -303,6 +303,16 @@ public void ShouldIncludeUnmappableStructComplexTypeMemberDetails()
             }
         }
 
+        [Fact]
+        public void ShouldIncludeUnmappableNoChildDataSourcesComplexTypeMemberDetails()
+        {
+            string plan = Mapper
+                .GetPlanFor(new { Int = default(int) })
+                .ToANew<PublicField<Address>>();
+
+            plan.ShouldContain("No data source for Value or any of its child members");
+        }
+
         [Fact]
         public void ShouldShowAllCachedMappingPlans()
         {

AgileMapper/Members/Population/MemberPopulation.cs

@@ -75,11 +75,18 @@ public static IMemberPopulation IgnoredMember(IMemberMapperData mapperData, Conf
             => CreateNullMemberPopulation(mapperData, configuredIgnore.GetIgnoreMessage);
 
         public static IMemberPopulation NoDataSource(IMemberMapperData mapperData)
-            => CreateNullMemberPopulation(mapperData, targetMember => "No data source for " + targetMember.Name);
+            => CreateNullMemberPopulation(mapperData, GetNoDataSourceMessage);
+
+        private static string GetNoDataSourceMessage(QualifiedMember targetMember)
+        {
+            return targetMember.IsSimple
+                ? "No data source for " + targetMember.Name
+                : $"No data source for {targetMember.Name} or any of its child members";
+        }
 
         private static IMemberPopulation CreateNullMemberPopulation(
             IMemberMapperData mapperData,
-            Func<IQualifiedMember, string> commentFactory)
+            Func<QualifiedMember, string> commentFactory)
         {
             return new MemberPopulation(
                 mapperData,

AgileMapper/ObjectPopulation/ComplexTypes/TargetObjectResolutionFactory.cs

@@ -97,15 +97,14 @@ private static bool MemberPopulationsExist(IEnumerable<Expression> populationsAn
 
         private static Expression AddExistingTargetCheckIfAppropriate(Expression value, IObjectMappingData mappingData)
         {
-            var mapperData = mappingData.MapperData;
-
-            if (mapperData.TargetMemberIsUserStruct() ||
-                mapperData.TargetIsDefinitelyUnpopulated())
+            if ((value.NodeType == ExpressionType.Default) ||
+                 mappingData.MapperData.TargetMemberIsUserStruct() ||
+                 mappingData.MapperData.TargetIsDefinitelyUnpopulated())
             {
                 return value;
             }
 
-            return Expression.Coalesce(mapperData.TargetObject, value);
+            return Expression.Coalesce(mappingData.MapperData.TargetObject, value);
         }
     }
 }

AgileMapper/ObjectPopulation/IObjectMapper.cs

@@ -5,6 +5,8 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 
     internal interface IObjectMapper : IObjectMapperFunc
     {
+        bool IsNullObject { get; }
+
         Expression MappingExpression { get; }
 
         LambdaExpression MappingLambda { get; }

AgileMapper/ObjectPopulation/MappingExpressionFactoryBase.cs

@@ -46,6 +46,11 @@ public Expression Create(IObjectMappingData mappingData)
             mappingExpressions.AddRange(GetObjectPopulation(mappingData).WhereNotNull());
             mappingExpressions.AddUnlessNullOrEmpty(mappingExtras.PostMappingCallback);
 
+            if (NothingIsBeingMapped(mappingExpressions))
+            {
+                return mapperData.IsRoot ? mapperData.TargetObject : Constants.EmptyExpression;
+            }
+
             mappingExpressions.InsertRange(0, GetShortCircuitReturns(returnNull, mappingData));
 
             var mappingBlock = GetMappingBlock(mappingExpressions, mappingExtras);
@@ -97,6 +102,13 @@ private static Expression GetMapToNullConditionOrNull(IMemberMapperData mapperDa
 
         protected abstract IEnumerable<Expression> GetObjectPopulation(IObjectMappingData mappingData);
 
+        private static bool NothingIsBeingMapped(IList<Expression> mappingExpressions)
+        {
+            return mappingExpressions.None() ||
+                  (mappingExpressions[0].NodeType == ExpressionType.Assign) &&
+                   ((BinaryExpression)mappingExpressions[0]).Right.NodeType == ExpressionType.Default;
+        }
+
         private Expression GetMappingBlock(IList<Expression> mappingExpressions, MappingExtras mappingExtras)
         {
             var mapperData = mappingExtras.MapperData;

AgileMapper/ObjectPopulation/MappingFactory.cs

@@ -169,6 +169,11 @@ public static Expression GetInlineMappingBlock(
         {
             var mapper = mappingData.Mapper;
 
+            if (mapper.IsNullObject)
+            {
+                return Constants.EmptyExpression;
+            }
+
             if (mapper.MapperData.Context.UsesMappingDataObject)
             {
                 return UseLocalSourceValueVariable(

AgileMapper/ObjectPopulation/ObjectMapper.cs

@@ -10,10 +10,16 @@ namespace AgileObjects.AgileMapper.ObjectPopulation
 
     internal class ObjectMapper<TSource, TTarget> : IObjectMapper
     {
+        public static readonly ObjectMapper<TSource, TTarget> Unmappable = new ObjectMapper<TSource, TTarget>();
+
         private readonly MapperFunc<TSource, TTarget> _mapperFunc;
         private readonly ICache<ObjectMapperKeyBase, IObjectMapper> _subMappersByKey;
         private readonly ICache<ObjectMapperKeyBase, IObjectMapperFunc> _recursionMappingFuncsByKey;
 
+        private ObjectMapper()
+        {
+        }
+
         public ObjectMapper(
             Expression<MapperFunc<TSource, TTarget>> mappingLambda,
             ObjectMapperData mapperData)
@@ -81,6 +87,8 @@ private ICache<ObjectMapperKeyBase, IObjectMapperFunc> CreateRecursionMapperFunc
 
         public LambdaExpression MappingLambda { get; }
 
+        public bool IsNullObject => this == Unmappable;
+
         public Expression MappingExpression => MappingLambda.Body;
 
         public ObjectMapperData MapperData { get; }

AgileMapper/ObjectPopulation/ObjectMapperFactory.cs

@@ -50,6 +50,11 @@ public ObjectMapper<TSource, TTarget> Create<TSource, TTarget>(ObjectMappingData
             var mappingExpressionFactory = _mappingExpressionFactories.First(mef => mef.IsFor(mappingData));
             var mappingExpression = mappingExpressionFactory.Create(mappingData);
 
+            if (mappingExpression.NodeType == ExpressionType.Default)
+            {
+                return ObjectMapper<TSource, TTarget>.Unmappable;
+            }
+
             mappingExpression = MappingFactory
                 .UseLocalSourceValueVariableIfAppropriate(mappingExpression, mappingData.MapperData);