Use reverse instead of forward (semantics) and add comparison operators

christabella · christabella · commit ad2b3776b9fc · 2020-12-29T13:17:27.000Z
diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -351,13 +351,13 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                 int clrnargs = pi.Length;
                 isOperator = isOperator && pynargs == clrnargs - 1;  // Handle mismatched arg numbers due to Python operator being bound.
                 // Preprocessing pi to remove either the first or second argument.
-                bool isForward = isOperator && OperatorMethod.IsForward((MethodInfo)mi);  // Only cast if isOperator.
-                if (isOperator && isForward) {
+                bool isReverse = isOperator && OperatorMethod.IsReverse((MethodInfo)mi);  // Only cast if isOperator.
+                if (isOperator && !isReverse) {
                     // The first Python arg is the right operand, while the bound instance is the left.
                     // We need to skip the first (left operand) CLR argument.
                     pi = pi.Skip(1).Take(1).ToArray();
                 }
-                else if (isOperator && !isForward) {
+                else if (isOperator && isReverse) {
                     // The first Python arg is the left operand.
                     // We need to take the first CLR argument.
                     pi = pi.Take(1).ToArray();
@@ -377,10 +377,10 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                         {
                             // Postprocessing to extend margs.
                             var margsTemp = new object[2];
-                            // If forward, the bound instance is the left operand.
-                            int boundOperandIndex = isForward ? 0 : 1;
-                            // If forward, the passed instance is the right operand.
-                            int passedOperandIndex = isForward ? 1 : 0;
+                            // If reverse, the passed instance is the left operand.
+                            int passedOperandIndex= isReverse ? 0 : 1;
+                            // If reverse, the bound instance is the right operand.
+                            int boundOperandIndex = isReverse ? 1 : 0;
                             margsTemp[boundOperandIndex] = co.inst;
                             margsTemp[passedOperandIndex] = margs[0];
                             margs = margsTemp;
diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -46,7 +46,11 @@ static OperatorMethod()
                 ["op_LeftShift"] = new SlotDefinition("__lshift__", TypeOffset.nb_lshift),
                 ["op_RightShift"] = new SlotDefinition("__rshift__", TypeOffset.nb_rshift),
                 ["op_Modulus"] = new SlotDefinition("__mod__", TypeOffset.nb_remainder),
-                ["op_OneComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert)
+                ["op_OneComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert),
+                ["op_GreaterThan"] = new SlotDefinition("__gt__", TypeOffset.tp_richcompare),
+                ["op_GreaterThanOrEqual"] = new SlotDefinition("__ge__", TypeOffset.tp_richcompare),
+                ["op_LessThan"] = new SlotDefinition("__lt__", TypeOffset.tp_richcompare),
+                ["op_LessThanOrEqual"] = new SlotDefinition("__le__", TypeOffset.tp_richcompare)
             };
         }
 
@@ -137,15 +141,15 @@ public static string ReversePyMethodName(string pyName)
         }
 
         /// <summary>
-        /// Check if the method is performing a forward or reverse operation.
+        /// Check if the method is performing a reverse operation.
         /// </summary>
         /// <param name="method">The operator method.</param>
         /// <returns></returns>
-        public static bool IsForward(MethodInfo method)
+        public static bool IsReverse(MethodInfo method)
         {
             Type declaringType = method.DeclaringType;
             Type leftOperandType = method.GetParameters()[0].ParameterType;
-            return leftOperandType == declaringType;
+            return leftOperandType != declaringType;
         }
 
         public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardMethods, out MethodInfo[] reverseMethods)
@@ -154,12 +158,12 @@ public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardM
             List<MethodInfo> reverseMethodsList = new List<MethodInfo>();
             foreach (var method in methods)
             {
-                if (IsForward(method))
+                if (IsReverse(method))
                 {
-                    forwardMethodsList.Add(method);
+                    reverseMethodsList.Add(method);
                 } else
                 {
-                    reverseMethodsList.Add(method);
+                    forwardMethodsList.Add(method);
                 }
 
             }

Original file line number	Diff line number	Diff line change
`@@ -46,7 +46,11 @@ static OperatorMethod()`
`46`	`46`	`["op_LeftShift"] = new SlotDefinition("__lshift__", TypeOffset.nb_lshift),`
`47`	`47`	`["op_RightShift"] = new SlotDefinition("__rshift__", TypeOffset.nb_rshift),`
`48`	`48`	`["op_Modulus"] = new SlotDefinition("__mod__", TypeOffset.nb_remainder),`
`49`		`- ["op_OneComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert)`
	`49`	`+ ["op_OneComplement"] = new SlotDefinition("__invert__", TypeOffset.nb_invert),`
	`50`	`+ ["op_GreaterThan"] = new SlotDefinition("__gt__", TypeOffset.tp_richcompare),`
	`51`	`+ ["op_GreaterThanOrEqual"] = new SlotDefinition("__ge__", TypeOffset.tp_richcompare),`
	`52`	`+ ["op_LessThan"] = new SlotDefinition("__lt__", TypeOffset.tp_richcompare),`
	`53`	`+ ["op_LessThanOrEqual"] = new SlotDefinition("__le__", TypeOffset.tp_richcompare)`
`50`	`54`	`};`
`51`	`55`	`}`
`52`	`56`
`@@ -137,15 +141,15 @@ public static string ReversePyMethodName(string pyName)`
`137`	`141`	`}`
`138`	`142`
`139`	`143`	`/// <summary>`
`140`		`- /// Check if the method is performing a forward or reverse operation.`
	`144`	`+ /// Check if the method is performing a reverse operation.`
`141`	`145`	`/// </summary>`
`142`	`146`	`/// <param name="method">The operator method.</param>`
`143`	`147`	`/// <returns></returns>`
`144`		`- public static bool IsForward(MethodInfo method)`
	`148`	`+ public static bool IsReverse(MethodInfo method)`
`145`	`149`	`{`
`146`	`150`	`Type declaringType = method.DeclaringType;`
`147`	`151`	`Type leftOperandType = method.GetParameters()[0].ParameterType;`
`148`		`- return leftOperandType == declaringType;`
	`152`	`+ return leftOperandType != declaringType;`
`149`	`153`	`}`
`150`	`154`
`151`	`155`	`public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardMethods, out MethodInfo[] reverseMethods)`
`@@ -154,12 +158,12 @@ public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardM`
`154`	`158`	`List<MethodInfo> reverseMethodsList = new List<MethodInfo>();`
`155`	`159`	`foreach (var method in methods)`
`156`	`160`	`{`
`157`		`- if (IsForward(method))`
	`161`	`+ if (IsReverse(method))`
`158`	`162`	`{`
`159`		`- forwardMethodsList.Add(method);`
	`163`	`+ reverseMethodsList.Add(method);`
`160`	`164`	`} else`
`161`	`165`	`{`
`162`		`- reverseMethodsList.Add(method);`
	`166`	`+ forwardMethodsList.Add(method);`
`163`	`167`	`}`
`164`	`168`
`165`	`169`	`}`