less allocations

src/AutoMapper/ApiCompatBaseline.txt

@@ -63,13 +63,15 @@ MembersMustExist : Member 'public System.Boolean AutoMapper.Execution.TypeDescri
 MembersMustExist : Member 'public System.Boolean AutoMapper.Execution.TypeDescription.op_Inequality(AutoMapper.Execution.TypeDescription, AutoMapper.Execution.TypeDescription)' does not exist in the implementation but it does exist in the contract.
 CannotSealType : Type 'AutoMapper.Execution.TypeMapPlanBuilder' is actually (has the sealed modifier) sealed in the implementation but not sealed in the contract.
 TypeCannotChangeClassification : Type 'AutoMapper.Execution.TypeMapPlanBuilder' is a 'struct' in the implementation but is a 'class' in the contract.
+MembersMustExist : Member 'public System.Linq.Expressions.LambdaExpression AutoMapper.Execution.TypeMapPlanBuilder.CreateMapperLambda(System.Collections.Generic.HashSet<AutoMapper.TypeMap>)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Reflection.ConstructorInfo System.Reflection.ConstructorInfo AutoMapper.Internal.ConstructorParameters.Constructor' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Reflection.ParameterInfo[] System.Reflection.ParameterInfo[] AutoMapper.Internal.ConstructorParameters.Parameters' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Internal.TypePair AutoMapper.Internal.MapRequest.RequestedTypes' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Internal.TypePair AutoMapper.Internal.MapRequest.RuntimeTypes' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public AutoMapper.MemberMap AutoMapper.MemberMap AutoMapper.Internal.MapRequest.MemberMap' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Boolean AutoMapper.Internal.MapRequest.op_Equality(AutoMapper.Internal.MapRequest, AutoMapper.Internal.MapRequest)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Boolean AutoMapper.Internal.MapRequest.op_Inequality(AutoMapper.Internal.MapRequest, AutoMapper.Internal.MapRequest)' does not exist in the implementation but it does exist in the contract.
+CannotChangeAttribute : Attribute 'System.Runtime.CompilerServices.IteratorStateMachineAttribute' on 'AutoMapper.Internal.TypeExtensions.GetTypeInheritance(System.Type)' changed from '[IteratorStateMachineAttribute(typeof(TypeExtensions.<GetTypeInheritance>d__19))]' in the contract to '[IteratorStateMachineAttribute(typeof(TypeExtensions.<GetTypeInheritance>d__22))]' in the implementation.
 MembersMustExist : Member 'public System.Type System.Type AutoMapper.Internal.TypePair.DestinationType' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Type System.Type AutoMapper.Internal.TypePair.SourceType' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Boolean AutoMapper.Internal.TypePair.Equals(AutoMapper.Internal.TypePair)' does not exist in the implementation but it does exist in the contract.
@@ -86,4 +88,4 @@ MembersMustExist : Member 'public AutoMapper.Internal.TypePair AutoMapper.Intern
 MembersMustExist : Member 'public System.Linq.IQueryable<TDestination> AutoMapper.QueryableExtensions.Extensions.Map<TSource, TDestination>(System.Linq.IQueryable<TSource>, System.Linq.IQueryable<TDestination>, AutoMapper.IConfigurationProvider)' does not exist in the implementation but it does exist in the contract.
 MembersMustExist : Member 'public System.Collections.Generic.IReadOnlyCollection<System.Reflection.MemberInfo> AutoMapper.QueryableExtensions.MemberVisitor.MemberPath.get()' does not exist in the implementation but it does exist in the contract.
 TypesMustExist : Type 'AutoMapper.QueryableExtensions.Impl.MemberAccessQueryMapperVisitor' does not exist in the implementation but it does exist in the contract.
-Total Issues: 87
+Total Issues: 89

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Security.Cryptography;
 using AutoMapper.Configuration;
 using AutoMapper.Features;
 using AutoMapper.Internal;
@@ -50,8 +51,6 @@ public class MapperConfiguration : IGlobalConfiguration
         private readonly IObjectMapper[] _mappers;
         private readonly Dictionary<TypePair, TypeMap> _configuredMaps;
         private readonly Dictionary<TypePair, TypeMap> _resolvedMaps;
-        private HashSet<TypeMap> _typeMapsPath = new();
-        private List<MemberInfo> _sourceMembers = new();
         private readonly LockingConcurrentDictionary<TypePair, TypeMap> _runtimeMaps;
         private readonly ProjectionBuilder _projectionBuilder;
         private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;
@@ -63,6 +62,12 @@ public class MapperConfiguration : IGlobalConfiguration
         private readonly Func<Type, object> _serviceCtor;
         private readonly bool _sealed;
         private readonly bool _hasOpenMaps;
+        private readonly HashSet<TypeMap> _typeMapsPath = new();
+        private readonly List<MemberInfo> _sourceMembers = new();
+        private readonly List<ParameterExpression> _variables = new();
+        private readonly ParameterExpression[] _parameters = new ParameterExpression[] { null, null, ContextParameter };
+        private readonly CatchBlock[] _catches = new CatchBlock[1];
+        private readonly List<Expression> _expressions = new();
         public MapperConfiguration(MapperConfigurationExpression configurationExpression)
         {
             var configuration = (IGlobalConfigurationExpression)configurationExpression;
@@ -107,6 +112,10 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
             }
             _typeMapsPath = null;
             _sourceMembers = null;
+            _expressions = null;
+            _variables = null;
+            _parameters = null;
+            _catches = null;
             _sealed = true;
             return;
             void Seal()
@@ -134,7 +143,7 @@ void Seal()
                 }
                 foreach (var typeMap in _configuredMaps.Values)
                 {
-                    typeMap.Seal(this, _typeMapsPath);
+                    typeMap.Seal(this);
                 }
                 _features.Seal(this);
             }
@@ -245,6 +254,11 @@ static MapperConfigurationExpression Build(Action<IMapperConfigurationExpression
         int IGlobalConfiguration.RecursiveQueriesMaxDepth => _recursiveQueriesMaxDepth;
         Features<IRuntimeFeature> IGlobalConfiguration.Features => _features;
         List<MemberInfo> IGlobalConfiguration.SourceMembers => _sourceMembers;
+        List<ParameterExpression> IGlobalConfiguration.Variables => _variables;
+        List<Expression> IGlobalConfiguration.Expressions => _expressions;
+        HashSet<TypeMap> IGlobalConfiguration.TypeMapsPath => _typeMapsPath;
+        ParameterExpression[] IGlobalConfiguration.Parameters => _parameters;
+        CatchBlock[] IGlobalConfiguration.Catches => _catches;
         Func<TSource, TDestination, ResolutionContext, TDestination> IGlobalConfiguration.GetExecutionPlan<TSource, TDestination>(in MapRequest mapRequest)
             => (Func<TSource, TDestination, ResolutionContext, TDestination>)GetExecutionPlan(mapRequest);
         private Delegate GetExecutionPlan(in MapRequest mapRequest) => _executionPlans.GetOrAdd(mapRequest);
@@ -285,7 +299,7 @@ TypeMap ResolveTypeMap(TypePair typePair)
                 {
                     lock (typeMap)
                     {
-                        typeMap.Seal(this, null);
+                        typeMap.Seal(this);
                     }
                 }
             }
@@ -295,7 +309,7 @@ TypeMap ResolveTypeMap(TypePair typePair)
                 _resolvedMaps.Add(typePair, typeMap);
                 if (typeMap != null && typeMap.MapExpression == null)
                 {
-                    typeMap.Seal(this, _typeMapsPath);
+                    typeMap.Seal(this);
                 }
             }
             return typeMap;
@@ -460,7 +474,6 @@ void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
             _validator.AssertConfigurationIsValid(_configuredMaps.Values.Where(typeMap => typeMap.Profile.Name == profileName));
         }
         void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);
-        void IGlobalConfiguration.Seal(TypeMap typeMap) => typeMap.Seal(this, _typeMapsPath);
         void IGlobalConfiguration.RegisterAsMap(TypeMapConfiguration typeMapConfiguration) =>
             _resolvedMaps[typeMapConfiguration.Types] = GetIncludedTypeMap(new(typeMapConfiguration.SourceType, typeMapConfiguration.DestinationTypeOverride));
     }

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -39,6 +39,7 @@ public static class ExpressionBuilder
         private static readonly ParameterExpression[] DisposableArray = new[] { Disposable };
         private static readonly Expression DisposeCall = IfNullElse(Disposable, Empty, Expression.Call(Disposable, DisposeMethod));
         private static readonly ParameterExpression Index = Variable(typeof(int), "sourceArrayIndex");
+        private static readonly ParameterExpression[] Indexes = new[] { Index };
         private static readonly BinaryExpression ResetIndex = Assign(Index, Zero);
         private static readonly UnaryExpression IncrementIndex = PostIncrementAssign(Index);
 
@@ -55,7 +56,7 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
                 nullCheck = !typeMap.HasTypeConverter && allowNull.HasValue && allowNull != profileMap.AllowNullDestinationValues;
                 if (!typeMap.HasDerivedTypesToInclude)
                 {
-                    configurationProvider.Seal(typeMap);
+                    typeMap.Seal(configurationProvider);
                     if (typeMap.MapExpression != null)
                     {
                         mapExpression = typeMap.Invoke(source, destination);
@@ -254,39 +255,41 @@ public static bool IsMemberPath(this LambdaExpression lambda, out Stack<Member>
             return currentExpression == lambda.Body;
         }
         public static LambdaExpression MemberAccessLambda(Type type, string memberPath) => GetMemberPath(type, memberPath).Lambda();
-        public static Expression ForEach(ParameterExpression loopVar, Expression collection, Expression loopContent)
+        public static Expression ForEach(List<ParameterExpression> variables, List<Expression> statements, ParameterExpression loopVar, Expression collection, Expression loopContent)
         {
             if (collection.Type.IsArray)
             {
-                return ForEachArrayItem(loopVar, collection, loopContent);
+                return ForEachArrayItem(variables, statements, loopVar, collection, loopContent);
             }
             var getEnumeratorCall = Call(collection, "GetEnumerator");
             var enumeratorVar = Variable(getEnumeratorCall.Type, "enumerator");
             var breakLabel = Label("LoopBreak");
-            var loop = Block(new[] { enumeratorVar, loopVar },
-                Assign(enumeratorVar, getEnumeratorCall),
-                Using(enumeratorVar,
+            variables.Add(enumeratorVar);
+            variables.Add(loopVar);
+            statements.Add(Assign(enumeratorVar, getEnumeratorCall));
+            statements.Add(Using(enumeratorVar,
                     Loop(
                         IfThenElse(
                             Call(enumeratorVar, "MoveNext"),
                             Block(Assign(loopVar, ToType(Property(enumeratorVar, "Current"), loopVar.Type)), loopContent),
                             Break(breakLabel)
                         ),
                     breakLabel)));
-            return loop;
-            static Expression ForEachArrayItem(ParameterExpression loopVar, Expression array, Expression loopContent)
+            return Block(variables, statements);
+            static Expression ForEachArrayItem(List<ParameterExpression> variables, List<Expression> statements, ParameterExpression loopVar, Expression array, Expression loopContent)
             {
                 var breakLabel = Label("LoopBreak");
-                var loop = Block(new[] { Index, loopVar },
-                    ResetIndex,
-                    Loop(
+                variables.Add(Index);
+                variables.Add(loopVar);
+                statements.Add(ResetIndex);
+                statements.Add(Loop(
                         IfThenElse(
                             LessThan(Index, ArrayLength(array)),
-                            Block(Assign(loopVar, ArrayAccess(array, Index)), loopContent, IncrementIndex),
+                            Block(Assign(loopVar, ArrayAccess(array, Indexes)), loopContent, IncrementIndex),
                             Break(breakLabel)
                         ),
                     breakLabel));
-                return loop;
+                return Block(variables, statements);
             }
             static Expression Using(Expression target, Expression body)
             {
@@ -315,21 +318,26 @@ public static MethodCallExpression Call(Expression target, string name, params E
             Expression.Call(target, target.Type.GetInheritedMethod(name), arguments);
         public static Expression ToObject(this Expression expression) => expression.Type.IsValueType ? Convert(expression, typeof(object)) : expression;
         public static Expression ToType(Expression expression, Type type) => expression.Type == type ? expression : Convert(expression, type);
-        public static Expression ReplaceParameters(this LambdaExpression initialLambda, params Expression[] newParameters) =>
+        public static Expression ReplaceParameters(this LambdaExpression initialLambda, Expression newParameter) =>
+            new ParameterReplaceVisitor().Replace(initialLambda, newParameter);
+        public static Expression ReplaceParameters(this LambdaExpression initialLambda, Expression[] newParameters) =>
             new ParameterReplaceVisitor().Replace(initialLambda, newParameters);
-        public static Expression ConvertReplaceParameters(this LambdaExpression initialLambda, params Expression[] newParameters) =>
+        public static Expression ConvertReplaceParameters(this LambdaExpression initialLambda, Expression newParameter) =>
+            new ConvertParameterReplaceVisitor().Replace(initialLambda, newParameter);
+        public static Expression ConvertReplaceParameters(this LambdaExpression initialLambda, Expression[] newParameters) =>
             new ConvertParameterReplaceVisitor().Replace(initialLambda, newParameters);
-        private static Expression Replace(this ParameterReplaceVisitor visitor, LambdaExpression initialLambda, params Expression[] newParameters)
+        private static Expression Replace(this ParameterReplaceVisitor visitor, LambdaExpression initialLambda, Expression newParameter) =>
+            visitor.Replace(initialLambda.Body, initialLambda.Parameters[0], newParameter);
+        private static Expression Replace(this ParameterReplaceVisitor visitor, LambdaExpression initialLambda, Expression[] newParameters)
         {
             var newLambda = initialLambda.Body;
             for (var i = 0; i < Math.Min(newParameters.Length, initialLambda.Parameters.Count); i++)
             {
-                visitor.Replace(initialLambda.Parameters[i], newParameters[i]);
-                newLambda = visitor.Visit(newLambda);
+                newLambda = visitor.Replace(newLambda, initialLambda.Parameters[i], newParameters[i]);
             }
             return newLambda;
         }
-        public static Expression Replace(this Expression exp, Expression old, Expression replace) => new ReplaceVisitor(old, replace).Visit(exp);
+        public static Expression Replace(this Expression exp, Expression old, Expression replace) => new ReplaceVisitor().Replace(exp, old, replace);
         public static Expression NullCheck(this Expression expression, MemberMap memberMap = null, Expression defaultValue = null)
         {
             var chain = expression.GetChain();
@@ -396,15 +404,15 @@ class ReplaceVisitorBase : ExpressionVisitor
         {
             protected Expression _oldNode;
             protected Expression _newNode;
-            public virtual void Replace(Expression oldNode, Expression newNode)
+            public virtual Expression Replace(Expression target, Expression oldNode, Expression newNode)
             {
                 _oldNode = oldNode;
                 _newNode = newNode;
+                return base.Visit(target);
             }
         }
         class ReplaceVisitor : ReplaceVisitorBase
         {
-            public ReplaceVisitor(Expression oldNode, Expression newNode) => Replace(oldNode, newNode);
             public override Expression Visit(Expression node) => _oldNode == node ? _newNode : base.Visit(node);
         }
         class ParameterReplaceVisitor : ReplaceVisitorBase
@@ -413,7 +421,7 @@ class ParameterReplaceVisitor : ReplaceVisitorBase
         }
         class ConvertParameterReplaceVisitor : ParameterReplaceVisitor
         {
-            public override void Replace(Expression oldNode, Expression newNode) => base.Replace(oldNode, ToType(newNode, oldNode.Type));
+            public override Expression Replace(Expression target, Expression oldNode, Expression newNode) => base.Replace(target, oldNode, ToType(newNode, oldNode.Type));
         }
     }
     public readonly record struct Member(Expression Expression, MemberInfo MemberInfo, Expression Target);