rename configurationProvider to the shorter configuration in most places

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -233,7 +233,7 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
                 if (nullCheck)
                 {
                     var profileMap = mapRequest.MemberMap.Profile ?? Configuration;
-                    fullExpression = NullCheckSource(profileMap, source, destination, fullExpression, mapRequest.MemberMap);
+                    fullExpression = this.NullCheckSource(profileMap, source, destination, fullExpression, mapRequest.MemberMap);
                 }
                 return Lambda(fullExpression, source, destination, ContextParameter);
             }

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -42,12 +42,33 @@ public static class ExpressionBuilder
         private static readonly ParameterExpression[] Indexes = new[] { Index };
         private static readonly BinaryExpression ResetIndex = Assign(Index, Zero);
         private static readonly UnaryExpression IncrementIndex = PostIncrementAssign(Index);
-
-        public static Expression MapExpression(this IGlobalConfiguration configurationProvider, ProfileMap profileMap, TypePair typePair, Expression source,
+        public static (List<ParameterExpression> Variables, List<Expression> Expressions) ScratchPad(this IGlobalConfiguration configuration)
+        {
+            var variables = configuration.Variables;
+            if (variables == null)
+            {
+                variables = new();
+            }
+            else
+            {
+                variables.Clear();
+            }
+            var expressions = configuration.Expressions;
+            if (expressions == null)
+            {
+                expressions = new();
+            }
+            else
+            {
+                expressions.Clear();
+            }
+            return (variables, expressions);
+        }
+        public static Expression MapExpression(this IGlobalConfiguration configuration, ProfileMap profileMap, TypePair typePair, Expression source,
             MemberMap memberMap = null, Expression destination = null)
         {
             destination ??= Default(typePair.DestinationType);
-            var typeMap = configurationProvider.ResolveTypeMap(typePair);
+            var typeMap = configuration.ResolveTypeMap(typePair);
             Expression mapExpression = null;
             bool nullCheck;
             if (typeMap != null)
@@ -56,7 +77,7 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
                 nullCheck = !typeMap.HasTypeConverter && allowNull.HasValue && allowNull != profileMap.AllowNullDestinationValues;
                 if (!typeMap.HasDerivedTypesToInclude)
                 {
-                    typeMap.Seal(configurationProvider);
+                    typeMap.Seal(configuration);
                     if (typeMap.MapExpression != null)
                     {
                         mapExpression = typeMap.Invoke(source, destination);
@@ -65,10 +86,10 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
             }
             else
             {
-                var mapper = configurationProvider.FindMapper(typePair);
+                var mapper = configuration.FindMapper(typePair);
                 if (mapper != null)
                 {
-                    mapExpression = mapper.MapExpression(configurationProvider, profileMap, memberMap, source, destination);
+                    mapExpression = mapper.MapExpression(configuration, profileMap, memberMap, source, destination);
                     nullCheck = mapExpression != source;
                     mapExpression = ToType(mapExpression, typePair.DestinationType);
                 }
@@ -78,9 +99,10 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
                 }
             }
             mapExpression ??= ContextMap(typePair, source, destination, memberMap);
-            return nullCheck ? NullCheckSource(profileMap, source, destination, mapExpression, memberMap) : mapExpression;
+            return nullCheck ? configuration.NullCheckSource(profileMap, source, destination, mapExpression, memberMap) : mapExpression;
         }
-        public static Expression NullCheckSource(ProfileMap profileMap, Expression source, Expression destination, Expression mapExpression, MemberMap memberMap)
+        public static Expression NullCheckSource(this IGlobalConfiguration configuration, ProfileMap profileMap, Expression source, Expression destination, 
+            Expression mapExpression, MemberMap memberMap)
         {
             var sourceType = source.Type;
             if (sourceType.IsValueType && !sourceType.IsNullableType())
@@ -120,10 +142,12 @@ Expression ClearDestinationCollection()
                     }
                     clearMethod = destinationCollectionType.GetMethod("Clear");
                 }
-                return Block(new[] { destinationVariable },
-                    Assign(destinationVariable, destination),
-                    Condition(ReferenceEqual(collection, Null), Empty, Expression.Call(collection, clearMethod)),
-                    destinationVariable);
+                var (variables, statements) = configuration.ScratchPad();
+                variables.Add(destinationVariable);
+                statements.Add(Assign(destinationVariable, destination));
+                statements.Add(Condition(ReferenceEqual(collection, Null), Empty, Expression.Call(collection, clearMethod)));
+                statements.Add(destinationVariable);
+                return Block(variables, statements);
             }
             Expression DefaultDestination()
             {
@@ -264,17 +288,19 @@ public static Expression ForEach(List<ParameterExpression> variables, List<Expre
             var getEnumeratorCall = Call(collection, "GetEnumerator");
             var enumeratorVar = Variable(getEnumeratorCall.Type, "enumerator");
             var breakLabel = Label("LoopBreak");
-            variables.Add(enumeratorVar);
-            variables.Add(loopVar);
-            statements.Add(Assign(enumeratorVar, getEnumeratorCall));
-            statements.Add(Using(enumeratorVar,
+            var usingEnumerator = Using(statements, enumeratorVar,
                     Loop(
                         IfThenElse(
                             Call(enumeratorVar, "MoveNext"),
                             Block(Assign(loopVar, ToType(Property(enumeratorVar, "Current"), loopVar.Type)), loopContent),
                             Break(breakLabel)
                         ),
-                    breakLabel)));
+                    breakLabel));
+            statements.Clear();
+            variables.Add(enumeratorVar);
+            variables.Add(loopVar);
+            statements.Add(Assign(enumeratorVar, getEnumeratorCall));
+            statements.Add(usingEnumerator);
             return Block(variables, statements);
             static Expression ForEachArrayItem(List<ParameterExpression> variables, List<Expression> statements, ParameterExpression loopVar, Expression array, Expression loopContent)
             {
@@ -291,7 +317,7 @@ static Expression ForEachArrayItem(List<ParameterExpression> variables, List<Exp
                     breakLabel));
                 return Block(variables, statements);
             }
-            static Expression Using(Expression target, Expression body)
+            static Expression Using(List<Expression> statements, Expression target, Expression body)
             {
                 Expression finallyDispose;
                 if (typeof(IDisposable).IsAssignableFrom(target.Type))
@@ -305,7 +331,9 @@ static Expression Using(Expression target, Expression body)
                         return body;
                     }
                     var assignDisposable = Assign(Disposable, TypeAs(target, typeof(IDisposable)));
-                    finallyDispose = Block(DisposableArray, assignDisposable, DisposeCall);
+                    statements.Add(assignDisposable);
+                    statements.Add(DisposeCall);
+                    finallyDispose = Block(DisposableArray, statements);
                 }
                 return TryFinally(body, finallyDispose);
             }

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -13,30 +13,30 @@ namespace AutoMapper.Execution
     public struct TypeMapPlanBuilder
     {
         private static readonly MethodInfo MappingError = typeof(TypeMapPlanBuilder).GetStaticMethod(nameof(MemberMappingError));
-        private readonly IGlobalConfiguration _configurationProvider;
+        private readonly IGlobalConfiguration _configuration;
         private readonly ParameterExpression _destination;
         private readonly ParameterExpression _initialDestination;
         private readonly TypeMap _typeMap;
         private List<ParameterExpression> _variables;
         private List<Expression> _expressions;
         private CatchBlock[] _catches;
-        public TypeMapPlanBuilder(IGlobalConfiguration configurationProvider, TypeMap typeMap)
+        public TypeMapPlanBuilder(IGlobalConfiguration configuration, TypeMap typeMap)
         {
-            _configurationProvider = configurationProvider;
+            _configuration = configuration;
             _typeMap = typeMap;
             Source = Parameter(typeMap.SourceType, "source");
             _initialDestination = Parameter(typeMap.DestinationType, "destination");
             _destination = Variable(_initialDestination.Type, "typeMapDestination");
-            _variables = configurationProvider.Variables;
-            _expressions = configurationProvider.Expressions;
-            _catches = configurationProvider.Catches;
+            _variables = configuration.Variables;
+            _expressions = configuration.Expressions;
+            _catches = configuration.Catches;
         }
         public Type DestinationType => _destination.Type;
         public ParameterExpression Source { get; }
         private static AutoMapperMappingException MemberMappingError(Exception innerException, MemberMap memberMap) => new("Error mapping types.", innerException, memberMap);
         ParameterExpression[] GetParameters(ParameterExpression source = null, ParameterExpression destination = null)
         {
-            var parameters = _configurationProvider.Parameters ?? new ParameterExpression[] { null, null, ContextParameter };
+            var parameters = _configuration.Parameters ?? new ParameterExpression[] { null, null, ContextParameter };
             parameters[0] = source ?? Source;
             parameters[1] = destination ?? _destination;
             return parameters;
@@ -52,9 +52,9 @@ public LambdaExpression CreateMapperLambda()
             _variables ??= new();
             _expressions ??= new();
             _catches ??= new CatchBlock[1];
-            var typeMapsPath = _configurationProvider.TypeMapsPath;
+            var typeMapsPath = _configuration.TypeMapsPath;
             Clear(ref typeMapsPath);
-            CheckForCycles(_configurationProvider, _typeMap, typeMapsPath);
+            CheckForCycles(_configuration, _typeMap, typeMapsPath);
             var createDestinationFunc = CreateDestinationFunc();
             var assignmentFunc = CreateAssignmentFunc(createDestinationFunc);
             var mapperFunc = CreateMapperFunc(assignmentFunc);
@@ -91,7 +91,7 @@ void IncludeMembers()
             _expressions.AddRange(_variables.Zip(_typeMap.IncludedMembersTypeMaps, (v, i) =>
                 Assign(v, i.MemberExpression.ReplaceParameters(source).NullCheck())));
         }
-        private static void CheckForCycles(IGlobalConfiguration configurationProvider, TypeMap typeMap, HashSet<TypeMap> typeMapsPath)
+        private static void CheckForCycles(IGlobalConfiguration configuration, TypeMap typeMap, HashSet<TypeMap> typeMapsPath)
         {
             typeMapsPath.Add(typeMap);
             foreach (var memberMap in MemberMaps())
@@ -101,7 +101,7 @@ private static void CheckForCycles(IGlobalConfiguration configurationProvider, T
                 {
                     continue;
                 }
-                if (memberMap.Inline && (memberTypeMap.PreserveReferences || typeMapsPath.Count == configurationProvider.MaxExecutionPlanDepth))
+                if (memberMap.Inline && (memberTypeMap.PreserveReferences || typeMapsPath.Count == configuration.MaxExecutionPlanDepth))
                 {
                     memberMap.Inline = false;
                     TraceInline(typeMap, memberMap);
@@ -127,21 +127,21 @@ private static void CheckForCycles(IGlobalConfiguration configurationProvider, T
                         memberMap.Inline = false;
                         TraceInline(typeMap, memberMap);
                     }
-                    foreach (var derivedTypeMap in configurationProvider.GetIncludedTypeMaps(memberTypeMap))
+                    foreach (var derivedTypeMap in configuration.GetIncludedTypeMaps(memberTypeMap))
                     {
                         derivedTypeMap.PreserveReferences = true;
                         Trace(typeMap, derivedTypeMap, memberMap);
                     }
                 }
-                CheckForCycles(configurationProvider, memberTypeMap, typeMapsPath);
+                CheckForCycles(configuration, memberTypeMap, typeMapsPath);
             }
             typeMapsPath.Remove(typeMap);
             return;
             IEnumerable<MemberMap> MemberMaps()
             {
                 var memberMaps = typeMap.MemberMaps;
                 return typeMap.HasDerivedTypesToInclude ?
-                    memberMaps.Concat(configurationProvider.GetIncludedTypeMaps(typeMap).SelectMany(tm => tm.MemberMaps)) :
+                    memberMaps.Concat(configuration.GetIncludedTypeMaps(typeMap).SelectMany(tm => tm.MemberMaps)) :
                     memberMaps;
             }
             TypeMap ResolveMemberTypeMap(MemberMap memberMap)
@@ -151,7 +151,7 @@ TypeMap ResolveMemberTypeMap(MemberMap memberMap)
                     return null;
                 }
                 var types = memberMap.Types();
-                return types.ContainsGenericParameters ? null : configurationProvider.ResolveAssociatedTypeMap(types);
+                return types.ContainsGenericParameters ? null : configuration.ResolveAssociatedTypeMap(types);
             }
             [Conditional("DEBUG")]
             static void Trace(TypeMap typeMap, TypeMap memberTypeMap, MemberMap memberMap) =>
@@ -247,7 +247,7 @@ private Expression CreateMapperFunc(Expression assignmentFunc)
             {
                 mapperFunc = Condition(overMaxDepth, Default(DestinationType), mapperFunc);
             }
-            mapperFunc = NullCheckSource(_typeMap.Profile, Source, _initialDestination, mapperFunc, null);
+            mapperFunc = _configuration.NullCheckSource(_typeMap.Profile, Source, _initialDestination, mapperFunc, null);
             return CheckReferencesCache(mapperFunc);
         }
         private Expression CheckReferencesCache(Expression valueBuilder)
@@ -280,10 +280,13 @@ private Expression CreateConstructorParameterExpression(ConstructorParameterMap
             var customSource = GetCustomSource(ctorParamMap);
             var resolvedExpression = BuildValueResolverFunc(ctorParamMap, customSource, defaultValue);
             var resolvedValue = Variable(resolvedExpression.Type, "resolvedValue");
-            var tryMap = Block(new[] { resolvedValue },
-                Assign(resolvedValue, resolvedExpression),
-                MapMember(ctorParamMap, defaultValue, resolvedValue));
-            return TryMemberMap(ctorParamMap, tryMap);
+            var mapMember = MapMember(ctorParamMap, defaultValue, resolvedValue);
+            _variables.Clear();
+            _variables.Add(resolvedValue);
+            _expressions.Clear();
+            _expressions.Add(Assign(resolvedValue, resolvedExpression));
+            _expressions.Add(mapMember);
+            return TryMemberMap(ctorParamMap, Block(_variables, _expressions));
         }
         private Expression TryPropertyMap(PropertyMap propertyMap)
         {
@@ -375,7 +378,7 @@ Expression MapMember(MemberMap memberMap, Expression destinationMemberValue, Par
         {
             var typePair = memberMap.Types();
             var mapMember = memberMap.Inline ?
-                _configurationProvider.MapExpression(_typeMap.Profile, typePair, resolvedValue, memberMap, destinationMemberValue) :
+                _configuration.MapExpression(_typeMap.Profile, typePair, resolvedValue, memberMap, destinationMemberValue) :
                 ContextMap(typePair, resolvedValue, destinationMemberValue, memberMap);
             return memberMap.ApplyTransformers(mapMember);
         }

src/AutoMapper/Features.cs

@@ -7,7 +7,7 @@ namespace AutoMapper.Features
 {
     public interface IGlobalFeature
     {
-        void Configure(IGlobalConfiguration configurationProvider);
+        void Configure(IGlobalConfiguration configuration);
     }
     public interface IMappingFeature
     {
@@ -16,7 +16,7 @@ public interface IMappingFeature
     }
     public interface IRuntimeFeature
     {
-        void Seal(IGlobalConfiguration configurationProvider);
+        void Seal(IGlobalConfiguration configuration);
     }
     public class Features<TFeature> : IReadOnlyCollection<TFeature>
     {
@@ -91,15 +91,15 @@ internal static void Configure(this Features<IMappingFeature> features, TypeMap
                 feature.Configure(typeMap);
             }
         }
-        internal static void Seal(this Features<IRuntimeFeature> features, IGlobalConfiguration configurationProvider)
+        internal static void Seal(this Features<IRuntimeFeature> features, IGlobalConfiguration configuration)
         {
             if (features.Count == 0)
             {
                 return;
             }
             foreach (var feature in features)
             {
-                feature.Seal(configurationProvider);
+                feature.Seal(configuration);
             }
         }
     }

src/AutoMapper/Internal/PrimitiveHelper.cs

@@ -8,17 +8,6 @@ namespace AutoMapper.Internal
     [EditorBrowsable(EditorBrowsableState.Never)]
     public static class PrimitiveHelper
     {
-        public static void Clear<T>(ref T collection) where T : IList, new()
-        {
-            if (collection == null)
-            {
-                collection = new();
-            }
-            else
-            {
-                collection.Clear();
-            }
-        }
         public static IReadOnlyCollection<T> NullCheck<T>(this IReadOnlyCollection<T> source) => source ?? Array.Empty<T>();
         public static IEnumerable<T> Concat<T>(this IReadOnlyCollection<T> collection, IReadOnlyCollection<T> otherCollection)
         {