we don't need to create As type maps

src/AutoMapper/Configuration/MapperConfiguration.cs

@@ -18,20 +18,17 @@ public interface IConfigurationProvider
         /// Dry run all configured type maps and throw <see cref="AutoMapperConfigurationException"/> for each problem
         /// </summary>
         void AssertConfigurationIsValid();
-
         /// <summary>
         /// Create a mapper instance based on this configuration. Mapper instances are lightweight and can be created as needed.
         /// </summary>
         /// <returns>The mapper instance</returns>
         IMapper CreateMapper();
-
         /// <summary>
         /// Create a mapper instance with the specified service constructor to be used for resolvers and type converters.
         /// </summary>
         /// <param name="serviceCtor">Service factory to create services</param>
         /// <returns>The mapper instance</returns>
         IMapper CreateMapper(Func<Type, object> serviceCtor);
-
         /// <summary>
         /// Builds the execution plan used to map the source to destination.
         /// Useful to understand what exactly is happening during mapping.
@@ -41,7 +38,6 @@ public interface IConfigurationProvider
         /// <param name="destinationType">the runtime type of the destination object</param>
         /// <returns>the execution plan</returns>
         LambdaExpression BuildExecutionPlan(Type sourceType, Type destinationType);
-
         /// <summary>
         /// Compile all underlying mapping expressions to cached delegates.
         /// Use if you want AutoMapper to compile all mappings up front instead of deferring expression compilation for each first map.
@@ -51,7 +47,6 @@ public interface IConfigurationProvider
     public class MapperConfiguration : IGlobalConfiguration
     {
         private static readonly MethodInfo MappingError = typeof(MapperConfiguration).GetMethod(nameof(GetMappingError));
-
         private readonly IObjectMapper[] _mappers;
         private readonly Dictionary<TypePair, TypeMap> _configuredMaps;
         private readonly Dictionary<TypePair, TypeMap> _resolvedMaps;
@@ -68,7 +63,6 @@ public class MapperConfiguration : IGlobalConfiguration
         private readonly Func<Type, object> _serviceCtor;
         private readonly bool _sealed;
         private readonly bool _hasOpenMaps;
-
         public MapperConfiguration(MapperConfigurationExpression configurationExpression)
         {
             var configuration = (IGlobalConfigurationExpression)configurationExpression;
@@ -129,15 +123,7 @@ void Seal()
                 var derivedMaps = new List<TypeMap>();
                 foreach (var typeMap in _configuredMaps.Values)
                 {
-                    if (typeMap.DestinationTypeOverride != null)
-                    {
-                        var derivedMap = globalConfiguration.GetIncludedTypeMap(typeMap.AsPair());
-                        _resolvedMaps[typeMap.Types] = derivedMap;
-                    }
-                    else
-                    {
-                        _resolvedMaps[typeMap.Types] = typeMap;
-                    }
+                    _resolvedMaps[typeMap.Types] = typeMap;
                     derivedMaps.Clear();
                     GetDerivedTypeMaps(typeMap, derivedMaps);
                     foreach (var derivedMap in derivedMaps)
@@ -387,7 +373,7 @@ TypeMap FindClosedGenericMap(TypePair typePair)
                     ProfileMap profile;
                     TypeMap cachedMap;
                     TypePair closedTypes;
-                    if (userMap != null && userMap.DestinationTypeOverride == null)
+                    if (userMap != null)
                     {
                         genericMapConfig = userMap.Profile.GetGenericMap(userMap.Types);
                         profile = userMap.Profile;
@@ -475,5 +461,7 @@ void IGlobalConfiguration.AssertConfigurationIsValid(string profileName)
         }
         void IGlobalConfiguration.AssertConfigurationIsValid<TProfile>() => this.Internal().AssertConfigurationIsValid(typeof(TProfile).FullName);
         void IGlobalConfiguration.Seal(TypeMap typeMap) => typeMap.Seal(this, _typeMapsPath);
+        void IGlobalConfiguration.RegisterAsMap(ITypeMapConfiguration typeMapConfiguration) =>
+            _resolvedMaps[typeMapConfiguration.Types] = GetIncludedTypeMap(new(typeMapConfiguration.SourceType, typeMapConfiguration.DestinationTypeOverride));
     }
 }

src/AutoMapper/Configuration/MappingExpressionBase.cs

@@ -16,6 +16,7 @@ public interface ITypeMapConfiguration
         void Configure(TypeMap typeMap, List<MemberInfo> sourceMembers);
         Type SourceType { get; }
         Type DestinationType { get; }
+        Type DestinationTypeOverride { get; }
         bool IsReverseMap { get; }
         TypePair Types { get; }
         ITypeMapConfiguration ReverseTypeMap { get; }
@@ -41,6 +42,7 @@ protected MappingExpressionBase(MemberList memberList, TypePair types)
             _memberList = memberList;
             _types = types;
         }
+        public Type DestinationTypeOverride { get; private set; }
         protected bool Projection { get; set; }
         public TypePair Types => _types;
         public bool IsReverseMap { get; set; }
@@ -56,6 +58,15 @@ protected MappingExpressionBase(MemberList memberList, TypePair types)
         protected List<IPropertyMapConfiguration> MemberConfigurations => _memberConfigurations ??= new();
         protected List<ISourceMemberConfiguration> SourceMemberConfigurations => _sourceMemberConfigurations ??= new();
         protected List<ICtorParameterConfiguration> CtorParamConfigurations => _ctorParamConfigurations ??= new();
+        public void As(Type typeOverride)
+        {
+            if (typeOverride == DestinationType)
+            {
+                throw new InvalidOperationException("As must specify a derived type, not " + DestinationType);
+            }
+            typeOverride.CheckIsDerivedFrom(DestinationType);
+            DestinationTypeOverride = typeOverride;
+        }
         public void Configure(TypeMap typeMap, List<MemberInfo> sourceMembers)
         {
             TypeMap = typeMap;
@@ -369,16 +380,6 @@ public TMappingExpression ForSourceMember(string sourceMemberName, Action<ISourc
             return this as TMappingExpression;
         }
 
-        public void As(Type typeOverride)
-        {
-            if (typeOverride == DestinationType)
-            {
-                throw new InvalidOperationException("As must specify a derived type, not " + DestinationType);
-            }
-            typeOverride.CheckIsDerivedFrom(DestinationType);
-            TypeMapActions.Add(tm => tm.DestinationTypeOverride = typeOverride);
-        }
-
         public TMappingExpression ConstructUsing(Expression<Func<TSource, TDestination>> ctor) => ConstructUsingCore(ctor);
 
         private TMappingExpression ConstructUsingCore(LambdaExpression ctor)

src/AutoMapper/Internal/InternalApi.cs

@@ -155,6 +155,7 @@ public interface IGlobalConfiguration : IConfigurationProvider
         TypeMap GetIncludedTypeMap(Type sourceType, Type destinationType);
         TypeMap[] GetIncludedTypeMaps(IReadOnlyCollection<TypePair> includedTypes);
         void Seal(TypeMap typeMap);
+        void RegisterAsMap(ITypeMapConfiguration typeMapConfiguration);
         List<MemberInfo> SourceMembers { get; }
     }
     [EditorBrowsable(EditorBrowsableState.Never)]

src/AutoMapper/ProfileMap.cs

@@ -135,32 +135,42 @@ public TypeDetails CreateTypeDetails(Type type)
         public void Register(IGlobalConfiguration configurationProvider)
         {
             foreach (var config in _typeMapConfigs)
-            {
-                BuildTypeMap(configurationProvider, config);
-                if (config.ReverseTypeMap != null)
+            {
+                if (config.DestinationTypeOverride == null)
                 {
-                    BuildTypeMap(configurationProvider, config.ReverseTypeMap);
+                    BuildTypeMap(configurationProvider, config);
+                    if (config.ReverseTypeMap != null)
+                    {
+                        BuildTypeMap(configurationProvider, config.ReverseTypeMap);
+                    }
                 }
             }
         }
+        private void BuildTypeMap(IGlobalConfiguration configurationProvider, ITypeMapConfiguration config)
+        {
+            var sourceMembers = configurationProvider.SourceMembers;
+            var typeMap = new TypeMap(config.SourceType, config.DestinationType, this, config, sourceMembers);
+            config.Configure(typeMap, sourceMembers);
+            configurationProvider.RegisterTypeMap(typeMap);
+        }
         public void Configure(IGlobalConfiguration configurationProvider)
         {
             foreach (var typeMapConfiguration in _typeMapConfigs)
             {
-                Configure(typeMapConfiguration, configurationProvider);
-                if (typeMapConfiguration.ReverseTypeMap != null)
+                if (typeMapConfiguration.DestinationTypeOverride == null)
                 {
-                    Configure(typeMapConfiguration.ReverseTypeMap, configurationProvider);
+                    Configure(typeMapConfiguration, configurationProvider);
+                    if (typeMapConfiguration.ReverseTypeMap != null)
+                    {
+                        Configure(typeMapConfiguration.ReverseTypeMap, configurationProvider);
+                    }
+                }
+                else
+                {
+                    configurationProvider.RegisterAsMap(typeMapConfiguration);
                 }
             }
         }
-        private void BuildTypeMap(IGlobalConfiguration configurationProvider, ITypeMapConfiguration config)
-        {
-            var sourceMembers = configurationProvider.SourceMembers;
-            var typeMap = new TypeMap(config.SourceType, config.DestinationType, this, config, sourceMembers);
-            config.Configure(typeMap, sourceMembers);
-            configurationProvider.RegisterTypeMap(typeMap);
-        }
         private void Configure(ITypeMapConfiguration typeMapConfiguration, IGlobalConfiguration configurationProvider)
         {
             var typeMap = typeMapConfiguration.TypeMap;

src/AutoMapper/TypeMap.cs

@@ -80,15 +80,6 @@ internal bool CanConstructorMap() => Profile.ConstructorMappingEnabled && !Desti
         public LambdaExpression CustomMapExpression => TypeConverter?.ProjectToExpression;
         public LambdaExpression CustomCtorFunction { get => _details?.CustomCtorFunction; set => Details.CustomCtorFunction = value; }
         public LambdaExpression CustomCtorExpression => CustomCtorFunction?.Parameters.Count == 1 ? CustomCtorFunction : null;
-        public Type DestinationTypeOverride
-        {
-            get => _details?.DestinationTypeOverride;
-            set
-            {
-                Details.DestinationTypeOverride = value;
-                _sealed = true;
-            }
-        }
         public bool IncludeAllDerivedTypes { get => (_details?.IncludeAllDerivedTypes).GetValueOrDefault(); set => Details.IncludeAllDerivedTypes = value; }
         public MemberList ConfiguredMemberList
         {
@@ -138,7 +129,7 @@ public IEnumerable<MemberMap> MemberMaps
         public bool CustomConstruction => CustomCtorFunction != null;
         public bool HasTypeConverter => TypeConverter != null;
         public TypeConverter TypeConverter { get; set; }
-        public bool ShouldCheckForValid => !HasTypeConverter && DestinationTypeOverride == null && ConfiguredMemberList != MemberList.None;
+        public bool ShouldCheckForValid => ConfiguredMemberList != MemberList.None && !HasTypeConverter;
         public LambdaExpression[] IncludedMembers { get => _details?.IncludedMembers ?? Array.Empty<LambdaExpression>(); set => Details.IncludedMembers = value; }
         public string[] IncludedMembersNames { get => _details?.IncludedMembersNames ?? Array.Empty<string>(); set => Details.IncludedMembersNames = value; }
         public IReadOnlyCollection<IncludedMember> IncludedMembersTypeMaps => (_details?.IncludedMembersTypeMaps).NullCheck();
@@ -196,7 +187,6 @@ public PropertyMap FindOrCreatePropertyMapFor(MemberInfo destinationProperty, Ty
             AddPropertyMap(propertyMap);
             return propertyMap;
         }
-        public TypePair AsPair() => new(SourceType, DestinationTypeOverride);
         private void CheckDifferent(TypePair types)
         {
             if (types == Types)
@@ -280,15 +270,7 @@ internal void CopyInheritedMapsTo(TypeMap typeMap)
             }
             _details.CopyInheritedMapsTo(typeMap);
         }
-        public void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes)
-        {
-            TypeConverter?.CloseGenerics(openMapConfig, closedTypes);
-            if (DestinationTypeOverride is { IsGenericTypeDefinition: true })
-            {
-                var neededParameters = DestinationTypeOverride.GenericParametersCount();
-                DestinationTypeOverride = DestinationTypeOverride.MakeGenericType(closedTypes.DestinationType.GenericTypeArguments.Take(neededParameters).ToArray());
-            }
-        }
+        public void CloseGenerics(ITypeMapConfiguration openMapConfig, TypePair closedTypes) => TypeConverter?.CloseGenerics(openMapConfig, closedTypes);
         public bool AddMemberMap(IncludedMember includedMember) => Details.AddMemberMap(includedMember);
         public PathMap FindOrCreatePathMapFor(LambdaExpression destinationExpression, MemberPath path, TypeMap typeMap) =>
             Details.FindOrCreatePathMapFor(destinationExpression, path, typeMap);
@@ -305,7 +287,6 @@ class TypeMapDetails
             public bool IncludeAllDerivedTypes;
             public LambdaExpression CustomCtorFunction;
             public MemberList ConfiguredMemberList;
-            public Type DestinationTypeOverride;
             public HashSet<LambdaExpression> AfterMapActions { get; private set; }
             public HashSet<LambdaExpression> BeforeMapActions { get; private set; }
             public HashSet<TypePair> IncludedDerivedTypes { get; private set; }