extracted TryConvertArguments from MethodBinder.Bind

lostmsu · lostmsu · commit 04b77d9b9049 · 2019-03-12T14:34:54.000-07:00
diff --git a/src/runtime/methodbinder.cs b/src/runtime/methodbinder.cs
@@ -280,7 +280,6 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
             // loop to find match, return invoker w/ or /wo error
             MethodBase[] _methods = null;
             var pynargs = (int)Runtime.PyTuple_Size(args);
-            object arg;
             var isGeneric = false;
             if (info != null)
             {
@@ -301,59 +300,15 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
                 }
                 ParameterInfo[] pi = mi.GetParameters();
                 ArrayList defaultArgList;
-                int arrayStart;
+                bool paramsArray;
 
-                if (!MatchesArgumentCount(pynargs, pi, out arrayStart, out defaultArgList)) {
+                if (!MatchesArgumentCount(pynargs, pi, out paramsArray, out defaultArgList)) {
                     continue;
                 }
                 var outs = 0;
-                var margs = new object[pi.Length];
-
-                for (int paramIndex = 0; paramIndex < pi.Length; paramIndex++)
-                {
-                    if (paramIndex >= pynargs)
-                    {
-                        if (defaultArgList != null)
-                        {
-                            margs[paramIndex] = defaultArgList[paramIndex - pynargs];
-                        }
-
-                        continue;
-                    }
-
-                    IntPtr op = (arrayStart == paramIndex)
-                        // map remaining Python arguments to a tuple since
-                        // the managed function accepts it - hopefully :]
-                        ? Runtime.PyTuple_GetSlice(args, arrayStart, pynargs)
-                        : Runtime.PyTuple_GetItem(args, paramIndex);
-
-                    var parameter = pi[paramIndex];
-
-                    var clrtype = TryComputeClrArgumentType(parameter.ParameterType, op, needsResolution: _methods.Length > 1);
-                    if (clrtype == null) {
-                        margs = null;
-                        break;
-                    }
-
-                    if (parameter.IsOut || clrtype.IsByRef)
-                    {
-                        outs++;
-                    }
-
-                    if (!Converter.ToManaged(op, clrtype, out arg, false))
-                    {
-                        Exceptions.Clear();
-                        margs = null;
-                        break;
-                    }
-                    if (arrayStart == paramIndex)
-                    {
-                        // GetSlice() creates a new reference but GetItem()
-                        // returns only a borrow reference.
-                        Runtime.XDecref(op);
-                    }
-                    margs[paramIndex] = arg;
-                }
+                var margs = TryConvertArguments(pi, paramsArray, args, pynargs, defaultArgList,
+                    needsResolution: _methods.Length > 1,
+                    outs: out outs);
 
                 if (margs == null)
                 {
@@ -394,6 +349,65 @@ internal Binding Bind(IntPtr inst, IntPtr args, IntPtr kw, MethodBase info, Meth
             return null;
         }
 
+        static object[] TryConvertArguments(ParameterInfo[] pi, bool paramsArray,
+            IntPtr args, int pyArgCount,
+            ArrayList defaultArgList,
+            bool needsResolution,
+            out int outs)
+        {
+            outs = 0;
+            var margs = new object[pi.Length];
+            int arrayStart = paramsArray ? pi.Length - 1 : -1;
+
+            for (int paramIndex = 0; paramIndex < pi.Length; paramIndex++)
+            {
+                if (paramIndex >= pyArgCount)
+                {
+                    if (defaultArgList != null)
+                    {
+                        margs[paramIndex] = defaultArgList[paramIndex - pyArgCount];
+                    }
+
+                    continue;
+                }
+
+                IntPtr op = (arrayStart == paramIndex)
+                    // map remaining Python arguments to a tuple since
+                    // the managed function accepts it - hopefully :]
+                    ? Runtime.PyTuple_GetSlice(args, arrayStart, pyArgCount)
+                    : Runtime.PyTuple_GetItem(args, paramIndex);
+
+                var parameter = pi[paramIndex];
+
+                var clrtype = TryComputeClrArgumentType(parameter.ParameterType, op, needsResolution: needsResolution);
+                if (clrtype == null)
+                {
+                    return null;
+                }
+
+                if (parameter.IsOut || clrtype.IsByRef)
+                {
+                    outs++;
+                }
+
+                object arg;
+                if (!Converter.ToManaged(op, clrtype, out arg, false))
+                {
+                    Exceptions.Clear();
+                    return null;
+                }
+                if (arrayStart == paramIndex)
+                {
+                    // GetSlice() creates a new reference but GetItem()
+                    // returns only a borrow reference.
+                    Runtime.XDecref(op);
+                }
+                margs[paramIndex] = arg;
+            }
+
+            return margs;
+        }
+
         static Type TryComputeClrArgumentType(Type parameterType, IntPtr argument, bool needsResolution)
         {
             // this logic below handles cases when multiple overloading methods
@@ -465,12 +479,12 @@ static Type TryComputeClrArgumentType(Type parameterType, IntPtr argument, bool
         }
 
         static bool MatchesArgumentCount(int argumentCount, ParameterInfo[] parameters,
-            out int paramsArrayStart,
+            out bool paramsArray,
             out ArrayList defaultArgList)
         {
             defaultArgList = null;
             var match = false;
-            paramsArrayStart = -1;
+            paramsArray = false;
 
             if (argumentCount == parameters.Length)
             {
@@ -491,7 +505,7 @@ static bool MatchesArgumentCount(int argumentCount, ParameterInfo[] parameters,
             {
                 // This is a `foo(params object[] bar)` style method
                 match = true;
-                paramsArrayStart = parameters.Length - 1;
+                paramsArray = true;
             }
 
             return match;
