Updates for PR review

Squash this commit out

docs/Configuration.md

@@ -176,9 +176,9 @@ Mapper.Initialize(cfg => {
 });
 ```
 
-## Global property/field/constructor filtering
+## Global property/field filtering
 
-By default, AutoMapper tries to map every public property/field, and all non-static declared constructors. You can filter out properties/fields/constructors with the property/field/constructor filters:
+By default, AutoMapper tries to map every public property/field. You can filter out properties/fields with the property/field filters:
 
 ```c#
 Mapper.Initialize(cfg =>
@@ -189,9 +189,6 @@ Mapper.Initialize(cfg =>
 	// map properties with a public or private getter
 	cfg.ShouldMapProperty = pi =>
 		pi.GetMethod != null && (pi.GetMethod.IsPublic || pi.GetMethod.IsPrivate);
-
-	// don't map private constructors
-	cfg.ShouldMapCtor = ci => !ci.IsPrivate;
 });
 ```
 
@@ -231,4 +228,4 @@ Mapper.Reset();
 Mapper.Initialize(cfg => { /* configure again */ });
 ```
 
-`Reset` should not be used in production code. It is intended to support testing scenarios only.
+`Reset` should not be used in production code. It is intended to support testing scenarios only.

docs/Construction.md

@@ -46,3 +46,10 @@ You can also disable constructor mapping :
 ```c#
 Mapper.Initialize(cfg => cfg.DisableConstructorMapping());
 ```
+
+You can configure which constructors are mapped:
+
+```c#
+// don't map private constructors
+Mapper.Initialize(cfg => cfg.ShouldMapConstructor = ci => !ci.IsPrivate);
+```

src/AutoMapper/Configuration/IProfileConfiguration.cs

@@ -43,7 +43,7 @@ public interface IProfileConfiguration
         /// Specify which constructors should be mapped.
         /// By default all non-static constructors are mapped.
         /// </summary>
-        Func<ConstructorInfo, bool> ShouldMapCtor { get; }
+        Func<ConstructorInfo, bool> ShouldMapConstructor { get; }
 
         string ProfileName { get; }
         IEnumerable<string> GlobalIgnores { get; }

src/AutoMapper/IProfileExpression.cs

@@ -145,7 +145,7 @@ public interface IProfileExpression
 
         Func<PropertyInfo, bool> ShouldMapProperty { get; set; }
         Func<FieldInfo, bool> ShouldMapField { get; set; }
-        Func<ConstructorInfo, bool> ShouldMapCtor { get; set; }
+        Func<ConstructorInfo, bool> ShouldMapConstructor { get; set; }
 
         string ProfileName { get; }
         IMemberConfiguration AddMemberConfiguration();

src/AutoMapper/Profile.cs

@@ -74,7 +74,7 @@ IEnumerable<Action<PropertyMap, IMemberConfigurationExpression>> IProfileConfigu
         public bool? EnableNullPropagationForQueryMapping { get; set; }
         public Func<PropertyInfo, bool> ShouldMapProperty { get; set; }
         public Func<FieldInfo, bool> ShouldMapField { get; set; }
-        public Func<ConstructorInfo, bool> ShouldMapCtor { get; set; }
+        public Func<ConstructorInfo, bool> ShouldMapConstructor { get; set; }
 
         public INamingConvention SourceMemberNamingConvention { get; set; }
         public INamingConvention DestinationMemberNamingConvention { get; set; }

src/AutoMapper/ProfileMap.cs

@@ -34,7 +34,7 @@ public ProfileMap(IProfileConfiguration profile, IConfiguration configuration)
             ConstructorMappingEnabled = profile.ConstructorMappingEnabled ?? configuration?.ConstructorMappingEnabled ?? true;
             ShouldMapField = profile.ShouldMapField ?? configuration?.ShouldMapField ?? (p => p.IsPublic());
             ShouldMapProperty = profile.ShouldMapProperty ?? configuration?.ShouldMapProperty ?? (p => p.IsPublic());
-            ShouldMapCtor = profile.ShouldMapCtor ?? configuration?.ShouldMapCtor ?? (c => true);
+            ShouldMapConstructor = profile.ShouldMapConstructor ?? configuration?.ShouldMapConstructor ?? (c => true);
             CreateMissingTypeMaps = profile.CreateMissingTypeMaps ?? configuration?.CreateMissingTypeMaps ?? true;
             ValidateInlineMaps = profile.ValidateInlineMaps ?? configuration?.ValidateInlineMaps ?? true;
 
@@ -84,7 +84,7 @@ public ProfileMap(IProfileConfiguration profile, IConfiguration configuration)
         public string Name { get; }
         public Func<FieldInfo, bool> ShouldMapField { get; }
         public Func<PropertyInfo, bool> ShouldMapProperty { get; }
-        public Func<ConstructorInfo, bool> ShouldMapCtor { get; }
+        public Func<ConstructorInfo, bool> ShouldMapConstructor { get; }
 
         public IEnumerable<Action<PropertyMap, IMemberConfigurationExpression>> AllPropertyMapActions { get; }
         public IEnumerable<Action<TypeMap, IMappingExpression>> AllTypeMapActions { get; }

src/AutoMapper/TypeDetails.cs

@@ -17,13 +17,13 @@ public class TypeDetails
         public TypeDetails(Type type, ProfileMap config)
         {
             Type = type;
-            var membersToMap = MembersToMap(config.ShouldMapProperty, config.ShouldMapField, config.ShouldMapCtor);
+            var membersToMap = MembersToMap(config.ShouldMapProperty, config.ShouldMapField);
             var publicReadableMembers = GetAllPublicReadableMembers(membersToMap);
             var publicWritableMembers = GetAllPublicWritableMembers(membersToMap);
             PublicReadAccessors = BuildPublicReadAccessors(publicReadableMembers);
             PublicWriteAccessors = BuildPublicAccessors(publicWritableMembers);
             PublicNoArgMethods = BuildPublicNoArgMethods();
-            Constructors = GetAllConstructors(membersToMap);
+            Constructors = GetAllConstructors(config.ShouldMapConstructor);
             PublicNoArgExtensionMethods = BuildPublicNoArgExtensionMethods(config.SourceExtensionMethods);
             AllMembers = PublicReadAccessors.Concat(PublicNoArgMethods).Concat(PublicNoArgExtensionMethods).ToList();
             DestinationMemberNames = AllMembers.Select(mi => new DestinationMemberName { Member = mi, Possibles = PossibleNames(mi.Name, config.Prefixes, config.Postfixes).ToArray() });
@@ -61,8 +61,7 @@ private static IEnumerable<string> PostFixes(IEnumerable<string> postfixes, stri
 
         private static Func<MemberInfo, bool> MembersToMap(
             Func<PropertyInfo, bool> shouldMapProperty, 
-            Func<FieldInfo, bool> shouldMapField,
-            Func<ConstructorInfo, bool> shouldMapCtor)
+            Func<FieldInfo, bool> shouldMapField)
         {
             return m =>
             {
@@ -72,8 +71,6 @@ private static Func<MemberInfo, bool> MembersToMap(
                         return !property.IsStatic() && shouldMapProperty(property);
                     case FieldInfo field:
                         return !field.IsStatic && shouldMapField(field);
-                    case ConstructorInfo constructor:
-                        return !constructor.IsStatic && shouldMapCtor(constructor);
                     default:
                         throw new ArgumentException("Should be a field, property or constructor.");
                 }
@@ -169,9 +166,9 @@ private IEnumerable<MemberInfo> GetAllPublicReadableMembers(Func<MemberInfo, boo
         private IEnumerable<MemberInfo> GetAllPublicWritableMembers(Func<MemberInfo, bool> membersToMap)
             => GetAllPublicMembers(PropertyWritable, FieldWritable, membersToMap);
 
-        private IEnumerable<ConstructorInfo> GetAllConstructors(Func<MemberInfo, bool> membersToMap)
+        private IEnumerable<ConstructorInfo> GetAllConstructors(Func<ConstructorInfo, bool> shouldMapConstructor)
         {
-            return Type.GetDeclaredConstructors().Where(ci => membersToMap(ci)).ToArray();
+            return Type.GetDeclaredConstructors().Where(shouldMapConstructor).ToArray();
         }
 
         private static bool PropertyReadable(PropertyInfo propertyInfo) => propertyInfo.CanRead;

src/AutoMapper/TypeMap.cs

@@ -182,10 +182,8 @@ public bool PassesCtorValidation()
             if (DestinationTypeToUse.IsValueType())
                 return true;
 
-            var constructors = DestinationTypeToUse
-                .GetDeclaredConstructors()
-                .Where(ci => !ci.IsStatic && Profile.ShouldMapCtor(ci));
-
+            var constructors = DestinationTypeDetails.Constructors;
+
             //find a ctor with only optional args
             var ctorWithOptionalArgs = constructors.FirstOrDefault(c => c.GetParameters().All(p => p.IsOptional));
 

src/UnitTests/AutoMapper.UnitTests.csproj

@@ -1,25 +1,20 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <TargetFrameworks>net452;netcoreapp2.0;netcoreapp1.1;</TargetFrameworks>
     <AssemblyName>AutoMapper.UnitTests</AssemblyName>
     <PackageId>AutoMapper.UnitTests</PackageId>
     <NoWarn>$(NoWarn);0649</NoWarn>
   </PropertyGroup>
-
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net452' ">
     <DefineConstants>NET45</DefineConstants>
   </PropertyGroup>
-
   <PropertyGroup Condition=" '$(TargetFramework)' == 'net452' OR '$(TargetFramework)' == 'netcoreapp2.0'">
     <DefineConstants>DYNAMIC_METHODS</DefineConstants>
   </PropertyGroup>
-
   <ItemGroup>
     <Compile Include="..\AutoMapper\ReflectionExtensions.cs" Link="ReflectionExtensions.cs" />
     <Compile Include="..\AutoMapper\TypeExtensions.cs" Link="TypeExtensions.cs" />
   </ItemGroup>
-
   <ItemGroup>
     <PackageReference Include="Shouldly" Version="3.0.0" />
     <PackageReference Include="FakeItEasy" Version="4.6.0" />
@@ -30,15 +25,12 @@
     <PackageReference Include="System.Collections.Concurrent" Version="4.3.0" />
     <ProjectReference Include="..\AutoMapper\AutoMapper.csproj" />
   </ItemGroup>
-
   <ItemGroup Condition=" '$(TargetFramework)' == 'netcoreapp1.1' ">
     <PackageReference Include="System.Runtime.Serialization.Primitives" Version="4.3.0" />
   </ItemGroup>
-
   <ItemGroup Condition=" '$(TargetFramework)' == 'net452' ">
     <Reference Include="System" />
     <Reference Include="Microsoft.CSharp" />
     <Reference Include="System.Runtime.Serialization" />
   </ItemGroup>
-
 </Project>