From 96c9d9ec16472aeb787dbd6c24f5fe9b04d9f688 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Wed, 22 Sep 2021 11:06:12 +0900 Subject: [PATCH] Group use for vm stuff to prevent reorder for rustpython_stdlib --- vm/src/stdlib/array.rs | 39 +++++++++++++++----------------- vm/src/stdlib/binascii.rs | 20 ++++++++-------- vm/src/stdlib/bisect.rs | 11 ++++----- vm/src/stdlib/cmath.rs | 8 ++++--- vm/src/stdlib/csv.rs | 23 ++++++++----------- vm/src/stdlib/dis.rs | 16 ++++++------- vm/src/stdlib/faulthandler.rs | 4 +--- vm/src/stdlib/fcntl.rs | 15 ++++++------ vm/src/stdlib/hashlib.rs | 11 ++++----- vm/src/stdlib/json.rs | 16 ++++++------- vm/src/stdlib/keyword.rs | 5 +--- vm/src/stdlib/math.rs | 15 +++++------- vm/src/stdlib/multiprocessing.rs | 5 +--- vm/src/stdlib/platform.rs | 3 +-- vm/src/stdlib/posixsubprocess.rs | 4 +--- vm/src/stdlib/pyexpat.rs | 3 +-- vm/src/stdlib/random.rs | 12 +++++----- vm/src/stdlib/re.rs | 12 ++++------ vm/src/stdlib/resource.rs | 8 +++---- vm/src/stdlib/scproxy.rs | 7 +++--- vm/src/stdlib/select.rs | 4 +--- vm/src/stdlib/signal.rs | 8 +++---- vm/src/stdlib/socket.rs | 25 ++++++++------------ vm/src/stdlib/ssl.rs | 17 +++++++------- vm/src/stdlib/syslog.rs | 12 +++++----- vm/src/stdlib/termios.rs | 9 ++++---- vm/src/stdlib/unicodedata.rs | 11 ++++----- vm/src/stdlib/weakref.rs | 3 +-- vm/src/stdlib/winapi.rs | 19 +++++++--------- vm/src/stdlib/winreg.rs | 12 +++++----- vm/src/stdlib/zlib.rs | 18 +++++++-------- 31 files changed, 167 insertions(+), 208 deletions(-) diff --git a/vm/src/stdlib/array.rs b/vm/src/stdlib/array.rs index 262a3d6cc..0a04f6064 100644 --- a/vm/src/stdlib/array.rs +++ b/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; diff --git a/vm/src/stdlib/binascii.rs b/vm/src/stdlib/binascii.rs index 925d5de0d..547ad971d 100644 --- a/vm/src/stdlib/binascii.rs +++ b/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), + Buffer(PyRef), + Ascii(PyRef), } impl TryFromObject for SerializedData { diff --git a/vm/src/stdlib/bisect.rs b/vm/src/stdlib/bisect.rs index 5a7ce5381..38b64e08d 100644 --- a/vm/src/stdlib/bisect.rs +++ b/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 { diff --git a/vm/src/stdlib/cmath.rs b/vm/src/stdlib/cmath.rs index d0b7dbf79..4fca95c1b 100644 --- a/vm/src/stdlib/cmath.rs +++ b/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. diff --git a/vm/src/stdlib/csv.rs b/vm/src/stdlib/csv.rs index 38971ebb2..49803ef60 100644 --- a/vm/src/stdlib/csv.rs +++ b/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, diff --git a/vm/src/stdlib/dis.rs b/vm/src/stdlib/dis.rs index 2c7a3bd67..56c2f6c37 100644 --- a/vm/src/stdlib/dis.rs +++ b/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::::try_from_object(vm, co)?; + print!("{}", &code.code); Ok(()) } diff --git a/vm/src/stdlib/faulthandler.rs b/vm/src/stdlib/faulthandler.rs index 257fd81e4..8a7019ddf 100644 --- a/vm/src/stdlib/faulthandler.rs +++ b/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!( diff --git a/vm/src/stdlib/fcntl.rs b/vm/src/stdlib/fcntl.rs index 5dc03141f..670d0e660 100644 --- a/vm/src/stdlib/fcntl.rs +++ b/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}; diff --git a/vm/src/stdlib/hashlib.rs b/vm/src/stdlib/hashlib.rs index def57e0e4..c2e72f87d 100644 --- a/vm/src/stdlib/hashlib.rs +++ b/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; diff --git a/vm/src/stdlib/json.rs b/vm/src/stdlib/json.rs index 5b0cf6fa0..417f0656e 100644 --- a/vm/src/stdlib/json.rs +++ b/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; diff --git a/vm/src/stdlib/keyword.rs b/vm/src/stdlib/keyword.rs index 9477427d5..7012a91f0 100644 --- a/vm/src/stdlib/keyword.rs +++ b/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::() { diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs index c8be7b7a7..9f1ff57a0 100644 --- a/vm/src/stdlib/math.rs +++ b/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: diff --git a/vm/src/stdlib/multiprocessing.rs b/vm/src/stdlib/multiprocessing.rs index e36dbcd52..99cb5a1e8 100644 --- a/vm/src/stdlib/multiprocessing.rs +++ b/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] diff --git a/vm/src/stdlib/platform.rs b/vm/src/stdlib/platform.rs index af22e5497..d834918de 100644 --- a/vm/src/stdlib/platform.rs +++ b/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 { diff --git a/vm/src/stdlib/posixsubprocess.rs b/vm/src/stdlib/posixsubprocess.rs index 8430f5492..4d31f1959 100644 --- a/vm/src/stdlib/posixsubprocess.rs +++ b/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 { diff --git a/vm/src/stdlib/pyexpat.rs b/vm/src/stdlib/pyexpat.rs index d08d37933..0d1036ada 100644 --- a/vm/src/stdlib/pyexpat.rs +++ b/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); diff --git a/vm/src/stdlib/random.rs b/vm/src/stdlib/random.rs index e9b18f837..4e81fbd1e 100644 --- a/vm/src/stdlib/random.rs +++ b/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}; diff --git a/vm/src/stdlib/re.rs b/vm/src/stdlib/re.rs index 94a7522fa..0f55e3930 100644 --- a/vm/src/stdlib/re.rs +++ b/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)] diff --git a/vm/src/stdlib/resource.rs b/vm/src/stdlib/resource.rs index dffee993f..1bac89d21 100644 --- a/vm/src/stdlib/resource.rs +++ b/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! { diff --git a/vm/src/stdlib/scproxy.rs b/vm/src/stdlib/scproxy.rs index 3a2824e0f..770650af6 100644 --- a/vm/src/stdlib/scproxy.rs +++ b/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}, diff --git a/vm/src/stdlib/select.rs b/vm/src/stdlib/select.rs index 8fcdb491e..85a77f546 100644 --- a/vm/src/stdlib/select.rs +++ b/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}; diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs index 398a3d07f..e23650b9f 100644 --- a/vm/src/stdlib/signal.rs +++ b/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)] diff --git a/vm/src/stdlib/socket.rs b/vm/src/stdlib/socket.rs index 57f4994cc..de7513ed1 100644 --- a/vm/src/stdlib/socket.rs +++ b/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)] diff --git a/vm/src/stdlib/ssl.rs b/vm/src/stdlib/ssl.rs index fd48002ee..5c2fb46d4 100644 --- a/vm/src/stdlib/ssl.rs +++ b/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}; diff --git a/vm/src/stdlib/syslog.rs b/vm/src/stdlib/syslog.rs index 6c23d772d..8e451a341 100644 --- a/vm/src/stdlib/syslog.rs +++ b/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] diff --git a/vm/src/stdlib/termios.rs b/vm/src/stdlib/termios.rs index 6d9ec82bd..e889cc492 100644 --- a/vm/src/stdlib/termios.rs +++ b/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; diff --git a/vm/src/stdlib/unicodedata.rs b/vm/src/stdlib/unicodedata.rs index 964e276f0..61195d079 100644 --- a/vm/src/stdlib/unicodedata.rs +++ b/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; diff --git a/vm/src/stdlib/weakref.rs b/vm/src/stdlib/weakref.rs index dbea81bbd..577e6d2a7 100644 --- a/vm/src/stdlib/weakref.rs +++ b/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) diff --git a/vm/src/stdlib/winapi.rs b/vm/src/stdlib/winapi.rs index 7f873f362..397d353ea 100644 --- a/vm/src/stdlib/winapi.rs +++ b/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() } } diff --git a/vm/src/stdlib/winreg.rs b/vm/src/stdlib/winreg.rs index 4e6addf90..2c751be57 100644 --- a/vm/src/stdlib/winreg.rs +++ b/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; diff --git a/vm/src/stdlib/zlib.rs b/vm/src/stdlib/zlib.rs index 8a6c2d75b..4b5e15815 100644 --- a/vm/src/stdlib/zlib.rs +++ b/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;