Support reverse binary operations

pythonnet · lostmsu · Jan 5, 2021 · Dec 16, 2020 · Dec 17, 2020 · Dec 17, 2020
commit e7da0bcc451856db03e901d29c64ffb2246cbbe9
diff --git a/src/embed_tests/TestOperator.cs b/src/embed_tests/TestOperator.cs
@@ -202,6 +202,42 @@ public void ForwardOperatorOverloads()
 assert c.Num == a.Num ^ b
 ");
         }
+
+
+        [Test]
+        public void ReverseOperatorOverloads()
+        {
+            string name = string.Format("{0}.{1}",
+                typeof(OperableObject).DeclaringType.Name,
+                typeof(OperableObject).Name);
+            string module = MethodBase.GetCurrentMethod().DeclaringType.Namespace;
+
+            PythonEngine.Exec($@"
+from {module} import *
+cls = {name}
+a = 2
+b = cls(10)
+
+c = a + b
+assert c.Num == a + b.Num
+
+c = a - b
+assert c.Num == a - b.Num
+
+c = a * b
+assert c.Num == a * b.Num
+
+c = a & b
+assert c.Num == a & b.Num
+
+c = a | b
+assert c.Num == a | b.Num
+
+c = a ^ b
+assert c.Num == a ^ b.Num
+");
+
+        }
         [Test]
         public void ShiftOperatorOverloads()
         {

diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -472,7 +472,14 @@ private static ClassInfo GetClassInfo(Type type)
                 ci.members[name] = ob;
                 if (mlist.Any(OperatorMethod.IsOperatorMethod))
                 {
-                    ci.members[OperatorMethod.GetPyMethodName(name)] = ob;
+                    string pyName = OperatorMethod.GetPyMethodName(name);
+                    string pyNameReverse = pyName.Insert(2, "r");
+                    MethodInfo[] forwardMethods, reverseMethods;
+                    OperatorMethod.FilterMethods(mlist, out forwardMethods, out reverseMethods);
+                    // Only methods where the left operand is the declaring type.
+                    ci.members[pyName] = new MethodObject(type, name, forwardMethods);
+                    // Only methods where only the right operand is the declaring type.
+                    ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods);
                 }
             }
 

diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -350,9 +350,20 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                 var outs = 0;
                 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) {
+                    // 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) {
+                    // The first Python arg is the left operand.
+                    // We need to take the first CLR argument.
+                    pi = pi.Take(1).ToArray();
+                }
                 var margs = TryConvertArguments(pi, paramsArray, args, pynargs, kwargDict, defaultArgList,
                     needsResolution: _methods.Length > 1,  // If there's more than one possible match.
-                    isOperator: isOperator,
                     outs: out outs);
                 if (margs == null)
                 {
@@ -364,7 +375,15 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                     {
                         if (ManagedType.GetManagedObject(inst) is CLRObject co)
                         {
-                            margs[0] = co.inst;
+                            // 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;
+                            margsTemp[boundOperandIndex] = co.inst;
+                            margsTemp[passedOperandIndex] = margs[0];
+                            margs = margsTemp;
                         }
                         else { break; }
                     }
@@ -488,15 +507,13 @@ static IntPtr HandleParamsArray(IntPtr args, int arrayStart, int pyArgCount, out
         /// <param name="kwargDict">Dictionary of keyword argument name to python object pointer</param>
         /// <param name="defaultArgList">A list of default values for omitted parameters</param>
         /// <param name="needsResolution"><c>true</c>, if overloading resolution is required</param>
-        /// <param name="isOperator"><c>true</c>, if is operator method</param>
         /// <param name="outs">Returns number of output parameters</param>
         /// <returns>An array of .NET arguments, that can be passed to a method.</returns>
         static object[] TryConvertArguments(ParameterInfo[] pi, bool paramsArray,
             IntPtr args, int pyArgCount,
             Dictionary<string, IntPtr> kwargDict,
             ArrayList defaultArgList,
             bool needsResolution,
-            bool isOperator,
             out int outs)
         {
             outs = 0;
@@ -535,13 +552,6 @@ static object[] TryConvertArguments(ParameterInfo[] pi, bool paramsArray,
                         op = Runtime.PyTuple_GetItem(args, paramIndex);
                     }
                 }
-                if (isOperator && paramIndex == 0)
-                {
-                    // After we've obtained the first argument from Python, we need to skip the first argument of the CLR
-                    // because operator method is a bound method in Python
-                    paramIndex++; // Leave the first .NET param as null (margs).
-                    parameter = pi[paramIndex];
-                }
 
                 bool isOut;
                 if (!TryConvertArgument(op, parameter.ParameterType, needsResolution, out margs[paramIndex], out isOut))

diff --git a/src/runtime/operatormethod.cs b/src/runtime/operatormethod.cs
@@ -130,5 +130,41 @@ private static PyObject GetOperatorType()
                 return locals.GetItem("OperatorMethod");
             }
         }
+
+        public static string ReversePyMethodName(string pyName)
+        {
+            return pyName.Insert(2, "r");
+        }
+
+        /// <summary>
+        /// Check if the method is performing a forward or reverse operation.
+        /// </summary>
+        /// <param name="method">The operator method.</param>
+        /// <returns></returns>
+        public static bool IsForward(MethodInfo method)
+        {
+            Type declaringType = method.DeclaringType;
+            Type leftOperandType = method.GetParameters()[0].ParameterType;
+            return leftOperandType == declaringType;
+        }
+
+        public static void FilterMethods(MethodInfo[] methods, out MethodInfo[] forwardMethods, out MethodInfo[] reverseMethods)
+        {
+            List<MethodInfo> forwardMethodsList = new List<MethodInfo>();
+            List<MethodInfo> reverseMethodsList = new List<MethodInfo>();
+            foreach (var method in methods)
+            {
+                if (IsForward(method))
+                {
+                    forwardMethodsList.Add(method);
+                } else
+                {
+                    reverseMethodsList.Add(method);
+                }
+
+            }
+            forwardMethods = forwardMethodsList.ToArray();
+            reverseMethods = reverseMethodsList.ToArray();
+        }
     }
 }