Simplify PyObj casting, logic of if blocks.

christabella · christabella · commit 7a2b5e296475 · 2021-01-12T09:59:43.000+02:00
diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
@@ -217,7 +217,7 @@ public OperableObject(int num)
                 using (Py.GIL())
                 {
                     // Assuming b is a tuple, take the first element.
-                    int bNum = (int)b.ToArray()[0].AsManagedObject(typeof(int));
+                    int bNum = b[0].As<int>();
                     return a.Num >= bNum;
                 }
             }
@@ -226,7 +226,7 @@ public OperableObject(int num)
                 using (Py.GIL())
                 {
                     // Assuming b is a tuple, take the first element.
-                    int bNum = (int)b.ToArray()[0].AsManagedObject(typeof(int));
+                    int bNum = b[0].As<int>();
                     return a.Num <= bNum;
                 }
             }
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -89,16 +89,10 @@ public static IntPtr tp_richcompare(IntPtr ob, IntPtr other, int op)
             // otherwise fallback to checking if an IComparable interface is handled.
             if (cls.richcompare.TryGetValue(op, out var methodObject))
             {
-                IntPtr args = other;
-                var free = false;
-                if (true)
-                {
-                    // 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;
-                }
+                // Wrap the `other` argument of a binary comparison operator in a PyTuple.
+                IntPtr args = Runtime.PyTuple_New(1);
+                Runtime.XIncref(other);
+                Runtime.PyTuple_SetItem(args, 0, other);
 
                 IntPtr value;
                 try
@@ -107,10 +101,7 @@ public static IntPtr tp_richcompare(IntPtr ob, IntPtr other, int op)
                 }
                 finally
                 {
-                    if (free)
-                    {
-                        Runtime.XDecref(args);  // Free args pytuple
-                    }
+                    Runtime.XDecref(args);  // Free args pytuple
                 }
                 return value;
             }
diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -104,9 +104,9 @@ public static void FixupSlots(IntPtr pyType, Type clrType)
             Debug.Assert(_opType != null);
             foreach (var method in clrType.GetMethods(flags))
             {
-                // We don't want to override slots for either non-operators or
+                // We only want to override slots for operators excluding
                 // comparison operators, which are handled by ClassBase.tp_richcompare.
-                if (!IsOperatorMethod(method) || IsComparisonOp(method))
+                if (!OpMethodMap.ContainsKey(method.Name))
                 {
                     continue;
                 }

Original file line number	Diff line number	Diff line change
`@@ -217,7 +217,7 @@ public OperableObject(int num)`
`217`	`217`	`using (Py.GIL())`
`218`	`218`	`{`
`219`	`219`	`// Assuming b is a tuple, take the first element.`
`220`		`- int bNum = (int)b.ToArray()[0].AsManagedObject(typeof(int));`
	`220`	`+ int bNum = b[0].As<int>();`
`221`	`221`	`return a.Num >= bNum;`
`222`	`222`	`}`
`223`	`223`	`}`
`@@ -226,7 +226,7 @@ public OperableObject(int num)`
`226`	`226`	`using (Py.GIL())`
`227`	`227`	`{`
`228`	`228`	`// Assuming b is a tuple, take the first element.`
`229`		`- int bNum = (int)b.ToArray()[0].AsManagedObject(typeof(int));`
	`229`	`+ int bNum = b[0].As<int>();`
`230`	`230`	`return a.Num <= bNum;`
`231`	`231`	`}`
`232`	`232`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,9 +104,9 @@ public static void FixupSlots(IntPtr pyType, Type clrType)`
`104`	`104`	`Debug.Assert(_opType != null);`
`105`	`105`	`foreach (var method in clrType.GetMethods(flags))`
`106`	`106`	`{`
`107`		`- // We don't want to override slots for either non-operators or`
	`107`	`+ // We only want to override slots for operators excluding`
`108`	`108`	`// comparison operators, which are handled by ClassBase.tp_richcompare.`
`109`		`- if (!IsOperatorMethod(method) \|\| IsComparisonOp(method))`
	`109`	`+ if (!OpMethodMap.ContainsKey(method.Name))`
`110`	`110`	`{`
`111`	`111`	`continue;`
`112`	`112`	`}`