cosmetic

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -45,10 +45,6 @@ public class MapperConfiguration : IGlobalConfiguration
     private readonly LockingConcurrentDictionary<MapRequest, Delegate> _executionPlans;
     private readonly ConfigurationValidator _validator;
     private readonly Features<IRuntimeFeature> _features = new();
-    private readonly int _recursiveQueriesMaxDepth;
-    private readonly int _maxExecutionPlanDepth;
-    private readonly bool _enableNullPropagationForQueryMapping;
-    private readonly Func<Type, object> _serviceCtor;
     private readonly bool _sealed;
     private readonly bool _hasOpenMaps;
     private readonly HashSet<TypeMap> _typeMapsPath = new();
@@ -71,11 +67,7 @@ public MapperConfiguration(MapperConfigurationExpression configurationExpression
         _mappers = configuration.Mappers.ToArray();
         _executionPlans = new(CompileExecutionPlan);
         _validator = new(configuration);
-        _serviceCtor = configuration.ServiceCtor;
-        _enableNullPropagationForQueryMapping = configuration.EnableNullPropagationForQueryMapping ?? false;
-        _maxExecutionPlanDepth = configuration.MaxExecutionPlanDepth + 1;
         _projectionBuilder = new(CreateProjectionBuilder);
-        _recursiveQueriesMaxDepth = configuration.RecursiveQueriesMaxDepth;
         Configuration = new((IProfileConfiguration)configuration);
         int typeMapsCount = Configuration.TypeMapsCount;
         int openTypeMapsCount = Configuration.OpenTypeMapsCount;
@@ -233,15 +225,16 @@ LambdaExpression GenerateObjectMapperExpression(in MapRequest mapRequest, IObjec
             return Lambda(fullExpression, source, destination, ContextParameter);
         }
     }
-    ProjectionBuilder CreateProjectionBuilder() => new(this, _validator.Expression.ProjectionMappers.ToArray());
+    IGlobalConfigurationExpression ConfigurationExpression => _validator.Expression;
+    ProjectionBuilder CreateProjectionBuilder() => new(this, ConfigurationExpression.ProjectionMappers.ToArray());
     IProjectionBuilder IGlobalConfiguration.ProjectionBuilder => _projectionBuilder.Value;
-    Func<Type, object> IGlobalConfiguration.ServiceCtor => _serviceCtor;
-    bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => _enableNullPropagationForQueryMapping;
-    int IGlobalConfiguration.MaxExecutionPlanDepth => _maxExecutionPlanDepth;
+    Func<Type, object> IGlobalConfiguration.ServiceCtor => ConfigurationExpression.ServiceCtor;
+    bool IGlobalConfiguration.EnableNullPropagationForQueryMapping => ConfigurationExpression.EnableNullPropagationForQueryMapping.GetValueOrDefault();
+    int IGlobalConfiguration.MaxExecutionPlanDepth => ConfigurationExpression.MaxExecutionPlanDepth + 1;
     private ProfileMap Configuration { get; }
     ProfileMap[] IGlobalConfiguration.Profiles => Profiles;
     internal ProfileMap[] Profiles { get; }
-    int IGlobalConfiguration.RecursiveQueriesMaxDepth => _recursiveQueriesMaxDepth;
+    int IGlobalConfiguration.RecursiveQueriesMaxDepth => ConfigurationExpression.RecursiveQueriesMaxDepth;
     Features<IRuntimeFeature> IGlobalConfiguration.Features => _features;
     List<MemberInfo> IGlobalConfiguration.SourceMembers => _sourceMembers;
     List<ParameterExpression> IGlobalConfiguration.Variables => _variables;

src/AutoMapper/Configuration/MappingExpression.cs

@@ -89,7 +89,7 @@ public IMappingExpression<TSource, TDestination> IncludeMembers(params Expressio
             e =>
             {
                 var bodyIsCastToObject = e.Body.NodeType == ExpressionType.Convert && e.Body.Type == typeof(object);
-                return bodyIsCastToObject ? Expression.Lambda(((UnaryExpression)e.Body).Operand, e.Parameters) : e;
+                return bodyIsCastToObject ? Lambda(((UnaryExpression)e.Body).Operand, e.Parameters) : e;
             });
         IncludeMembersCore(memberExpressionsWithoutCastToObject);
         return this;

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -449,5 +449,5 @@ public class ParameterReplaceVisitor : ReplaceVisitorBase
 public class ConvertParameterReplaceVisitor : ParameterReplaceVisitor
 {
     public override Expression Replace(Expression target, Expression oldNode, Expression newNode) => 
-        base.Replace(target, oldNode, ExpressionBuilder.ToType(newNode, oldNode.Type));
+        base.Replace(target, oldNode, ToType(newNode, oldNode.Type));
 }

src/AutoMapper/Internal/TypeDetails.cs

@@ -93,15 +93,15 @@ class GenericMethod : MemberInfo
     {
         readonly MethodInfo _genericMethod;
         readonly Type _genericInterface;
-        MethodInfo _closedMethod = ExpressionBuilder.DecTypeDepthInfo;
+        MethodInfo _closedMethod = DecTypeDepthInfo;
         public GenericMethod(MethodInfo genericMethod, Type genericInterface)
         {
             _genericMethod = genericMethod;
             _genericInterface = genericInterface;
         }
         public MethodInfo Close()
         {
-            if (_closedMethod == ExpressionBuilder.DecTypeDepthInfo)
+            if (_closedMethod == DecTypeDepthInfo)
             {
                 // Use method.MakeGenericMethod(genericArguments) wrapped in a try/catch(ArgumentException)
                 // in order to catch exceptions resulting from the generic arguments not being compatible

src/AutoMapper/Mappers/ConstructorMapper.cs

@@ -7,6 +7,6 @@ private static ConstructorInfo GetConstructor(Type sourceType, Type destinationT
     public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
     {
         var constructor = GetConstructor(sourceExpression.Type, destExpression.Type);
-        return Expression.New(constructor, ToType(sourceExpression, constructor.FirstParameterType()));
+        return New(constructor, ToType(sourceExpression, constructor.FirstParameterType()));
     }
 }

src/AutoMapper/Mappers/ConversionOperatorMapper.cs

@@ -18,6 +18,6 @@ private MethodInfo GetConversionOperator(Type sourceType, Type destinationType)
     public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
     {
         var conversionOperator = GetConversionOperator(sourceExpression.Type, destExpression.Type);
-        return Expression.Call(conversionOperator, ToType(sourceExpression, conversionOperator.FirstParameterType()));
+        return Call(conversionOperator, ToType(sourceExpression, conversionOperator.FirstParameterType()));
     }
 }

src/AutoMapper/Mappers/KeyValueMapper.cs

@@ -12,6 +12,6 @@ public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap p
         var values = new TypePair(sourceArguments[1], destinationArguments[1]);
         var mapKeys = configuration.MapExpression(profileMap, keys, ExpressionBuilder.Property(sourceExpression, "Key"));
         var mapValues = configuration.MapExpression(profileMap, values, ExpressionBuilder.Property(sourceExpression, "Value"));
-        return Expression.New(destinationType.GetConstructor(destinationArguments), mapKeys, mapValues);
+        return New(destinationType.GetConstructor(destinationArguments), mapKeys, mapValues);
     }
 }

src/AutoMapper/Mappers/ParseStringMapper.cs

@@ -5,5 +5,5 @@ public class ParseStringMapper : IObjectMapper
     public bool IsMatch(TypePair context) => context.SourceType == typeof(string) && HasParse(context.DestinationType);
     static bool HasParse(Type type) => type == typeof(Guid) || type == typeof(TimeSpan) || type == typeof(DateTimeOffset);
     public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression) =>
-        Expression.Call(destExpression.Type.GetMethod("Parse", new[] { typeof(string) }), sourceExpression);
+        Call(destExpression.Type.GetMethod("Parse", new[] { typeof(string) }), sourceExpression);
 }

src/AutoMapper/Mappers/ToStringMapper.cs

@@ -5,7 +5,7 @@ public class ToStringMapper : IObjectMapper
     public Expression MapExpression(IGlobalConfiguration configuration, ProfileMap profileMap, MemberMap memberMap, Expression sourceExpression, Expression destExpression)
     {
         var sourceType = sourceExpression.Type;
-        var toStringCall = Call(sourceExpression, ExpressionBuilder.ObjectToString);
+        var toStringCall = Call(sourceExpression, ObjectToString);
         return sourceType.IsEnum ? StringToEnumMapper.CheckEnumMember(sourceExpression, sourceType, toStringCall) : toStringCall;
     }
 }

src/AutoMapper/QueryableExtensions/Extensions.cs

@@ -9,7 +9,7 @@ public static class Extensions
 {
     static readonly MethodInfo SelectMethod = typeof(Queryable).StaticGenericMethod("Select", parametersCount: 2);
     static IQueryable Select(IQueryable source, LambdaExpression lambda) => source.Provider.CreateQuery(
-        Expression.Call(SelectMethod.MakeGenericMethod(source.ElementType, lambda.ReturnType), source.Expression, Expression.Quote(lambda)));
+        Call(SelectMethod.MakeGenericMethod(source.ElementType, lambda.ReturnType), source.Expression, Quote(lambda)));
     /// <summary>
     /// Extension method to project from a queryable using the provided mapping engine
     /// </summary>

src/AutoMapper/QueryableExtensions/NullsafeQueryRewriter.cs

@@ -95,17 +95,17 @@ static Expression BeSafe(Expression target, Expression expression, Func<Expressi
         if (fallback != null)
         {
             // coalesce instead, a bit intrusive but fast...
-            return update(Expression.Coalesce(target, fallback));
+            return update(Coalesce(target, fallback));
         }
 
         // target can be null, which is why we are actually here...
-        var targetFallback = Expression.Constant(null, target.Type);
+        var targetFallback = Constant(null, target.Type);
 
         // expression can be default or null, which is basically the same...
         var expressionFallback = !IsNullableOrReferenceType(expression.Type)
-            ? (Expression)Expression.Default(expression.Type) : Expression.Constant(null, expression.Type);
+            ? (Expression)Default(expression.Type) : Constant(null, expression.Type);
 
-        return Expression.Condition(Expression.Equal(target, targetFallback), expressionFallback, expression);
+        return Condition(Equal(target, targetFallback), expressionFallback, expression);
     }
 
     static bool IsSafe(Expression expression)
@@ -129,7 +129,7 @@ static Expression Fallback(Type type)
         // default value for arrays
         if (type.IsArray)
         {
-            return Expression.NewArrayInit(type.GetElementType());
+            return NewArrayInit(type.GetElementType());
         }
 
         return null;
@@ -142,7 +142,7 @@ static Expression CollectionFallback(Type definition, Type type)
         // try if an instance of this collection would suffice
         if (type.GetTypeInfo().IsAssignableFrom(collection.GetTypeInfo()))
         {
-            return Expression.Convert(Expression.New(collection), type);
+            return Convert(New(collection), type);
         }
 
         return null;

src/AutoMapper/QueryableExtensions/ProjectionMappers/AssignableProjectionMapper.cs

@@ -1,9 +1,8 @@
 namespace AutoMapper.QueryableExtensions.Impl;
-
 [EditorBrowsable(EditorBrowsableState.Never)]
 public class AssignableProjectionMapper : IProjectionMapper
 {
     public bool IsMatch(TypePair context) => context.DestinationType.IsAssignableFrom(context.SourceType);
     public Expression Project(IGlobalConfiguration configuration, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)
-        => ExpressionBuilder.ToType(resolvedSource, request.DestinationType);
+        => ToType(resolvedSource, request.DestinationType);
 }

src/AutoMapper/QueryableExtensions/ProjectionMappers/StringProjectionMapper.cs

@@ -5,5 +5,5 @@ public class StringProjectionMapper : IProjectionMapper
 {
     public bool IsMatch(TypePair context) => context.DestinationType == typeof(string);
     public Expression Project(IGlobalConfiguration configuration, in ProjectionRequest request, Expression resolvedSource, LetPropertyMaps letPropertyMaps)
-        => Expression.Call(resolvedSource, ExpressionBuilder.ObjectToString);
+        => Call(resolvedSource, ObjectToString);
 }