Fix off-GIL AttributeError-hint callback: use a native __getattr__ thunk

The __getattr__ hook restored from #124 exposed the hint builder to
Python as a .NET delegate (Func<PyObject, string, string>). Python
invoked it through DelegateObject.tp_call -> MethodBinder.Invoke, and
MethodBinder releases the GIL around every reflected invocation
(allow_threads defaults to true). The callback therefore ran CPython
C-API calls (GetPythonType, GetManagedString, ...) without holding the
GIL on every attribute miss (hasattr, getattr with default, typos). It
usually survived by luck, but segfaulted whenever the pythonnet
Finalizer fired mid-callback: Finalizer.DisposeAll() starts with
PyErr_Fetch, which dereferences the current thread state - NULL when
the GIL is not held. This is what crashed Lean's CI test host on
2.0.55 after all 35k tests passed.

Replace the Python-function-plus-delegate pair with a native method
descriptor: a PyMethodDef (METH_VARARGS) around a managed thunk,
turned into __getattr__ via PyDescr_NewMethod (newly bound). CPython's
slot_tp_getattr_hook now calls the managed hook directly as a native
method call with the GIL held - MethodBinder is never involved. The
PyMethodDef and thunk are allocated once and kept for the process
lifetime, since descriptors reference them and can outlive engine
shutdown bookkeeping.

Verified with an instrumented build (PyGILState_Check inside
BuildMissingAttributeMessage): the delegate-based hook reports
"GIL held: False" on every miss; this version reports "GIL held: True".
Also survives a 20s stress run of concurrent attribute misses plus
finalizer churn across 6 threads, and behaves identically for hasattr/
getattr-with-default, dunder probes, Python subclasses with their own
__getattr__, and suggestion messages.

Add a regression test asserting the installed __getattr__ is a native
method_descriptor, which is the property that keeps the callback out of
MethodBinder's allow-threads path.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: jhonabreul

src/runtime/AttributeErrorHint.cs

@@ -1,4 +1,6 @@
 using System;
+using System.Reflection;
+using System.Runtime.InteropServices;
 
 using Python.Runtime.Native;
 
@@ -17,44 +19,55 @@ namespace Python.Runtime
     /// pythonnet's metatype does not run CPython's slot-fixup machinery when an attribute
     /// is set on a type, so simply adding <c>__getattr__</c> to the type dict would not
     /// rewire the slot — we therefore wire <c>tp_getattro</c> to the hook manually.
+    ///
+    /// The <c>__getattr__</c> itself is a native method descriptor (PyDescr_NewMethod)
+    /// around a managed thunk, NOT a .NET delegate exposed to Python: delegate calls go
+    /// through <see cref="MethodBinder"/>, which releases the GIL around the invocation
+    /// (allow_threads), so the callback would run CPython C-API calls off-GIL and crash
+    /// whenever the <see cref="Finalizer"/> fires mid-callback. The native thunk is
+    /// called directly by the interpreter with the GIL held.
     /// </remarks>
     internal static class AttributeErrorHint
     {
-        // The shared __getattr__ function object installed on every eligible type.
-        private static PyObject? _getAttr;
-        // The managed message builder exposed to Python, kept alive for _getAttr's globals.
-        private static PyObject? _messageBuilder;
+        // Unmanaged PyMethodDef backing the shared __getattr__ method descriptors.
+        // Descriptors keep a raw pointer to it (d_method) and can outlive engine
+        // shutdown bookkeeping, so it is allocated once and kept for the process
+        // lifetime (as are the thunks in Interop.allocatedThunks).
+        private static IntPtr _methodDef;
+        // Keeps the thunk delegate for GetAttrHook alive.
+        private static ThunkInfo? _thunk;
         // Address of CPython's slot_tp_getattr_hook (extracted from a probe type).
         private static IntPtr _hookSlot;
         // Address of PyObject_GenericGetAttr, used to detect types we may safely redirect.
         private static IntPtr _genericGetAttr;
 
-        private static bool IsReady => _getAttr is not null && _hookSlot != IntPtr.Zero;
+        private static bool IsReady => _methodDef != IntPtr.Zero && _hookSlot != IntPtr.Zero;
 
         internal static void Initialize()
         {
             try
             {
                 _genericGetAttr = Util.ReadIntPtr(Runtime.PyBaseObjectType, TypeOffset.tp_getattro);
 
-                Func<PyObject, string, string> builder = ClassBase.BuildMissingAttributeMessage;
-                _messageBuilder = builder.ToPython();
+                if (_methodDef == IntPtr.Zero)
+                {
+                    _thunk = Interop.GetThunk(typeof(AttributeErrorHint).GetMethod(
+                        nameof(GetAttrHook), BindingFlags.Static | BindingFlags.Public)!);
+                    IntPtr methodDef = Marshal.AllocHGlobal(4 * IntPtr.Size);
+                    TypeManager.WriteMethodDef(methodDef, "__getattr__", _thunk.Address);
+                    _methodDef = methodDef;
+                }
 
+                // Define a probe class whose tp_getattro is slot_tp_getattr_hook so we
+                // can read that function pointer.
                 using var globals = new PyDict();
                 Runtime.PyDict_SetItemString(globals.Reference, "__builtins__", Runtime.PyEval_GetBuiltins());
-                globals["__clr_attr_msg__"] = _messageBuilder;
-
-                // Define the shared hook, plus a probe class whose tp_getattro is
-                // slot_tp_getattr_hook so we can read that function pointer.
                 PythonEngine.Exec(
-                    "def __clr_getattr__(self, name):\n" +
-                    "    raise AttributeError(__clr_attr_msg__(self, name))\n" +
                     "class __clr_getattr_probe__:\n" +
                     "    def __getattr__(self, name):\n" +
                     "        raise AttributeError(name)\n",
                     globals);
 
-                _getAttr = globals["__clr_getattr__"];
                 using var probe = globals["__clr_getattr_probe__"];
                 _hookSlot = Util.ReadIntPtr(probe.Reference, TypeOffset.tp_getattro);
             }
@@ -86,7 +99,15 @@ internal static void Install(BorrowedReference type)
                 return;
             }
 
-            if (Runtime.PyObject_SetAttrString(type, "__getattr__", _getAttr!.Reference) != 0)
+            using var descr = Runtime.PyDescr_NewMethod(type, _methodDef);
+            if (descr.IsNull())
+            {
+                Exceptions.Clear();
+                return;
+            }
+
+            BorrowedReference dict = Util.ReadRef(type, TypeOffset.tp_dict);
+            if (Runtime.PyDict_SetItemString(dict, "__getattr__", descr.Borrow()) != 0)
             {
                 Exceptions.Clear();
                 return;
@@ -96,12 +117,45 @@ internal static void Install(BorrowedReference type)
             Runtime.PyType_Modified(type);
         }
 
+        /// <summary>
+        /// The <c>__getattr__(self, name)</c> implementation (METH_VARARGS). CPython's
+        /// <c>slot_tp_getattr_hook</c> only calls it after the normal lookup has failed
+        /// and the original AttributeError has been cleared, so the full message is
+        /// rebuilt here. Runs as a direct native method call with the GIL held.
+        /// </summary>
+        public static NewReference GetAttrHook(BorrowedReference ob, BorrowedReference args)
+        {
+            string? name = null;
+            string message;
+            try
+            {
+                if (Runtime.PyTuple_Size(args) == 1)
+                {
+                    BorrowedReference key = Runtime.PyTuple_GetItem(args, 0);
+                    if (Runtime.PyString_Check(key))
+                    {
+                        name = Runtime.GetManagedString(key);
+                    }
+                }
+
+                using var self = new PyObject(ob);
+                message = ClassBase.BuildMissingAttributeMessage(self, name ?? "?");
+            }
+            catch
+            {
+                // Never let message building turn into a different exception.
+                message = $"object has no attribute '{name ?? "?"}'";
+            }
+
+            Exceptions.SetError(Exceptions.AttributeError, message);
+            return default;
+        }
+
         internal static void Shutdown()
         {
-            _getAttr?.Dispose();
-            _getAttr = null;
-            _messageBuilder?.Dispose();
-            _messageBuilder = null;
+            // _methodDef and _thunk are deliberately kept: method descriptors created
+            // from them may still be reachable during interpreter teardown, and both
+            // are reused by the next Initialize.
             _hookSlot = IntPtr.Zero;
             _genericGetAttr = IntPtr.Zero;
         }

src/runtime/Runtime.Delegates.cs

@@ -230,6 +230,7 @@ static Delegates()
             PyObject_GenericGetAttr = (delegate* unmanaged[Cdecl]<BorrowedReference, BorrowedReference, NewReference>)GetFunctionByName(nameof(PyObject_GenericGetAttr), GetUnmanagedDll(_PythonDll));
             PyObject_GenericGetDict = (delegate* unmanaged[Cdecl]<BorrowedReference, IntPtr, NewReference>)GetFunctionByName(nameof(PyObject_GenericGetDict), GetUnmanagedDll(PythonDLL));
             PyObject_GenericSetAttr = (delegate* unmanaged[Cdecl]<BorrowedReference, BorrowedReference, BorrowedReference, int>)GetFunctionByName(nameof(PyObject_GenericSetAttr), GetUnmanagedDll(_PythonDll));
+            PyDescr_NewMethod = (delegate* unmanaged[Cdecl]<BorrowedReference, IntPtr, NewReference>)GetFunctionByName(nameof(PyDescr_NewMethod), GetUnmanagedDll(_PythonDll));
             PyObject_GC_Del = (delegate* unmanaged[Cdecl]<StolenReference, void>)GetFunctionByName(nameof(PyObject_GC_Del), GetUnmanagedDll(_PythonDll));
             try
             {
@@ -504,6 +505,7 @@ static Delegates()
         internal static delegate* unmanaged[Cdecl]<BorrowedReference, BorrowedReference, BorrowedReference> _PyType_Lookup { get; }
         internal static delegate* unmanaged[Cdecl]<BorrowedReference, BorrowedReference, NewReference> PyObject_GenericGetAttr { get; }
         internal static delegate* unmanaged[Cdecl]<BorrowedReference, BorrowedReference, BorrowedReference, int> PyObject_GenericSetAttr { get; }
+        internal static delegate* unmanaged[Cdecl]<BorrowedReference, IntPtr, NewReference> PyDescr_NewMethod { get; }
         internal static delegate* unmanaged[Cdecl]<StolenReference, void> PyObject_GC_Del { get; }
         internal static delegate* unmanaged[Cdecl]<BorrowedReference, int> PyObject_GC_IsTracked { get; }
         internal static delegate* unmanaged[Cdecl]<BorrowedReference, void> PyObject_GC_Track { get; }

src/runtime/Runtime.cs

@@ -1738,6 +1738,13 @@ internal static bool PyType_IsSameAsOrSubtype(BorrowedReference type, BorrowedRe
 
         internal static int PyObject_GenericSetAttr(BorrowedReference obj, BorrowedReference name, BorrowedReference value) => Delegates.PyObject_GenericSetAttr(obj, name, value);
 
+
+        /// <summary>
+        /// Creates a method descriptor for <paramref name="type"/> from an unmanaged
+        /// <c>PyMethodDef*</c>, which must remain valid for the descriptor's lifetime.
+        /// </summary>
+        internal static NewReference PyDescr_NewMethod(BorrowedReference type, IntPtr methodDef) => Delegates.PyDescr_NewMethod(type, methodDef);
+
         internal static NewReference PyObject_GenericGetDict(BorrowedReference o) => PyObject_GenericGetDict(o, IntPtr.Zero);
         internal static NewReference PyObject_GenericGetDict(BorrowedReference o, IntPtr context) => Delegates.PyObject_GenericGetDict(o, context);
 

tests/test_class.py

@@ -104,6 +104,23 @@ def test_missing_attribute_hasattr_still_false():
     assert hasattr(s, "Length")
 
 
+def test_missing_attribute_hook_is_native():
+    """The __getattr__ hook must be a native method descriptor.
+
+    If it were a Python function calling into .NET through a delegate, the call
+    would go through MethodBinder, which releases the GIL around the invocation:
+    the hint-building callback would then run CPython C-API calls off-GIL and
+    crash whenever the pythonnet Finalizer fires mid-callback (the Lean CI crash
+    on 2.0.55).
+    """
+    hook = next(
+        c.__dict__["__getattr__"]
+        for c in type(System.String("x")).__mro__
+        if "__getattr__" in c.__dict__
+    )
+    assert type(hook).__name__ == "method_descriptor"
+
+
 def test_basic_subclass():
     """Test basic subclass of a managed class."""
     from System.Collections import Hashtable