reuse the execution plan between user Map calls and internal Map calls

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -173,15 +173,15 @@ public MapperConfiguration(Action<IMapperConfigurationExpression> configure)
         public IMapper CreateMapper(Func<Type, object> serviceCtor) => new Mapper(this, serviceCtor);
         public void CompileMappings()
         {
-            foreach (var request in _resolvedMaps.Keys.Where(t => !t.IsGenericTypeDefinition).Select(types => new MapRequest(types, types)).ToArray())
+            foreach (var request in _resolvedMaps.Keys.Where(t => !t.IsGenericTypeDefinition).Select(types => new MapRequest(types, types, MemberMap.Instance)).ToArray())
             {
                 GetExecutionPlan(request);
             }
         }
         public LambdaExpression BuildExecutionPlan(Type sourceType, Type destinationType)
         {
             var typePair = new TypePair(sourceType, destinationType);
-            return this.Internal().BuildExecutionPlan(new(typePair, typePair));
+            return this.Internal().BuildExecutionPlan(new(typePair, typePair, MemberMap.Instance));
         }
         LambdaExpression IGlobalConfiguration.BuildExecutionPlan(in MapRequest mapRequest)
         {
@@ -237,7 +237,7 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
                     var throwExpression = Throw(newException, runtimeDestinationType);
                     fullExpression = TryCatch(ToType(map, runtimeDestinationType), Catch(ExceptionParameter, throwExpression));
                 }
-                var profileMap = mapRequest.MemberMap?.Profile ?? Configuration;
+                var profileMap = mapRequest.MemberMap.Profile ?? Configuration;
                 var nullCheckSource = NullCheckSource(profileMap, source, destination, fullExpression, mapRequest.MemberMap);
                 return Lambda(nullCheckSource, source, destination, ContextParameter);
             }

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -31,7 +31,7 @@ public static class ExpressionBuilder
         public static readonly MethodInfo OverTypeDepthMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.OverTypeDepth));
         public static readonly MethodInfo CacheDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.CacheDestination));
         public static readonly MethodInfo GetDestinationMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.GetDestination));
-        private static readonly MethodCallExpression CheckContextCall = Expression.Call(
+        public static readonly MethodCallExpression CheckContextCall = Expression.Call(
             typeof(ResolutionContext).GetStaticMethod(nameof(ResolutionContext.CheckContext)), ContextParameter);
         private static readonly MethodInfo ContextMapMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.MapInternal));
         private static readonly MethodInfo ArrayEmptyMethod = typeof(Array).GetStaticMethod(nameof(Array.Empty));
@@ -81,9 +81,7 @@ public static Expression NullCheckSource(ProfileMap profileMap, Expression sourc
             var destinationType = destinationParameter.Type;
             var isCollection = destinationType.IsCollection();
             var mustUseDestination = memberMap is { MustUseDestination: true };
-            var ifSourceNull = memberMap == null ? 
-                destinationParameter.IfNullElse(DefaultDestination(), ClearDestinationCollection()) :
-                mustUseDestination ? ClearDestinationCollection() : DefaultDestination();
+            var ifSourceNull = mustUseDestination ? ClearDestinationCollection() : DefaultDestination();
             return sourceParameter.IfNullElse(ifSourceNull, mapExpression);
             Expression ClearDestinationCollection()
             {
@@ -109,13 +107,13 @@ Expression ClearDestinationCollection()
                         }
                         var destinationElementType = GetEnumerableElementType(destinationType);
                         destinationCollectionType = typeof(ICollection<>).MakeGenericType(destinationElementType);
-                        collection = Convert(collection, destinationCollectionType);
+                        collection = TypeAs(collection, destinationCollectionType);
                     }
                     clearMethod = destinationCollectionType.GetMethod("Clear");
                 }
                 return Block(new[] { destinationVariable },
                     Assign(destinationVariable, destinationParameter),
-                    Condition(ReferenceEqual(destinationVariable, Null), Empty, Expression.Call(collection, clearMethod)),
+                    Condition(ReferenceEqual(collection, Null), Empty, Expression.Call(collection, clearMethod)),
                     destinationVariable);
             }
             Expression DefaultDestination()
@@ -141,14 +139,6 @@ public static Expression ContextMap(TypePair typePair, Expression sourceParamete
             var mapMethod = ContextMapMethod.MakeGenericMethod(typePair.SourceType, typePair.DestinationType);
             return Expression.Call(ContextParameter, mapMethod, sourceParameter, destinationParameter, Constant(memberMap, typeof(MemberMap)));
         }
-        public static Expression CheckContext(TypeMap typeMap)
-        {
-            if (typeMap.MaxDepth > 0 || typeMap.PreserveReferences)
-            {
-                return CheckContextCall;
-            }
-            return null;
-        }
         public static Expression OverMaxDepth(TypeMap typeMap) => typeMap?.MaxDepth > 0 ? Expression.Call(ContextParameter, OverTypeDepthMethod, Constant(typeMap)) : null;
         public static Expression NullSubstitute(this MemberMap memberMap, Expression sourceExpression) =>
             Coalesce(sourceExpression, ToType(Constant(memberMap.NullSubstitute), sourceExpression.Type));

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -54,10 +54,9 @@ public LambdaExpression CreateMapperLambda(HashSet<TypeMap> typeMapsPath)
             var createDestinationFunc = CreateDestinationFunc();
             var assignmentFunc = CreateAssignmentFunc(createDestinationFunc);
             var mapperFunc = CreateMapperFunc(assignmentFunc);
-            var checkContext = CheckContext(_typeMap);
-            if (checkContext != null)
+            if (_typeMap.MaxDepth > 0 || _typeMap.PreserveReferences)
             {
-                statements.Add(checkContext);
+                statements.Add(CheckContextCall);
             }
             statements.Add(mapperFunc);
             variables.Add(_destination);

src/AutoMapper/Internal/TypePair.cs

@@ -8,16 +8,16 @@ namespace AutoMapper.Internal
         public readonly TypePair RequestedTypes;
         public readonly TypePair RuntimeTypes;
         public readonly MemberMap MemberMap;
-        public MapRequest(TypePair requestedTypes, TypePair runtimeTypes, MemberMap memberMap = null) 
+        public MapRequest(TypePair requestedTypes, TypePair runtimeTypes, MemberMap memberMap) 
         {
             RequestedTypes = requestedTypes;
             RuntimeTypes = runtimeTypes;
             MemberMap = memberMap;
         }
         public bool Equals(MapRequest other) => RequestedTypes.Equals(other.RequestedTypes) && RuntimeTypes.Equals(other.RuntimeTypes) &&
-            (MemberMap == other.MemberMap || (MemberMap?.MapperEquals(other.MemberMap)).GetValueOrDefault());
+            (MemberMap == other.MemberMap || MemberMap.MapperEquals(other.MemberMap));
         public override bool Equals(object obj) => obj is MapRequest other && Equals(other);
-        public override int GetHashCode() => HashCode.Combine(RequestedTypes, RuntimeTypes, MemberMap?.MapperGetHashCode());
+        public override int GetHashCode() => HashCode.Combine(RequestedTypes, RuntimeTypes, MemberMap.MapperGetHashCode());
         public static bool operator ==(in MapRequest left, in MapRequest right) => left.Equals(right);
         public static bool operator !=(in MapRequest left, in MapRequest right) => !left.Equals(right);
     }

src/AutoMapper/Mapper.cs

@@ -198,6 +198,7 @@ private TDestination MapCore<TSource, TDestination>(
         {
             TypePair requestedTypes = new(typeof(TSource), typeof(TDestination));
             TypePair runtimeTypes = new(source?.GetType() ?? sourceType ?? typeof(TSource), destination?.GetType() ?? destinationType ?? typeof(TDestination));
+            memberMap ??= destination == null ? MemberMap.Instance : MemberMap.InstanceUseDestination;
             MapRequest mapRequest = new(requestedTypes, runtimeTypes, memberMap);
             return _configurationProvider.GetExecutionPlan<TSource, TDestination>(mapRequest)(source, destination, context);
         }

src/AutoMapper/Mappers/CollectionMapper.cs

@@ -74,17 +74,12 @@ Expression MapCollectionCore(Expression destExpression)
                     addItems = Condition(overMaxDepth, ExpressionBuilder.Empty, addItems);
                 }
                 var clearMethod = isIList ? IListClear : destinationCollectionType.GetMethod("Clear");
-                var checkNull = Block(new[] { newExpression, passedDestination },
+                return Block(new[] { newExpression, passedDestination },
                         Assign(passedDestination, destExpression),
                         assignNewExpression,
                         Call(destination, clearMethod),
                         addItems,
                         destination);
-                if (memberMap != null)
-                {
-                    return checkNull;
-                }
-                return CheckContext();
                 void GetDestinationType()
                 {
                     var immutableCollection = !mustUseDestination && destinationType.IsValueType;
@@ -133,20 +128,6 @@ void UseDestinationValue()
                         assignNewExpression = Assign(newExpression, Coalesce(passedDestination, ObjectFactory.GenerateConstructorExpression(passedDestination.Type)));
                     }
                 }
-                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);
-                }
             }
         }
         private static Expression CreateNameValueCollection(Expression sourceExpression) =>

src/AutoMapper/MemberMap.cs

@@ -18,7 +18,8 @@ public class MemberMap : IValueResolver
     {
         private static readonly LambdaExpression EmptyLambda = Lambda(ExpressionBuilder.Null);
         protected MemberMap(TypeMap typeMap = null) => TypeMap = typeMap;
-        public static readonly MemberMap Instance = new();
+        internal static readonly MemberMap Instance = new();
+        internal static readonly MemberMap InstanceUseDestination = new PropertyMap(default(MemberInfo), null, null) { UseDestinationValue = true };
         public TypeMap TypeMap { get; protected set; }
         public LambdaExpression CustomMapExpression => Resolver?.ProjectToExpression;
         public bool IsResolveConfigured => Resolver != null && Resolver != this;
@@ -64,15 +65,8 @@ public Expression ChainSourceMembers(Expression source, Type destinationType, Ex
         public bool AllowsNullCollections => (Profile?.AllowsNullCollectionsFor(this)).GetValueOrDefault();
         public ProfileMap Profile => TypeMap?.Profile;
         private int MaxDepth => (TypeMap?.MaxDepth).GetValueOrDefault();
-        public bool MapperEquals(MemberMap other)
-        {
-            if (other == null)
-            {
-                return false;
-            }
-            return other.MustUseDestination == MustUseDestination && other.MaxDepth == MaxDepth && 
+        public bool MapperEquals(MemberMap other) => other.MustUseDestination == MustUseDestination && other.MaxDepth == MaxDepth && 
                 other.AllowsNullDestinationValues == AllowsNullDestinationValues && other.AllowsNullCollections == AllowsNullCollections;
-        }
         public int MapperGetHashCode() => HashCode.Combine(MustUseDestination, MaxDepth, AllowsNullDestinationValues, AllowsNullCollections);
         protected Type GetSourceType() => Resolver?.ResolvedType ?? DestinationType;
         public void MapByConvention(MemberInfo[] sourceMembers)