- BREAKING: when inheriting from .NET types in Python if you override `__init__` you

must explicitly call base constructor using `super().__init__(.....)`. Not doing so will lead

to undefined behavior.

- Fixed parameterless .NET constructor being silently called when a matching constructor overload is not found ([#238][i238])

[i238]: https://github.com/pythonnet/pythonnet/issues/238

[Test]

public void ConstrctorRoundtrip()

{

var ctor = typeof(MethodTestHost).GetConstructor(new[] { typeof(int) });

var maybeConstructor = new MaybeMethodBase<MethodBase>(ctor);

var restored = SerializationRoundtrip(maybeConstructor);

Assert.IsTrue(restored.Valid);

Assert.AreEqual(ctor, restored.Value);

}

public MethodTestHost(int _) { }

/// <summary>

/// Creates new instance of <see cref="NewReference"/> which now owns the pointer.

/// Sets the original reference to <c>null</c>, as it no longer owns the pointer.

/// </summary>

public NewReference Move()

{

var result = new NewReference(this);

this.pointer = default;

return result;

}

public virtual bool HasCustomNew() => this.GetType().GetMethod("tp_new") is not null;

public override bool Init(BorrowedReference obj, BorrowedReference args, BorrowedReference kw)

{

if (this.HasCustomNew())

// initialization must be done in tp_new

return true;

return base.Init(obj, args, kw);

}

protected override NewReference NewObjectToPython(object obj, BorrowedReference tp)

var self = base.NewObjectToPython(obj, tp);

SetPyObj((IPythonDerivedType)obj, self.Borrow());

// Decrement the python object's reference count.

// This doesn't actually destroy the object, it just sets the reference to this object

// to be a weak reference and it will be destroyed when the C# object is destroyed.

if (!self.IsNull())

Runtime.XDecref(self.Steal());

return Converter.ToPython(obj, type.Value);

}

protected override void SetTypeNewSlot(BorrowedReference pyType, SlotsHolder slotsHolder)

{

// Python derived types rely on base tp_new and overridden __init__

var selfRef = GetPyObj(obj);

if (selfRef.Ref == null)

{

// this might happen when the object is created from .NET

using var _ = Py.GIL();

// In the end we decrement the python object's reference count.

// This doesn't actually destroy the object, it just sets the reference to this object

// to be a weak reference and it will be destroyed when the C# object is destroyed.

using var self = CLRObject.GetReference(obj, obj.GetType());

SetPyObj(obj, self.Borrow());

}

internal static void SetPyObj(IPythonDerivedType obj, BorrowedReference pyObj)

ClassInfo info = GetClassInfo(type, impl);

if (co.NumCtors > 0 && !co.HasCustomNew())

// HACK: __init__ points to instance constructors.

// When unbound they fully instantiate object, so we get overloads for free from MethodBinding.

var init = info.members["__init__"];

Runtime.PyDict_SetItem(dict, PyIdentifier.__overloads__, init);

Runtime.PyDict_SetItem(dict, PyIdentifier.Overloads, init);

private static ClassInfo GetClassInfo(Type type, ClassBase impl)

var methods = new Dictionary<string, List<MethodBase>>();

//TODO mangle?

if (name == "__init__" && !impl.HasCustomNew())

continue;

methodList = methods[name] = new List<MethodBase>();

case MemberTypes.Constructor when !impl.HasCustomNew():

var ctor = (ConstructorInfo)mi;

if (ctor.IsStatic)

{

continue;

}

name = "__init__";

if (!methods.TryGetValue(name, out methodList))

{

methodList = methods[name] = new List<MethodBase>();

}

methodList.Add(ctor);

continue;

using System.Diagnostics;

using System.Runtime.Serialization;

internal readonly int NumCtors = 0;

if (!type.Valid)

{

return Exceptions.RaiseTypeError(type.DeletedMessage);

}

MethodBase[] methods = type.Value.GetConstructors();

static NewReference tp_new_impl(BorrowedReference tp, BorrowedReference args, BorrowedReference kw)

if (IsGenericNullable(type))

// Nullable<T> has special handling in .NET runtime.

// Invoking its constructor via reflection on an uninitialized instance

// does not actually set the object fields.

return NewNullable(type, args, kw, tp);

object obj = FormatterServices.GetUninitializedObject(type);

return self.NewObjectToPython(obj, tp);

}

protected virtual void SetTypeNewSlot(BorrowedReference pyType, SlotsHolder slotsHolder)

{

TypeManager.InitializeSlotIfEmpty(pyType, TypeOffset.tp_new, new Interop.BBB_N(tp_new_impl), slotsHolder);

}

public override bool HasCustomNew()

{

if (base.HasCustomNew()) return true;

Type clrType = type.Value;

return clrType.IsPrimitive

|| clrType.IsEnum

|| clrType == typeof(string)

|| IsGenericNullable(clrType);

static bool IsGenericNullable(Type type)

=> type.IsValueType && type.IsGenericType

&& type.GetGenericTypeDefinition() == typeof(Nullable<>);

public override void InitializeSlots(BorrowedReference pyType, SlotsHolder slotsHolder)

{

base.InitializeSlots(pyType, slotsHolder);

this.SetTypeNewSlot(pyType, slotsHolder);

}

protected virtual NewReference NewObjectToPython(object obj, BorrowedReference tp)

=> CLRObject.GetReference(obj, tp);

private static NewReference NewNullable(Type type, BorrowedReference args, BorrowedReference kw, BorrowedReference tp)

{

Debug.Assert(IsGenericNullable(type));

if (kw != null)

{

return Exceptions.RaiseTypeError("System.Nullable<T> constructor does not support keyword arguments");

}

nint argsCount = Runtime.PyTuple_Size(args);

if (argsCount != 1)

{

return Exceptions.RaiseTypeError("System.Nullable<T> constructor expects 1 argument, got " + (int)argsCount);

}

var value = Runtime.PyTuple_GetItem(args, 0);

var elementType = type.GetGenericArguments()[0];

return Converter.ToManaged(value, elementType, out var result, setError: true)

? CLRObject.GetReference(result!, tp)

: default;

}