Use reverse instead of forward (semantics)

christabella · christabella · commit a37683894791 · 2020-12-29T14:44:09.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
@@ -137,15 +137,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 +154,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
`@@ -137,15 +137,15 @@ public static string ReversePyMethodName(string pyName)`
`137`	`137`	`}`
`138`	`138`
`139`	`139`	`/// <summary>`
`140`		`- /// Check if the method is performing a forward or reverse operation.`
	`140`	`+ /// Check if the method is performing a reverse operation.`
`141`	`141`	`/// </summary>`
`142`	`142`	`/// <param name="method">The operator method.</param>`
`143`	`143`	`/// <returns></returns>`
`144`		`- public static bool IsForward(MethodInfo method)`
	`144`	`+ public static bool IsReverse(MethodInfo method)`
`145`	`145`	`{`
`146`	`146`	`Type declaringType = method.DeclaringType;`
`147`	`147`	`Type leftOperandType = method.GetParameters()[0].ParameterType;`
`148`		`- return leftOperandType == declaringType;`
	`148`	`+ return leftOperandType != declaringType;`
`149`	`149`	`}`
`150`	`150`
`151`	`151`	`public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardMethods, out MethodInfo[] reverseMethods)`
`@@ -154,12 +154,12 @@ public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardM`
`154`	`154`	`List<MethodInfo> reverseMethodsList = new List<MethodInfo>();`
`155`	`155`	`foreach (var method in methods)`
`156`	`156`	`{`
`157`		`- if (IsForward(method))`
	`157`	`+ if (IsReverse(method))`
`158`	`158`	`{`
`159`		`- forwardMethodsList.Add(method);`
	`159`	`+ reverseMethodsList.Add(method);`
`160`	`160`	`} else`
`161`	`161`	`{`
`162`		`- reverseMethodsList.Add(method);`
	`162`	`+ forwardMethodsList.Add(method);`
`163`	`163`	`}`
`164`	`164`
`165`	`165`	`}`