Fix comparison to null/None

Author: jhonabreul

src/embed_tests/EnumTests.cs

@@ -544,5 +544,85 @@ def are_same7():
             Assert.IsFalse(module.InvokeMethod("are_same6").As<bool>());
             Assert.IsFalse(module.InvokeMethod("are_same7").As<bool>());
         }
+
+        private PyModule GetCSharpObjectsComparisonTestModule(string @operator)
+        {
+            return PyModule.FromString("GetCSharpObjectsComparisonTestModule", $@"
+from clr import AddReference
+AddReference(""Python.EmbeddingTest"")
+
+from Python.EmbeddingTest import *
+
+enum_value = {nameof(EnumTests)}.{nameof(VerticalDirection)}.{VerticalDirection.Up}
+
+def compare_with_none1():
+    return enum_value {@operator} None
+
+def compare_with_none2():
+    return None {@operator} enum_value
+
+def compare_with_csharp_object1(csharp_object):
+    return enum_value {@operator} csharp_object
+
+def compare_with_csharp_object2(csharp_object):
+    return csharp_object {@operator} enum_value
+");
+        }
+
+        [TestCase("==", false)]
+        [TestCase("!=", true)]
+        public void EqualityComparisonWithNull(string @operator, bool expectedResult)
+        {
+            using var _ = Py.GIL();
+            using var module = GetCSharpObjectsComparisonTestModule(@operator);
+
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_none1").As<bool>());
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_none2").As<bool>());
+
+            using var pyNull = ((TestClass)null).ToPython();
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_csharp_object1", pyNull).As<bool>());
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_csharp_object2", pyNull).As<bool>());
+        }
+
+        [TestCase("==", false)]
+        [TestCase("!=", true)]
+        public void ComparisonOperatorsWithNonEnumObjectsThrows(string @operator, bool expectedResult)
+        {
+            using var _ = Py.GIL();
+            using var module = GetCSharpObjectsComparisonTestModule(@operator);
+
+            using var pyCSharpObject = new TestClass().ToPython();
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_csharp_object1", pyCSharpObject).As<bool>());
+            Assert.AreEqual(expectedResult, module.InvokeMethod("compare_with_csharp_object2", pyCSharpObject).As<bool>());
+        }
+
+        [Test]
+        public void ThrowsOnObjectComparisonOperators([Values("<", "<=", ">", ">=")] string @operator)
+        {
+            using var _ = Py.GIL();
+            using var module = GetCSharpObjectsComparisonTestModule(@operator);
+
+            using var pyCSharpObject = new TestClass().ToPython();
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_csharp_object1", pyCSharpObject));
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_csharp_object2", pyCSharpObject));
+        }
+
+        [Test]
+        public void ThrowsOnNullComparisonOperators([Values("<", "<=", ">", ">=")] string @operator)
+        {
+            using var _ = Py.GIL();
+            using var module = GetCSharpObjectsComparisonTestModule(@operator);
+
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_none1").As<bool>());
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_none2").As<bool>());
+
+            using var pyNull = ((TestClass)null).ToPython();
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_csharp_object1", pyNull));
+            Assert.Throws<PythonException>(() => module.InvokeMethod("compare_with_csharp_object2", pyNull));
+        }
+
+        public class TestClass
+        {
+        }
     }
 }

src/runtime/Util/OpsHelper.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Runtime.CompilerServices;
+
 using static Python.Runtime.OpsHelper;
 
 namespace Python.Runtime
@@ -444,6 +446,11 @@ public static bool op_Inequality(string a, T b)
 
         public static bool op_Equality(T a, Enum b)
         {
+            if (b == null)
+            {
+                return false;
+            }
+
             if (b.GetType().GetEnumUnderlyingType() == typeof(UInt64))
             {
                 return op_Equality(a, Convert.ToUInt64(b));
@@ -466,8 +473,23 @@ public static bool op_Inequality(Enum a, T b)
             return !op_Equality(b, a);
         }
 
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        private static void ThrowOnNull(object obj, string @operator)
+        {
+            if (obj == null)
+            {
+                using (Py.GIL())
+                {
+                    Exceptions.RaiseTypeError($"'{@operator}' not supported between instances of '{typeof(T).Name}' and null/None");
+                    PythonException.ThrowLastAsClrException();
+                }
+            }
+        }
+
         public static bool op_LessThan(T a, Enum b)
         {
+            ThrowOnNull(b, "<");
+
             if (b.GetType().GetEnumUnderlyingType() == typeof(UInt64))
             {
                 return op_LessThan(a, Convert.ToUInt64(b));
@@ -477,11 +499,14 @@ public static bool op_LessThan(T a, Enum b)
 
         public static bool op_LessThan(Enum a, T b)
         {
+            ThrowOnNull(a, "<");
             return op_GreaterThan(b, a);
         }
 
         public static bool op_GreaterThan(T a, Enum b)
         {
+            ThrowOnNull(b, ">");
+
             if (b.GetType().GetEnumUnderlyingType() == typeof(UInt64))
             {
                 return op_GreaterThan(a, Convert.ToUInt64(b));
@@ -491,11 +516,14 @@ public static bool op_GreaterThan(T a, Enum b)
 
         public static bool op_GreaterThan(Enum a, T b)
         {
+            ThrowOnNull(a, ">");
             return op_LessThan(b, a);
         }
 
         public static bool op_LessThanOrEqual(T a, Enum b)
         {
+            ThrowOnNull(b, "<=");
+
             if (b.GetType().GetEnumUnderlyingType() == typeof(UInt64))
             {
                 return op_LessThanOrEqual(a, Convert.ToUInt64(b));
@@ -505,11 +533,14 @@ public static bool op_LessThanOrEqual(T a, Enum b)
 
         public static bool op_LessThanOrEqual(Enum a, T b)
         {
+            ThrowOnNull(a, "<=");
             return op_GreaterThanOrEqual(b, a);
         }
 
         public static bool op_GreaterThanOrEqual(T a, Enum b)
         {
+            ThrowOnNull(b, ">=");
+
             if (b.GetType().GetEnumUnderlyingType() == typeof(UInt64))
             {
                 return op_GreaterThanOrEqual(a, Convert.ToUInt64(b));
@@ -519,9 +550,34 @@ public static bool op_GreaterThanOrEqual(T a, Enum b)
 
         public static bool op_GreaterThanOrEqual(Enum a, T b)
         {
+            ThrowOnNull(a, ">=");
             return op_LessThanOrEqual(b, a);
         }
 
         #endregion
+
+        #region Object equality operators
+
+        public static bool op_Equality(T a, object b)
+        {
+            return false;
+        }
+
+        public static bool op_Equality(object a, T b)
+        {
+            return false;
+        }
+
+        public static bool op_Inequality(T a, object b)
+        {
+            return true;
+        }
+
+        public static bool op_Inequality(object a, T b)
+        {
+            return true;
+        }
+
+        #endregion
     }
 }