Auto-format: cargo fmt --all

github-actions[bot] · github-actions[bot] · commit 233f0f4592da · 2026-02-26T17:11:21.000Z
diff --git a/crates/vm/src/builtins/frame.rs b/crates/vm/src/builtins/frame.rs
@@ -11,7 +11,9 @@ use crate::{
     types::Representable,
 };
 use num_traits::Zero;
-use rustpython_compiler_core::bytecode::{self, Constant, Instruction, InstructionMetadata, StackEffect};
+use rustpython_compiler_core::bytecode::{
+    self, Constant, Instruction, InstructionMetadata, StackEffect,
+};
 
 /// Stack state analysis for safe line-number jumps.
 ///
@@ -249,7 +251,8 @@ pub(crate) mod stack_analysis {
                         // the stack and POP_ITER removes it.
                         let mut j = oparg as usize;
                         if j < instructions.len() {
-                            let target_op = instructions[j].op.to_base().unwrap_or(instructions[j].op);
+                            let target_op =
+                                instructions[j].op.to_base().unwrap_or(instructions[j].op);
                             if matches!(target_op, Instruction::EndFor) {
                                 j += 1;
                             }
diff --git a/crates/vm/src/frame.rs b/crates/vm/src/frame.rs
@@ -292,7 +292,8 @@ impl Frame {
     pub(crate) fn set_pending_stack_pops(&self, val: u32) {
         #[cfg(feature = "threading")]
         {
-            self.pending_stack_pops.store(val, atomic::Ordering::Relaxed);
+            self.pending_stack_pops
+                .store(val, atomic::Ordering::Relaxed);
         }
         #[cfg(not(feature = "threading"))]
         {
@@ -303,7 +304,8 @@ impl Frame {
     pub(crate) fn pending_unwind_from_stack(&self) -> i64 {
         #[cfg(feature = "threading")]
         {
-            self.pending_unwind_from_stack.load(atomic::Ordering::Relaxed)
+            self.pending_unwind_from_stack
+                .load(atomic::Ordering::Relaxed)
         }
         #[cfg(not(feature = "threading"))]
         {
@@ -314,7 +316,8 @@ impl Frame {
     pub(crate) fn set_pending_unwind_from_stack(&self, val: i64) {
         #[cfg(feature = "threading")]
         {
-            self.pending_unwind_from_stack.store(val, atomic::Ordering::Relaxed);
+            self.pending_unwind_from_stack
+                .store(val, atomic::Ordering::Relaxed);
         }
         #[cfg(not(feature = "threading"))]
         {
@@ -533,12 +536,7 @@ impl ExecutingFrame<'_> {
     /// loop holds the state mutex.  Instead it records the work in
     /// `pending_stack_pops` / `pending_unwind_from_stack` and we execute it
     /// here, inside the execution loop where we already own the state.
-    fn unwind_stack_for_lineno(
-        &mut self,
-        pop_count: usize,
-        from_stack: i64,
-        vm: &VirtualMachine,
-    ) {
+    fn unwind_stack_for_lineno(&mut self, pop_count: usize, from_stack: i64, vm: &VirtualMachine) {
         use crate::builtins::frame::stack_analysis::{Kind, pop_value, top_of_stack};
 
         let mut cur_stack = from_stack;
@@ -550,8 +548,7 @@ impl ExecutingFrame<'_> {
                     if vm.is_none(&exc_obj) {
                         vm.set_exception(None);
                     } else {
-                        let exc =
-                            exc_obj.downcast::<crate::builtins::PyBaseException>().ok();
+                        let exc = exc_obj.downcast::<crate::builtins::PyBaseException>().ok();
                         vm.set_exception(exc);
                     }
                 }
@@ -582,7 +579,10 @@ impl ExecutingFrame<'_> {
             // Skip RESUME – it should not generate user-visible line events.
             if vm.use_tracing.get()
                 && !vm.is_none(&self.object.trace.lock())
-                && !matches!(instructions.get(idx).map(|u| u.op), Some(Instruction::Resume { .. } | Instruction::InstrumentedResume))
+                && !matches!(
+                    instructions.get(idx).map(|u| u.op),
+                    Some(Instruction::Resume { .. } | Instruction::InstrumentedResume)
+                )
                 && let Some((loc, _)) = self.code.locations.get(idx)
                 && loc.line.get() as u32 != self.prev_line
             {

Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,8 @@ impl Frame {`
`292`	`292`	`pub(crate) fn set_pending_stack_pops(&self, val: u32) {`
`293`	`293`	`#[cfg(feature = "threading")]`
`294`	`294`	`{`
`295`		`- self.pending_stack_pops.store(val, atomic::Ordering::Relaxed);`
	`295`	`+ self.pending_stack_pops`
	`296`	`+ .store(val, atomic::Ordering::Relaxed);`
`296`	`297`	`}`
`297`	`298`	`#[cfg(not(feature = "threading"))]`
`298`	`299`	`{`
`@@ -303,7 +304,8 @@ impl Frame {`
`303`	`304`	`pub(crate) fn pending_unwind_from_stack(&self) -> i64 {`
`304`	`305`	`#[cfg(feature = "threading")]`
`305`	`306`	`{`
`306`		`- self.pending_unwind_from_stack.load(atomic::Ordering::Relaxed)`
	`307`	`+ self.pending_unwind_from_stack`
	`308`	`+ .load(atomic::Ordering::Relaxed)`
`307`	`309`	`}`
`308`	`310`	`#[cfg(not(feature = "threading"))]`
`309`	`311`	`{`
`@@ -314,7 +316,8 @@ impl Frame {`
`314`	`316`	`pub(crate) fn set_pending_unwind_from_stack(&self, val: i64) {`
`315`	`317`	`#[cfg(feature = "threading")]`
`316`	`318`	`{`
`317`		`- self.pending_unwind_from_stack.store(val, atomic::Ordering::Relaxed);`
	`319`	`+ self.pending_unwind_from_stack`
	`320`	`+ .store(val, atomic::Ordering::Relaxed);`
`318`	`321`	`}`
`319`	`322`	`#[cfg(not(feature = "threading"))]`
`320`	`323`	`{`
`@@ -533,12 +536,7 @@ impl ExecutingFrame<'_> {`
`533`	`536`	`/// loop holds the state mutex. Instead it records the work in`
`534`	`537`	/// `pending_stack_pops` / `pending_unwind_from_stack` and we execute it
`535`	`538`	`/// here, inside the execution loop where we already own the state.`
`536`		`- fn unwind_stack_for_lineno(`
`537`		`- &mut self,`
`538`		`- pop_count: usize,`
`539`		`- from_stack: i64,`
`540`		`- vm: &VirtualMachine,`
`541`		`- ) {`
	`539`	`+ fn unwind_stack_for_lineno(&mut self, pop_count: usize, from_stack: i64, vm: &VirtualMachine) {`
`542`	`540`	`use crate::builtins::frame::stack_analysis::{Kind, pop_value, top_of_stack};`
`543`	`541`
`544`	`542`	`let mut cur_stack = from_stack;`
`@@ -550,8 +548,7 @@ impl ExecutingFrame<'_> {`
`550`	`548`	`if vm.is_none(&exc_obj) {`
`551`	`549`	`vm.set_exception(None);`
`552`	`550`	`} else {`
`553`		`- let exc =`
`554`		`- exc_obj.downcast::<crate::builtins::PyBaseException>().ok();`
	`551`	`+ let exc = exc_obj.downcast::<crate::builtins::PyBaseException>().ok();`
`555`	`552`	`vm.set_exception(exc);`
`556`	`553`	`}`
`557`	`554`	`}`
`@@ -582,7 +579,10 @@ impl ExecutingFrame<'_> {`
`582`	`579`	`// Skip RESUME – it should not generate user-visible line events.`
`583`	`580`	`if vm.use_tracing.get()`
`584`	`581`	`&& !vm.is_none(&self.object.trace.lock())`
`585`		`- && !matches!(instructions.get(idx).map(\|u\| u.op), Some(Instruction::Resume { .. } \| Instruction::InstrumentedResume))`
	`582`	`+ && !matches!(`
	`583`	`+ instructions.get(idx).map(\|u\| u.op),`
	`584`	`+ Some(Instruction::Resume { .. } \| Instruction::InstrumentedResume)`
	`585`	`+ )`
`586`	`586`	`&& let Some((loc, _)) = self.code.locations.get(idx)`
`587`	`587`	`&& loc.line.get() as u32 != self.prev_line`
`588`	`588`	`{`