crates/vm/src/builtins/type.rs (1)

612-660: Optional: factor out the duplicated __abc_tpflags__ parse/validate/apply logic.

The own-class branch (lines 615–633) and the legacy base-class branch (lines 643–659) repeat the same five steps: downcast to PyInt, convert via to_i64, build PyTypeFlags, mask with COLLECTION_FLAGS, reject the both-bits case, and OR into slots.flags. The error string is also duplicated verbatim, so any future tweak (wording, behavior on non-int, BigInt overflow handling) has to be kept in sync in two places.

A small helper would tighten this up without changing semantics:

♻️ Proposed extraction

+    /// Parse `__abc_tpflags__` (if it is an int), reject the
+    /// `SEQUENCE | MAPPING` combination, and return the masked
+    /// collection bits to be ORed into `slots.flags`. Returns
+    /// `Ok(None)` if the value is missing or not a `PyInt`.
+    fn parse_abc_tpflags(
+        value: Option<&PyObjectRef>,
+        collection_flags: PyTypeFlags,
+    ) -> Result<Option<PyTypeFlags>, String> {
+        let Some(obj) = value else { return Ok(None) };
+        let Some(int_obj) = obj.downcast_ref::<crate::builtins::int::PyInt>() else {
+            return Ok(None);
+        };
+        let flags_val = int_obj.as_bigint().to_i64().unwrap_or(0);
+        let masked = PyTypeFlags::from_bits_truncate(flags_val as u64) & collection_flags;
+        if masked == collection_flags {
+            return Err(
+                "__abc_tpflags__ cannot be both Py_TPFLAGS_SEQUENCE and Py_TPFLAGS_MAPPING"
+                    .to_owned(),
+            );
+        }
+        Ok(Some(masked))
+    }

Then check_abc_tpflags becomes a straight orchestration over attrs.get(...) and the base loop, each calling parse_abc_tpflags and applying slots.flags |= masked under the existing "don't override inherited" rule.

Pre-existing nit on the same surface: COLLECTION_FLAGS is also defined identically in inherit_patma_flags (lines 581–583) — pulling it up to a module-level const would let both functions share it.

🤖 Prompt for AI Agents

Verify each finding against the current code and only fix it if needed.

In `@crates/vm/src/builtins/type.rs` around lines 612 - 660, Extract the
duplicated parse/validate/apply logic into a small helper (e.g.
parse_and_validate_abc_tpflags) that takes a PyObjectRef (or Option<&PyObject>)
and returns Result<Option<PyTypeFlags>, String> or similar: it should downcast
to crate::builtins::int::PyInt, convert via to_i64().unwrap_or(0), build
PyTypeFlags::from_bits_truncate(...), mask with COLLECTION_FLAGS, and return
Err(...) if both sequence and mapping bits are set; then replace the two
duplicated blocks in the current function with calls to that helper and apply
slots.flags |= masked only under the existing inherited-bit check; also promote
COLLECTION_FLAGS to a module-level const so inherit_patma_flags and this new
helper share the same constant.