Merge pull request #38 from BlaiseD/master

Fix for issue #37 - InvalidOperationException when mapping UnaryExpressions

Author: BlaiseD

Directory.Build.props

@@ -2,7 +2,7 @@
   <PropertyGroup>
     <Authors>Jimmy Bogard</Authors>
     <LangVersion>latest</LangVersion>
-    <VersionPrefix>3.0.0</VersionPrefix>
+    <VersionPrefix>3.0.1</VersionPrefix>
     <WarningsAsErrors>true</WarningsAsErrors>
     <NoWarn>$(NoWarn);1701;1702;1591</NoWarn>
   </PropertyGroup>

src/AutoMapper.Extensions.ExpressionMapping/MapIncludesVisitor.cs

@@ -16,31 +16,6 @@ public MapIncludesVisitor(IMapper mapper, IConfigurationProvider configurationPr
         {
         }
 
-        protected override Expression VisitUnary(UnaryExpression node)
-        {
-            switch (node.NodeType)
-            {
-                case ExpressionType.Convert:
-                case ExpressionType.ConvertChecked:
-
-                    var me = node.Operand as MemberExpression;
-                    var parameterExpression = node.GetParameterExpression();
-                    var sType = parameterExpression?.Type;
-                    if (me != null && (sType != null && me.Expression.NodeType == ExpressionType.MemberAccess && me.Type.IsLiteralType()))
-                    {
-                        //just pass me and let the FindMemberExpressionsVisitor handle removing of the value type
-                        //me.Expression will not match the PathMap name.
-                        return Visit(me);
-                    }
-                    else
-                    {
-                        return base.VisitUnary(node);
-                    }
-                default:
-                    return base.VisitUnary(node);
-            }
-        }
-
         protected override Expression VisitMember(MemberExpression node)
         {
             string sourcePath;

src/AutoMapper.Extensions.ExpressionMapping/XpressionMapperVisitor.cs

@@ -145,32 +145,15 @@ Expression DoVisitConditional(Expression test, Expression ifTrue, Expression ifF
 
         protected override Expression VisitUnary(UnaryExpression node)
         {
-            switch (node.NodeType)
+            return DoVisitUnary(Visit(node.Operand));
+
+            Expression DoVisitUnary(Expression updated)
             {
-                case ExpressionType.Convert:
-                case ExpressionType.ConvertChecked:
-                    switch (node.Operand.NodeType)
-                    {
-                        case ExpressionType.Constant:
-                            return ProcessConstant((ConstantExpression)node.Operand);
-                        default:
-                            return base.VisitUnary(node);
-                    }
-                case ExpressionType.Lambda:
-                    var lambdaExpression = (LambdaExpression)node.Operand;
-                    var ex = this.Visit(lambdaExpression.Body);
-
-                    var mapped = Expression.Quote(Expression.Lambda(ex, lambdaExpression.GetDestinationParameterExpressions(this.InfoDictionary, this.TypeMappings)));
-                    this.TypeMappings.AddTypeMapping(ConfigurationProvider, node.Type, mapped.Type);
-                    return mapped;
-                default:
-                    return base.VisitUnary(node);
-            }
+                if (updated != node.Operand)
+                    return node.Update(updated);
 
-            Expression ProcessConstant(ConstantExpression operand)
-                                => this.TypeMappings.TryGetValue(operand.Type, out Type newType)
-                                    ? Expression.Constant(Mapper.Map(operand.Value, node.Type, newType), newType)
-                                    : base.VisitUnary(node);
+                return node;
+            }
         }
 
         protected override Expression VisitConstant(ConstantExpression node)

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

@@ -28,6 +28,52 @@ public class Dest
             public int ChildValue { get; set; }
         }
 
+        public enum SourceEnum
+        {
+            Foo,
+            Bar
+        }
+
+        public enum DestEnum
+        {
+            Foo,
+            Bar
+        }
+
+        public class SourceWithEnum : Source
+        {
+            public SourceEnum Enum { get; set; }
+        }
+
+        public class DestWithEnum : Dest
+        {
+            public DestEnum Enum { get; set; }
+        }
+
+        [Fact]
+        public void Can_map_unary_expression_converting_enum_to_int()
+        {
+            var config = new MapperConfiguration(cfg =>
+            {
+                cfg.AddExpressionMapping();
+                cfg.CreateMap<SourceEnum, DestEnum>();
+                cfg.CreateMap<DestWithEnum, SourceWithEnum>();
+            });
+
+            Expression<Func<SourceWithEnum, bool>> expr = s => s.Enum == SourceEnum.Bar;
+
+            var mapped = config.CreateMapper().MapExpression<Expression<Func<SourceWithEnum, bool>>, Expression<Func<DestWithEnum, bool>>>(expr);
+
+            var items = new[]
+           {
+                new DestWithEnum {Enum = DestEnum.Foo},
+                new DestWithEnum {Enum = DestEnum.Bar},
+                new DestWithEnum {Enum = DestEnum.Bar}
+            };
+
+            var items2 = items.AsQueryable().Select(mapped).ToList();
+        }
+
         [Fact]
         public void Can_map_single_properties()
         {