Merge pull request #2232 from AutoMapper/ConsolidateNullable

jbogard · web-flow · commit f93c059768b3 · 2017-07-21T15:52:30.000-05:00
Consolidate destination nullable mappings
diff --git a/src/AutoMapper/ConfigurationValidator.cs b/src/AutoMapper/ConfigurationValidator.cs
@@ -77,12 +77,6 @@ private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types,
             else
             {
                 var mapperToUse = _config.FindMapper(types);
-                if (mapperToUse == null && types.SourceType.IsNullableType())
-                {
-                    var nullableTypes = new TypePair(Nullable.GetUnderlyingType(types.SourceType),
-                        types.DestinationType);
-                    mapperToUse = _config.FindMapper(nullableTypes);
-                }
                 if (mapperToUse == null)
                 {
                     throw new AutoMapperConfigurationException(types) { PropertyMap = propertyMap };
diff --git a/src/AutoMapper/Execution/TypeMapPlanBuilder.cs b/src/AutoMapper/Execution/TypeMapPlanBuilder.cs
@@ -472,7 +472,7 @@ private Expression BuildValueResolverFunc(PropertyMap propertyMap, Expression de
                 var returnType = destinationNullable && destinationPropertyType.GetTypeOfNullable() ==
                                  nullCheckedExpression.Type
                     ? destinationPropertyType
-                    : nullCheckedExpression.Type;
+                    : nullCheckedExpression.Type;
                 valueResolverFunc =
                     TryCatch(
                         ToType(nullCheckedExpression, returnType),
diff --git a/src/AutoMapper/Mappers/ConvertMapper.cs b/src/AutoMapper/Mappers/ConvertMapper.cs
@@ -23,7 +23,7 @@ private static Dictionary<TypePair, LazyExpression> GetConverters()
             };
             return
                 (from sourceType in primitiveTypes
-                 from destinationType in primitiveTypes.Concat(from type in primitiveTypes.Where(t => t.IsValueType()) select typeof(Nullable<>).MakeGenericType(type))
+                 from destinationType in primitiveTypes
                  select new
                  {
                      Key = new TypePair(sourceType, destinationType),
@@ -34,8 +34,7 @@ from destinationType in primitiveTypes.Concat(from type in primitiveTypes.Where(
 
         static LambdaExpression ConvertExpression(Type sourceType, Type destinationType)
         {
-            var underlyingDestinationType = Nullable.GetUnderlyingType(destinationType) ?? destinationType;
-            var convertMethod = typeof(Convert).GetDeclaredMethod("To" + underlyingDestinationType.Name, new[] { sourceType });
+            var convertMethod = typeof(Convert).GetDeclaredMethod("To" + destinationType.Name, new[] { sourceType });
             var sourceParameter = Parameter(sourceType, "source");
             return Lambda(Call(convertMethod, sourceParameter), sourceParameter);
         }
diff --git a/src/AutoMapper/Mappers/EnumToUnderlyingTypeMapper.cs b/src/AutoMapper/Mappers/EnumToUnderlyingTypeMapper.cs
@@ -26,7 +26,7 @@ public Expression MapExpression(IConfigurationProvider configurationProvider, Pr
             Expression contextExpression) =>
                 ToType(
                     Call(ChangeTypeMethod, ToObject(sourceExpression),
-                        Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type)),
+                        Constant(destExpression.Type)),
                     destExpression.Type
                 );
     }
diff --git a/src/AutoMapper/Mappers/FlagsEnumMapper.cs b/src/AutoMapper/Mappers/FlagsEnumMapper.cs
@@ -30,7 +30,7 @@ public Expression MapExpression(IConfigurationProvider configurationProvider, Pr
             Expression contextExpression) =>
                 ToType(
                     Call(EnumParseMethod,
-                        Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type),
+                        Constant(destExpression.Type),
                         Call(sourceExpression, sourceExpression.Type.GetDeclaredMethod("ToString")),
                         Constant(true)
                     ),
diff --git a/src/AutoMapper/Mappers/ImplicitConversionOperatorMapper.cs b/src/AutoMapper/Mappers/ImplicitConversionOperatorMapper.cs
@@ -17,10 +17,6 @@ public bool IsMatch(TypePair context)
         private static MethodInfo GetImplicitConversionOperator(TypePair context)
         {
             var destinationType = context.DestinationType;
-            if(destinationType.IsNullableType())
-            {
-                destinationType = destinationType.GetTypeOfNullable();
-            }
             var sourceTypeMethod = context.SourceType
                 .GetDeclaredMethods()
                 .FirstOrDefault(mi => mi.IsPublic && mi.IsStatic && mi.Name == "op_Implicit" && mi.ReturnType == destinationType);
diff --git a/src/AutoMapper/Mappers/Internal/ElementTypeHelper.cs b/src/AutoMapper/Mappers/Internal/ElementTypeHelper.cs
@@ -49,11 +49,6 @@ public static Type[] GetElementTypes(Type enumerableType, IEnumerable enumerable
 
         public static Type GetEnumerationType(Type enumType)
         {
-            if (enumType.IsNullableType())
-            {
-                enumType = enumType.GetTypeInfo().GenericTypeArguments[0];
-            }
-
             return !enumType.IsEnum() ? null : enumType;
         }
 
diff --git a/src/AutoMapper/Mappers/MapperRegistry.cs b/src/AutoMapper/Mappers/MapperRegistry.cs
@@ -7,6 +7,7 @@ internal static class MapperRegistry
         public static IList<IObjectMapper> Mappers() => new List<IObjectMapper>
         {
             new NullableSourceMapper(),
+            new NullableDestinationMapper(),
             new ExpressionMapper(), 
             new FlagsEnumMapper(),
             new StringToEnumMapper(), 
diff --git a/src/AutoMapper/Mappers/NullableDestinationMapper.cs b/src/AutoMapper/Mappers/NullableDestinationMapper.cs
@@ -0,0 +1,28 @@
+using System;
+using System.Linq.Expressions;
+using AutoMapper.Configuration;
+using AutoMapper.Execution;
+
+namespace AutoMapper.Mappers
+{
+    public class NullableDestinationMapper : IObjectMapperInfo
+    {
+        public bool IsMatch(TypePair context) => context.DestinationType.IsNullableType();
+
+        public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
+            PropertyMap propertyMap, Expression sourceExpression, Expression destExpression,
+            Expression contextExpression) =>
+            ExpressionBuilder.MapExpression(configurationProvider, profileMap,
+                new TypePair(sourceExpression.Type, Nullable.GetUnderlyingType(destExpression.Type)),
+                sourceExpression,
+                contextExpression,
+                propertyMap,
+                Expression.Property(destExpression, destExpression.Type.GetDeclaredProperty("Value"))
+            );
+
+        public TypePair GetAssociatedTypes(TypePair initialTypes)
+        {
+            return new TypePair(initialTypes.SourceType, Nullable.GetUnderlyingType(initialTypes.DestinationType));
+        }
+    }
+}
diff --git a/src/AutoMapper/Mappers/TypeConverterMapper.cs b/src/AutoMapper/Mappers/TypeConverterMapper.cs
@@ -19,12 +19,6 @@ private static TDestination Map<TSource, TDestination>(TSource source)
                 return (TDestination)typeConverter.ConvertTo(source, typeof(TDestination));
             }
 
-            if (typeof(TDestination).IsNullableType() &&
-                typeConverter.CanConvertTo(Nullable.GetUnderlyingType(typeof(TDestination))))
-            {
-                return (TDestination)typeConverter.ConvertTo(source, Nullable.GetUnderlyingType(typeof(TDestination)));
-            }
-
             typeConverter = GetTypeConverter(typeof(TDestination));
             if (typeConverter.CanConvertFrom(typeof(TSource)))
             {
@@ -41,8 +35,7 @@ public bool IsMatch(TypePair context)
             var sourceTypeConverter = GetTypeConverter(context.SourceType);
             var destTypeConverter = GetTypeConverter(context.DestinationType);
 
-            return sourceTypeConverter.CanConvertTo(context.DestinationType) || context.DestinationType.IsNullableType() &&
-                   sourceTypeConverter.CanConvertTo(Nullable.GetUnderlyingType(context.DestinationType)) || destTypeConverter.CanConvertFrom(context.SourceType);
+            return sourceTypeConverter.CanConvertTo(context.DestinationType) || destTypeConverter.CanConvertFrom(context.SourceType);
         }
 
         public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,
diff --git a/src/AutoMapper/Mappers/UnderlyingTypeToEnumMapper.cs b/src/AutoMapper/Mappers/UnderlyingTypeToEnumMapper.cs
@@ -24,7 +24,7 @@ public Expression MapExpression(IConfigurationProvider configurationProvider, Pr
             PropertyMap propertyMap, Expression sourceExpression, Expression destExpression,
             Expression contextExpression) =>
                 ToType(
-                    Call(EnumToObject, Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type),
+                    Call(EnumToObject, Constant(destExpression.Type),
                         ToObject(sourceExpression)),
                     destExpression.Type
                 );

Original file line number	Diff line number	Diff line change
`@@ -77,12 +77,6 @@ private void DryRunTypeMap(ICollection<TypeMap> typeMapsChecked, TypePair types,`
`77`	`77`	`else`
`78`	`78`	`{`
`79`	`79`	`var mapperToUse = _config.FindMapper(types);`
`80`		`- if (mapperToUse == null && types.SourceType.IsNullableType())`
`81`		`- {`
`82`		`- var nullableTypes = new TypePair(Nullable.GetUnderlyingType(types.SourceType),`
`83`		`- types.DestinationType);`
`84`		`- mapperToUse = _config.FindMapper(nullableTypes);`
`85`		`- }`
`86`	`80`	`if (mapperToUse == null)`
`87`	`81`	`{`
`88`	`82`	`throw new AutoMapperConfigurationException(types) { PropertyMap = propertyMap };`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ private static Dictionary<TypePair, LazyExpression> GetConverters()`
`23`	`23`	`};`
`24`	`24`	`return`
`25`	`25`	`(from sourceType in primitiveTypes`
`26`		`- from destinationType in primitiveTypes.Concat(from type in primitiveTypes.Where(t => t.IsValueType()) select typeof(Nullable<>).MakeGenericType(type))`
	`26`	`+ from destinationType in primitiveTypes`
`27`	`27`	`select new`
`28`	`28`	`{`
`29`	`29`	`Key = new TypePair(sourceType, destinationType),`
`@@ -34,8 +34,7 @@ from destinationType in primitiveTypes.Concat(from type in primitiveTypes.Where(`
`34`	`34`
`35`	`35`	`static LambdaExpression ConvertExpression(Type sourceType, Type destinationType)`
`36`	`36`	`{`
`37`		`- var underlyingDestinationType = Nullable.GetUnderlyingType(destinationType) ?? destinationType;`
`38`		`- var convertMethod = typeof(Convert).GetDeclaredMethod("To" + underlyingDestinationType.Name, new[] { sourceType });`
	`37`	`+ var convertMethod = typeof(Convert).GetDeclaredMethod("To" + destinationType.Name, new[] { sourceType });`
`39`	`38`	`var sourceParameter = Parameter(sourceType, "source");`
`40`	`39`	`return Lambda(Call(convertMethod, sourceParameter), sourceParameter);`
`41`	`40`	`}`
Original file line number	Diff line number	Diff line change
`@@ -26,7 +26,7 @@ public Expression MapExpression(IConfigurationProvider configurationProvider, Pr`
`26`	`26`	`Expression contextExpression) =>`
`27`	`27`	`ToType(`
`28`	`28`	`Call(ChangeTypeMethod, ToObject(sourceExpression),`
`29`		`- Constant(Nullable.GetUnderlyingType(destExpression.Type) ?? destExpression.Type)),`
	`29`	`+ Constant(destExpression.Type)),`
`30`	`30`	`destExpression.Type`
`31`	`31`	`);`
`32`	`32`	`}`
Original file line number	Diff line number	Diff line change
`@@ -49,11 +49,6 @@ public static Type[] GetElementTypes(Type enumerableType, IEnumerable enumerable`
`49`	`49`
`50`	`50`	`public static Type GetEnumerationType(Type enumType)`
`51`	`51`	`{`
`52`		`- if (enumType.IsNullableType())`
`53`		`- {`
`54`		`- enumType = enumType.GetTypeInfo().GenericTypeArguments[0];`
`55`		`- }`
`56`		`-`
`57`	`52`	`return !enumType.IsEnum() ? null : enumType;`
`58`	`53`	`}`
`59`	`54`
Original file line number	Diff line number	Diff line change
`@@ -7,6 +7,7 @@ internal static class MapperRegistry`
`7`	`7`	`public static IList<IObjectMapper> Mappers() => new List<IObjectMapper>`
`8`	`8`	`{`
`9`	`9`	`new NullableSourceMapper(),`
	`10`	`+ new NullableDestinationMapper(),`
`10`	`11`	`new ExpressionMapper(),`
`11`	`12`	`new FlagsEnumMapper(),`
`12`	`13`	`new StringToEnumMapper(),`
Original file line number	Diff line number	Diff line change
`@@ -19,12 +19,6 @@ private static TDestination Map<TSource, TDestination>(TSource source)`
`19`	`19`	`return (TDestination)typeConverter.ConvertTo(source, typeof(TDestination));`
`20`	`20`	`}`
`21`	`21`
`22`		`- if (typeof(TDestination).IsNullableType() &&`
`23`		`- typeConverter.CanConvertTo(Nullable.GetUnderlyingType(typeof(TDestination))))`
`24`		`- {`
`25`		`- return (TDestination)typeConverter.ConvertTo(source, Nullable.GetUnderlyingType(typeof(TDestination)));`
`26`		`- }`
`27`		`-`
`28`	`22`	`typeConverter = GetTypeConverter(typeof(TDestination));`
`29`	`23`	`if (typeConverter.CanConvertFrom(typeof(TSource)))`
`30`	`24`	`{`
`@@ -41,8 +35,7 @@ public bool IsMatch(TypePair context)`
`41`	`35`	`var sourceTypeConverter = GetTypeConverter(context.SourceType);`
`42`	`36`	`var destTypeConverter = GetTypeConverter(context.DestinationType);`
`43`	`37`
`44`		`- return sourceTypeConverter.CanConvertTo(context.DestinationType) \|\| context.DestinationType.IsNullableType() &&`
`45`		`- sourceTypeConverter.CanConvertTo(Nullable.GetUnderlyingType(context.DestinationType)) \|\| destTypeConverter.CanConvertFrom(context.SourceType);`
	`38`	`+ return sourceTypeConverter.CanConvertTo(context.DestinationType) \|\| destTypeConverter.CanConvertFrom(context.SourceType);`
`46`	`39`	`}`
`47`	`40`
`48`	`41`	`public Expression MapExpression(IConfigurationProvider configurationProvider, ProfileMap profileMap,`