reworked PythonException to simplify memory management, and enable .N…

…ET interop New method ThrowLastAsClrException should be used everywhere instead of obsolete PythonException constructor. It automatically restores .NET exceptions, and applies codecs for Python exceptions. Traceback, PyVal and PyType are now stored and returned as PyObjects. PythonException now has InnerException set from its cause (e.g. __cause__ in Python, if any). PythonException.Restore no longer clears the exception instance. All helper methods were removed from public API surface.
pythonnet · lostmsu · Jun 1, 2021 · May 5, 2020 · Feb 25, 2020 · May 5, 2020
commit 663df73b856b312460fc316ac121e0692dd87141
diff --git a/src/runtime/BorrowedReference.cs b/src/runtime/BorrowedReference.cs
@@ -14,6 +14,8 @@ readonly ref struct BorrowedReference
         public IntPtr DangerousGetAddress()
             => this.IsNull ? throw new NullReferenceException() : this.pointer;
 
+        public static BorrowedReference Null => new BorrowedReference();
+
         /// <summary>
         /// Creates new instance of <see cref="BorrowedReference"/> from raw pointer. Unsafe.
         /// </summary>

diff --git a/src/runtime/NewReference.cs b/src/runtime/NewReference.cs
@@ -28,6 +28,11 @@ public PyObject MoveToPyObject()
             return result;
         }
         /// <summary>
+        /// Returns <see cref="PyObject"/> wrapper around this reference, which now owns
+        /// the pointer. Sets the original reference to <c>null</c>, as it no longer owns it.
+        /// </summary>
+        public PyObject MoveToPyObjectOrNull() => this.IsNull() ? null : this.MoveToPyObject();
+        /// <summary>
         /// Removes this reference to a Python object, and sets it to <c>null</c>.
         /// </summary>
         public void Dispose()

diff --git a/src/runtime/converterextensions.cs b/src/runtime/converterextensions.cs
@@ -110,6 +110,8 @@ static IPyObjectEncoder[] GetEncoders(Type type)
         #region Decoding
         static readonly ConcurrentDictionary<TypePair, Converter.TryConvertFromPythonDelegate>
             pythonToClr = new ConcurrentDictionary<TypePair, Converter.TryConvertFromPythonDelegate>();
+        internal static bool TryDecode(BorrowedReference value, BorrowedReference type, Type targetType, out object result)
+            => TryDecode(value.DangerousGetAddress(), type.DangerousGetAddress(), targetType, out result);
         internal static bool TryDecode(IntPtr pyHandle, IntPtr pyType, Type targetType, out object result)
         {
             if (pyHandle == IntPtr.Zero) throw new ArgumentNullException(nameof(pyHandle));

diff --git a/src/runtime/exceptions.cs b/src/runtime/exceptions.cs
@@ -279,10 +279,7 @@ public static void SetError(Exception e)
             var pe = e as PythonException;
             if (pe != null)
             {
-                Runtime.XIncref(pe.PyType);
-                Runtime.XIncref(pe.PyValue);
-                Runtime.XIncref(pe.PyTB);
-                Runtime.PyErr_Restore(pe.PyType, pe.PyValue, pe.PyTB);
+                pe.Restore();
                 return;
             }
 

diff --git a/src/runtime/managedtype.cs b/src/runtime/managedtype.cs
@@ -15,6 +15,12 @@ internal abstract class ManagedType
         internal IntPtr tpHandle; // PyType *
 
 
+        /// <summary>
+        /// Given a Python object, return the associated managed object or null.
+        /// </summary>
+        internal static ManagedType GetManagedObject(BorrowedReference ob)
+            => GetManagedObject(ob.DangerousGetAddress());
+
         /// <summary>
         /// Given a Python object, return the associated managed object or null.
         /// </summary>

diff --git a/src/runtime/pyobject.cs b/src/runtime/pyobject.cs
@@ -31,7 +31,10 @@ public class PyObject : DynamicObject, IEnumerable, IPyDisposable
 
         protected internal IntPtr obj = IntPtr.Zero;
 
-        internal BorrowedReference Reference => new BorrowedReference(obj);
+        public static PyObject None => new PyObject(new BorrowedReference(Runtime.PyNone));
+        internal BorrowedReference Reference => new BorrowedReference(this.obj);
+        internal NewReference MakeNewReference()
+            => NewReference.DangerousFromPointer(Runtime.SelfIncRef(this.obj));
 
         /// <summary>
         /// PyObject Constructor
@@ -125,6 +128,13 @@ public static PyObject FromManagedObject(object ob)
             return new PyObject(op);
         }
 
+        /// <summary>
+        /// Creates new <see cref="PyObject"/> from a nullable reference.
+        /// When <paramref name="reference"/> is <c>null</c>, <c>null</c> is returned.
+        /// </summary>
+        internal static PyObject FromNullableReference(BorrowedReference reference)
+            => reference.IsNull ? null : new PyObject(reference);
+
 
         /// <summary>
         /// AsManagedObject Method
@@ -226,6 +236,9 @@ public IntPtr[] GetTrackedHandles()
             return new IntPtr[] { obj };
         }
 
+        internal BorrowedReference GetPythonTypeReference()
+            => new BorrowedReference(Runtime.PyObject_TYPE(obj));
+
         /// <summary>
         /// GetPythonType Method
         /// </summary>

diff --git a/src/runtime/pythonengine.cs b/src/runtime/pythonengine.cs
@@ -755,9 +755,9 @@ public static void With(PyObject obj, Action<dynamic> Body)
             // Behavior described here: 
             // https://docs.python.org/2/reference/datamodel.html#with-statement-context-managers
 
-            IntPtr type = Runtime.PyNone;
-            IntPtr val = Runtime.PyNone;
-            IntPtr traceBack = Runtime.PyNone;
+            PyObject type = PyObject.None;
+            PyObject val = PyObject.None;
+            PyObject traceBack = PyObject.None;
             PythonException ex = null;
 
             try
@@ -769,15 +769,12 @@ public static void With(PyObject obj, Action<dynamic> Body)
             catch (PythonException e)
             {
                 ex = e;
-                type = ex.PyType.Coalesce(type);
-                val = ex.PyValue.Coalesce(val);
-                traceBack = ex.PyTB.Coalesce(traceBack);
+                type = ex.PyType ?? type;
+                val = ex.PyValue ?? val;
+                traceBack = ex.PyTB ?? traceBack;
             }
 
-            Runtime.XIncref(type);
-            Runtime.XIncref(val);
-            Runtime.XIncref(traceBack);
-            var exitResult = obj.InvokeMethod("__exit__", new PyObject(type), new PyObject(val), new PyObject(traceBack));
+            var exitResult = obj.InvokeMethod("__exit__", type, val, traceBack);
 
             if (ex != null && !exitResult.IsTrue()) throw ex;
         }