Revert "Remove isOperator from MatchesArgumentCount (simplify)"

This partially reverts commit 8cce61d. Due to breaking change
pythonnet · lostmsu · Jan 5, 2021 · Dec 16, 2020 · Dec 17, 2020 · Dec 17, 2020
commit 09a2047f502fd6869744aae2234bbe474f9aaa94
diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -477,9 +477,11 @@ private static ClassInfo GetClassInfo(Type type)
                     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);
+                    if (forwardMethods.Length > 0)
+                        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);
+                    if (reverseMethods.Length > 0)
+                        ci.members[pyNameReverse] = new MethodObject(type, name, reverseMethods);
                 }
             }
 

diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -343,14 +343,13 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                 int kwargsMatched;
                 int defaultsNeeded;
                 bool isOperator = OperatorMethod.IsOperatorMethod(mi);
-                int clrnargs = pi.Length;
-                // Binary operator methods will have 2 CLR args but only one Python arg
-                // (unary operators will have 1 less each), since Python operator methods are bound.
-                isOperator = isOperator && pynargs == clrnargs - 1;
-                if (!MatchesArgumentCount(pynargs, pi, kwargDict, out paramsArray, out defaultArgList, out kwargsMatched, out defaultsNeeded) && !isOperator)
+                if (!MatchesArgumentCount(pynargs, pi, kwargDict, isOperator, out paramsArray, out defaultArgList, out kwargsMatched, out defaultsNeeded))
                 {
                     continue;
                 }
+                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 isReverse = isOperator && OperatorMethod.IsReverse((MethodInfo)mi);  // Only cast if isOperator.
                 if (isOperator && !isReverse) {
@@ -363,7 +362,6 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                     // We need to take the first CLR argument.
                     pi = pi.Take(1).ToArray();
                 }
-                var outs = 0;
                 var margs = TryConvertArguments(pi, paramsArray, args, pynargs, kwargDict, defaultArgList,
                     needsResolution: _methods.Length > 1,  // If there's more than one possible match.
                     outs: out outs);
@@ -687,13 +685,15 @@ static Type TryComputeClrArgumentType(Type parameterType, IntPtr argument, bool
         /// <param name="positionalArgumentCount">Number of positional args passed from Python.</param>
         /// <param name="parameters">Parameters of the specified .NET method.</param>
         /// <param name="kwargDict">Keyword args passed from Python.</param>
+        /// <param name="isOperator">True if the parameters' method is an operator.</param>
         /// <param name="paramsArray">True if the final param of the .NET method is an array (`params` keyword).</param>
         /// <param name="defaultArgList">List of default values for arguments.</param>
         /// <param name="kwargsMatched">Number of kwargs from Python that are also present in the .NET method.</param>
         /// <param name="defaultsNeeded">Number of non-null defaultsArgs.</param>
         /// <returns></returns>
         static bool MatchesArgumentCount(int positionalArgumentCount, ParameterInfo[] parameters,
             Dictionary<string, IntPtr> kwargDict,
+            bool isOperator,
             out bool paramsArray,
             out ArrayList defaultArgList,
             out int kwargsMatched,
@@ -711,8 +711,12 @@ static bool MatchesArgumentCount(int positionalArgumentCount, ParameterInfo[] pa
             else if (positionalArgumentCount < parameters.Length && (!paramsArray || positionalArgumentCount == parameters.Length - 1))
             {
                 match = true;
-                if (positionalArgumentCount == parameters.Length - 1)
+                // operator methods will have 2 CLR args but only one Python arg,
+                // since Python operator methods are bound
+                if (isOperator && positionalArgumentCount == parameters.Length - 1)
                 {
+                    // return early since a C# operator method cannot have
+                    // keyword args, default args, or params arrays (exclusive cases)
                     return match;
                 }
                 // every parameter past 'positionalArgumentCount' must have either