Default implementation for GetSubQueryMarker

Setup.ps1

@@ -27,6 +27,7 @@ Import-Module BitsTransfer
 Start-BitsTransfer -Source https://download.microsoft.com/download/7/c/1/7c14e92e-bdcb-4f89-b7cf-93543e7112d1/SqlLocalDB.msi -Destination SqlLocalDB.msi
 Write-Host "Installing"
 Start-Process -FilePath "SqlLocalDB.msi" -Wait -ArgumentList "/qn", "/norestart", "/l*v SqlLocalDBInstall.log", "IACCEPTSQLLOCALDBLICENSETERMS=YES";
+<#
 Write-Host "Checking"
 sqlcmd -l 60 -S "(localdb)\MSSQLLocalDB" -Q "SELECT @@VERSION;"
-
+#>

src/AutoMapper/Configuration/ConfigurationValidator.cs

@@ -33,7 +33,7 @@ public void AssertConfigurationExpressionIsValid(IEnumerable<TypeMap> typeMaps)
         {
             if (!_expression.AllowAdditiveTypeMapCreation)
             {
-                var duplicateTypeMapConfigs = _expression.Profiles.Concat(new[] { (Profile)_expression })
+                var duplicateTypeMapConfigs = _expression.Profiles.Append((Profile)_expression)
                     .SelectMany(p => p.TypeMapConfigs, (profile, typeMap) => (profile, typeMap))
                     .GroupBy(x => x.typeMap.Types)
                     .Where(g => g.Count() > 1)

src/AutoMapper/Configuration/MappingExpressionBase.cs

@@ -20,6 +20,7 @@ public interface ITypeMapConfiguration
         TypePair Types { get; }
         ITypeMapConfiguration ReverseTypeMap { get; }
         TypeMap TypeMap { get; }
+        bool HasTypeConverter { get; }
     }
     public abstract class MappingExpressionBase : ITypeMapConfiguration
     {
@@ -42,6 +43,7 @@ protected MappingExpressionBase(MemberList memberList, TypePair types)
         protected bool Projection { get; set; }
         public TypePair Types => _types;
         public bool IsReverseMap { get; set; }
+        public bool HasTypeConverter { get; protected set; }
         public TypeMap TypeMap { get; private set; }
         public Type SourceType => _types.SourceType;
         public Type DestinationType => _types.DestinationType;
@@ -451,11 +453,15 @@ public TMappingExpression ConstructUsing(Func<TSource, ResolutionContext, TDesti
             return this as TMappingExpression;
         }
 
-        public void ConvertUsing(Type typeConverterType) 
-            => TypeMapActions.Add(tm => tm.TypeConverterType = typeConverterType);
+        public void ConvertUsing(Type typeConverterType)
+        {
+            HasTypeConverter = true;
+            TypeMapActions.Add(tm => tm.TypeConverterType = typeConverterType);
+        }
 
         public void ConvertUsing(Func<TSource, TDestination, TDestination> mappingFunction)
         {
+            HasTypeConverter = true;
             TypeMapActions.Add(tm =>
             {
                 Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =
@@ -467,6 +473,7 @@ public void ConvertUsing(Func<TSource, TDestination, TDestination> mappingFuncti
 
         public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestination> mappingFunction)
         {
+            HasTypeConverter = true;
             TypeMapActions.Add(tm =>
             {
                 Expression<Func<TSource, TDestination, ResolutionContext, TDestination>> expr =
@@ -476,13 +483,11 @@ public void ConvertUsing(Func<TSource, TDestination, ResolutionContext, TDestina
             });
         }
 
-        public void ConvertUsing(ITypeConverter<TSource, TDestination> converter)
-        {
-            ConvertUsing(converter.Convert);
-        }
+        public void ConvertUsing(ITypeConverter<TSource, TDestination> converter) => ConvertUsing(converter.Convert);
 
         public void ConvertUsing<TTypeConverter>() where TTypeConverter : ITypeConverter<TSource, TDestination>
         {
+            HasTypeConverter = true;
             TypeMapActions.Add(tm => tm.TypeConverterType = typeof(TTypeConverter));
         }
 
@@ -517,8 +522,11 @@ public TMappingExpression IgnoreAllSourcePropertiesWithAnInaccessibleSetter()
 
         private static IEnumerable<PropertyInfo> PropertiesWithAnInaccessibleSetter(Type type) => type.GetRuntimeProperties().Where(p => p.GetSetMethod() == null);
 
-        public void ConvertUsing(Expression<Func<TSource, TDestination>> mappingFunction) =>
+        public void ConvertUsing(Expression<Func<TSource, TDestination>> mappingFunction)
+        {
+            HasTypeConverter = true;
             TypeMapActions.Add(tm => tm.CustomMapExpression = mappingFunction);
+        }
 
         public TMappingExpression AsProxy()
         {

src/AutoMapper/Execution/ExpressionBuilder.cs

@@ -16,7 +16,6 @@ public static class ExpressionBuilder
     {
         public static readonly MethodInfo ObjectToString = typeof(object).GetMethod(nameof(object.ToString));
         private static readonly MethodInfo DisposeMethod = typeof(IDisposable).GetMethod(nameof(IDisposable.Dispose));
-        public static readonly Expression False = Constant(false, typeof(bool));
         public static readonly Expression True = Constant(true, typeof(bool));
         public static readonly Expression Null = Constant(null, typeof(object));
         public static readonly Expression Empty = Empty();
@@ -34,6 +33,12 @@ public static class ExpressionBuilder
         private static readonly MethodInfo CheckContextMethod = typeof(ResolutionContext).GetStaticMethod(nameof(ResolutionContext.CheckContext));
         private static readonly MethodInfo ContextMapMethod = typeof(ResolutionContext).GetInstanceMethod(nameof(ResolutionContext.MapInternal));
         private static readonly MethodInfo ArrayEmptyMethod = typeof(Array).GetStaticMethod(nameof(Array.Empty));
+        private static readonly ParameterExpression Disposable = Variable(typeof(IDisposable), "disposableEnumerator");
+        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 BinaryExpression ResetIndex = Assign(Index, Zero);
+        private static readonly UnaryExpression IncrementIndex = PostIncrementAssign(Index);
 
         public static Expression MapExpression(this IGlobalConfiguration configurationProvider, ProfileMap profileMap, TypePair typePair, Expression sourceParameter,
             MemberMap propertyMap = null, Expression destinationParameter = null)
@@ -47,7 +52,7 @@ public static Expression MapExpression(this IGlobalConfiguration configurationPr
                 hasTypeConverter = typeMap.HasTypeConverter;
                 if (!typeMap.HasDerivedTypesToInclude)
                 {
-                    typeMap.Seal(configurationProvider);
+                    configurationProvider.Seal(typeMap);
                     mapExpression = typeMap.MapExpression?.ConvertReplaceParameters(sourceParameter, destinationParameter);
                 }
             }
@@ -263,36 +268,34 @@ public static Expression ForEach(ParameterExpression loopVar, Expression collect
             static Expression ForEachArrayItem(ParameterExpression loopVar, Expression array, Expression loopContent)
             {
                 var breakLabel = Label("LoopBreak");
-                var index = Variable(typeof(int), "sourceArrayIndex");
-                var loop = Block(new[] { index, loopVar },
-                    Assign(index, Zero),
+                var loop = Block(new[] { Index, loopVar },
+                    ResetIndex,
                     Loop(
                         IfThenElse(
-                            LessThan(index, ArrayLength(array)),
-                            Block(Assign(loopVar, ArrayAccess(array, index)), loopContent, PostIncrementAssign(index)),
+                            LessThan(Index, ArrayLength(array)),
+                            Block(Assign(loopVar, ArrayAccess(array, Index)), loopContent, IncrementIndex),
                             Break(breakLabel)
                         ),
                     breakLabel));
                 return loop;
             }
-            static Expression Using(Expression disposable, Expression body)
+            static Expression Using(Expression target, Expression body)
             {
-                Expression disposeCall;
-                if (typeof(IDisposable).IsAssignableFrom(disposable.Type))
+                Expression finallyDispose;
+                if (typeof(IDisposable).IsAssignableFrom(target.Type))
                 {
-                    disposeCall = Expression.Call(disposable, DisposeMethod);
+                    finallyDispose = Expression.Call(target, DisposeMethod);
                 }
                 else
                 {
-                    if (disposable.Type.IsValueType)
+                    if (target.Type.IsValueType)
                     {
                         return body;
                     }
-                    var disposableVariable = Variable(typeof(IDisposable), "disposableVariable");
-                    var assignDisposable = Assign(disposableVariable, TypeAs(disposable, typeof(IDisposable)));
-                    disposeCall = Block(new[] { disposableVariable }, assignDisposable, IfNullElse(disposableVariable, Empty, Expression.Call(disposableVariable, DisposeMethod)));
+                    var assignDisposable = Assign(Disposable, TypeAs(target, typeof(IDisposable)));
+                    finallyDispose = Block(DisposableArray, assignDisposable, DisposeCall);
                 }
-                return TryFinally(body, disposeCall);
+                return TryFinally(body, finallyDispose);
             }
         }
         // Expression.Property(string) is inefficient because it does a case insensitive match
@@ -325,9 +328,9 @@ public static Expression NullCheck(this Expression expression, Type destinationT
             {
                 return expression;
             }
-            var returnType = (destinationType != null && destinationType != expression.Type && Nullable.GetUnderlyingType(destinationType) == expression.Type) ? 
+            var returnType = (destinationType != null && destinationType != expression.Type && Nullable.GetUnderlyingType(destinationType) == expression.Type) ?
                 destinationType : expression.Type;
-            var defaultReturn = defaultValue?.Type == returnType ? defaultValue : Default(returnType);
+            var defaultReturn = (defaultValue is { NodeType: ExpressionType.Default } && defaultValue.Type == returnType) ? defaultValue : Default(returnType);
             ParameterExpression[] variables = null;
             var name = parameter.Name;
             int index = 0;
@@ -351,9 +354,9 @@ static Expression UpdateTarget(Expression sourceExpression, Expression newTarget
                 sourceExpression switch
                 {
                     MemberExpression memberExpression => memberExpression.Update(newTarget),
-                    MethodCallExpression { Method: { IsStatic: true }, Arguments: var args } methodCall when args[0] != newTarget =>
-                        methodCall.Update(null, new[] { newTarget }.Concat(args.Skip(1))),
-                    MethodCallExpression { Method: { IsStatic: false } } methodCall => methodCall.Update(newTarget, methodCall.Arguments),
+                    MethodCallExpression { Method.IsStatic: true, Arguments: var args } methodCall when args[0] != newTarget =>
+                        methodCall.Update(null, args.Skip(1).Prepend(newTarget)),
+                    MethodCallExpression { Method.IsStatic: false } methodCall => methodCall.Update(newTarget, methodCall.Arguments),
                     _ => sourceExpression,
                 };
         }

src/AutoMapper/Execution/ProxyGenerator.cs

@@ -19,8 +19,10 @@ public static class ProxyGenerator
         private static readonly LockingConcurrentDictionary<TypeDescription, Type> ProxyTypes = new LockingConcurrentDictionary<TypeDescription, Type>(EmitProxy);
         private static ModuleBuilder CreateProxyModule()
         {
-            var builder = AssemblyBuilder.DefineDynamicAssembly(typeof(Mapper).Assembly.GetName(), AssemblyBuilderAccess.Run);
-            return builder.DefineDynamicModule("AutoMapper.Proxies.emit");
+            var assemblyName = typeof(Mapper).Assembly.GetName();
+            assemblyName.Name = "AutoMapper.Proxies.emit";
+            var builder = AssemblyBuilder.DefineDynamicAssembly(assemblyName, AssemblyBuilderAccess.Run);
+            return builder.DefineDynamicModule(assemblyName.Name);
         }
         private static Type EmitProxy(TypeDescription typeDescription)
         {

src/AutoMapper/Execution/TypeMapPlanBuilder.cs

@@ -87,7 +87,7 @@ private static void CheckForCycles(IGlobalConfiguration configurationProvider, T
         {
             if (typeMap.DestinationTypeOverride != null)
             {
-                CheckForCycles(configurationProvider, configurationProvider.GetIncludedTypeMap(typeMap.GetAsPair()), typeMapsPath);
+                CheckForCycles(configurationProvider, configurationProvider.GetIncludedTypeMap(typeMap.AsPair()), typeMapsPath);
                 return;
             }
             typeMapsPath.Add(typeMap);
@@ -179,13 +179,12 @@ private Expression CreateAssignmentFunc(Expression createDestination)
             {
                 actions.Add(beforeMapAction.ReplaceParameters(Source, _destination, ContextParameter));
             }
-            var isConstructorMapping = _typeMap.ConstructorMapping;
             foreach (var propertyMap in _typeMap.PropertyMaps)
             {
                 if (propertyMap.CanResolveValue)
                 {
                     var property = TryPropertyMap(propertyMap);
-                    if (isConstructorMapping && _typeMap.ConstructorParameterMatches(propertyMap.DestinationName))
+                    if (_typeMap.ConstructorParameterMatches(propertyMap.DestinationName))
                     {
                         property = _initialDestination.IfNullElse(Default(property.Type), property);
                     }
@@ -219,7 +218,7 @@ private Expression TryPathMap(PathMap pathMap)
             return TryMemberMap(pathMap, pathMapExpression);
             static Expression CreateInnerObjects(Expression destination)
             {
-                return Block(destination.GetMemberExpressions().Select(NullCheck).Concat(new[] { ExpressionBuilder.Empty }));
+                return Block(destination.GetMemberExpressions().Select(NullCheck).Append(ExpressionBuilder.Empty));
                 static Expression NullCheck(MemberExpression memberExpression)
                 {
                     var setter = GetSetter(memberExpression);
@@ -274,7 +273,7 @@ private Expression ConstructorMapping(ConstructorMap constructorMap)
             var ctorArgs = constructorMap.CtorParams.Select(CreateConstructorParameterExpression);
             var variables = constructorMap.Ctor.GetParameters().Select(parameter => Variable(parameter.ParameterType, parameter.Name)).ToArray();
             var body = variables.Zip(ctorArgs, (variable, expression) => (Expression)Assign(variable, ToType(expression, variable.Type)))
-                .Concat(new[] { CheckReferencesCache(New(constructorMap.Ctor, variables)) });
+                .Append(CheckReferencesCache(New(constructorMap.Ctor, variables)));
             return Block(variables, body);
         }
         private Expression CreateConstructorParameterExpression(ConstructorParameterMap ctorParamMap)
@@ -396,7 +395,7 @@ private Expression BuildValueResolverFunc(MemberMap memberMap, Expression destVa
                 { ValueResolverConfig: { } } => BuildResolveCall(memberMap, customSource, destValueExpr),
                 { CustomMapFunction: LambdaExpression function } => function.ConvertReplaceParameters(customSource, _destination, destValueExpr, ContextParameter),
                 { CustomMapExpression: LambdaExpression mapFrom } => CustomMapExpression(mapFrom.ReplaceParameters(customSource), destinationPropertyType, destValueExpr),
-                { SourceMembers: { Length: > 0 } } => memberMap.ChainSourceMembers(customSource, destinationPropertyType, destValueExpr),
+                { SourceMembers.Length: > 0 } => memberMap.ChainSourceMembers(customSource, destinationPropertyType, destValueExpr),
                 _ => destValueExpr
             };
             if (memberMap.NullSubstitute != null)
@@ -444,7 +443,7 @@ private Expression BuildResolveCall(MemberMap memberMap, Expression source, Expr
             }
             var parameters = new[] { source, _destination, sourceMember, destValueExpr }.Where(p => p != null)
                 .Zip(iResolverType.GenericTypeArguments, ToType)
-                .Concat(new[] { ContextParameter })
+                .Append(ContextParameter)
                 .ToArray();
             return Call(ToType(resolverInstance, iResolverType), "Resolve", parameters);
         }

src/AutoMapper/Internal/InternalApi.cs

@@ -153,6 +153,7 @@ public interface IGlobalConfiguration : IConfigurationProvider
         TypeMap GetIncludedTypeMap(TypePair typePair);
         TypeMap GetIncludedTypeMap(Type sourceType, Type destinationType);
         TypeMap[] GetIncludedTypeMaps(IReadOnlyCollection<TypePair> includedTypes);
+        void Seal(TypeMap typeMap);
     }
     [EditorBrowsable(EditorBrowsableState.Never)]
     public interface IProfileExpressionInternal : IProfileExpression

src/AutoMapper/Internal/ReflectionHelper.cs

@@ -9,6 +9,7 @@ namespace AutoMapper.Internal
     [EditorBrowsable(EditorBrowsableState.Never)]
     public static class ReflectionHelper
     {
+        public static Type FirstParameterType(this MethodBase method) => method.GetParameters()[0].ParameterType;
         public static Type GetElementType(Type type) => type.IsArray ? type.GetElementType() : GetEnumerableElementType(type);
         public static Type GetEnumerableElementType(Type type) => type.GetIEnumerableType()?.GenericTypeArguments[0] ?? typeof(object);
         public static TypeMap[] GetIncludedTypeMaps(this IGlobalConfiguration configuration, TypeMap typeMap) =>