Fix exceptions with generic source types

src/AutoMapper.Extensions.ExpressionMapping/ExpressionMapper.cs

@@ -173,7 +173,7 @@ private Expression VisitAllParametersExpression<T>(Expression<T> expression)
                     from t in expression.Parameters
                     let sourceParamType = t.Type
                     from destParamType in _destSubTypes.Where(dt => dt != sourceParamType)
-                    let a = destParamType.IsGenericType() ? destParamType.GetTypeInfo().GenericTypeArguments[0] : destParamType
+                    let a = destParamType.IsEnumerableType() ? destParamType.GetGenericElementType() : destParamType
                     let typeMap = _configurationProvider.ResolveTypeMap(a, sourceParamType)
                     where typeMap != null
                     let oldParam = t

src/AutoMapper.Extensions.ExpressionMapping/TypeExtensions.cs

@@ -171,5 +171,8 @@ public static bool IsQueryableType(this Type type)
 
         public static Type GetGenericElementType(this Type type)
             => type.HasElementType ? type.GetElementType() : type.GetTypeInfo().GenericTypeArguments[0];
+
+        public static bool IsEnumerableType(this Type type) =>
+            type.IsGenericType && typeof(System.Collections.IEnumerable).IsAssignableFrom(type);
     }
 }

tests/AutoMapper.Extensions.ExpressionMapping.UnitTests/ExpressionMappingWithUseAsDataSource.cs

@@ -42,6 +42,35 @@ public void When_Apply_Where_Clause_Over_Queryable_As_Data_Source()
             result.ShouldAllBe(expOverDTO);
         }
 
+        [Fact]
+        public void Should_Map_From_Generic_Type()
+        {
+            // Arrange
+            var mapper = CreateMapper();
+
+            var models = new List<GenericModel<bool>>()
+            {
+                new GenericModel<bool> {ABoolean = true},
+                new GenericModel<bool> {ABoolean = false},
+                new GenericModel<bool> {ABoolean = true},
+                new GenericModel<bool> {ABoolean = false}
+            };
+
+            var queryable = models.AsQueryable();
+
+            Expression<Func<DTO, bool>> expOverDTO = (dto) => dto.Nested.AnotherBoolean;
+
+            // Act
+            var q = queryable.UseAsDataSource(mapper).For<DTO>().Where(expOverDTO);
+
+            var result = q.ToList();
+
+            // Assert
+            result.ShouldNotBeNull();
+            result.Count.ShouldBe(2);
+            result.ShouldAllBe(expOverDTO);
+        }
+
         private static IMapper CreateMapper()
         {
             var mapperConfig = new MapperConfiguration(cfg =>
@@ -52,7 +81,10 @@ private static IMapper CreateMapper()
                     .ForMember(d => d.AnotherBoolean, opt => opt.MapFrom(s => s.ABoolean));
                 cfg.CreateMap<DTO, Model>()
                     .ForMember(d => d.ABoolean, opt => opt.MapFrom(s => s.Nested.AnotherBoolean));
-
+                cfg.CreateMap<GenericModel<bool>, DTO>()
+                    .ForMember(d => d.Nested, opt => opt.MapFrom(s => s));
+                cfg.CreateMap<GenericModel<bool>, DTO.DTONested>()
+                    .ForMember(d => d.AnotherBoolean, opt => opt.MapFrom(s => s.ABoolean));
             });
 
             var mapper = mapperConfig.CreateMapper();
@@ -73,5 +105,11 @@ private class Model
         {
             public bool ABoolean { get; set; }
         }
+
+
+        private class GenericModel<T>
+        {
+            public T ABoolean { get; set; }
+        }
     }
 }