GeezerVison

- Ability to instantiate new .NET arrays using `Array[T](dim1, dim2, ...)` syntax

- Python operator method will call C# operator method for supported binary and unary operators ([#1324][p1324]).

- Add GetPythonThreadID and Interrupt methods in PythonEngine

- Ability to implement delegates with `ref` and `out` parameters in Python, by returning the modified parameter values in a tuple. ([#1355][i1355])

- Drop support for Python 2, 3.4, and 3.5

- floating point values passed from Python are no longer silently truncated

when .NET expects an integer [#1342][i1342]

- More specific error messages for method argument mismatch

- BREAKING: Methods with `ref` or `out` parameters and void return type return a tuple of only the `ref` and `out` parameters.

- Fixed issue when calling PythonException.Format where another exception would be raise for unnormalized exceptions

- Made it possible to call `ToString`, `GetHashCode`, and `GetType` on inteface objects

- Fixed objects returned by enumerating `PyObject` being disposed too soon

- Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException

- `import` may now raise errors with more detail than "No module named X"

- Incorrectly using a non-generic type with type parameters now produces a helpful Python error instead of throwing NullReferenceException ([#1325][i1325])

- `import` may now raise errors with more detail than "No module named X"

- Providing an invalid type parameter to a generic type or method produces a helpful Python error

if (mt != null)

{

if (mt is CLRObject)

if (mt is CLRObject co)

{

object tmp = ((CLRObject)mt).inst;

object tmp = co.inst;

if (obType.IsInstanceOfType(tmp))

{

result = tmp;

return true;

}

if (setError)

{

Exceptions.SetError(Exceptions.TypeError, $"value cannot be converted to {obType}");

string typeString = tmp is null ? "null" : tmp.GetType().ToString();

Exceptions.SetError(Exceptions.TypeError, $"{typeString} value cannot be converted to {obType}");

}

return false;

}

if (mt is ClassBase)

if (mt is ClassBase cb)

{

var cb = (ClassBase)mt;

if (!cb.type.Valid)

{

Exceptions.SetError(Exceptions.TypeError, cb.type.DeletedMessage);

using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using System.Reflection.Emit;

using System.Text;

namespace Python.Runtime

/// </summary>

internal class DelegateManager

{

private Hashtable cache;

private Type basetype;

private Type listtype;

private Type voidtype;

private Type typetype;

private Type ptrtype;

private CodeGenerator codeGenerator;

private readonly Dictionary<Type,Type> cache = new Dictionary<Type, Type>();

private readonly Type basetype = typeof(Dispatcher);

private readonly Type arrayType = typeof(object[]);

private readonly Type voidtype = typeof(void);

private readonly Type typetype = typeof(Type);

private readonly Type ptrtype = typeof(IntPtr);

private readonly CodeGenerator codeGenerator = new CodeGenerator();

private readonly ConstructorInfo arrayCtor;

private readonly MethodInfo dispatch;

public DelegateManager()

{

basetype = typeof(Dispatcher);

listtype = typeof(ArrayList);

voidtype = typeof(void);

typetype = typeof(Type);

ptrtype = typeof(IntPtr);

cache = new Hashtable();

codeGenerator = new CodeGenerator();

arrayCtor = arrayType.GetConstructor(new[] { typeof(int) });

dispatch = basetype.GetMethod("Dispatch");

}

/// <summary>

// unique signatures rather than delegate types, since multiple

// delegate types with the same sig could use the same dispatcher.

object item = cache[dtype];

if (item != null)

if (cache.TryGetValue(dtype, out Type item))

{

return (Type)item;

return item;

}

string name = $"__{dtype.FullName}Dispatcher";

MethodBuilder mb = tb.DefineMethod("Invoke", MethodAttributes.Public, method.ReturnType, signature);

ConstructorInfo ctor = listtype.GetConstructor(Type.EmptyTypes);

MethodInfo dispatch = basetype.GetMethod("Dispatch");

MethodInfo add = listtype.GetMethod("Add");

il = mb.GetILGenerator();

il.DeclareLocal(listtype);

il.Emit(OpCodes.Newobj, ctor);

// loc_0 = new object[pi.Length]

il.DeclareLocal(arrayType);

il.Emit(OpCodes.Ldc_I4, pi.Length);

il.Emit(OpCodes.Newobj, arrayCtor);

il.Emit(OpCodes.Stloc_0);

bool anyByRef = false;

for (var c = 0; c < signature.Length; c++)

{

Type t = signature[c];

il.Emit(OpCodes.Ldloc_0);

il.Emit(OpCodes.Ldc_I4, c);

il.Emit(OpCodes.Ldarg_S, (byte)(c + 1));

if (t.IsByRef)

{

// The argument is a pointer. We must dereference the pointer to get the value or object it points to.

t = t.GetElementType();

if (t.IsValueType)

{

il.Emit(OpCodes.Ldobj, t);

}

else

{

il.Emit(OpCodes.Ldind_Ref);

}

anyByRef = true;

}

if (t.IsValueType)

{

il.Emit(OpCodes.Box, t);

}

il.Emit(OpCodes.Callvirt, add);

il.Emit(OpCodes.Pop);

// args[c] = arg

il.Emit(OpCodes.Stelem_Ref);

}

il.Emit(OpCodes.Ldarg_0);

il.Emit(OpCodes.Ldloc_0);

il.Emit(OpCodes.Call, dispatch);

if (anyByRef)

{

// Dispatch() will have modified elements of the args list that correspond to out parameters.

for (var c = 0; c < signature.Length; c++)

{

Type t = signature[c];

if (t.IsByRef)

{

t = t.GetElementType();

// *arg = args[c]

il.Emit(OpCodes.Ldarg_S, (byte)(c + 1));

il.Emit(OpCodes.Ldloc_0);

il.Emit(OpCodes.Ldc_I4, c);

il.Emit(OpCodes.Ldelem_Ref);

if (t.IsValueType)

{

il.Emit(OpCodes.Unbox_Any, t);

il.Emit(OpCodes.Stobj, t);

}

else

{

il.Emit(OpCodes.Stind_Ref);

}

}

}

}

if (method.ReturnType == voidtype)

{

il.Emit(OpCodes.Pop);

GC.SuppressFinalize(this);

}

public object Dispatch(ArrayList args)

public object Dispatch(object[] args)

{

IntPtr gs = PythonEngine.AcquireLock();

object ob;

return ob;

}

public object TrueDispatch(ArrayList args)

private object TrueDispatch(object[] args)

{

MethodInfo method = dtype.GetMethod("Invoke");

ParameterInfo[] pi = method.GetParameters();

throw e;

}

if (rtype == typeof(void))

try

{

return null;

}

int byRefCount = pi.Count(parameterInfo => parameterInfo.ParameterType.IsByRef);

if (byRefCount > 0)

{

// By symmetry with MethodBinder.Invoke, when there are out

// parameters we expect to receive a tuple containing

// the result, if any, followed by the out parameters. If there is only

// one out parameter and the return type of the method is void,

// we instead receive the out parameter as the result from Python.

bool isVoid = rtype == typeof(void);

int tupleSize = byRefCount + (isVoid ? 0 : 1);

if (isVoid && byRefCount == 1)

{

// The return type is void and there is a single out parameter.

for (int i = 0; i < pi.Length; i++)

{

Type t = pi[i].ParameterType;

if (t.IsByRef)

{

if (!Converter.ToManaged(op, t, out object newArg, true))

{

Exceptions.RaiseTypeError($"The Python function did not return {t.GetElementType()} (the out parameter type)");

throw new PythonException();

}

args[i] = newArg;

break;

}

}

return null;

}

else if (Runtime.PyTuple_Check(op) && Runtime.PyTuple_Size(op) == tupleSize)

{

int index = isVoid ? 0 : 1;

for (int i = 0; i < pi.Length; i++)

{

Type t = pi[i].ParameterType;

if (t.IsByRef)

{

IntPtr item = Runtime.PyTuple_GetItem(op, index++);

if (!Converter.ToManaged(item, t, out object newArg, true))

{

Exceptions.RaiseTypeError($"The Python function returned a tuple where element {i} was not {t.GetElementType()} (the out parameter type)");

throw new PythonException();

}

args[i] = newArg;

}

}

if (isVoid)

{

return null;

}

IntPtr item0 = Runtime.PyTuple_GetItem(op, 0);

if (!Converter.ToManaged(item0, rtype, out object result0, true))

{

Exceptions.RaiseTypeError($"The Python function returned a tuple where element 0 was not {rtype} (the return type)");

throw new PythonException();

}

return result0;

}

else

{

string tpName = Runtime.PyObject_GetTypeName(op);

if (Runtime.PyTuple_Check(op))

{

tpName += $" of size {Runtime.PyTuple_Size(op)}";

}

StringBuilder sb = new StringBuilder();

if (!isVoid) sb.Append(rtype.FullName);

for (int i = 0; i < pi.Length; i++)

{

Type t = pi[i].ParameterType;

if (t.IsByRef)

{

if (sb.Length > 0) sb.Append(",");

sb.Append(t.GetElementType().FullName);

}

}

string returnValueString = isVoid ? "" : "the return value and ";

Exceptions.RaiseTypeError($"Expected a tuple ({sb}) of {returnValueString}the values for out and ref parameters, got {tpName}.");

throw new PythonException();

}

}

if (rtype == typeof(void))

{

return null;

}

object result;

if (!Converter.ToManaged(op, rtype, out result, true))

object result;

if (!Converter.ToManaged(op, rtype, out result, true))

{

throw new PythonException();

}

return result;

}

finally

{

Runtime.XDecref(op);

throw new PythonException();

}

Runtime.XDecref(op);

return result;

}

}

}

// If there are out parameters, we return a tuple containing

// the result followed by the out parameters. If there is only

// the result, if any, followed by the out parameters. If there is only

// one out parameter and the return type of the method is void,

// we return the out parameter as the result to Python (for

// code compatibility with ironpython).

var mi = (MethodInfo)binding.info;

if (binding.outs == 1 && mi.ReturnType == typeof(void))

{

}

if (binding.outs > 0)

{

ParameterInfo[] pi = mi.GetParameters();

int c = pi.Length;

var n = 0;

IntPtr t = Runtime.PyTuple_New(binding.outs + 1);

IntPtr v = Converter.ToPython(result, mi.ReturnType);

Runtime.PyTuple_SetItem(t, n, v);

n++;

bool isVoid = mi.ReturnType == typeof(void);

int tupleSize = binding.outs + (isVoid ? 0 : 1);

IntPtr t = Runtime.PyTuple_New(tupleSize);

if (!isVoid)

{

IntPtr v = Converter.ToPython(result, mi.ReturnType);

Runtime.PyTuple_SetItem(t, n, v);

n++;

}

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

{

Type pt = pi[i].ParameterType;

if (pi[i].IsOut || pt.IsByRef)

if (pt.IsByRef)

{

v = Converter.ToPython(binding.args[i], pt.GetElementType());

IntPtr v = Converter.ToPython(binding.args[i], pt.GetElementType());

Runtime.PyTuple_SetItem(t, n, v);

n++;

}

}

if (binding.outs == 1 && mi.ReturnType == typeof(void))

{

v = Runtime.PyTuple_GetItem(t, 1);

IntPtr v = Runtime.PyTuple_GetItem(t, 0);

Runtime.XIncref(v);

Runtime.XDecref(t);

return v;