Finish comparison operator impl and add tests

pythonnet · lostmsu · Jan 12, 2021 · Dec 29, 2020 · Dec 29, 2020 · Jan 6, 2021
commit 31f3ed1309ddb7358f0a7ec315bdd006d048aaad
diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
@@ -270,6 +270,12 @@ public void SymmetricalOperatorOverloads()
 
 c = a > b
 assert c == (a.Num > b.Num)
+
+c = a == b
+assert c == (a.Num == b.Num)
+
+c = a != b
+assert c == (a.Num != b.Num)
 ");
         }
 
@@ -339,6 +345,12 @@ public void ForwardOperatorOverloads()
 
 c = a > b
 assert c == (a.Num > b)
+
+c = a == b
+assert c == (a.Num == b)
+
+c = a != b
+assert c == (a.Num != b)
 ");
         }
 
@@ -392,6 +404,12 @@ public void ReverseOperatorOverloads()
 
 c = a > b
 assert c == (a > b.Num)
+
+c = a == b
+assert c == (a == b.Num)
+
+c = a != b
+assert c == (a != b.Num)
 ");
 
         }

diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -21,6 +21,7 @@ internal class ClassBase : ManagedType
         [NonSerialized]
         internal List<string> dotNetMembers;
         internal Indexer indexer;
+        internal Hashtable richcompare;
         internal MaybeType type;
 
         internal ClassBase(Type tp)
@@ -35,6 +36,15 @@ internal virtual bool CanSubclass()
             return !type.Value.IsEnum;
         }
 
+        public readonly static Dictionary<int, string> PyToCilOpMap = new Dictionary<int, string>
+        {
+            [Runtime.Py_EQ] = "op_Equality",
+            [Runtime.Py_NE] = "op_Inequality",
+            [Runtime.Py_GT] = "op_GreaterThan",
+            [Runtime.Py_GE] = "op_GreaterThanOrEqual",
+            [Runtime.Py_LT] = "op_LessThan",
+            [Runtime.Py_LE] = "op_LessThanOrEqual",
+        };
 
         /// <summary>
         /// Default implementation of [] semantics for reflected types.
@@ -72,6 +82,42 @@ public static IntPtr tp_richcompare(IntPtr ob, IntPtr other, int op)
         {
             CLRObject co1;
             CLRObject co2;
+            IntPtr tp = Runtime.PyObject_TYPE(ob);
+            var cls = (ClassBase)GetManagedObject(tp);
+            // C# operator methods take precedence over IComparable.
+            // We first check if there's a comparison operator by looking up the richcompare table,
+            // otherwise fallback to checking if an IComparable interface is handled.
+            if (PyToCilOpMap.ContainsKey(op)) {
+                string CilOp = PyToCilOpMap[op];
+                if (cls.richcompare.Contains(CilOp)) {
+                    var methodObject = (MethodObject)cls.richcompare[CilOp];
+                    IntPtr args = other;
+                    var free = false;
+                    if (!Runtime.PyTuple_Check(other))
 result = binding.info.Invoke(binding.inst, BindingFlags.Default, null, binding.args, null); 
 result = binding.info.Invoke(binding.inst, BindingFlags.Default, null, binding.args, null); 
+                    {
+                        // Wrap the `other` argument of a binary comparison operator in a PyTuple.
+                        args = Runtime.PyTuple_New(1);
+                        Runtime.XIncref(other);
+                        Runtime.PyTuple_SetItem(args, 0, other);
+                        free = true;
+                    }
+
+                    IntPtr value;
+                    try
+                    {
+                        value = methodObject.Invoke(ob, args, IntPtr.Zero);
+                    }
+                    finally
+                    {
+                        if (free)
+                        {
+                            Runtime.XDecref(args);  // Free args pytuple
+                        }
+                    }
+                    return value;
+                }
+            }
+
             switch (op)
             {
                 case Runtime.Py_EQ:

diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -259,6 +259,7 @@ private static void InitClassBase(Type type, ClassBase impl)
             ClassInfo info = GetClassInfo(type);
 
             impl.indexer = info.indexer;
+            impl.richcompare = new Hashtable();
 
             // Now we allocate the Python type object to reflect the given
             // managed type, filling the Python type slots with thunks that
@@ -284,6 +285,9 @@ private static void InitClassBase(Type type, ClassBase impl)
                 Runtime.PyDict_SetItemString(dict, name, item.pyHandle);
                 // Decref the item now that it's been used.
                 item.DecrRefCount();
+                if (ClassBase.PyToCilOpMap.ContainsValue(name)) {
+                    impl.richcompare.Add(name, iter.Value);
+                }
             }
 
             // If class has constructors, generate an __doc__ attribute.

diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -50,6 +50,8 @@ static OperatorMethod()
                 ["op_UnaryNegation"] = new SlotDefinition("__neg__", TypeOffset.nb_negative),
                 ["op_UnaryPlus"] = new SlotDefinition("__pos__", TypeOffset.nb_positive),
                 ["op_OneComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert),
+                ["op_Equality"] = new SlotDefinition("__eq__", TypeOffset.tp_richcompare),
+                ["op_Inequality"] = new SlotDefinition("__ne__", TypeOffset.tp_richcompare),
                 ["op_GreaterThan"] = new SlotDefinition("__gt__", TypeOffset.tp_richcompare),
                 ["op_GreaterThanOrEqual"] = new SlotDefinition("__ge__", TypeOffset.tp_richcompare),
                 ["op_LessThan"] = new SlotDefinition("__lt__", TypeOffset.tp_richcompare),
@@ -79,6 +81,12 @@ public static bool IsOperatorMethod(MethodBase method)
             }
             return OpMethodMap.ContainsKey(method.Name);
         }
+
+        public static bool IsComparisonOp(MethodInfo method)
+        {
+            return OpMethodMap[method.Name].TypeOffset == TypeOffset.tp_richcompare;
+        }
+
         /// <summary>
         /// For the operator methods of a CLR type, set the special slots of the
         /// corresponding Python type's operator methods.
@@ -91,7 +99,7 @@ public static void FixupSlots(IntPtr pyType, Type clrType)
             Debug.Assert(_opType != null);
             foreach (var method in clrType.GetMethods(flags))
             {
-                if (!IsOperatorMethod(method))
+                if (!IsOperatorMethod(method) || IsComparisonOp(method))  // We don't want to override ClassBase.tp_richcompare.
                 {
                     continue;
                 }