Minor fixes

Author: jhonabreul

src/runtime/MethodBinder.cs

@@ -2,7 +2,6 @@
 using System.Collections;
 using System.Collections.Generic;
 using System.Linq;
-using System.Numerics;
 using System.Reflection;
 using System.Text;
 
@@ -320,18 +319,40 @@ internal List<MethodInformation> GetMethods()
         /// See: https://github.com/jythontools/jython/blob/master/src/org/python/core/ReflectedArgs.java#L192
         /// </remarks>
         private static int GetPrecedence(MethodInformation methodInformation)
+        {
+            return GetMatchedArgumentsPrecedence(methodInformation, null, null);
+        }
+
+        /// <summary>
+        /// Gets the precedence of a method's arguments, considering only those arguments that have been matched,
+        /// that is, those that are not default values.
+        /// </summary>
+        private static int GetMatchedArgumentsPrecedence(MethodInformation methodInformation, int? matchedPositionalArgsCount, IEnumerable<string> matchedKwargsNames)
         {
             ParameterInfo[] pi = methodInformation.ParameterInfo;
             var mi = methodInformation.MethodBase;
             int val = mi.IsStatic ? 3000 : 0;
-            int num = pi.Length;
-
             var isOperatorMethod = OperatorMethod.IsOperatorMethod(methodInformation.MethodBase);
 
             val += mi.IsGenericMethod ? 1 : 0;
-            for (var i = 0; i < num; i++)
+
+            if (!matchedPositionalArgsCount.HasValue)
+            {
+                for (var i = 0; i < pi.Length; i++)
+                {
+                    val += ArgPrecedence(pi[i].ParameterType, isOperatorMethod);
+                }
+            }
+            else
             {
-                val += ArgPrecedence(pi[i].ParameterType, isOperatorMethod);
+                matchedKwargsNames ??= Array.Empty<string>();
+                for (var i = 0; i < pi.Length; i++)
+                {
+                    if (i < matchedPositionalArgsCount || matchedKwargsNames.Contains(methodInformation.ParameterNames[i]))
+                    {
+                        val += ArgPrecedence(pi[i].ParameterType, isOperatorMethod);
+                    }
+                }
             }
 
             var info = mi as MethodInfo;
@@ -351,32 +372,6 @@ private static int GetPrecedence(MethodInformation methodInformation)
             return val;
         }
 
-        /// <summary>
-        /// Gets the precedence of a method's arguments, considering only those arguments that have been matched,
-        /// that is, those that are not default values.
-        /// </summary>
-        private static int GetMatchedArgumentsPrecedence(MethodInformation method, int matchedPositionalArgsCount, IEnumerable<string> matchedKwargsNames)
-        {
-            var isOperatorMethod = OperatorMethod.IsOperatorMethod(method.MethodBase);
-            var pi = method.ParameterInfo;
-            var val = 0;
-            for (var i = 0; i < pi.Length; i++)
-            {
-                if (i < matchedPositionalArgsCount || matchedKwargsNames.Contains(method.ParameterNames[i]))
-                {
-                    val += ArgPrecedence(pi[i].ParameterType, isOperatorMethod);
-                }
-            }
-
-            var mi = method.MethodBase;
-            var info = mi as MethodInfo;
-            if (info != null)
-            {
-                val += ArgPrecedence(info.ReturnType, isOperatorMethod);
-            }
-            return val;
-        }
-
         /// <summary>
         /// Return a precedence value for a particular Type object.
         /// </summary>
@@ -390,7 +385,7 @@ internal static int ArgPrecedence(Type t, bool isOperatorMethod)
 
             if (t.IsAssignableFrom(typeof(PyObject)) && !isOperatorMethod)
             {
-                return -3000;
+                return -1;
             }
 
             if (t.IsArray)
@@ -746,26 +741,16 @@ internal Binding Bind(BorrowedReference inst, BorrowedReference args, BorrowedRe
                 // We favor matches that do not use implicit conversion
                 var matchesTouse = matches.Count > 0 ? matches : matchesUsingImplicitConversion;
 
-                // The best match would be the one with the most named arguments matched
-                var maxKwargsMatched = matchesTouse.Max(x => x.KwargsMatched);
-                // Don't materialize the enumerable, just enumerate twice if necessary to avoid creating a collection instance.
-                var bestMatches = matchesTouse.Where(x => x.KwargsMatched == maxKwargsMatched);
-                var bestMatchesCount = bestMatches.Count();
-
-                MatchedMethod bestMatch;
-                // Multiple best matches, we can still resolve the ambiguity because
-                // some method might take precedence if it received PyObject instances.
-                // So let's get the best match by the precedence of the actual passed arguments,
-                // without considering optional arguments without a passed value
-                if (bestMatchesCount > 1)
-                {
-                    bestMatch = bestMatches.MinBy(x => GetMatchedArgumentsPrecedence(methods.First(m => m.MethodBase == x.Method), pyArgCount,
-                        kwArgDict?.Keys ?? Enumerable.Empty<string>()));
-                }
-                else
-                {
-                    bestMatch = bestMatches.First();
-                }
+                // The best match would be the one with the most named arguments matched.
+                // But if multiple matches have the same max number of named arguments matched,
+                // we solve the ambiguity by taking the one with the highest precedence but only
+                // considering the actual arguments passed, ignoring the optional arguments for
+                // which the default values were used
+                var bestMatch = matchesTouse
+                    .GroupBy(x => x.KwargsMatched)
+                    .OrderByDescending(x => x.Key)
+                    .First()
+                    .MinBy(x => GetMatchedArgumentsPrecedence(methods.First(m => m.MethodBase == x.Method), pyArgCount, kwArgDict?.Keys));
 
                 var margs = bestMatch.ManagedArgs;
                 var outs = bestMatch.Outs;