⚠️ Potential issue | 🟠 Major

Require traverse when clear is enabled.
If clear is set without traverse, HAS_TRAVERSE stays false and GC traversal becomes a no-op.

 let has_traverse = class_meta.inner()._has_key("traverse")?;
 let has_clear = if class_meta.inner()._has_key("clear")? {
     // If clear attribute is present, use its value
     class_meta.inner()._bool("clear")?
 } else {
     // If clear attribute is absent, default to same as traverse
     has_traverse
 };
+if has_clear && !has_traverse {
+    bail_span!(
+        item,
+        "`clear` requires `traverse` (use `traverse` or `traverse = \"manual\"`)"
+    );
+}

In `@crates/derive-impl/src/pyclass.rs` around lines 588 - 595, The code currently
allows `clear` to be true while `traverse` is absent which leaves `HAS_TRAVERSE`
false and makes GC traversal a no-op; update the logic around `has_traverse` and
`has_clear` in the block using `class_meta.inner()._has_key` and
`class_meta.inner()._bool` to validate that if `clear` is present and true then
`traverse` must also be present (or return an error) — e.g. after computing
`has_clear` check `if has_clear && !has_traverse { return Err(...) }`
referencing the same symbols (`has_traverse`, `has_clear`,
`class_meta.inner()._has_key`, `_bool`, `HAS_TRAVERSE`) so the parser fails the
derive when `clear` is enabled without `traverse`.

⚠️ Potential issue | 🔴 Critical

🏁 Script executed:

# Search for TraverseFn definition
rg -n "type TraverseFn|struct TraverseFn|trait TraverseFn" crates/vm/src/object -A 3 -B 1

Repository: RustPython/RustPython

Length of output: 186

🏁 Script executed:

# Check current code at lines 643-644 in the file
sed -n '640,650p' crates/derive-impl/src/pyclass.rs

Repository: RustPython/RustPython

Length of output: 186

🏁 Script executed:

# Search for other uses of TraverseFn in the codebase to see patterns
rg -n "TraverseFn" crates/ --type rs | head -20

Repository: RustPython/RustPython

Length of output: 186

🌐 Web query:

RustPython TraverseFn lifetime generic type definition

💡 Result:

Definition (from rustpython-vm crate):
pub type TraverseFn<'a> = dyn FnMut(&PyObject) + 'a. [1][2]

Sources:

• rustpython-vm API docs — TraverseFn type alias. [1]
• rustpython-vm source (object/mod.rs) showing the type alias. [2]

🌐 Web query:

RustPython vm object TraverseFn signature

💡 Result:

I can look that up in the RustPython source (to give the exact current Rust signature). Do you want me to fetch the signature from the repository (GitHub/docs.rs) now?

Fix the missing lifetime on TraverseFn in generated signatures.
The TraverseFn type is defined as dyn FnMut(&PyObject) + 'a and requires a lifetime parameter. Generated code must include it for type-checking.

-            fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn) {
+            fn try_traverse(&self, tracer_fn: &mut ::rustpython_vm::object::TraverseFn<'_>) {
                 `#try_traverse_body`
             }

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

In `@crates/derive-impl/src/pyclass.rs` around lines 643 - 644, The generated
signature for try_traverse is using ::rustpython_vm::object::TraverseFn without
its required lifetime; update the generated code so all uses of TraverseFn
include the lifetime parameter (e.g. TraverseFn<'a>) and propagate that 'a into
the impl/generics for try_traverse and any surrounding impl blocks where
tracer_fn is referenced (look for the try_traverse function and references to
::rustpython_vm::object::TraverseFn and add the 'a lifetime consistently).

⚠️ Potential issue | 🟠 Major

Avoid blocking locks in traverse to prevent GC deadlocks.

PyMutex::lock() can block if the lock is held when GC runs, which can deadlock traversal. Prefer the Traverse impl for PyMutex (uses try_lock) instead of manual locking.

-        self.type_params.lock().traverse(tracer_fn);
-        self.annotations.lock().traverse(tracer_fn);
-        self.module.lock().traverse(tracer_fn);
-        self.doc.lock().traverse(tracer_fn);
+        self.type_params.traverse(tracer_fn);
+        self.annotations.traverse(tracer_fn);
+        self.module.traverse(tracer_fn);
+        self.doc.traverse(tracer_fn);

‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.

In `@crates/vm/src/builtins/function.rs` around lines 54 - 58, The traversal
currently grabs blocking locks (e.g. self.type_params.lock().traverse(...),
self.annotations.lock().traverse(...), self.module.lock().traverse(...),
self.doc.lock().traverse(...)) which can block the GC and deadlock; instead call
the Traverse implementation on the PyMutex fields directly (use the PyMutex's
non-blocking traverse method or try_lock-based impl) — replace usages of
.lock().traverse(tracer_fn) with the PyMutex/field's traverse(tracer_fn) so
traversal uses the non-blocking path for type_params, annotations, module and
doc.