pythonnet · amos402 · Sep 24, 2020 · Oct 22, 2020 · Oct 22, 2020 · Dec 10, 2020
diff --git a/src/embed_tests/Python.EmbeddingTest.csproj b/src/embed_tests/Python.EmbeddingTest.csproj
@@ -1,4 +1,4 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003" ToolsVersion="4.0">
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -90,6 +90,7 @@
     <Compile Include="pyinitialize.cs" />
     <Compile Include="pyrunstring.cs" />
     <Compile Include="References.cs" />
+    <Compile Include="TestClass.cs" />
     <Compile Include="TestConverter.cs" />
     <Compile Include="TestCustomMarshal.cs" />
     <Compile Include="TestDomainReload.cs" />

diff --git a/src/embed_tests/TestClass.cs b/src/embed_tests/TestClass.cs
@@ -0,0 +1,82 @@
+using System;
+using System.Runtime.InteropServices;
+
+using NUnit.Framework;
+
+using Python.Runtime;
+
+using PyRuntime = Python.Runtime.Runtime;
+
+namespace Python.EmbeddingTest
+{
+    public class TestClass
+    {
+        public class MyClass
+        {
+        }
+
+        [OneTimeSetUp]
+        public void SetUp()
+        {
+            PythonEngine.Initialize();
+        }
+
+        [OneTimeTearDown]
+        public void Dispose()
+        {
+            PythonEngine.Shutdown();
+        }
+
+        [Test]
+        public void WeakRefForClrObject()
+        {
+            var obj = new MyClass();
+            using (var scope = Py.CreateScope())
+            {
+                scope.Set("clr_obj", obj);
+                scope.Exec(@"
+import weakref
+ref = weakref.ref(clr_obj)
+");
+                using (PyObject pyobj = scope.Get("clr_obj"))
+                {
+                    ValidateAttachedGCHandle(obj, pyobj.Handle);
+                }
+            }
+        }
+
+        [Test]
+        public void WeakRefForSubClass()
+        {
+            using (var scope = Py.CreateScope())
+            {
+                scope.Exec(@"
+from Python.EmbeddingTest import TestClass
+import weakref
+
+class Sub(TestClass.MyClass):
+    pass
+
+obj = Sub()
+ref = weakref.ref(obj)
+");
+                using (PyObject pyobj = scope.Get("obj"))
+                {
+                    IntPtr op = pyobj.Handle;
+                    IntPtr type = PyRuntime.PyObject_TYPE(op);
+                    IntPtr clrHandle = Marshal.ReadIntPtr(op, ObjectOffset.magic(type));
+                    var clobj = (CLRObject)GCHandle.FromIntPtr(clrHandle).Target;
+                    Assert.IsTrue(clobj.inst is MyClass);
+                }
+            }
+        }
+
+        private static void ValidateAttachedGCHandle(object obj, IntPtr op)
+        {
+            IntPtr type = PyRuntime.PyObject_TYPE(op);
+            IntPtr clrHandle = Mars
8000
hal.ReadIntPtr(op, ObjectOffset.magic(type));
+            var clobj = (CLRObject)GCHandle.FromIntPtr(clrHandle).Target;
+            Assert.True(ReferenceEquals(clobj.inst, obj));
+        }
+    }
+}
diff --git a/src/runtime/classbase.cs b/src/runtime/classbase.cs
@@ -1,9 +1,7 @@
 using System;
 using System.Collections;
 using System.Collections.Generic;
-using System.Diagnostics;
 using System.Runtime.InteropServices;
-using System.Runtime.Serialization;
 
 namespace Python.Runtime
 {
@@ -303,44 +301,40 @@ public static IntPtr tp_repr(IntPtr ob)
         public static void tp_dealloc(IntPtr ob)
         {
             ManagedType self = GetManagedObject(ob);
+            if (Runtime.PyType_SUPPORTS_WEAKREFS(Runtime.PyObject_TYPE(ob)))
+            {
+                Runtime.PyObject_ClearWeakRefs(ob);
+            }
             tp_clear(ob);
-            Runtime.PyObject_GC_UnTrack(self.pyHandle);
-            Runtime.PyObject_GC_Del(self.pyHandle);
+            Runtime.PyObject_GC_UnTrack(ob);
+            Runtime.PyObject_GC_Del(ob);
             self.FreeGCHandle();
         }
 
         public static int tp_clear(IntPtr ob)
         {
             ManagedType self = GetManagedObject(ob);
-            if (!self.IsTypeObject())
-            {
-                ClearObjectDict(ob);
-            }
-            self.tpHandle = IntPtr.Zero;
+            ClearObjectDict(ob);
+            Runtime.Py_CLEAR(ref self.tpHandle);
             return 0;
         }
 
         protected override void OnSave(InterDomainContext context)
         {
             base.OnSave(context);
-            if (pyHandle != tpHandle)
-            {
-                IntPtr dict = GetObjectDict(pyHandle);
-                Runtime.XIncref(dict);
-                context.Storage.AddValue("dict", dict);
-            }
+            IntPtr dict = GetObjectDict(pyHandle);
+            Runtime.XIncref(dict);
+            Runtime.XIncref(tpHandle);
+            context.Storage.AddValue("dict", dict);
         }
 
         protected override void OnLoad(InterDomainContext context)
         {
             base.OnLoad(context);
-            if (pyHandle != tpHandle)
-            {
-                IntPtr dict = context.Storage.GetValue<IntPtr>("dict");
-                SetObjectDict(pyHandle, dict);
-            }
+            IntPtr dict = context.Storage.GetValue<IntPtr>("dict");
+            SetObjectDict(pyHandle, dict);
             gcHandle = AllocGCHandle();
-            Marshal.WriteIntPtr(pyHandle, TypeOffset.magic(), (IntPtr)gcHandle);
+            Marshal.WriteIntPtr(pyHandle, ObjectOffset.magic(tpHandle), (IntPtr)gcHandle);
         }
 
 

diff --git a/src/runtime/classmanager.cs b/src/runtime/classmanager.cs
@@ -443,6 +443,7 @@ private static ClassInfo GetClassInfo(Type type)
                         }
                         // Note the given instance might be uninitialized
                         ob = GetClass(tp);
+                        ob.IncrRefCount();
                         ci.members[mi.Name] = ob;
                         continue;
                 }

diff --git a/src/runtime/clrobject.cs b/src/runtime/clrobject.cs
@@ -29,10 +29,6 @@ internal CLRObject(object ob, IntPtr tp)
             tpHandle = tp;
             pyHandle = py;
             inst = ob;
-
-            // Fix the BaseException args (and __cause__ in case of Python 3)
-            // slot if wrapping a CLR exception
-            Exceptions.SetArgsAndCause(py);
         }
 
         protected CLRObject()
@@ -48,7 +44,7 @@ static CLRObject GetInstance(object ob, IntPtr pyType)
         static CLRObject GetInstance(object ob)
         {
             ClassBase cc = ClassManager.GetClass(ob.GetType());
-            return GetInstance(ob, cc.tpHandle);
+            return GetInstance(ob, cc.pyHandle);
         }
 
 
@@ -62,7 +58,7 @@ internal static IntPtr GetInstHandle(object ob, IntPtr pyType)
         internal static IntPtr GetInstHandle(object ob, Type type)
         {
             ClassBase cc = ClassManager.GetClass(type);
-            CLRObject co = GetInstance(ob, cc.tpHandle);
+            CLRObject co = GetInstance(ob, cc.pyHandle);
             return co.pyHandle;
         }
 

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
@@ -82,6 +82,13 @@ internal static Exception ToException(IntPtr ob)
             }
             return Runtime.PyUnicode_FromString(message);
         }
+
+        public static int tp_init(IntPtr ob, IntPtr args, IntPtr kwds)
+        {
+            Exceptions.SetArgsAndCause(ob);
+            return 0;
+        }
+
     }
 
     /// <summary>
@@ -177,15 +184,23 @@ internal static void SetArgsAndCause(IntPtr ob)
                 args = Runtime.PyTuple_New(0);
             }
 
-            Marshal.WriteIntPtr(ob, ExceptionOffset.args, args);
-
+            int baseOffset = OriginalObjectOffsets.Size;
+            Runtime.Py_SETREF(ob, baseOffset + ExceptionOffset.args, args);
+
             if (e.InnerException != null)
             {
-                IntPtr cause = CLRObject.GetInstHandle(e.InnerException);
-                Marshal.WriteIntPtr(ob, ExceptionOffset.cause, cause);
+                IntPtr cause = GetExceptHandle(e.InnerException);
+                Runtime.Py_SETREF(ob, baseOffset + ExceptionOffset.cause, cause);
             }
         }
 
+        internal static IntPtr GetExceptHandle(Exception e)
+        {
+            IntPtr op = CLRObject.GetInstHandle(e);
+            SetArgsAndCause(op);
+            return op;
+        }
+
         /// <summary>
         /// Shortcut for (pointer == NULL) -&gt; throw PythonException
         /// </summary>
@@ -283,7 +298,7 @@ public static void SetError(Exception e)
                 return;
             }
 
-            IntPtr op = CLRObject.GetInstHandle(e);
+            IntPtr op = GetExceptHandle(e);
             IntPtr etype = Runtime.PyObject_GetAttrString(op, "__class__");
             Runtime.PyErr_SetObject(new BorrowedReference(etype), new BorrowedReference(op));
             Runtime.XDecref(etype);