Moving inline map creation back to inside type map resolving

src/AutoMapper/Configuration/Conventions/SourceToDestinationNameMapperAttributesMember.cs

@@ -1,5 +1,4 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
 
@@ -8,15 +7,18 @@ namespace AutoMapper.Configuration.Conventions
     public class SourceToDestinationNameMapperAttributesMember : ISourceToDestinationNameMapper
     {
         private static readonly SourceMember[] Empty = new SourceMember[0];
-        private readonly Dictionary<TypeDetails, SourceMember[]> _allSourceMembers = new Dictionary<TypeDetails, SourceMember[]>();
+        private LockingConcurrentDictionary<TypeDetails, SourceMember[]> _allSourceMembers
+            = new LockingConcurrentDictionary<TypeDetails, SourceMember[]>(_ => Empty);
 
         public MemberInfo GetMatchingMemberInfo(IGetTypeInfoMembers getTypeInfoMembers, TypeDetails typeInfo, Type destType, Type destMemberType, string nameToSearch)
         {
-            if (!_allSourceMembers.TryGetValue(typeInfo, out SourceMember[] sourceMembers))
-            {
-                sourceMembers = getTypeInfoMembers.GetMemberInfos(typeInfo).Select(sourceMember => new SourceMember(sourceMember)).Where(s => s.Attribute != null).ToArray();
-                _allSourceMembers[typeInfo] = sourceMembers.Length == 0 ? Empty : sourceMembers;
-            }
+            SourceMember[] ValueFactory(TypeDetails td) => getTypeInfoMembers.GetMemberInfos(td)
+                .Select(sourceMember => new SourceMember(sourceMember))
+                .Where(s => s.Attribute != null)
+                .ToArray();
+
+            var sourceMembers = _allSourceMembers.GetOrAdd(typeInfo, td => new Lazy<SourceMember[]>(() => ValueFactory(td)));
+
             return sourceMembers.FirstOrDefault(d => d.Attribute.IsMatch(typeInfo, d.Member, destType, destMemberType, nameToSearch)).Member;
         }
 

src/AutoMapper/Configuration/ITypeMapConfiguration.cs

@@ -5,7 +5,6 @@ namespace AutoMapper.Configuration
     public interface ITypeMapConfiguration
     {
         void Configure(TypeMap typeMap);
-        MemberList MemberList { get; }
         Type SourceType { get; }
         Type DestinationType { get; }
         bool IsOpenGeneric { get; }

src/AutoMapper/Configuration/MappingExpression.cs

@@ -152,12 +152,11 @@ public MappingExpression(MemberList memberList, Type sourceType, Type destinatio
 
         public MappingExpression(MemberList memberList, TypePair types)
         {
-            MemberList = memberList;
             Types = types;
             IsOpenGeneric = types.SourceType.IsGenericTypeDefinition() || types.DestinationType.IsGenericTypeDefinition();
+            TypeMapActions.Add(tm => tm.ConfiguredMemberList = memberList);
         }
 
-        public MemberList MemberList { get; }
         public TypePair Types { get; }
         public Type SourceType => Types.SourceType;
         public Type DestinationType => Types.DestinationType;

src/AutoMapper/IConfigurationProvider.cs

@@ -47,6 +47,23 @@ public interface IConfigurationProvider
         /// <returns>Type map configuration</returns>
         TypeMap ResolveTypeMap(Type sourceType, Type destinationType);
 
+        /// <summary>
+        /// Resolve the <see cref="TypeMap"/> for the configured source and destination type, checking parent types
+        /// </summary>
+        /// <param name="sourceType">Configured source type</param>
+        /// <param name="destinationType">Configured destination type</param>
+        /// <param name="inlineConfiguration">Inline type map configuration if exists</param>
+        /// <returns>Type map configuration</returns>
+        TypeMap ResolveTypeMap(Type sourceType, Type destinationType, ITypeMapConfiguration inlineConfiguration);
+
+        /// <summary>
+        /// Resolve the <see cref="TypeMap"/> for the configured type pair, checking parent types
+        /// </summary>
+        /// <param name="typePair">Type pair</param>
+        /// <param name="inlineConfiguration">Inline type map configuration if exists</param>
+        /// <returns>Type map configuration</returns>
+        TypeMap ResolveTypeMap(TypePair typePair, ITypeMapConfiguration inlineConfiguration);
+
         /// <summary>
         /// Resolve the <see cref="TypeMap"/> for the configured type pair, checking parent types
         /// </summary>

src/AutoMapper/LockingConcurrentDictionary.cs

@@ -16,6 +16,7 @@ public LockingConcurrentDictionary(Func<TKey, TValue> valueFactory)
         }
 
         public TValue GetOrAdd(TKey key) => _dictionary.GetOrAdd(key, _valueFactory).Value;
+        public TValue GetOrAdd(TKey key, Func<TKey, Lazy<TValue>> valueFactory) => _dictionary.GetOrAdd(key, valueFactory).Value;
 
         public TValue this[TKey key]
         {

src/AutoMapper/MapperConfiguration.cs

@@ -18,6 +18,7 @@ namespace AutoMapper
 
     public class MapperConfiguration : IConfigurationProvider
     {
+        private static readonly Type[] ExcludedTypes = { typeof(object), typeof(ValueType), typeof(Enum) };
         private static readonly ConstructorInfo ExceptionConstructor = typeof(AutoMapperMappingException).GetDeclaredConstructors().Single(c => c.GetParameters().Length == 3);
 
         private readonly IEnumerable<IObjectMapper> _mappers;
@@ -110,19 +111,12 @@ public LambdaExpression BuildExecutionPlan(Type sourceType, Type destinationType
 
         public LambdaExpression BuildExecutionPlan(MapRequest mapRequest)
         {
-            var typeMap = ResolveTypeMap(mapRequest.RuntimeTypes) ?? ResolveTypeMap(mapRequest.RequestedTypes);
+            var typeMap = ResolveTypeMap(mapRequest.RuntimeTypes, mapRequest.InlineConfig) ?? ResolveTypeMap(mapRequest.RequestedTypes, mapRequest.InlineConfig);
             if (typeMap != null)
             {
                 return GenerateTypeMapExpression(mapRequest, typeMap);
             }
             var mapperToUse = FindMapper(mapRequest.RuntimeTypes);
-            if (Configuration.CreateMissingTypeMaps && mapperToUse == null)
-            {
-                typeMap = Configuration.CreateInlineMap(_typeMapRegistry, mapRequest.InlineConfig ?? new DefaultTypeMapConfig(mapRequest.RuntimeTypes));
-                _typeMapPlanCache[mapRequest.RuntimeTypes] = typeMap;
-                typeMap.Seal(this);
-                return GenerateTypeMapExpression(mapRequest, typeMap);
-            }
             return GenerateObjectMapperExpression(mapRequest, mapperToUse, this);
         }
 
@@ -193,17 +187,28 @@ public TypeMap ResolveTypeMap(Type sourceType, Type destinationType)
         {
             var typePair = new TypePair(sourceType, destinationType);
 
-            return ResolveTypeMap(typePair);
+            return ResolveTypeMap(typePair, new DefaultTypeMapConfig(typePair));
+        }
+
+        public TypeMap ResolveTypeMap(Type sourceType, Type destinationType, ITypeMapConfiguration inlineConfiguration)
+        {
+            var typePair = new TypePair(sourceType, destinationType);
+
+            return ResolveTypeMap(typePair, inlineConfiguration);
         }
 
         public TypeMap ResolveTypeMap(TypePair typePair)
+            => ResolveTypeMap(typePair, new DefaultTypeMapConfig(typePair));
+
+        public TypeMap ResolveTypeMap(TypePair typePair, ITypeMapConfiguration inlineConfiguration)
         {
             var typeMap = _typeMapPlanCache.GetOrAdd(typePair);
             // if it's a dynamically created type map, we need to seal it outside GetTypeMap to handle recursion
             if (typeMap != null && typeMap.MapExpression == null && _typeMapRegistry.GetTypeMap(typePair) == null)
             {
                 lock (typeMap)
-                {
+                {
+                    inlineConfiguration.Configure(typeMap);
                     typeMap.Seal(this);
                 }
             }
@@ -217,7 +222,10 @@ private TypeMap GetTypeMap(TypePair initialTypes)
             {
                 if (types != initialTypes && _typeMapPlanCache.TryGetValue(types, out var typeMap))
                 {
-                    return typeMap;
+                    if (typeMap != null)
+                    {
+                        return typeMap;
+                    }
                 }
                 typeMap = FindTypeMapFor(types);
                 if (typeMap != null)
@@ -239,6 +247,16 @@ private TypeMap GetTypeMap(TypePair initialTypes)
                 }
             }
 
+            if (!hasMapper.Value 
+                && Configuration.CreateMissingTypeMaps
+                && !(initialTypes.SourceType.IsAbstract() && initialTypes.SourceType.IsClass())
+                && !(initialTypes.DestinationType.IsAbstract() && initialTypes.DestinationType.IsClass())
+                && !ExcludedTypes.Contains(initialTypes.SourceType)
+                && !ExcludedTypes.Contains(initialTypes.DestinationType))
+            {
+                return Configuration.CreateInlineMap(_typeMapRegistry, initialTypes);
+            }
+
             return null;
         }
 
@@ -405,7 +423,7 @@ private static Expression<UntypedMapperFunc> Wrap(MapRequest mapRequest, Delegat
             }
         }
 
-        private class DefaultTypeMapConfig : ITypeMapConfiguration
+        internal class DefaultTypeMapConfig : ITypeMapConfiguration
         {
             public DefaultTypeMapConfig(TypePair types)
             {
@@ -414,7 +432,6 @@ public DefaultTypeMapConfig(TypePair types)
 
             public void Configure(TypeMap typeMap) { }
 
-            public MemberList MemberList => MemberList.Destination;
             public Type SourceType => Types.SourceType;
             public Type DestinationType => Types.DestinationType;
             public bool IsOpenGeneric => false;

src/AutoMapper/ProfileMap.cs

@@ -16,7 +16,6 @@ struct IConvertible{}
     [DebuggerDisplay("{Name}")]
     public class ProfileMap
     {
-        private static readonly Type[] ExcludedTypes = { typeof(object), typeof(ValueType), typeof(Enum), typeof(IComparable), typeof(IFormattable), typeof(IConvertible) };
         private readonly TypeMapFactory _typeMapFactory = new TypeMapFactory();
         private readonly IEnumerable<ITypeMapConfiguration> _typeMapConfigs;
         private readonly IEnumerable<ITypeMapConfiguration> _openTypeMapConfigs;
@@ -129,7 +128,7 @@ public void Configure(TypeMapRegistry typeMapRegistry)
 
         private void BuildTypeMap(TypeMapRegistry typeMapRegistry, ITypeMapConfiguration config)
         {
-            var typeMap = _typeMapFactory.CreateTypeMap(config.SourceType, config.DestinationType, this, config.MemberList);
+            var typeMap = _typeMapFactory.CreateTypeMap(config.SourceType, config.DestinationType, this);
 
             config.Configure(typeMap);
 
@@ -176,7 +175,7 @@ public bool IsConventionMap(TypePair types)
 
         public TypeMap CreateConventionTypeMap(TypeMapRegistry typeMapRegistry, TypePair types)
         {
-            var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this, MemberList.Destination);
+            var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this);
 
             typeMap.IsConventionMap = true;
 
@@ -189,22 +188,20 @@ public TypeMap CreateConventionTypeMap(TypeMapRegistry typeMapRegistry, TypePair
             return typeMap;
         }
 
-        public TypeMap CreateInlineMap(TypeMapRegistry typeMapRegistry, ITypeMapConfiguration inlineConfig)
+        public TypeMap CreateInlineMap(TypeMapRegistry typeMapRegistry, TypePair types)
         {
-            var typeMap = _typeMapFactory.CreateTypeMap(inlineConfig.SourceType, inlineConfig.DestinationType, this, inlineConfig.MemberList);
+            var typeMap = _typeMapFactory.CreateTypeMap(types.SourceType, types.DestinationType, this);
 
             typeMap.IsConventionMap = true;
 
-            inlineConfig.Configure(typeMap);
-
             Configure(typeMapRegistry, typeMap);
 
             return typeMap;
         }
 
         public TypeMap CreateClosedGenericTypeMap(ITypeMapConfiguration openMapConfig, TypeMapRegistry typeMapRegistry, TypePair closedTypes)
         {
-            var closedMap = _typeMapFactory.CreateTypeMap(closedTypes.SourceType, closedTypes.DestinationType, this, openMapConfig.MemberList);
+            var closedMap = _typeMapFactory.CreateTypeMap(closedTypes.SourceType, closedTypes.DestinationType, this);
 
             openMapConfig.Configure(closedMap);
 

src/AutoMapper/QueryableExtensions/ExpressionBuilder.cs

@@ -463,7 +463,7 @@ public override QueryExpressions GetSubQueryExpression(ExpressionBuilder builder
                 TypeMap firstTypeMap;
                 lock(_configurationProvider)
                 {
-                    firstTypeMap = typeMapFactory.CreateTypeMap(request.SourceType, letType, typeMap.Profile, MemberList.None);
+                    firstTypeMap = typeMapFactory.CreateTypeMap(request.SourceType, letType, typeMap.Profile);
                 }
                 var secondParameter = Parameter(letType, "dto");
 

src/AutoMapper/TypeMap.cs

@@ -31,13 +31,12 @@ public class TypeMap
         private readonly IList<TypeMap> _inheritedTypeMaps = new List<TypeMap>();
         private readonly List<ValueTransformerConfiguration> _valueTransformerConfigs = new List<ValueTransformerConfiguration>();
 
-        public TypeMap(TypeDetails sourceType, TypeDetails destinationType, MemberList memberList, ProfileMap profile)
+        public TypeMap(TypeDetails sourceType, TypeDetails destinationType, ProfileMap profile)
         {
             SourceTypeDetails = sourceType;
             DestinationTypeDetails = destinationType;
             Types = new TypePair(sourceType.Type, destinationType.Type);
             Profile = profile;
-            ConfiguredMemberList = memberList;
         }
 
         public PathMap FindOrCreatePathMapFor(LambdaExpression destinationExpression, MemberPath path, TypeMap typeMap)
@@ -77,7 +76,7 @@ public PathMap FindPathMapByDestinationPath(string destinationFullPath) =>
 
         public bool ConstructDestinationUsingServiceLocator { get; set; }
 
-        public MemberList ConfiguredMemberList { get; }
+        public MemberList ConfiguredMemberList { get; set; }
 
         public IEnumerable<TypePair> IncludedDerivedTypes => _includedDerivedTypes;
         public IEnumerable<TypePair> IncludedBaseTypes => _includedBaseTypes;

src/AutoMapper/TypeMapFactory.cs

@@ -8,12 +8,12 @@ namespace AutoMapper
 {
     public class TypeMapFactory
     {
-        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, ProfileMap options, MemberList memberList)
+        public TypeMap CreateTypeMap(Type sourceType, Type destinationType, ProfileMap options)
         {
             var sourceTypeInfo = options.CreateTypeDetails(sourceType);
             var destTypeInfo = options.CreateTypeDetails(destinationType);
 
-            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, memberList, options);
+            var typeMap = new TypeMap(sourceTypeInfo, destTypeInfo, options);
 
             foreach (var destProperty in destTypeInfo.PublicWriteAccessors)
             {

src/AutoMapper/TypePair.cs

@@ -15,7 +15,7 @@ public struct MapRequest : IEquatable<MapRequest>
         public ITypeMapConfiguration InlineConfig { get; }
 
         public MapRequest(TypePair requestedTypes, TypePair runtimeTypes) 
-            : this(requestedTypes, runtimeTypes, null)
+            : this(requestedTypes, runtimeTypes, new MapperConfiguration.DefaultTypeMapConfig(requestedTypes))
         {
         }
 

src/UnitTests/Bug/BaseMapWithIncludesAndUnincludedMappings.cs

@@ -51,12 +51,12 @@ public class Container2
         {
             public BaseB Item { get; set; }
         }
-        public class BaseA
+        public abstract class BaseA
         {
             public string Name { get; set; }
         }
 
-        public class BaseB
+        public abstract class BaseB
         {
             public string Name { get; set; }
         }
@@ -84,7 +84,8 @@ public void TestInitialiserProxyOfSub()
                 cfg.CreateMap<Container, Container2>();
             });
 
-            var mapped = config.CreateMapper().Map<Container, Container2>(new Container() { Item = new ProxyOfSubA() { Name = "Martin", Description = "Hello" } });
+            var mapped = config.CreateMapper()
+                .Map<Container, Container2>(new Container() { Item = new ProxyOfSubA() { Name = "Martin", Description = "Hello" } });
             Assert.IsType<SubB>(mapped.Item);
 
         }

src/UnitTests/Bug/ExpressionMapping.cs

@@ -127,6 +127,7 @@ public Parent Parent
 
         protected override MapperConfiguration Configuration { get; } = new MapperConfiguration(cfg =>
         {
+            cfg.CreateMissingTypeMaps = false;
             cfg.CreateMap<GrandParent, GrandParentDTO>().ReverseMap();
             cfg.CreateMap<Parent, ParentDTO>().ReverseMap();
             cfg.CreateMap<Child, ChildDTO>()

src/UnitTests/DynamicMapping.cs

@@ -3,6 +3,7 @@
 using Xunit;
 using Shouldly;
 using System.Collections.Generic;
+using AutoMapper.QueryableExtensions;
 
 namespace AutoMapper.UnitTests.DynamicMapping
 {
@@ -396,6 +397,32 @@ public void Should_map()
         }
     }
 
+    public class When_automatically_dynamically_projecting : NonValidatingSpecBase
+    {
+        public class Source
+        {
+            public int Value { get; set; }
+        }
+
+        public class Dest
+        {
+            public int Value { get; set; }
+        }
+
+        protected override MapperConfiguration Configuration { get; } = new MapperConfiguration(cfg => {});
+
+        [Fact]
+        public void Should_map()
+        {
+            var source = new Source {Value = 5};
+            var items = new[] {source}.AsQueryable();
+            var dest = items.ProjectTo<Dest>(ConfigProvider).ToArray();
+
+            dest.Length.ShouldBe(1);
+            dest[0].Value.ShouldBe(5);
+        }
+    }
+
     public class When_mixing_auto_and_manual_map : NonValidatingSpecBase
     {
         public class Source

src/UnitTests/Projection/ProjectTest.cs

@@ -44,6 +44,7 @@ public ProjectTest()
             {
                 cfg.CreateMap<Address, AddressDto>();
                 cfg.CreateMap<Customer, CustomerDto>();
+                cfg.CreateMissingTypeMaps = false;
             });
         }
 

src/UnitTests/Query/SourceInjectedQuery.cs

@@ -628,6 +628,7 @@ private static IMapper SetupAutoMapper()
         {
             var config = new MapperConfiguration(cfg =>
             {
+                cfg.CreateMissingTypeMaps = false;
                 cfg.CreateMap<User, UserModel>()
                 .ForMember(d => d.Id, opt => opt.MapFrom(s => s.UserId))
                 .ForMember(d => d.FullName, opt => opt.MapFrom(s => s.Name))