{

/// <summary>

/// The overloads of this method

/// </summary>

public List<MaybeMethodBase> list;

[NonSerialized]

public MethodBase[]? methods;

// volatile + lock: first-time GetMethods() races would otherwise sort `list`

// concurrently and publish a partial methods array.

[NonSerialized]

public volatile bool init = false;

public const bool DefaultAllowThreads = true;

public bool allow_threads = DefaultAllowThreads;

public bool argsReversed = false;

internal MethodBinder()

{

list = new List<MaybeMethodBase>();

}

internal MethodBinder(MethodInfo mi)

{

list = new List<MaybeMethodBase> { new MaybeMethodBase(mi) };

}

public int Count

{

get { return list.Count; }

}

internal void AddMethod(MethodBase m)

{

list.Add(m);

}

internal void AddRange(IEnumerable<MethodBase> methods)

{

list.AddRange(methods.Select(m => new MaybeMethodBase(m)));

}

/// <summary>

/// Given a sequence of MethodInfo and a sequence of types, return the

/// MethodInfo that matches the signature represented by those types.

/// </summary>

internal static MethodBase? MatchSignature(MethodBase[] mi, Type[] tp)

{

if (tp == null)

{

return null;

}

int count = tp.Length;

foreach (MethodBase t in mi)

{

ParameterInfo[] pi = t.GetParameters();

if (pi.Length != count)

{

continue;

}

for (var n = 0; n < pi.Length; n++)

{

if (tp[n] != pi[n].ParameterType)

{

break;

}

if (n == pi.Length - 1)

{

return t;

}

}

}

return null;

}

/// <summary>

/// Given a sequence of MethodInfo and a sequence of type parameters,

/// return the MethodInfo(s) that represents the matching closed generic.

/// If unsuccessful, returns null and may set a Python error.

/// </summary>

internal static MethodInfo[] MatchParameters(MethodBase[] mi, Type[]? tp)

{

if (tp == null)

{

return Array.Empty<MethodInfo>();

}

int count = tp.Length;

var result = new List<MethodInfo>();

foreach (MethodInfo t in mi)

{

if (!t.IsGenericMethodDefinition)

{

continue;

}

Type[] args = t.GetGenericArguments();

if (args.Length != count)

{

continue;

}

try

{

// MakeGenericMethod can throw ArgumentException if the type parameters do not obey the constraints.

MethodInfo method = t.MakeGenericMethod(tp);

result.Add(method);

}

catch (ArgumentException)

{

// The error will remain set until cleared by a successful match.

}

}

return result.ToArray();

}

/// <summary>

/// Given a sequence of MethodInfo and two sequences of type parameters,

/// return the MethodInfo that matches the signature and the closed generic.

/// </summary>

internal static MethodInfo? MatchSignatureAndParameters(MethodBase[] mi, Type[] genericTp, Type[] sigTp)

{

if (genericTp == null || sigTp == null)

{

return null;

}

int genericCount = genericTp.Length;

int signatureCount = sigTp.Length;

foreach (MethodInfo t in mi)

{

if (!t.IsGenericMethodDefinition)

{

continue;

}

Type[] genericArgs = t.GetGenericArguments();

if (genericArgs.Length != genericCount)

{

continue;

}

ParameterInfo[] pi = t.GetParameters();

if (pi.Length != signatureCount)

{

continue;

}

for (var n = 0; n < pi.Length; n++)

{

if (sigTp[n] != pi[n].ParameterType)

{

break;

}

if (n == pi.Length - 1)

{

MethodInfo match = t;

if (match.IsGenericMethodDefinition)

{

// FIXME: typeArgs not used

Type[] typeArgs = match.GetGenericArguments();

return match.MakeGenericMethod(genericTp);

}

return match;

}

}

}

return null;

}

/// <summary>

/// Return the array of MethodInfo for this method. The result array

/// is arranged in order of precedence (done lazily to avoid doing it

/// at all for methods that are never called).

/// </summary>

internal MethodBase[] GetMethods()

{

if (init) return methods!;

lock (list)

{

if (init) return methods!;

// Filter invalid + precompute precedence (GetParameters allocates) in one

// pass so the comparator only does cheap int/type compares O(N log N) times.

var pairs = new List<KeyValuePair<MethodBase, int>>(list.Count);

foreach (var m in list)

{

if (m.Valid) pairs.Add(new(m.Value, GetPrecedence(m.Value)));

}

if (pairs.Count > 1) pairs.Sort(CompareByDeclaringTypeThenPrecedence);

var arr = new MethodBase[pairs.Count];

for (int i = 0; i < pairs.Count; i++) arr[i] = pairs[i].Key;

methods = arr;

init = true;

return methods!;

}

}

/// <summary>

/// Sort key for <see cref="GetMethods"/>: derived-class methods come before

/// their base, otherwise by precomputed precedence (lower wins).

/// </summary>

private static int CompareByDeclaringTypeThenPrecedence(

KeyValuePair<MethodBase, int> a, KeyValuePair<MethodBase, int> b)

{

Type ta = a.Key.DeclaringType, tb = b.Key.DeclaringType;

if (ta != tb)

{

if (ta.IsAssignableFrom(tb)) return 1;

if (tb.IsAssignableFrom(ta)) return -1;

}

return a.Value.CompareTo(b.Value);

}

/// <summary>

/// Precedence algorithm largely lifted from Jython - the concerns are

/// generally the same so we'll start with this and tweak as necessary.

/// </summary>

/// <remarks>

/// Based from Jython `org.python.core.ReflectedArgs.precedence`

/// See: https://github.com/jythontools/jython/blob/master/src/org/python/core/ReflectedArgs.java#L192

/// </remarks>

internal static int GetPrecedence(MethodBase mi)

{

if (mi == null)

{

return int.MaxValue;

}

ParameterInfo[] pi = mi.GetParameters();

int val = mi.IsStatic ? 3000 : 0;

int num = pi.Length;

val += mi.IsGenericMethod ? 1 : 0;

for (var i = 0; i < num; i++)

{

val += ArgPrecedence(pi[i].ParameterType);

}

return val;

}

/// <summary>

/// Return a precedence value for a particular Type object.

/// </summary>

internal static int ArgPrecedence(Type t)

{

Type objectType = typeof(object);

if (t == objectType)

{

return 3000;

}

if (t.IsArray)

{

Type e = t.GetElementType();

if (e == objectType)

{

return 2500;

}

return 100 + ArgPrecedence(e);

}

TypeCode tc = Type.GetTypeCode(t);

// TODO: Clean up

return tc switch

{

TypeCode.Object => 1,

TypeCode.UInt64 => 10,

TypeCode.UInt32 => 11,

TypeCode.UInt16 => 12,

TypeCode.Int64 => 13,

TypeCode.Int32 => 14,

TypeCode.Int16 => 15,

TypeCode.Char => 16,

TypeCode.SByte => 17,

TypeCode.Byte => 18,

TypeCode.Single => 20,

TypeCode.Double => 21,

TypeCode.String => 30,

TypeCode.Boolean => 40,

_ => 2000,

};

}

/// <summary>

/// Bind the given Python instance and arguments to a particular method

/// overload in <see cref="list"/> and return a structure that contains the converted Python

/// instance, converted arguments and the correct method to call.

/// If unsuccessful, may set a Python error.

/// </summary>

/// <param name="inst">The Python target of the method invocation.</param>

/// <param name="args">The Python arguments.</param>

/// <param name="kw">The Python keyword arguments.</param>

/// <returns>A Binding if successful. Otherwise null.</returns>

internal Binding? Bind(BorrowedReference inst, BorrowedReference args, BorrowedReference kw)

{

return Bind(inst, args, kw, null, null);

}

/// <summary>

/// Bind the given Python instance and arguments to a particular method

/// overload in <see cref="list"/> and return a structure that contains the converted Python

/// instance, converted arguments and the correct method to call.

/// If unsuccessful, may set a Python error.

/// </summary>

/// <param name="inst">The Python target of the method invocation.</param>

/// <param name="args">The Python arguments.</param>

/// <param name="kw">The Python keyword arguments.</param>

/// <param name="info">If not null, only bind to that method.</param>

/// <returns>A Binding if successful. Otherwise null.</returns>

internal Binding? Bind(BorrowedReference inst, BorrowedReference args, BorrowedReference kw, MethodBase? info)

{

return Bind(inst, args, kw, info, null);

}

private readonly struct MatchedMethod

{

public MatchedMethod(int kwargsMatched, int defaultsNeeded, object?[] margs, int outs, MethodBase mb)

{

KwargsMatched = kwargsMatched;

DefaultsNeeded = defaultsNeeded;

ManagedArgs = margs;

Outs = outs;

Method = mb;

}

public int KwargsMatched { get; }

public int DefaultsNeeded { get; }

public object?[] ManagedArgs { get; }

public int Outs { get; }

public MethodBase Method { get; }

}

private readonly struct MismatchedMethod

{

public MismatchedMethod(Exception exception, MethodBase mb)

{

Exception = exception;

Method = mb;

}

public Exception Exception { get; }

public MethodBase Method { get; }

}

/// <summary>

/// Bind the given Python instance and arguments to a particular method

/// overload in <see cref="list"/> and return a structure that contains the converted Python

/// instance, converted arguments and the correct method to call.

/// If unsuccessful, may set a Python error.

/// </summary>

/// <param name="inst">The Python target of the method invocation.</param>

/// <param name="args">The Python arguments.</param>

/// <param name="kw">The Python keyword arguments.</param>

/// <param name="info">If not null, only bind to that method.</param>

/// <param name="methodinfo">If not null, additionally attempt to bind to the generic methods in this array by inferring generic type parameters.</param>

/// <returns>A Binding if successful. Otherwise null.</returns>

internal Binding? Bind(BorrowedReference inst, BorrowedReference args, BorrowedReference kw, MethodBase? info, MethodBase[]? methodinfo)

{

// loop to find match, return invoker w/ or w/o error

var kwargDict = new Dictionary<string, PyObject>();

if (kw != null)

{

nint pynkwargs = Runtime.PyDict_Size(kw);

using var keylist = Runtime.PyDict_Keys(kw);

using var valueList = Runtime.PyDict_Values(kw);

for (int i = 0; i < pynkwargs; ++i)

{

var keyStr = Runtime.GetManagedString(Runtime.PyList_GetItem(keylist.Borrow(), i));

BorrowedReference value = Runtime.PyList_GetItem(valueList.Borrow(), i);

kwargDict[keyStr!] = new PyObject(value);

}

}

MethodBase[] _methods;

if (info != null)

{

_methods = new MethodBase[1];

_methods.SetValue(info, 0);

}

else

{

_methods = GetMethods();

}

return Bind(inst, args, kwargDict, _methods, matchGenerics: true, argsReversed);

}

private static Binding? Bind(BorrowedReference inst, BorrowedReference args, Dictionary<string, PyObject> kwargDict, MethodBase[] methods, bool matchGenerics, bool argsReversed = false)

{

var pynargs = (int)Runtime.PyTuple_Size(args);

var isGeneric = false;

var argMatchedMethods = new List<MatchedMethod>(methods.Length);

var mismatchedMethods = new List<MismatchedMethod>();

// TODO: Clean up

foreach (MethodBase mi in methods)

{

if (mi.IsGenericMethod)

{

isGeneric = true;

}

ParameterInfo[] pi = mi.GetParameters();

bool isOperator = OperatorMethod.IsOperatorMethod(mi);

// 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 == pi.Length - 1;

bool isReverse = isOperator && argsReversed; // Only cast if isOperator.

if (isReverse && OperatorMethod.IsComparisonOp((MethodInfo)mi))

continue; // Comparison operators in Python have no reverse mode.

if (!MatchesArgumentCount(pynargs, pi, kwargDict, out bool paramsArray, out ArrayList? defaultArgList, out int kwargsMatched, out int defaultsNeeded) && !isOperator)

{

continue;

}

// Preprocessing pi to remove either the first or second argument.

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).ToArray();

}

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();

}

var margs = TryConvertArguments(pi, paramsArray, args, pynargs, kwargDict, defaultArgList, outs: out int outs);

if (margs == null)

{

var mismatchCause = PythonException.FetchCurrent();

mismatchedMethods.Add(new MismatchedMethod(mismatchCause, mi));

continue;

}

if (isOperator)

{

if (inst != null)

{

if (ManagedType.GetManagedObject(inst) is CLRObject co)

{

bool isUnary = pynargs == 0;

// Postprocessing to extend margs.

var margsTemp = isUnary ? new object?[1] : new object?[2];

// If reverse, the bound instance is the right operand.

int boundOperandIndex = isReverse ? 1 : 0;

// If reverse, the passed instance is the left operand.

int passedOperandIndex = isReverse ? 0 : 1;

margsTemp[boundOperandIndex] = co.inst;

if (!isUnary)

{

margsTemp[passedOperandIndex] = margs[0];

}

margs = margsTemp;

}

else continue;

}

}

var matchedMethod = new MatchedMethod(kwargsMatched, defaultsNeeded, margs, outs, mi);

argMatchedMethods.Add(matchedMethod);

}

if (argMatchedMethods.Count > 0)

{

var bestKwargMatchCount = argMatchedMethods.Max(x => x.KwargsMatched);

var fewestDefaultsRequired = argMatchedMethods.Where(x => x.KwargsMatched == bestKwargMatchCount).Min(x => x.DefaultsNeeded);

int bestCount = 0;

int bestMatchIndex = -1;

for (int index = 0; index < argMatchedMethods.Count; index++)

{

var testMatch = argMatchedMethods[index];

if (testMatch.DefaultsNeeded == fewestDefaultsRequired && testMatch.KwargsMatched == bestKwargMatchCount)

{

bestCount++;

if (bestMatchIndex == -1)

bestMatchIndex = index;

}

}

if (bestCount > 1 && fewestDefaultsRequired > 0)

{

// Best effort for determining method to match on gives multiple possible

// matches and we need at least one default argument - bail from this point

var stringBuilder = new StringBuilder("Not enough arguments provided to disambiguate the method. Found:");

foreach (var matchedMethod in argMatchedMethods)

{

stringBuilder.AppendLine();

stringBuilder.Append(matchedMethod.Method.ToString());

}

Exceptions.SetError(Exceptions.TypeError, stringBuilder.ToString());

return null;

}

// If we're here either:

// (a) There is only one best match

// (b) There are multiple best matches but none of them require

// default arguments

// in the case of (a) we're done by default. For (b) regardless of which

// method we choose, all arguments are specified _and_ can be converted

// from python to C# so picking any will suffice

MatchedMethod bestMatch = argMatchedMethods[bestMatchIndex];

var margs = bestMatch.ManagedArgs;

var outs = bestMatch.Outs;

var mi = bestMatch.Method;

object? target = null;

if (!mi.IsStatic && inst != null)

{

//CLRObject co = (CLRObject)ManagedType.GetManagedObject(inst);

// InvalidCastException: Unable to cast object of type

// 'Python.Runtime.ClassObject' to type 'Python.Runtime.CLRObject'

// Sanity check: this ensures a graceful exit if someone does

// something intentionally wrong like call a non-static method

// on the class rather than on an instance of the class.

// XXX maybe better to do this before all the other rigmarole.

if (ManagedType.GetManagedObject(inst) is CLRObject co)

{

target = co.inst;

}

else

{

Exceptions.SetError(Exceptions.TypeError, "Invoked a non-static method with an invalid instance");

return null;

}

}

return new Binding(mi, target, margs, outs);

}

else if (matchGenerics && isGeneric)

{

// We weren't able to find a matching method but at least one

// is a generic method and info is null. That happens when a generic

// method was not called using the [] syntax. Let's introspect the

// type of the arguments and use it to construct the correct method.

Type[]? types = Runtime.PythonArgsToTypeArray(args, true);

MethodInfo[] overloads = MatchParameters(methods, types);

if (overloads.Length != 0)

{

return Bind(inst, args, kwargDict, overloads, matchGenerics: false);

}

}

if (mismatchedMethods.Count > 0)

{

var aggregateException = GetAggregateException(mismatchedMethods);

Exceptions.SetError(aggregateException);

}

return null;

}

static AggregateException GetAggregateException(IEnumerable<MismatchedMethod> mismatchedMethods)

{

return new AggregateException(mismatchedMethods.Select(m => new ArgumentException($"{m.Exception.Message} in method {m.Method}", m.Exception)));

}

static BorrowedReference HandleParamsArray(BorrowedReference args, int arrayStart, int pyArgCount, out NewReference tempObject)

{

BorrowedReference op;

tempObject = default;

// for a params method, we may have a sequence or single/multiple items

// here we look to see if the item at the paramIndex is there or not

// and then if it is a sequence itself.

if ((pyArgCount - arrayStart) == 1)

{

// we only have one argument left, so we need to check it

// to see if it is a sequence or a single item

BorrowedReference item = Runtime.PyTuple_GetItem(args, arrayStart);

if (!Runtime.PyString_Check(item) && Runtime.PySequence_Check(item))

{

// it's a sequence (and not a string), so we use it as the op

op = item;

}

else

{

tempObject = Runtime.PyTuple_GetSlice(args, arrayStart, pyArgCount);

op = tempObject.Borrow();

}

}

else

{

tempObject = Runtime.PyTuple_GetSlice(args, arrayStart, pyArgCount);

op = tempObject.Borrow();

}

return op;

}

/// <summary>

/// Attempts to convert Python positional argument tuple and keyword argument table

/// into an array of managed objects, that can be passed to a method.

/// If unsuccessful, returns null and may set a Python error.

/// </summary>

/// <param name="pi">Information about expected parameters</param>

/// <param name="paramsArray"><c>true</c>, if the last parameter is a params array.</param>

/// <param name="args">A pointer to the Python argument tuple</param>

/// <param name="pyArgCount">Number of arguments, passed by Python</param>

/// <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="outs">Returns number of output parameters</param>

/// <returns>If successful, an array of .NET arguments that can be passed to the method. Otherwise null.</returns>

static object?[]? TryConvertArguments(ParameterInfo[] pi, bool paramsArray,

BorrowedReference args, int pyArgCount,

Dictionary<string, PyObject> kwargDict,

ArrayList? defaultArgList,

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++)

{

var parameter = pi[paramIndex];

bool hasNamedParam = parameter.Name != null && kwargDict.ContainsKey(parameter.Name);

if (paramIndex >= pyArgCount && !(hasNamedParam || (paramsArray && paramIndex == arrayStart)))

{

if (defaultArgList != null)

{

margs[paramIndex] = defaultArgList[paramIndex - pyArgCount];

}

if (parameter.ParameterType.IsByRef)

{

outs++;

}

continue;

}

BorrowedReference op;

NewReference tempObject = default;

if (hasNamedParam)

{

op = kwargDict[parameter.Name!];

}

else

{

if(arrayStart == paramIndex)

{

op = HandleParamsArray(args, arrayStart, pyArgCount, out tempObject);

}

else

{

op = Runtime.PyTuple_GetItem(args, paramIndex);

}

}

if (!TryConvertArgument(op, parameter.ParameterType, out margs[paramIndex], out bool isOut))

{

tempObject.Dispose();

return null;

}

tempObject.Dispose();

if (isOut)

{

outs++;

}

}

return margs;

}

/// <summary>

/// Try to convert a Python argument object to a managed CLR type.

/// If unsuccessful, may set a Python error.

/// </summary>

/// <param name="op">Pointer to the Python argument object.</param>

/// <param name="parameterType">That parameter's managed type.</param>

/// <param name="arg">Converted argument.</param>

/// <param name="isOut">Whether the CLR type is passed by reference.</param>

/// <returns>true on success</returns>

static bool TryConvertArgument(BorrowedReference op, Type parameterType,

out object? arg, out bool isOut)

{

arg = null;

isOut = false;

var clrtype = TryComputeClrArgumentType(parameterType, op);

if (clrtype == null)

{

return false;

}

if (!Converter.ToManaged(op, clrtype, out arg, true))

{

return false;

}

isOut = clrtype.IsByRef;

return true;

}

/// <summary>

/// Determine the managed type that a Python argument object needs to be converted into.

/// </summary>

/// <param name="parameterType">The parameter's managed type.</param>

/// <param name="argument">Pointer to the Python argument object.</param>

/// <returns>null if conversion is not possible</returns>

static Type? TryComputeClrArgumentType(Type parameterType, BorrowedReference argument)

{

// this logic below handles cases when multiple overloading methods

// are ambiguous, hence comparison between Python and CLR types

// is necessary

Type? clrtype = null;

if (clrtype != null)

{

if ((parameterType != typeof(object)) && (parameterType != clrtype))

{

BorrowedReference pytype = Converter.GetPythonTypeByAlias(parameterType);

BorrowedReference pyoptype = Runtime.PyObject_TYPE(argument);

var typematch = false;

if (pyoptype != null)

{

if (pytype != pyoptype)

{

typematch = false;

}

else

{

typematch = true;

clrtype = parameterType;

}

}

if (!typematch)

{

// this takes care of enum values

TypeCode parameterTypeCode = Type.GetTypeCode(parameterType);

TypeCode clrTypeCode = Type.GetTypeCode(clrtype);

if (parameterTypeCode == clrTypeCode)

{

typematch = true;

clrtype = parameterType;

}

else

{

Exceptions.RaiseTypeError($"Expected {parameterTypeCode}, got {clrTypeCode}");

}

}

if (!typematch)

{

return null;

}

}

else

{

clrtype = parameterType;

}

}

else

{

clrtype = parameterType;

}

return clrtype;

}

/// <summary>

/// Check whether the number of Python and .NET arguments match, and compute additional arg information.

/// </summary>

/// <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="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, PyObject> kwargDict,

out bool paramsArray,

out ArrayList? defaultArgList,

out int kwargsMatched,

out int defaultsNeeded)

{

defaultArgList = null;

var match = false;

paramsArray = parameters.Length > 0 && Attribute.IsDefined(parameters[parameters.Length - 1], typeof(ParamArrayAttribute));

kwargsMatched = 0;

defaultsNeeded = 0;

if (positionalArgumentCount == parameters.Length && kwargDict.Count == 0)

{

match = true;

}

else if (positionalArgumentCount < parameters.Length && (!paramsArray || positionalArgumentCount == parameters.Length - 1))

{

match = true;

// every parameter past 'positionalArgumentCount' must have either

// a corresponding keyword arg or a default param, unless the method

// method accepts a params array (which cannot have a default value)

defaultArgList = new ArrayList();

for (var v = positionalArgumentCount; v < parameters.Length; v++)

{

if (kwargDict.ContainsKey(parameters[v].Name))

{

// we have a keyword argument for this parameter,

// no need to check for a default parameter, but put a null

// placeholder in defaultArgList

defaultArgList.Add(null);

kwargsMatched++;

}

else if (parameters[v].IsOptional)

{

// IsOptional will be true if the parameter has a default value,

// or if the parameter has the [Optional] attribute specified.

// The GetDefaultValue() extension method will return the value

// to be passed in as the parameter value

defaultArgList.Add(parameters[v].GetDefaultValue());

defaultsNeeded++;

}

else if (parameters[v].IsOut) {

defaultArgList.Add(null);

}

else if (!paramsArray)

{

match = false;

}

}

}

else if (positionalArgumentCount > parameters.Length && parameters.Length > 0 &&

Attribute.IsDefined(parameters[parameters.Length - 1], typeof(ParamArrayAttribute)))

{

// This is a `foo(params object[] bar)` style method

match = true;

paramsArray = true;

}

return match;

}

internal virtual NewReference Invoke(BorrowedReference inst, BorrowedReference args, BorrowedReference kw)

{

return Invoke(inst, args, kw, null, null);

}

internal virtual NewReference Invoke(BorrowedReference inst, BorrowedReference args, BorrowedReference kw, MethodBase? info)

{

return Invoke(inst, args, kw, info, null);

}

protected static void AppendArgumentTypes(StringBuilder to, BorrowedReference args)

{

Runtime.AssertNoErorSet();

nint argCount = Runtime.PyTuple_Size(args);

to.Append("(");

for (nint argIndex = 0; argIndex < argCount; argIndex++)

{

BorrowedReference arg = Runtime.PyTuple_GetItem(args, argIndex);

if (arg != null)

{

BorrowedReference type = Runtime.PyObject_TYPE(arg);

if (type != null)

{

using var description = Runtime.PyObject_Str(type);

if (description.IsNull())

{

Exceptions.Clear();

to.Append(Util.BadStr);

}

else

{

to.Append(Runtime.GetManagedString(description.Borrow()));

}

}

}

if (argIndex + 1 < argCount)

to.Append(", ");

}

to.Append(')');

}

internal virtual NewReference Invoke(BorrowedReference inst, BorrowedReference args, BorrowedReference kw, MethodBase? info, MethodBase[]? methodinfo)

{

// No valid methods, nothing to bind.

if (GetMethods().Length == 0)

{

var msg = new StringBuilder("The underlying C# method(s) have been deleted");

if (list.Count > 0 && list[0].Name != null)

{

msg.Append($": {list[0]}");

}

return Exceptions.RaiseTypeError(msg.ToString());

}

Binding? binding = Bind(inst, args, kw, info, methodinfo);

object result;

IntPtr ts = IntPtr.Zero;

if (binding == null)

{

var value = new StringBuilder("No method matches given arguments");

if (methodinfo != null && methodinfo.Length > 0)

{