Auto-format: cargo fmt --all

RustPython · terryluan12 · Dec 29, 2025 · Dec 29, 2025 · Dec 29, 2025 · Dec 29, 2025
commit 86957cc9fc62f53578b51e0a7dcc70ab14fd0ca1
diff --git a/crates/codegen/src/compile.rs b/crates/codegen/src/compile.rs
@@ -16,6 +16,7 @@ use crate::{
     symboltable::{self, CompilerScope, SymbolFlags, SymbolScope, SymbolTable},
     unparse::UnparseExpr,
 };
+use alloc::borrow::Cow;
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex;
@@ -42,7 +43,6 @@ use rustpython_compiler_core::{
     },
 };
 use rustpython_wtf8::Wtf8Buf;
-use alloc::borrow::Cow;
 use std::collections::HashSet;
 
 const MAXBLOCKS: usize = 20;

diff --git a/crates/codegen/src/error.rs b/crates/codegen/src/error.rs
@@ -1,6 +1,6 @@
-use rustpython_compiler_core::SourceLocation;
 use alloc::fmt;
 use core::fmt::Display;
+use rustpython_compiler_core::SourceLocation;
 use thiserror::Error;
 
 #[derive(Debug)]

diff --git a/crates/codegen/src/symboltable.rs b/crates/codegen/src/symboltable.rs
@@ -11,6 +11,7 @@ use crate::{
     IndexMap,
     error::{CodegenError, CodegenErrorType},
 };
+use alloc::{borrow::Cow, fmt};
 use bitflags::bitflags;
 use ruff_python_ast::{
     self as ast, Comprehension, Decorator, Expr, Identifier, ModExpression, ModModule, Parameter,
@@ -20,7 +21,6 @@ use ruff_python_ast::{
 };
 use ruff_text_size::{Ranged, TextRange};
 use rustpython_compiler_core::{PositionEncoding, SourceFile, SourceLocation};
-use alloc::{borrow::Cow, fmt};
 
 /// Captures all symbols in the current scope, and has a list of sub-scopes in this scope.
 #[derive(Clone)]
@@ -261,8 +261,8 @@ fn drop_class_free(symbol_table: &mut SymbolTable) {
 type SymbolMap = IndexMap<String, Symbol>;
 
 mod stack {
-    use std::panic;
     use core::ptr::NonNull;
+    use std::panic;
     pub struct StackStack<T> {
         v: Vec<NonNull<T>>,
     }

diff --git a/crates/codegen/src/unparse.rs b/crates/codegen/src/unparse.rs
@@ -1,12 +1,12 @@
+use alloc::fmt;
+use core::fmt::Display as _;
 use ruff_python_ast::{
     self as ruff, Arguments, BoolOp, Comprehension, ConversionFlag, Expr, Identifier, Operator,
     Parameter, ParameterWithDefault, Parameters,
 };
 use ruff_text_size::Ranged;
 use rustpython_compiler_core::SourceFile;
 use rustpython_literal::escape::{AsciiEscape, UnicodeEscape};
-use alloc::fmt;
-use core::fmt::Display as _;
 
 mod precedence {
     macro_rules! precedence {

diff --git a/crates/common/src/boxvec.rs b/crates/common/src/boxvec.rs
@@ -5,10 +5,10 @@
 use alloc::{fmt, slice};
 use core::{
     borrow::{Borrow, BorrowMut},
-    cmp, 
+    cmp,
     mem::{self, MaybeUninit},
     ops::{Bound, Deref, DerefMut, RangeBounds},
-    ptr, 
+    ptr,
 };
 
 pub struct BoxVec<T> {

diff --git a/crates/common/src/cformat.rs b/crates/common/src/cformat.rs
@@ -1,16 +1,16 @@
 //! Implementation of Printf-Style string formatting
 //! as per the [Python Docs](https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting).
-use bitflags::bitflags;
-use itertools::Itertools;
-use malachite_bigint::{BigInt, Sign};
-use num_traits::Signed;
-use rustpython_literal::{float, format::Case};
 use alloc::fmt;
+use bitflags::bitflags;
 use core::{
     cmp,
     iter::{Enumerate, Peekable},
     str::FromStr,
 };
+use itertools::Itertools;
+use malachite_bigint::{BigInt, Sign};
+use num_traits::Signed;
+use rustpython_literal::{float, format::Case};
 
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 

diff --git a/crates/common/src/format.rs b/crates/common/src/format.rs
@@ -1,4 +1,6 @@
 // spell-checker:ignore ddfe
+use core::ops::Deref;
+use core::{cmp, str::FromStr};
 use itertools::{Itertools, PeekingNext};
 use malachite_base::num::basic::floats::PrimitiveFloat;
 use malachite_bigint::{BigInt, Sign};
@@ -7,8 +9,6 @@ use num_traits::FromPrimitive;
 use num_traits::{Signed, cast::ToPrimitive};
 use rustpython_literal::float;
 use rustpython_literal::format::Case;
-use core::ops::Deref;
-use core::{cmp, str::FromStr};
 
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 

diff --git a/crates/common/src/hash.rs b/crates/common/src/hash.rs
@@ -1,7 +1,7 @@
+use core::hash::{BuildHasher, Hash, Hasher};
 use malachite_bigint::BigInt;
 use num_traits::ToPrimitive;
 use siphasher::sip::SipHasher24;
-use core::hash::{BuildHasher, Hash, Hasher};
 
 pub type PyHash = i64;
 pub type PyUHash = u64;

diff --git a/crates/common/src/lock/cell_lock.rs b/crates/common/src/lock/cell_lock.rs
@@ -1,9 +1,9 @@
 // spell-checker:ignore upgradably sharedly
+use core::{cell::Cell, num::NonZero};
 use lock_api::{
     GetThreadId, RawMutex, RawRwLock, RawRwLockDowngrade, RawRwLockRecursive, RawRwLockUpgrade,
     RawRwLockUpgradeDowngrade,
 };
-use core::{cell::Cell, num::NonZero};
 
 pub struct RawCellMutex {
     locked: Cell<bool>,

diff --git a/crates/common/src/lock/immutable_mutex.rs b/crates/common/src/lock/immutable_mutex.rs
@@ -1,8 +1,8 @@
 #![allow(clippy::needless_lifetimes)]
 
-use lock_api::{MutexGuard, RawMutex};
 use alloc::fmt;
 use core::{marker::PhantomData, ops::Deref};
+use lock_api::{MutexGuard, RawMutex};
 
 /// A mutex guard that has an exclusive lock, but only an immutable reference; useful if you
 /// need to map a mutex guard with a function that returns an `&T`. Construct using the

diff --git a/crates/common/src/lock/thread_mutex.rs b/crates/common/src/lock/thread_mutex.rs
@@ -1,6 +1,5 @@
 #![allow(clippy::needless_lifetimes)]
 
-use lock_api::{GetThreadId, GuardNoSend, RawMutex};
 use alloc::fmt;
 use core::{
     cell::UnsafeCell,
@@ -9,6 +8,7 @@ use core::{
     ptr::NonNull,
     sync::atomic::{AtomicUsize, Ordering},
 };
+use lock_api::{GetThreadId, GuardNoSend, RawMutex};
 
 // based off ReentrantMutex from lock_api
 

diff --git a/crates/common/src/str.rs b/crates/common/src/str.rs
@@ -4,8 +4,8 @@ use crate::format::CharLen;
 use crate::wtf8::{CodePoint, Wtf8, Wtf8Buf};
 use ascii::{AsciiChar, AsciiStr, AsciiString};
 use core::fmt;
-use core::sync::atomic::Ordering::Relaxed;
 use core::ops::{Bound, RangeBounds};
+use core::sync::atomic::Ordering::Relaxed;
 
 #[cfg(not(target_arch = "wasm32"))]
 #[allow(non_camel_case_types)]

diff --git a/crates/compiler-core/src/bytecode.rs b/crates/compiler-core/src/bytecode.rs
@@ -5,13 +5,13 @@ use crate::{
     marshal::MarshalError,
     {OneIndexed, SourceLocation},
 };
+use alloc::{collections::BTreeSet, fmt};
 use bitflags::bitflags;
+use core::{hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
 use itertools::Itertools;
 use malachite_bigint::BigInt;
 use num_complex::Complex64;
 use rustpython_wtf8::{Wtf8, Wtf8Buf};
-use alloc::{collections::BTreeSet, fmt};
-use core::{hash, marker::PhantomData, mem, num::NonZeroU8, ops::Deref};
 
 /// Oparg values for [`Instruction::ConvertValue`].
 ///

diff --git a/crates/compiler-core/src/marshal.rs b/crates/compiler-core/src/marshal.rs
@@ -1,8 +1,8 @@
 use crate::{OneIndexed, SourceLocation, bytecode::*};
+use core::convert::Infallible;
 use malachite_bigint::{BigInt, Sign};
 use num_complex::Complex64;
 use rustpython_wtf8::Wtf8;
-use core::convert::Infallible;
 
 pub const FORMAT_VERSION: u32 = 4;
 

diff --git a/crates/derive-impl/src/pyclass.rs b/crates/derive-impl/src/pyclass.rs
@@ -4,11 +4,11 @@ use crate::util::{
     ItemMeta, ItemMetaInner, ItemNursery, SimpleItemMeta, format_doc, pyclass_ident_and_attrs,
     pyexception_ident_and_attrs, text_signature,
 };
+use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, Span, TokenStream, TokenTree};
 use quote::{ToTokens, quote, quote_spanned};
 use rustpython_doc::DB;
 use std::collections::{HashMap, HashSet};
-use core::str::FromStr;
 use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
 use syn_ext::ext::*;
 use syn_ext::types::*;

diff --git a/crates/derive-impl/src/pymodule.rs b/crates/derive-impl/src/pymodule.rs
@@ -5,11 +5,11 @@ use crate::util::{
     ErrorVec, ItemMeta, ItemNursery, ModuleItemMeta, SimpleItemMeta, format_doc, iter_use_idents,
     pyclass_ident_and_attrs, text_signature,
 };
+use core::str::FromStr;
 use proc_macro2::{Delimiter, Group, TokenStream, TokenTree};
 use quote::{ToTokens, quote, quote_spanned};
 use rustpython_doc::DB;
-use std::{collections::HashSet};
-use core::str::FromStr;
+use std::collections::HashSet;
 use syn::{Attribute, Ident, Item, Result, parse_quote, spanned::Spanned};
 use syn_ext::ext::*;
 use syn_ext::types::PunctuatedNestedMeta;

diff --git a/crates/sre_engine/src/engine.rs b/crates/sre_engine/src/engine.rs
@@ -6,8 +6,8 @@ use crate::string::{
 };
 
 use super::{MAXREPEAT, SreAtCode, SreCatCode, SreInfo, SreOpcode, StrDrive, StringCursor};
-use optional::Optioned;
 use core::{convert::TryFrom, ptr::null};
+use optional::Optioned;
 
 #[derive(Debug, Clone, Copy)]
 pub struct Request<'a, S> {

diff --git a/crates/stdlib/src/array.rs b/crates/stdlib/src/array.rs
@@ -68,11 +68,11 @@ mod array {
             },
         },
     };
+    use alloc::fmt;
+    use core::cmp::Ordering;
     use itertools::Itertools;
     use num_traits::ToPrimitive;
     use rustpython_common::wtf8::{CodePoint, Wtf8, Wtf8Buf};
-    use alloc::fmt;
-    use core::cmp::Ordering;
     use std::os::raw;
     macro_rules! def_array_enum {
         ($(($n:ident, $t:ty, $c:literal, $scode:literal)),*$(,)?) => {

diff --git a/crates/stdlib/src/bz2.rs b/crates/stdlib/src/bz2.rs
@@ -15,10 +15,10 @@ mod _bz2 {
         object::PyResult,
         types::Constructor,
     };
+    use alloc::fmt;
     use bzip2::{Decompress, Status, write::BzEncoder};
     use rustpython_vm::convert::ToPyException;
     use std::io::Write;
-    use alloc::fmt;
 
     const BUFSIZ: usize = 8192;
 

diff --git a/crates/stdlib/src/contextvars.rs b/crates/stdlib/src/contextvars.rs
@@ -31,13 +31,13 @@ mod _contextvars {
         protocol::{PyMappingMethods, PySequenceMethods},
         types::{AsMapping, AsSequence, Constructor, Hashable, Representable},
     };
-    use crossbeam_utils::atomic::AtomicCell;
-    use indexmap::IndexMap;
-    use std::sync::LazyLock;
     use core::{
         cell::{Cell, RefCell, UnsafeCell},
         sync::atomic::Ordering,
     };
+    use crossbeam_utils::atomic::AtomicCell;
+    use indexmap::IndexMap;
+    use std::sync::LazyLock;
 
     // TODO: Real hamt implementation
     type Hamt = IndexMap<PyRef<ContextVar>, PyObjectRef, ahash::RandomState>;

diff --git a/crates/stdlib/src/csv.rs b/crates/stdlib/src/csv.rs
@@ -12,14 +12,14 @@ mod _csv {
         raise_if_stop,
         types::{Constructor, IterNext, Iterable, SelfIter},
     };
+    use alloc::fmt;
     use csv_core::Terminator;
     use itertools::{self, Itertools};
     use parking_lot::Mutex;
     use rustpython_vm::match_class;
+    use std::collections::HashMap;
     use std::sync::LazyLock;
-    use std::{collections::HashMap};
-    use alloc::fmt;
-
+
     #[pyattr]
     const QUOTE_MINIMAL: i32 = QuoteStyle::Minimal as i32;
     #[pyattr]

diff --git a/crates/stdlib/src/faulthandler.rs b/crates/stdlib/src/faulthandler.rs
@@ -7,13 +7,13 @@ mod decl {
         PyObjectRef, PyResult, VirtualMachine, builtins::PyFloat, frame::Frame,
         function::OptionalArg, py_io::Write,
     };
+    use alloc::sync::Arc;
+    use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
+    use core::time::Duration;
     use parking_lot::{Condvar, Mutex};
     #[cfg(any(unix, windows))]
     use rustpython_common::os::{get_errno, set_errno};
-    use alloc::sync::Arc;
-    use core::sync::atomic::{AtomicBool, AtomicI32, Ordering};
     use std::thread;
-    use core::time::Duration;
 
     /// fault_handler_t
     #[cfg(unix)]
@@ -144,7 +144,8 @@ mod decl {
     static mut FRAME_SNAPSHOTS: [FrameSnapshot; MAX_SNAPSHOT_FRAMES] =
         [FrameSnapshot::EMPTY; MAX_SNAPSHOT_FRAMES];
     #[cfg(any(unix, windows))]
-    static SNAPSHOT_COUNT: core::sync::atomic::AtomicUsize = core::sync::atomic::AtomicUsize::new(0);
+    static SNAPSHOT_COUNT: core::sync::atomic::AtomicUsize =
+        core::sync::atomic::AtomicUsize::new(0);
 
     // Signal-safe output functions
 

diff --git a/crates/stdlib/src/grp.rs b/crates/stdlib/src/grp.rs
@@ -10,8 +10,8 @@ mod grp {
         exceptions,
         types::PyStructSequence,
     };
-    use nix::unistd;
     use core::ptr::NonNull;
+    use nix::unistd;
 
     #[pystruct_sequence_data]
     struct GroupData {

diff --git a/crates/stdlib/src/json.rs b/crates/stdlib/src/json.rs
@@ -12,9 +12,9 @@ mod _json {
         protocol::PyIterReturn,
         types::{Callable, Constructor},
     };
+    use core::str::FromStr;
     use malachite_bigint::BigInt;
     use rustpython_common::wtf8::Wtf8Buf;
-    use core::str::FromStr;
 
     #[pyattr(name = "make_scanner")]
     #[pyclass(name = "Scanner", traverse)]

diff --git a/crates/stdlib/src/lib.rs b/crates/stdlib/src/lib.rs
@@ -4,7 +4,6 @@
 #![allow(clippy::module_inception)]
 #![cfg_attr(all(target_os = "wasi", target_env = "p2"), feature(wasip2))]
 
-
 #[macro_use]
 extern crate rustpython_derive;
 extern crate alloc;

diff --git a/crates/stdlib/src/locale.rs b/crates/stdlib/src/locale.rs
@@ -41,17 +41,14 @@ use libc::localeconv;
 
 #[pymodule]
 mod _locale {
+    use alloc::ffi::CString;
+    use core::{ffi::CStr, ptr};
     use rustpython_vm::{
         PyObjectRef, PyResult, VirtualMachine,
         builtins::{PyDictRef, PyIntRef, PyListRef, PyStrRef, PyTypeRef},
         convert::ToPyException,
         function::OptionalArg,
     };
-    use alloc::ffi::CString;
-    use core::{
-        ffi::CStr,
-        ptr,
-    };
 
     #[cfg(all(
         unix,

diff --git a/crates/stdlib/src/lzma.rs b/crates/stdlib/src/lzma.rs
@@ -8,6 +8,7 @@ mod _lzma {
         CompressFlushKind, CompressState, CompressStatusKind, Compressor, DecompressArgs,
         DecompressError, DecompressState, DecompressStatus, Decompressor,
     };
+    use alloc::fmt;
     #[pyattr]
     use lzma_sys::{
         LZMA_CHECK_CRC32 as CHECK_CRC32, LZMA_CHECK_CRC64 as CHECK_CRC64,
@@ -38,7 +39,6 @@ mod _lzma {
     use rustpython_vm::function::ArgBytesLike;
     use rustpython_vm::types::Constructor;
     use rustpython_vm::{Py, PyObjectRef, PyPayload, PyResult, VirtualMachine};
-    use alloc::fmt;
     use xz2::stream::{Action, Check, Error, Filters, LzmaOptions, Status, Stream};
 
     #[cfg(windows)]

diff --git a/crates/stdlib/src/math.rs b/crates/stdlib/src/math.rs
@@ -10,11 +10,11 @@ mod math {
         function::{ArgIndex, ArgIntoFloat, ArgIterable, Either, OptionalArg, PosArgs},
         identifier,
     };
+    use core::cmp::Ordering;
     use itertools::Itertools;
     use malachite_bigint::BigInt;
     use num_traits::{One, Signed, ToPrimitive, Zero};
     use rustpython_common::{float_ops, int::true_div};
-    use core::cmp::Ordering;
 
     // Constants
     #[pyattr]