Validate closed generic maps

src/AutoMapper/ConfigurationValidator.cs

@@ -57,10 +57,19 @@ private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types,
         {
             if(typeMap == null)
             {
+                if (types.SourceType.IsGenericParameter || types.DestinationType.IsGenericParameter)
+                {
+                    return;
+                }
                 typeMap = _config.ResolveTypeMap(types.SourceType, types.DestinationType);
             }
             if (typeMap != null)
             {
+                if (typeMap.IsClosedGeneric)
+                {
+                    // it was already validated
+                    return;
+                }
                 // dynamic maps get mapped at runtime yolo
                 if (typeMap.IsConventionMap && typeMap.Profile.CreateMissingTypeMaps)
                 {

src/AutoMapper/Mapper.cs

@@ -186,8 +186,8 @@ public Mapper(IConfigurationProvider configurationProvider)
 
         public Mapper(IConfigurationProvider configurationProvider, Func<Type, object> serviceCtor)
         {
-            _configurationProvider = configurationProvider;
-            _serviceCtor = serviceCtor;
+            _configurationProvider = configurationProvider ?? throw new ArgumentNullException(nameof(configurationProvider));
+            _serviceCtor = serviceCtor ?? throw new ArgumentNullException(nameof(serviceCtor));
             DefaultContext = new ResolutionContext(new ObjectMappingOperationOptions(serviceCtor), this);
         }
 

src/AutoMapper/MapperConfiguration.cs

@@ -218,6 +218,10 @@ public TypeMap ResolveTypeMap(TypePair typePair, ITypeMapConfiguration inlineCon
                 {
                     inlineConfiguration.Configure(typeMap);
                     typeMap.Seal(this);
+                    if (typeMap.IsClosedGeneric)
+                    {
+                        AssertConfigurationIsValid(typeMap);
+                    }
                 }
             }
             return typeMap;
@@ -297,7 +301,7 @@ public void AssertConfigurationIsValid()
         {
             _expressionValidator.AssertConfigurationExpressionIsValid();
 
-            _validator.AssertConfigurationIsValid(_typeMapRegistry.Values.Where(tm => !tm.SourceType.IsGenericTypeDefinition() && !tm.DestinationType.IsGenericTypeDefinition()));
+            _validator.AssertConfigurationIsValid(_typeMapRegistry.Values);
         }
 
         public IMapper CreateMapper() => new Mapper(this);

src/AutoMapper/ProfileMap.cs

@@ -198,7 +198,7 @@ public TypeMap CreateInlineMap(TypePair types, IConfigurationProvider configurat
         public TypeMap CreateClosedGenericTypeMap(ITypeMapConfiguration openMapConfig, TypePair closedTypes, IConfigurationProvider configurationProvider)
         {
             var closedMap = _typeMapFactory.CreateTypeMap(closedTypes.SourceType, closedTypes.DestinationType, this);
-
+            closedMap.IsClosedGeneric = true;
             openMapConfig.Configure(closedMap);
 
             Configure(closedMap, configurationProvider);

src/AutoMapper/PropertyMap.cs

@@ -7,7 +7,8 @@
 
 namespace AutoMapper
 {
-    using static Internal.ExpressionFactory;
+    using static Internal.ExpressionFactory;
+    using static Expression;
 
     [DebuggerDisplay("{DestinationMember.Name}")]
     public class PropertyMap : IMemberMap
@@ -116,11 +117,11 @@ public void MapFrom(LambdaExpression sourceMember)
 
         public void MapFrom(string propertyOrField)
         {
-            if(TypeMap.SourceType.IsGenericTypeDefinition())
-            {
-                return;
-            }
-            MapFrom(MemberAccessLambda(TypeMap.SourceType, propertyOrField));
+            var mapExpression = TypeMap.SourceType.IsGenericTypeDefinition() ?
+                                                // just a placeholder so the member is mapped
+                                                Lambda(Default(DestinationType)) :
+                                                MemberAccessLambda(TypeMap.SourceType, propertyOrField);
+            MapFrom(mapExpression);
         }
 
         public void AddValueTransformation(ValueTransformerConfiguration valueTransformerConfiguration)

src/AutoMapper/TypeMap.cs

@@ -128,6 +128,8 @@ public PathMap FindOrCreatePathMapFor(LambdaExpression destinationExpression, Me
             && ConfiguredMemberList != MemberList.None
             && !(IsValid ?? false);
 
+        public bool IsClosedGeneric { get; internal set; }
+
         public bool ConstructorParameterMatches(string destinationPropertyName) =>
             ConstructorMap?.CtorParams.Any(c => !c.HasDefaultValue && string.Equals(c.Parameter.Name, destinationPropertyName, StringComparison.OrdinalIgnoreCase)) == true;
 

src/UnitTests/Bug/UseDestinationValue.cs

@@ -85,7 +85,7 @@ public CollectionController(object owner)
         {
             cfg.CreateMap<OrganizationDTO, Organization>().ForMember(d=>d.BranchCollection, o=>o.UseDestinationValue());
             cfg.CreateMap<BranchDTO, Branch>();
-            cfg.CreateMap(typeof(CollectionDTOController<,>), typeof(CollectionController<,,>));
+            cfg.CreateMap(typeof(CollectionDTOController<,>), typeof(CollectionController<,,>), MemberList.None);
         });
 
         protected override void Because_of()
@@ -178,7 +178,7 @@ public CollectionController(object owner)
         {
             cfg.CreateMap<OrganizationDTO, Organization>();
             cfg.CreateMap<BranchDTO, Branch>();
-            cfg.CreateMap(typeof(CollectionDTOController<,>), typeof(CollectionController<,,>));
+            cfg.CreateMap(typeof(CollectionDTOController<,>), typeof(CollectionController<,,>), MemberList.None);
         });
 
         [Fact]

src/UnitTests/InterfaceMapping.cs

@@ -101,7 +101,8 @@ public interface IDestinationBase<T>
 
         protected override MapperConfiguration Configuration => new MapperConfiguration(cfg=>
             cfg.CreateMap(typeof(IList<>), typeof(IDestinationBase<>))
-                    .ForMember(nameof(IDestinationBase<Object>.Items), p_Expression => p_Expression.MapFrom(p_Source => p_Source)));
+                    .ForMember(nameof(IDestinationBase<Object>.Items), p_Expression => p_Expression.MapFrom(p_Source => p_Source))
+                    .ForMember("PropertyToMap", o=>o.Ignore()));
 
         [Fact]
         public void Should_work()

src/UnitTests/OpenGenerics.cs

@@ -2,6 +2,8 @@
 {
     using MappingInheritance;
     using Shouldly;
+    using System;
+    using System.Linq;
     using Xunit;
 
     public class RecursiveOpenGenerics : AutoMapperSpecBase
@@ -42,6 +44,85 @@ public void Should_work()
         }
     }
 
+    public class OpenGenericsValidation : NonValidatingSpecBase
+    {
+        public class Source<T>
+        {
+            public T Value { get; set; }
+        }
+
+        public class Dest<T>
+        {
+            public int A { get; set; }
+            public T Value { get; set; }
+        }
+
+        protected override MapperConfiguration Configuration => new MapperConfiguration(cfg => cfg.CreateMap(typeof(Source<>), typeof(Dest<>)));
+
+        [Fact]
+        public void Should_report_unmapped_property()
+        {
+            new Action(()=>Mapper.Map<Dest<int>>(new Source<int>{ Value = 5 }))
+                .ShouldThrow<AutoMapperConfigurationException>()
+                .Errors.Single().UnmappedPropertyNames.Single().ShouldBe("A");
+        }
+    }
+
+    public class OpenGenericsProfileValidationNonGenericMembers : NonValidatingSpecBase
+    {
+        public class Source<T>
+        {
+            public T[] Value { get; set; }
+        }
+
+        public class Dest<T>
+        {
+            public int A { get; set; }
+            public T[] Value { get; set; }
+        }
+
+        class MyProfile : Profile
+        {
+            public MyProfile()
+            {
+                CreateMap(typeof(Source<>), typeof(Dest<>));
+            }
+        }
+
+        protected override MapperConfiguration Configuration => new MapperConfiguration(cfg => cfg.AddProfile<MyProfile>());
+
+        [Fact]
+        public void Should_report_unmapped_property()
+        {
+            new Action(()=>Configuration.AssertConfigurationIsValid<MyProfile>())
+                .ShouldThrow<AutoMapperConfigurationException>()
+                .Errors.Single().UnmappedPropertyNames.Single().ShouldBe("A"); ;
+        }
+    }
+
+    public class OpenGenericsProfileValidation : AutoMapperSpecBase
+    {
+        public class Source<T>
+        {
+            public T[] Value { get; set; }
+        }
+
+        public class Dest<T>
+        {
+            public T[] Value { get; set; }
+        }
+
+        class MyProfile : Profile
+        {
+            public MyProfile()
+            {
+                CreateMap(typeof(Source<>), typeof(Dest<>));
+            }
+        }
+
+        protected override MapperConfiguration Configuration => new MapperConfiguration(cfg => cfg.AddProfile<MyProfile>());
+    }
+
     public class OpenGenerics
     {
         public class Source<T>