Fixing nullable enum translation, re: #134

agileobjects · Nov 10, 2023 · 3be6e38 · 3be6e38
1 parent 6b9aa2c
commit 3be6e38
Show file tree

Hide file tree

Showing 4 changed files with 55 additions and 8 deletions.
diff --git a/src/ReadableExpressions/Translations/BinaryTranslation.cs b/src/ReadableExpressions/Translations/BinaryTranslation.cs
@@ -187,16 +187,17 @@ private static bool IsEnumType(
 
     private static Expression GetEnumValue(
         Expression expression,
-        Type enumType)
+        Type enumValueType)
     {
         if (expression.NodeType != Constant)
         {
             return expression;
         }
 
         var value = ((ConstantExpression)expression).Value;
+        var enumType = enumValueType.GetNonNullableType();
         var enumValue = Enum.Parse(enumType, value.ToString());
-        return Expression.Constant(enumValue, enumType);
+        return Expression.Constant(enumValue, enumValueType);
     }
 
     #endregion

diff --git a/src/ReadableExpressions/Translations/ConstantTranslation.cs b/src/ReadableExpressions/Translations/ConstantTranslation.cs
@@ -34,11 +34,13 @@ public static INodeTranslation For(
             return DefaultValueTranslation.For(constant, context);
         }
 
-        if (constant.Type.IsEnum())
+        var constantType = constant.Type.GetNonNullableType();
+
+        if (constantType.IsEnum() && constant.Value != null)
         {
-            return constant.Type.HasAttribute<FlagsAttribute>()
-                ? new FlagsEnumConstantTranslation(constant, context)
-                : new EnumConstantTranslation(constant, context);
+            return constantType.HasAttribute<FlagsAttribute>()
+                ? new FlagsEnumConstantTranslation(constant, constantType, context)
+                : new EnumConstantTranslation(constant, constantType, context);
         }
 
         if (TryTranslateFromTypeCode(constant, context, out var translation))
@@ -337,9 +339,9 @@ private class FlagsEnumConstantTranslation : INodeTranslation
 
         public FlagsEnumConstantTranslation(
             ConstantExpression constant,
+            Type enumType,
             ITranslationContext context)
         {
-            var enumType = constant.Type;
             _typeNameTranslation = context.GetTranslationFor(enumType);
 
             var enumValue = constant.Value;
@@ -416,9 +418,10 @@ private class EnumConstantTranslation : INodeTranslation
 
         public EnumConstantTranslation(
             ConstantExpression constant,
+            Type constantType,
             ITranslationContext context)
         {
-            _typeNameTranslation = context.GetTranslationFor(constant.Type);
+            _typeNameTranslation = context.GetTranslationFor(constantType);
             _enumMemberName = constant.Value.ToString();
         }
 

diff --git a/src/Tests/ReadableExpressions.UnitTests/WhenTranslatingComparisons.cs b/src/Tests/ReadableExpressions.UnitTests/WhenTranslatingComparisons.cs
@@ -22,6 +22,17 @@ public void ShouldTranslateAnEqualityExpression()
             translated.ShouldBe("(i1, i2) => i1 == i2");
         }
 
+        [Fact]
+        public void ShouldTranslateAnEnumEqualityExpression()
+        {
+            var enumEqualsOne =
+                CreateLambda((OddNumber number) => number == OddNumber.One);
+
+            var translated = enumEqualsOne.ToReadableString();
+
+            translated.ShouldBe("number => number == OddNumber.One");
+        }
+
         [Fact]
         public void ShouldTranslateALessThanExpression()
         {
@@ -72,6 +83,18 @@ public void ShouldTranslateAnInequalityExpression()
             translated.ShouldBe("(i1, i2) => i1 != i2");
         }
 
+        // See https://github.com/agileobjects/ReadableExpressions/issues/134
+        [Fact]
+        public void ShouldTranslateANullableEnumInequalityExpression()
+        {
+            var enumDoesNotEqualOne =
+                CreateLambda((OddNumber? number) => number != OddNumber.One);
+
+            var translated = enumDoesNotEqualOne.ToReadableString();
+
+            translated.ShouldBe("number => number != OddNumber.One");
+        }
+
         [Fact]
         public void ShouldAbbreviateBooleanTrueComparisons()
         {

diff --git a/src/Tests/ReadableExpressions.UnitTests/WhenTranslatingConstants.cs b/src/Tests/ReadableExpressions.UnitTests/WhenTranslatingConstants.cs
@@ -234,6 +234,26 @@ public void ShouldTranslateAnEnumMember()
         translated.ShouldBe("OddNumber.One");
     }
 
+    [Fact]
+    public void ShouldTranslateANullableEnumMember()
+    {
+        var enumConstant = Constant(OddNumber.One, typeof(OddNumber?));
+
+        var translated = enumConstant.ToReadableString();
+
+        translated.ShouldBe("OddNumber.One");
+    }
+
+    [Fact]
+    public void ShouldTranslateANullNullableEnumMember()
+    {
+        var nullEnumConstant = Constant(default(OddNumber?));
+
+        var translated = nullEnumConstant.ToReadableString();
+
+        translated.ShouldBe("null");
+    }
+
     [Fact]
     public void ShouldTranslateADefaultFlagsEnumMember()
     {