Move __init__ call in ClassDerived to tp_init.

filmor · filmor · commit 5cf42daa7f6b · 2017-06-19T12:46:24.000+02:00
diff --git a/src/runtime/classderived.cs b/src/runtime/classderived.cs
@@ -1,4 +1,4 @@
-using System;
+﻿using System;
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
@@ -55,6 +55,33 @@ internal ClassDerivedObject(Type tp) : base(tp)
             return Converter.ToPython(obj, cls.GetType());
         }
 
+        public new static int tp_init(IntPtr obj, IntPtr args, IntPtr kw)
+        {
+            Runtime.XIncref(obj);
+            Runtime.XIncref(Runtime.PyNone);
+            using (var pyself = new PyObject(obj))
+            using (var pynone = new PyObject(Runtime.PyNone))
+            using (var init = pyself.GetAttr("__init__", pynone))
+            {
+                if (init.Handle != Runtime.PyNone)
+                {
+                    // if __init__ hasn't been overridden then it will be a managed object
+                    if (GetManagedObject(init.Handle) == null)
+                    {
+                        Runtime.XIncref(args);
+                        Runtime.XIncref(kw);
+                        using (var args_ = new PyTuple(args))
+                        using (var kw_ = new PyDict(kw))
+                        using (var res = init.Invoke(args_, kw_))
+                        {
+                        }
+                    }
+                }
+            }
+
+            return 0;
+        }
+
         public new static void tp_dealloc(IntPtr ob)
         {
             var self = (CLRObject)GetManagedObject(ob);
@@ -801,6 +828,8 @@ public static void InvokeSetProperty<T>(IPythonDerivedType obj, string propertyN
 
         public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, object[] args)
         {
+            Console.Error.WriteLine($"{origCtorName}: {string.Join(", ", args)}");
+
             // call the base constructor
             obj.GetType().InvokeMember(origCtorName,
                 BindingFlags.InvokeMethod,
@@ -822,33 +851,7 @@ public static void InvokeCtor(IPythonDerivedType obj, string origCtorName, objec
                 FieldInfo fi = obj.GetType().GetField("__pyobj__");
                 fi.SetValue(obj, self);
 
-                Runtime.XIncref(self.pyHandle);
-                var pyself = new PyObject(self.pyHandle);
-                disposeList.Add(pyself);
-
-                Runtime.XIncref(Runtime.PyNone);
-                var pynone = new PyObject(Runtime.PyNone);
-                disposeList.Add(pynone);
 
-                // call __init__
-                PyObject init = pyself.GetAttr("__init__", pynone);
-                disposeList.Add(init);
-                if (init.Handle != Runtime.PyNone)
-                {
-                    // if __init__ hasn't been overridden then it will be a managed object
-                    ManagedType managedMethod = ManagedType.GetManagedObject(init.Handle);
-                    if (null == managedMethod)
-                    {
-                        var pyargs = new PyObject[args.Length];
-                        for (var i = 0; i < args.Length; ++i)
-                        {
-                            pyargs[i] = new PyObject(Converter.ToPython(args[i], args[i]?.GetType()));
-                            disposeList.Add(pyargs[i]);
-                        }
-
-                        disposeList.Add(init.Invoke(pyargs));
-                    }
-                }
             }
             finally
             {
diff --git a/src/runtime/metatype.cs b/src/runtime/metatype.cs
@@ -125,6 +125,57 @@ public static IntPtr tp_new(IntPtr tp, IntPtr args, IntPtr kw)
         }
 
 
+        /// <summary>
+        /// Metatype __call__ implementation. This is needed to ensure correct
+        /// initialization (__init__ support), because the tp_call we inherit
+        /// from PyType_Type won't call __init__ for metatypes it doesn't know.
+        /// </summary>
+        public static IntPtr tp_call(IntPtr tp, IntPtr args, IntPtr kw)
+        {
+            IntPtr func = Marshal.ReadIntPtr(tp, TypeOffset.tp_new);
+            if (func == IntPtr.Zero)
+            {
+                return Exceptions.RaiseTypeError("invalid object");
+            }
+
+            IntPtr obj = NativeCall.Call_3(func, tp, args, kw);
+            if (obj == IntPtr.Zero)
+            {
+                return IntPtr.Zero;
+            }
+
+            IntPtr py__init__ = Runtime.PyString_FromString("__init__");
+            IntPtr type = Runtime.PyObject_TYPE(obj);
+            IntPtr init = Runtime._PyType_Lookup(type, py__init__);
+            Runtime.XDecref(py__init__);
+            Runtime.PyErr_Clear();
+
+            if (init != IntPtr.Zero)
+            {
+                IntPtr bound = Runtime.GetBoundArgTuple(obj, args);
+                if (bound == IntPtr.Zero)
+                {
+                    Runtime.XDecref(obj);
+                    return IntPtr.Zero;
+                }
+
+                IntPtr result = Runtime.PyObject_Call(init, bound, kw);
+                Runtime.XDecref(bound);
+
+                if (result == IntPtr.Zero)
+                {
+                    Runtime.XDecref(obj);
+                    return IntPtr.Zero;
+                }
+
+                Runtime.XDecref(result);
+            }
+
+            return obj;
+        }
+
+
+
         public static IntPtr tp_alloc(IntPtr mt, int n)
         {
             IntPtr type = Runtime.PyType_GenericAlloc(mt, n);
