Group use for vm stuff to prevent reorder for rustpython_stdlib

vm/src/stdlib/array.rs

@@ -2,30 +2,27 @@ pub(crate) use array::make_module;
 
 #[pymodule(name = "array")]
 mod array {
-    use crate::buffer::{BufferOptions, PyBuffer, PyBufferInternal, ResizeGuard};
-    use crate::builtins::list::{PyList, PyListRef};
-    use crate::builtins::pystr::{PyStr, PyStrRef};
-    use crate::builtins::pytype::PyTypeRef;
-    use crate::builtins::slice::PySliceRef;
-    use crate::builtins::IntoPyFloat;
-    use crate::builtins::{PyByteArray, PyBytes, PyBytesRef, PyIntRef};
-    use crate::byteslike::ArgBytesLike;
-    use crate::common::borrow::{BorrowedValue, BorrowedValueMut};
-    use crate::common::lock::{
-        PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyRwLock, PyRwLockReadGuard,
-        PyRwLockWriteGuard,
+    use crate::common::{
+        borrow::{BorrowedValue, BorrowedValueMut},
+        lock::{
+            PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyRwLock, PyRwLockReadGuard,
+            PyRwLockWriteGuard,
+        },
+        str::wchar_t,
     };
-    use crate::common::str::wchar_t;
-    use crate::function::OptionalArg;
-    use crate::sliceable::{
-        saturate_index, PySliceableSequence, PySliceableSequenceMut, SequenceIndex,
-    };
-    use crate::slots::{AsBuffer, Comparable, Iterable, PyComparisonOp, PyIter, SlotConstructor};
     use crate::{
-        IdProtocol, IntoPyObject, PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult,
-        PyValue, StaticType, TryFromObject, TypeProtocol,
+        buffer::{BufferOptions, PyBuffer, PyBufferInternal, ResizeGuard},
+        builtins::{
+            IntoPyFloat, PyByteArray, PyBytes, PyBytesRef, PyIntRef, PyList, PyListRef, PySliceRef,
+            PyStr, PyStrRef, PyTypeRef,
+        },
+        byteslike::ArgBytesLike,
+        function::OptionalArg,
+        sliceable::{saturate_index, PySliceableSequence, PySliceableSequenceMut, SequenceIndex},
+        slots::{AsBuffer, Comparable, Iterable, PyComparisonOp, PyIter, SlotConstructor},
+        IdProtocol, IntoPyObject, IntoPyResult, PyComparisonValue, PyIterable, PyObjectRef, PyRef,
+        PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, VirtualMachine,
     };
-    use crate::{IntoPyResult, VirtualMachine};
     use crossbeam_utils::atomic::AtomicCell;
     use itertools::Itertools;
     use lexical_core::Integer;

vm/src/stdlib/binascii.rs

@@ -2,21 +2,19 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "binascii")]
 mod decl {
-    use crate::builtins::bytearray::{PyByteArray, PyByteArrayRef};
-    use crate::builtins::bytes::{PyBytes, PyBytesRef};
-    use crate::builtins::pystr::{PyStr, PyStrRef};
-    use crate::builtins::PyTypeRef;
-    use crate::byteslike::ArgBytesLike;
-    use crate::function::OptionalArg;
-    use crate::vm::VirtualMachine;
-    use crate::{PyObjectRef, PyResult, TryFromObject, TypeProtocol};
+    use crate::{
+        builtins::{PyByteArray, PyBytes, PyStr, PyTypeRef},
+        byteslike::ArgBytesLike,
+        function::OptionalArg,
+        PyObjectRef, PyRef, PyResult, TryFromObject, TypeProtocol, VirtualMachine,
+    };
     use crc::{crc32, Hasher32};
     use itertools::Itertools;
 
     enum SerializedData {
-        Bytes(PyBytesRef),
-        Buffer(PyByteArrayRef),
-        Ascii(PyStrRef),
+        Bytes(PyRef<PyBytes>),
+        Buffer(PyRef<PyByteArray>),
+        Ascii(PyRef<PyStr>),
     }
 
     impl TryFromObject for SerializedData {

vm/src/stdlib/bisect.rs

@@ -2,13 +2,12 @@ pub(crate) use _bisect::make_module;
 
 #[pymodule]
 mod _bisect {
-    use std::convert::TryFrom;
-
-    use crate::function::OptionalArg;
-    use crate::slots::PyComparisonOp::Lt;
-    use crate::vm::VirtualMachine;
-    use crate::{ItemProtocol, PyObjectRef, PyResult};
+    use crate::{
+        function::OptionalArg, slots::PyComparisonOp::Lt, ItemProtocol, PyObjectRef, PyResult,
+        VirtualMachine,
+    };
     use num_traits::ToPrimitive;
+    use std::convert::TryFrom;
 
     #[derive(FromArgs)]
     struct BisectArgs {

vm/src/stdlib/cmath.rs

@@ -22,9 +22,11 @@ pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
 /// This module provides access to mathematical functions for complex numbers.
 #[pymodule]
 mod cmath {
-    use crate::builtins::{IntoPyComplex, IntoPyFloat};
-    use crate::function::OptionalArg;
-    use crate::{PyResult, VirtualMachine};
+    use crate::{
+        builtins::{IntoPyComplex, IntoPyFloat},
+        function::OptionalArg,
+        PyResult, VirtualMachine,
+    };
     use num_complex::Complex64;
 
     /// Return argument, also known as the phase angle, of a complex.

vm/src/stdlib/csv.rs

@@ -1,19 +1,16 @@
+use crate::common::lock::PyMutex;
+use crate::{
+    builtins::{PyStr, PyStrRef, PyTypeRef},
+    function::{ArgumentError, FromArgs, FuncArgs},
+    iterator,
+    slots::PyIter,
+    types::create_simple_type,
+    PyClassImpl, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
+    TypeProtocol, VirtualMachine,
+};
 use itertools::{self, Itertools};
 use std::fmt;
 
-use crate::builtins::pystr::{PyStr, PyStrRef};
-use crate::builtins::pytype::PyTypeRef;
-use crate::common::lock::PyMutex;
-use crate::function::{ArgumentError, FromArgs, FuncArgs};
-use crate::iterator;
-use crate::slots::PyIter;
-use crate::types::create_simple_type;
-use crate::VirtualMachine;
-use crate::{
-    PyClassImpl, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
-    TypeProtocol,
-};
-
 #[repr(i32)]
 pub enum QuoteStyle {
     Minimal = 0,

vm/src/stdlib/dis.rs

@@ -2,13 +2,11 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "dis")]
 mod decl {
-    use crate::builtins::code::PyCodeRef;
-    use crate::builtins::dict::PyDictRef;
-    use crate::builtins::pystr::PyStrRef;
-    use crate::bytecode::CodeFlags;
-    use crate::compile;
-    use crate::vm::VirtualMachine;
-    use crate::{ItemProtocol, PyObjectRef, PyResult, TryFromObject};
+    use crate::{
+        builtins::{PyCode, PyDictRef, PyStrRef},
+        bytecode::CodeFlags,
+        compile, ItemProtocol, PyObjectRef, PyRef, PyResult, TryFromObject, VirtualMachine,
+    };
 
     #[pyfunction]
     fn dis(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
@@ -28,8 +26,8 @@ mod decl {
 
     #[pyfunction]
     fn disassemble(co: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> {
-        let code = &PyCodeRef::try_from_object(vm, co)?.code;
-        print!("{}", code);
+        let code = PyRef::<PyCode>::try_from_object(vm, co)?;
+        print!("{}", &code.code);
         Ok(())
     }
 

vm/src/stdlib/faulthandler.rs

@@ -2,9 +2,7 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "faulthandler")]
 mod decl {
-    use crate::frame::FrameRef;
-    use crate::function::OptionalArg;
-    use crate::vm::VirtualMachine;
+    use crate::{frame::FrameRef, function::OptionalArg, VirtualMachine};
 
     fn dump_frame(frame: &FrameRef) {
         eprintln!(

vm/src/stdlib/fcntl.rs

@@ -2,13 +2,14 @@ pub(crate) use fcntl::make_module;
 
 #[pymodule]
 mod fcntl {
-    use super::super::{io, os};
-    use crate::builtins::int;
-    use crate::byteslike::{ArgMemoryBuffer, ArgStrOrBytesLike};
-    use crate::function::OptionalArg;
-    use crate::utils::Either;
-    use crate::PyResult;
-    use crate::VirtualMachine;
+    use crate::{
+        builtins::int,
+        byteslike::{ArgMemoryBuffer, ArgStrOrBytesLike},
+        function::OptionalArg,
+        stdlib::{io, os},
+        utils::Either,
+        PyResult, VirtualMachine,
+    };
 
     #[pyattr]
     use libc::{FD_CLOEXEC, F_GETFD, F_GETFL, F_SETFD, F_SETFL};

vm/src/stdlib/hashlib.rs

@@ -2,13 +2,12 @@ pub(crate) use hashlib::make_module;
 
 #[pymodule]
 mod hashlib {
-    use crate::builtins::bytes::{PyBytes, PyBytesRef};
-    use crate::builtins::pystr::PyStrRef;
-    use crate::builtins::pytype::PyTypeRef;
     use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
-    use crate::function::{FuncArgs, OptionalArg};
-    use crate::vm::VirtualMachine;
-    use crate::{PyResult, PyValue, StaticType};
+    use crate::{
+        builtins::{PyBytes, PyBytesRef, PyStrRef, PyTypeRef},
+        function::{FuncArgs, OptionalArg},
+        PyResult, PyValue, StaticType, VirtualMachine,
+    };
     use blake2::{Blake2b, Blake2s};
     use digest::DynDigest;
     use md5::Md5;

vm/src/stdlib/json.rs

@@ -3,18 +3,16 @@ mod machinery;
 
 #[pymodule]
 mod _json {
-    use super::*;
-    use crate::builtins::pystr::PyStrRef;
-    use crate::builtins::pytype::PyTypeRef;
-    use crate::exceptions::PyBaseExceptionRef;
-    use crate::function::{FuncArgs, OptionalArg};
-    use crate::iterator;
-    use crate::slots::{Callable, SlotConstructor};
-    use crate::VirtualMachine;
+    use super::machinery;
     use crate::{
+        builtins::{PyStrRef, PyTypeRef},
+        exceptions::PyBaseExceptionRef,
+        function::{FuncArgs, OptionalArg},
+        iterator,
+        slots::{Callable, SlotConstructor},
         IdProtocol, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject,
+        VirtualMachine,
     };
-
     use num_bigint::BigInt;
     use std::str::FromStr;
 

vm/src/stdlib/keyword.rs

@@ -3,13 +3,10 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "keyword")]
 mod decl {
+    use crate::{builtins::PyStr, PyObjectRef, VirtualMachine};
     use itertools::Itertools;
     use rustpython_parser::lexer;
 
-    use crate::builtins::PyStr;
-    use crate::vm::VirtualMachine;
-    use crate::PyObjectRef;
-
     #[pyfunction]
     fn iskeyword(s: PyObjectRef) -> bool {
         if let Some(s) = s.payload::<PyStr>() {

vm/src/stdlib/math.rs

@@ -3,19 +3,16 @@
  *
  */
 
+use crate::{
+    builtins::{try_bigint_to_f64, try_f64_to_bigint, IntoPyFloat, PyFloatRef, PyInt, PyIntRef},
+    function::{Args, OptionalArg},
+    utils::Either,
+    PyIterable, PyObjectRef, PyResult, PySequence, TypeProtocol, VirtualMachine,
+};
 use num_bigint::BigInt;
 use num_traits::{One, Signed, Zero};
 use puruspe::{erf, erfc, gamma, ln_gamma};
-
-use crate::builtins::{
-    try_bigint_to_f64, try_f64_to_bigint, IntoPyFloat, PyFloatRef, PyInt, PyIntRef,
-};
-use crate::function::{Args, OptionalArg};
-use crate::utils::Either;
-use crate::vm::VirtualMachine;
-use crate::{PyIterable, PyObjectRef, PyResult, PySequence, TypeProtocol};
 use rustpython_common::float_ops;
-
 use std::cmp::Ordering;
 
 // Helper macro:

vm/src/stdlib/multiprocessing.rs

@@ -3,10 +3,7 @@ pub(crate) use _multiprocessing::make_module;
 #[cfg(windows)]
 #[pymodule]
 mod _multiprocessing {
-    use super::super::os;
-    use crate::byteslike::ArgBytesLike;
-    use crate::PyResult;
-    use crate::VirtualMachine;
+    use crate::{byteslike::ArgBytesLike, stdlib::os, PyResult, VirtualMachine};
     use winapi::um::winsock2::{self, SOCKET};
 
     #[pyfunction]

vm/src/stdlib/platform.rs

@@ -2,8 +2,7 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "platform")]
 mod decl {
-    use crate::version;
-    use crate::vm::VirtualMachine;
+    use crate::{version, VirtualMachine};
 
     #[pyfunction]
     fn python_implementation(_vm: &VirtualMachine) -> String {

vm/src/stdlib/posixsubprocess.rs

@@ -3,9 +3,7 @@ pub(crate) use _posixsubprocess::make_module;
 #[pymodule]
 mod _posixsubprocess {
     use super::{exec, CStrPathLike, ForkExecArgs, ProcArgs};
-    use crate::exceptions::IntoPyException;
-    use crate::PyResult;
-    use crate::VirtualMachine;
+    use crate::{exceptions::IntoPyException, PyResult, VirtualMachine};
 
     #[pyfunction]
     fn fork_exec(args: ForkExecArgs, vm: &VirtualMachine) -> PyResult<libc::pid_t> {

vm/src/stdlib/pyexpat.rs

@@ -3,8 +3,7 @@
 *
 */
 
-use crate::vm::VirtualMachine;
-use crate::PyObjectRef;
+use crate::{PyObjectRef, VirtualMachine};
 
 pub fn make_module(vm: &VirtualMachine) -> PyObjectRef {
     let module = _pyexpat::make_module(vm);

vm/src/stdlib/random.rs

@@ -4,13 +4,13 @@ pub(crate) use _random::make_module;
 
 #[pymodule]
 mod _random {
-    use crate::builtins::int::PyIntRef;
-    use crate::builtins::pytype::PyTypeRef;
     use crate::common::lock::PyMutex;
-    use crate::function::OptionalOption;
-    use crate::slots::SlotConstructor;
-    use crate::VirtualMachine;
-    use crate::{PyObjectRef, PyResult, PyValue, StaticType};
+    use crate::{
+        builtins::{PyIntRef, PyTypeRef},
+        function::OptionalOption,
+        slots::SlotConstructor,
+        PyObjectRef, PyResult, PyValue, StaticType, VirtualMachine,
+    };
     use num_bigint::{BigInt, Sign};
     use num_traits::{Signed, Zero};
     use rand::{rngs::StdRng, RngCore, SeedableRng};

vm/src/stdlib/re.rs

@@ -8,13 +8,11 @@ use num_traits::Signed;
 use regex::bytes::{Captures, Regex, RegexBuilder};
 use std::fmt;
 use std::ops::Range;
-
-use crate::builtins::int::{PyInt, PyIntRef};
-use crate::builtins::pystr::{PyStr, PyStrRef};
-use crate::builtins::pytype::PyTypeRef;
-use crate::function::{Args, OptionalArg};
-use crate::vm::VirtualMachine;
-use crate::{IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyValue, StaticType, TryFromObject};
+use crate::
+    {builtins::{
+    PyInt, PyIntRef, PyStr, PyStrRef, PyTypeRef},
+    function::{Args, OptionalArg},
+    VirtualMachine, IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyValue, StaticType, TryFromObject};
 
 #[pyclass(module = "re", name = "Pattern")]
 #[derive(Debug, PyValue)]

vm/src/stdlib/resource.rs

@@ -2,10 +2,10 @@ pub(crate) use resource::make_module;
 
 #[pymodule]
 mod resource {
-    use super::super::os;
-    use crate::exceptions::IntoPyException;
-    use crate::VirtualMachine;
-    use crate::{IntoPyObject, PyObjectRef, PyResult, PyStructSequence, TryFromBorrowedObject};
+    use crate::{
+        exceptions::IntoPyException, stdlib::os, IntoPyObject, PyObjectRef, PyResult,
+        PyStructSequence, TryFromBorrowedObject, VirtualMachine,
+    };
     use std::{io, mem};
 
     cfg_if::cfg_if! {

vm/src/stdlib/scproxy.rs

@@ -4,9 +4,10 @@ pub(crate) use _scproxy::make_module;
 mod _scproxy {
     // straight-forward port of Modules/_scproxy.c
 
-    use crate::builtins::{PyDictRef, PyStr};
-    use crate::VirtualMachine;
-    use crate::{IntoPyObject, ItemProtocol, PyResult};
+    use crate::{
+        builtins::{PyDictRef, PyStr},
+        IntoPyObject, ItemProtocol, PyResult, VirtualMachine,
+    };
     use system_configuration::core_foundation::{
         array::CFArray,
         base::{CFType, FromVoid, TCFType},

vm/src/stdlib/select.rs

@@ -1,5 +1,4 @@
-use crate::vm::VirtualMachine;
-use crate::{PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject};
+use crate::{PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject, VirtualMachine};
 use std::{io, mem};
 
 pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef {
@@ -26,7 +25,6 @@ mod platform {
 #[allow(non_snake_case)]
 #[cfg(windows)]
 mod platform {
-
     use winapi::um::winsock2;
     pub use winsock2::{fd_set, select, timeval, FD_SETSIZE, SOCKET as RawFd};
 

vm/src/stdlib/signal.rs

@@ -1,7 +1,7 @@
-use crate::exceptions::IntoPyException;
-use crate::vm::{VirtualMachine, NSIG};
-use crate::{PyObjectRef, PyResult, TryFromBorrowedObject};
-
+use crate::{
+    exceptions::IntoPyException, vm::NSIG, PyObjectRef, PyResult, TryFromBorrowedObject,
+    VirtualMachine,
+};
 use std::sync::atomic::{self, AtomicBool, Ordering};
 
 #[cfg(unix)]

vm/src/stdlib/socket.rs

@@ -1,3 +1,13 @@
+use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};
+use crate::{
+    builtins::{int, PyStrRef, PyTupleRef, PyTypeRef},
+    byteslike::{ArgBytesLike, ArgMemoryBuffer},
+    exceptions::{IntoPyException, PyBaseExceptionRef},
+    function::{FuncArgs, OptionalArg, OptionalOption},
+    utils::{Either, ToCString},
+    IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType,
+    TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine,
+};
 use crossbeam_utils::atomic::AtomicCell;
 use gethostname::gethostname;
 #[cfg(all(unix, not(target_os = "redox")))]
@@ -10,21 +20,6 @@ use std::net::{self, Ipv4Addr, Ipv6Addr, Shutdown, SocketAddr, ToSocketAddrs};
 use std::time::{Duration, Instant};
 use std::{ffi, io};
 
-use crate::builtins::int;
-use crate::builtins::pystr::PyStrRef;
-use crate::builtins::pytype::PyTypeRef;
-use crate::builtins::tuple::PyTupleRef;
-use crate::byteslike::{ArgBytesLike, ArgMemoryBuffer};
-use crate::common::lock::{PyMappedRwLockReadGuard, PyRwLock, PyRwLockReadGuard};
-use crate::exceptions::{IntoPyException, PyBaseExceptionRef};
-use crate::function::{FuncArgs, OptionalArg, OptionalOption};
-use crate::utils::{Either, ToCString};
-use crate::VirtualMachine;
-use crate::{
-    IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType,
-    TryFromBorrowedObject, TryFromObject, TypeProtocol,
-};
-
 #[cfg(unix)]
 type RawSocket = std::os::unix::io::RawFd;
 #[cfg(windows)]

vm/src/stdlib/ssl.rs

@@ -1,16 +1,15 @@
-use super::os::PyPathLike;
 use super::socket::{self, PySocketRef};
-use crate::builtins::{pytype, weakref::PyWeak, PyStrRef, PyTypeRef};
-use crate::byteslike::{ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike};
 use crate::common::lock::{PyRwLock, PyRwLockWriteGuard};
-use crate::exceptions::{create_exception_type, IntoPyException, PyBaseExceptionRef};
-use crate::function::OptionalArg;
-use crate::slots::SlotConstructor;
-use crate::utils::{Either, ToCString};
-use crate::VirtualMachine;
 use crate::{
+    builtins::{pytype, weakref::PyWeak, PyStrRef, PyTypeRef},
+    byteslike::{ArgBytesLike, ArgMemoryBuffer, ArgStrOrBytesLike},
+    exceptions::{create_exception_type, IntoPyException, PyBaseExceptionRef},
+    function::OptionalArg,
+    slots::SlotConstructor,
+    stdlib::os::PyPathLike,
+    utils::{Either, ToCString},
     IntoPyObject, ItemProtocol, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue,
-    StaticType,
+    StaticType, VirtualMachine,
 };
 use crossbeam_utils::atomic::AtomicCell;
 use foreign_types_shared::{ForeignType, ForeignTypeRef};

vm/src/stdlib/syslog.rs

@@ -2,13 +2,13 @@ pub(crate) use syslog::make_module;
 
 #[pymodule(name = "syslog")]
 mod syslog {
-    use crate::builtins::pystr::{PyStr, PyStrRef};
     use crate::common::lock::PyRwLock;
-    use crate::function::{OptionalArg, OptionalOption};
-    use crate::pyobject::PyValue;
-    use crate::utils::ToCString;
-    use crate::vm::VirtualMachine;
-    use crate::{PyObjectRef, PyResult, TryFromObject};
+    use crate::{
+        builtins::pystr::{PyStr, PyStrRef},
+        function::{OptionalArg, OptionalOption},
+        utils::ToCString,
+        PyObjectRef, PyResult, PyValue, TryFromObject, VirtualMachine,
+    };
     use std::{ffi::CStr, os::raw::c_char};
 
     #[pyattr]

vm/src/stdlib/termios.rs

@@ -2,10 +2,11 @@ pub(crate) use self::termios::make_module;
 
 #[pymodule]
 mod termios {
-    use crate::builtins::{int, PyBytes, PyInt, PyListRef, PyTypeRef};
-    use crate::exceptions::PyBaseExceptionRef;
-    use crate::VirtualMachine;
-    use crate::{IntoPyObject, PyObjectRef, PyResult, TryFromObject};
+    use crate::{
+        builtins::{int, PyBytes, PyInt, PyListRef, PyTypeRef},
+        exceptions::PyBaseExceptionRef,
+        IntoPyObject, PyObjectRef, PyResult, TryFromObject, VirtualMachine,
+    };
     use std::convert::TryFrom;
     use termios::Termios;
 

vm/src/stdlib/unicodedata.rs

@@ -2,12 +2,11 @@
    See also: https://docs.python.org/3/library/unicodedata.html
 */
 
-use crate::builtins::pystr::PyStrRef;
-use crate::builtins::pytype::PyTypeRef;
-use crate::function::OptionalArg;
-use crate::vm::VirtualMachine;
-use crate::{PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType};
-
+use crate::{
+    builtins::{PyStrRef, PyTypeRef},
+    function::OptionalArg,
+    PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType, VirtualMachine,
+};
 use itertools::Itertools;
 use unic_char_property::EnumeratedCharProperty;
 use unic_normal::StrNormalForm;

vm/src/stdlib/weakref.rs

@@ -5,8 +5,7 @@
 //! - [rust weak struct](https://doc.rust-lang.org/std/rc/struct.Weak.html)
 //!
 
-use crate::vm::VirtualMachine;
-use crate::PyObjectRef;
+use crate::{PyObjectRef, VirtualMachine};
 
 fn _weakref_getweakrefcount(obj: PyObjectRef) -> usize {
     PyObjectRef::weak_count(&obj)

vm/src/stdlib/winapi.rs

@@ -1,22 +1,19 @@
 #![allow(non_snake_case)]
 
+use super::os::errno_err;
+use crate::{
+    builtins::{dict::PyMapping, PyDictRef, PyStrRef},
+    exceptions::IntoPyException,
+    function::OptionalArg,
+    PyObjectRef, PyResult, PySequence, TryFromObject, VirtualMachine,
+};
 use std::ptr::{null, null_mut};
-
 use winapi::shared::winerror;
-use winapi::um::winnt::HANDLE;
 use winapi::um::{
     fileapi, handleapi, namedpipeapi, processenv, processthreadsapi, synchapi, winbase, winnt,
-    winuser,
+    winnt::HANDLE, winuser,
 };
 
-use super::os::errno_err;
-use crate::builtins::dict::{PyDictRef, PyMapping};
-use crate::builtins::pystr::PyStrRef;
-use crate::exceptions::IntoPyException;
-use crate::function::OptionalArg;
-use crate::VirtualMachine;
-use crate::{PyObjectRef, PyResult, PySequence, TryFromObject};
-
 fn GetLastError() -> u32 {
     unsafe { winapi::um::errhandlingapi::GetLastError() }
 }

vm/src/stdlib/winreg.rs

@@ -1,11 +1,11 @@
 #![allow(non_snake_case)]
-use crate::builtins::pystr::PyStrRef;
-use crate::builtins::pytype::PyTypeRef;
-use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
-use crate::exceptions::IntoPyException;
-use crate::VirtualMachine;
-use crate::{PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject};
 
+use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard};
+use crate::{
+    builtins::{PyStrRef, PyTypeRef},
+    exceptions::IntoPyException,
+    PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, VirtualMachine,
+};
 use std::convert::TryInto;
 use std::ffi::OsStr;
 use std::io;

vm/src/stdlib/zlib.rs

@@ -2,17 +2,15 @@ pub(crate) use decl::make_module;
 
 #[pymodule(name = "zlib")]
 mod decl {
-    use crate::builtins::bytes::{PyBytes, PyBytesRef};
-    use crate::builtins::int::{self, PyIntRef};
-    use crate::builtins::pytype::PyTypeRef;
-    use crate::byteslike::ArgBytesLike;
     use crate::common::lock::PyMutex;
-    use crate::exceptions::PyBaseExceptionRef;
-    use crate::function::OptionalArg;
-    use crate::types::create_simple_type;
-    use crate::vm::VirtualMachine;
-    use crate::{IntoPyRef, PyResult, PyValue, StaticType};
-
+    use crate::{
+        builtins::{int, PyBytes, PyBytesRef, PyIntRef, PyTypeRef},
+        byteslike::ArgBytesLike,
+        exceptions::PyBaseExceptionRef,
+        function::OptionalArg,
+        types::create_simple_type,
+        IntoPyRef, PyResult, PyValue, StaticType, VirtualMachine,
+    };
     use adler32::RollingAdler32 as Adler32;
     use crc32fast::Hasher as Crc32;
     use crossbeam_utils::atomic::AtomicCell;