less null checks

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -207,33 +207,38 @@ static LambdaExpression GenerateTypeMapExpression(TypePair requestedTypes, TypeM
             }
             static Expression CheckNullValueType(Expression expression, Type runtimeType) =>
                 !expression.Type.IsValueType && runtimeType.IsValueType ? Coalesce(expression, Default(runtimeType)) : expression;
-            LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjectMapper mapperToUse)
+            LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjectMapper mapper)
             {
                 var source = Parameter(mapRequest.RequestedTypes.SourceType, "source");
-                var destination = Parameter(mapRequest.RequestedTypes.DestinationType, "mapperDestination");
+                var destinationType = mapRequest.RequestedTypes.DestinationType;
+                var destination = Parameter(destinationType, "mapperDestination");
                 var runtimeDestinationType = mapRequest.RuntimeTypes.DestinationType;
                 Expression fullExpression;
-                if (mapperToUse == null)
+                bool nullCheck;
+                if (mapper == null)
                 {
                     var exception = new AutoMapperMappingException("Missing type map configuration or unsupported mapping.", null, mapRequest.RuntimeTypes)
                     {
                         MemberMap = mapRequest.MemberMap
                     };
+                    nullCheck = true;
                     fullExpression = Throw(Constant(exception), runtimeDestinationType);
                 }
                 else
                 {
                     var checkNullValueTypeDest = CheckNullValueType(destination, runtimeDestinationType);
-                    var map = mapperToUse.MapExpression(this, Configuration, mapRequest.MemberMap,
-                                                                            ToType(source, mapRequest.RuntimeTypes.SourceType),
-                                                                            ToType(checkNullValueTypeDest, runtimeDestinationType));
+                    var mapperSource = ToType(source, mapRequest.RuntimeTypes.SourceType);
+                    var map = mapper.MapExpression(this, Configuration, mapRequest.MemberMap, mapperSource, ToType(checkNullValueTypeDest, runtimeDestinationType));
+                    nullCheck = map != mapperSource;
                     var newException = Call(MappingError, ExceptionParameter, Constant(mapRequest));
-                    var throwExpression = Throw(newException, runtimeDestinationType);
-                    fullExpression = TryCatch(ToType(map, runtimeDestinationType), Catch(ExceptionParameter, throwExpression));
+                    fullExpression = TryCatch(ToType(map, destinationType), Catch(ExceptionParameter, Throw(newException, destinationType)));
                 }
-                var profileMap = mapRequest.MemberMap.Profile ?? Configuration;
-                var nullCheckSource = NullCheckSource(profileMap, source, destination, fullExpression, mapRequest.MemberMap);
-                return Lambda(nullCheckSource, source, destination, ContextParameter);
+                if (nullCheck)
+                {
+                    var profileMap = mapRequest.MemberMap.Profile ?? Configuration;
+                    fullExpression = NullCheckSource(profileMap, source, destination, fullExpression, mapRequest.MemberMap);
+                }
+                return Lambda(fullExpression, source, destination, ContextParameter);
             }
         }
         static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression> configure)

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -43,15 +43,16 @@ public static class ExpressionBuilder
         private static readonly UnaryExpression IncrementIndex = PostIncrementAssign(Index);
 
         public static Expression MapExpression(this IGlobalConfiguration configurationProvider, ProfileMap profileMap, TypePair typePair, Expression source,
-            MemberMap propertyMap = null, Expression destination = null)
+            MemberMap memberMap = null, Expression destination = null)
         {
             destination ??= Default(typePair.DestinationType);
             var typeMap = configurationProvider.ResolveTypeMap(typePair);
             Expression mapExpression = null;
-            bool hasTypeConverter;
+            bool nullCheck;
             if (typeMap != null)
             {
-                hasTypeConverter = typeMap.HasTypeConverter;
+                var allowNull = memberMap?.AllowNull;
+                nullCheck = !typeMap.HasTypeConverter && allowNull.HasValue && allowNull != profileMap.AllowNullDestinationValues;
                 if (!typeMap.HasDerivedTypesToInclude)
                 {
                     configurationProvider.Seal(typeMap);
@@ -63,37 +64,41 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
             }
             else
             {
-                hasTypeConverter = false;
                 var mapper = configurationProvider.FindMapper(typePair);
-                mapExpression = mapper?.MapExpression(configurationProvider, profileMap, propertyMap, source, destination);
-            }
-            mapExpression ??= ContextMap(typePair, source, destination, propertyMap);
-            if (!hasTypeConverter)
-            {
-                mapExpression = NullCheckSource(profileMap, source, destination, mapExpression, propertyMap);
+                if (mapper != null)
+                {
+                    mapExpression = mapper.MapExpression(configurationProvider, profileMap, memberMap, source, destination);
+                    nullCheck = mapExpression != source;
+                    mapExpression = ToType(mapExpression, typePair.DestinationType);
+                }
+                else
+                {
+                    nullCheck = true;
+                }
             }
-            return ToType(mapExpression, typePair.DestinationType);
+            mapExpression ??= ContextMap(typePair, source, destination, memberMap);
+            return nullCheck ? NullCheckSource(profileMap, source, destination, mapExpression, memberMap) : mapExpression;
         }
-        public static Expression NullCheckSource(ProfileMap profileMap, Expression sourceParameter, Expression destinationParameter, Expression mapExpression, MemberMap memberMap)
+        public static Expression NullCheckSource(ProfileMap profileMap, Expression source, Expression destination, Expression mapExpression, MemberMap memberMap)
         {
-            var sourceType = sourceParameter.Type;
+            var sourceType = source.Type;
             if (sourceType.IsValueType && !sourceType.IsNullableType())
             {
                 return mapExpression;
             }
-            var destinationType = destinationParameter.Type;
+            var destinationType = destination.Type;
             var isCollection = destinationType.IsCollection();
             var mustUseDestination = memberMap is { MustUseDestination: true };
             var ifSourceNull = mustUseDestination ? ClearDestinationCollection() : DefaultDestination();
-            return sourceParameter.IfNullElse(ifSourceNull, mapExpression);
+            return source.IfNullElse(ifSourceNull, mapExpression);
             Expression ClearDestinationCollection()
             {
                 if (!isCollection)
                 {
-                    return destinationParameter;
+                    return destination;
                 }
                 MethodInfo clearMethod;
-                var destinationVariable = Variable(destinationParameter.Type, "collectionDestination");
+                var destinationVariable = Variable(destination.Type, "collectionDestination");
                 Expression collection = destinationVariable;
                 if (destinationType.IsListType())
                 {
@@ -106,7 +111,7 @@ Expression ClearDestinationCollection()
                     {
                         if (!mustUseDestination)
                         {
-                            return destinationParameter;
+                            return destination;
                         }
                         var destinationElementType = GetEnumerableElementType(destinationType);
                         destinationCollectionType = typeof(ICollection<>).MakeGenericType(destinationElementType);
@@ -115,22 +120,22 @@ Expression ClearDestinationCollection()
                     clearMethod = destinationCollectionType.GetMethod("Clear");
                 }
                 return Block(new[] { destinationVariable },
-                    Assign(destinationVariable, destinationParameter),
+                    Assign(destinationVariable, destination),
                     Condition(ReferenceEqual(collection, Null), Empty, Expression.Call(collection, clearMethod)),
                     destinationVariable);
             }
             Expression DefaultDestination()
             {
                 if ((isCollection && profileMap.AllowsNullCollectionsFor(memberMap)) || (!isCollection && profileMap.AllowsNullDestinationValuesFor(memberMap)))
                 {
-                    return destinationParameter.NodeType == ExpressionType.Default ? destinationParameter : Default(destinationType);
+                    return destination.NodeType == ExpressionType.Default ? destination : Default(destinationType);
                 }
                 if (destinationType.IsArray)
                 {
                     var destinationElementType = destinationType.GetElementType();
                     var rank = destinationType.GetArrayRank();
-                    return rank == 1 ? 
-                        Expression.Call(ArrayEmptyMethod.MakeGenericMethod(destinationElementType)) : 
+                    return rank == 1 ?
+                        Expression.Call(ArrayEmptyMethod.MakeGenericMethod(destinationElementType)) :
                         NewArrayBounds(destinationElementType, Enumerable.Repeat(Zero, rank));
                 }
                 return ObjectFactory.GenerateConstructorExpression(destinationType);
@@ -164,7 +169,7 @@ public static Expression ApplyTransformers(this MemberMap memberMap, Expression
             }
             var transformers = perMember.Concat(perMap).Concat(perProfile);
             return Apply(transformers, memberMap, source);
-            static Expression Apply(IEnumerable<ValueTransformerConfiguration> transformers, MemberMap memberMap, Expression source) => 
+            static Expression Apply(IEnumerable<ValueTransformerConfiguration> transformers, MemberMap memberMap, Expression source) =>
                 transformers.Where(vt => vt.IsMatch(memberMap)).Aggregate(source,
                     (current, vtConfig) => ToType(vtConfig.TransformerExpression.ReplaceParameters(ToType(current, vtConfig.ValueType)), memberMap.DestinationType));
         }
@@ -325,22 +330,36 @@ private static Expression Replace(this ParameterReplaceVisitor visitor, LambdaEx
             return newLambda;
         }
         public static Expression Replace(this Expression exp, Expression old, Expression replace) => new ReplaceVisitor(old, replace).Visit(exp);
-        public static Expression NullCheck(this Expression expression, Type destinationType = null, Expression defaultValue = null)
+        public static Expression NullCheck(this Expression expression, MemberMap memberMap = null, Expression defaultValue = null)
         {
             var chain = expression.GetChain();
-            if (chain.Count == 0 || chain.Peek().Target is not ParameterExpression parameter)
+            var min = memberMap?.IncludedMember != null ? 1 : 2;
+            if (chain.Count < min || chain.Peek().Target is not ParameterExpression parameter)
             {
                 return expression;
             }
+            var destinationType = memberMap?.DestinationType;
             var returnType = (destinationType != null && destinationType != expression.Type && Nullable.GetUnderlyingType(destinationType) == expression.Type) ?
                 destinationType : expression.Type;
             var defaultReturn = (defaultValue is { NodeType: ExpressionType.Default } && defaultValue.Type == returnType) ? defaultValue : Default(returnType);
             ParameterExpression[] variables = null;
-            var name = parameter.Name;
+            Expression begin;
+            string name;
+            if (min == 1)
+            {
+                begin = parameter;
+                name = parameter.Name;
+            }
+            else
+            {
+                var second = chain.Pop();
+                begin = second.Expression;
+                name = parameter.Name + second.MemberInfo.Name;
+            }
             int index = 0;
-            var nullCheckedExpression = NullCheck(parameter);
+            var nullCheckedExpression = NullCheck(begin);
             return variables == null ? nullCheckedExpression : Block(variables, nullCheckedExpression);
-            Expression NullCheck(ParameterExpression variable)
+            Expression NullCheck(Expression variable)
             {
                 var member = chain.Pop();
                 if (chain.Count == 0)

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -235,10 +235,7 @@ private Expression CreateMapperFunc(Expression assignmentFunc)
             {
                 mapperFunc = Condition(overMaxDepth, Default(DestinationType), mapperFunc);
             }
-            if (_typeMap.Profile.AllowNullDestinationValues)
-            {
-                mapperFunc = Source.IfNullElse(Default(DestinationType), mapperFunc);
-            }
+            mapperFunc = NullCheckSource(_typeMap.Profile, Source, _initialDestination, mapperFunc, null);
             return CheckReferencesCache(mapperFunc);
         }
         private Expression CheckReferencesCache(Expression valueBuilder)
@@ -421,7 +418,7 @@ public ExpressionResolver(LambdaExpression lambda) : base(lambda) { }
         public Expression GetExpression(MemberMap memberMap, Expression source, Expression _, Expression destinationMember)
         {
             var mapFrom = Lambda.ReplaceParameters(source);
-            var nullCheckedExpression = mapFrom.NullCheck(memberMap.DestinationType, destinationMember);
+            var nullCheckedExpression = mapFrom.NullCheck(memberMap, destinationMember);
             if (nullCheckedExpression != mapFrom)
             {
                 return nullCheckedExpression;
@@ -461,7 +458,7 @@ public Expression GetExpression(MemberMap memberMap, Expression source, Expressi
             var sourceMember = SourceMemberLambda?.ReplaceParameters(source) ??
                 (SourceMemberName != null ?
                     PropertyOrField(source, SourceMemberName) :
-                    memberMap.ChainSourceMembers(source, iResolverTypeArgs[1], destinationMember) ?? Throw(Constant(BuildExceptionMessage()), iResolverTypeArgs[0]));
+                    memberMap.ChainSourceMembers(source, destinationMember) ?? Throw(Constant(BuildExceptionMessage()), iResolverTypeArgs[0]));
             return Call(ToType(_instance, InterfaceType), "Convert", ToType(sourceMember, iResolverTypeArgs[0]), ContextParameter);
             AutoMapperConfigurationException BuildExceptionMessage()
                 => new($"Cannot find a source member to pass to the value converter of type {ConcreteType}. Configure a source member to map from.");

src/AutoMapper/Mappers/CollectionMapper.cs

@@ -74,13 +74,13 @@ Expression MapCollectionCore(Expression destExpression)
                     addItems = Condition(overMaxDepth, ExpressionBuilder.Empty, addItems);
                 }
                 var clearMethod = isIList ? IListClear : destinationCollectionType.GetMethod("Clear");
-                var checkNull = Block(new[] { newExpression, passedDestination },
-                        Assign(passedDestination, destExpression),
-                        assignNewExpression,
-                        Call(destination, clearMethod),
-                        addItems,
-                        destination);
-                return CheckContext();
+                return Block(new[] { newExpression, passedDestination },
+                                    CheckContext() ?? ExpressionBuilder.Empty,
+                                    Assign(passedDestination, destExpression),
+                                    assignNewExpression,
+                                    Call(destination, clearMethod),
+                                    addItems,
+                                    destination);
                 void GetDestinationType()
                 {
                     var immutableCollection = !mustUseDestination && destinationType.IsValueType;
@@ -132,16 +132,7 @@ void UseDestinationValue()
                 Expression CheckContext()
                 {
                     var elementTypeMap = configurationProvider.ResolveTypeMap(sourceElementType, destinationElementType);
-                    if (elementTypeMap == null)
-                    {
-                        return checkNull;
-                    }
-                    var checkContext = ExpressionBuilder.CheckContext(elementTypeMap);
-                    if (checkContext == null)
-                    {
-                        return checkNull;
-                    }
-                    return Block(checkContext, checkNull);
+                    return elementTypeMap == null ? null : ExpressionBuilder.CheckContext(elementTypeMap);
                 }
             }
         }

src/AutoMapper/MemberMap.cs

@@ -59,8 +59,8 @@ public void MapFrom(string sourceMembersPath)
         }
         public override string ToString() => DestinationName;
         public Expression ChainSourceMembers(Expression source) => SourceMembers.Chain(source);
-        public Expression ChainSourceMembers(Expression source, Type destinationType, Expression defaultValue) =>
-            ChainSourceMembers(source)?.NullCheck(destinationType, defaultValue);
+        public Expression ChainSourceMembers(Expression source, Expression defaultValue) =>
+            ChainSourceMembers(source)?.NullCheck(this, defaultValue);
         public bool AllowsNullDestinationValues => Profile?.AllowsNullDestinationValuesFor(this) ?? true;
         public bool AllowsNullCollections => (Profile?.AllowsNullCollectionsFor(this)).GetValueOrDefault();
         public ProfileMap Profile => TypeMap?.Profile;
@@ -76,7 +76,7 @@ public void MapByConvention(MemberInfo[] sourceMembers)
             Resolver = this;
         }
         Expression IValueResolver.GetExpression(MemberMap memberMap, Expression source, Expression destination, Expression destinationMember) =>
-            ChainSourceMembers(source, memberMap.DestinationType, destinationMember);
+            ChainSourceMembers(source, destinationMember);
         MemberInfo IValueResolver.GetSourceMember(MemberMap memberMap) => SourceMembers[0];
         Type IValueResolver.ResolvedType => SourceMembers[^1].GetMemberType();
     }