diff --git a/benches/execution.rs b/benches/execution.rs index 697055b220..9c00f89552 100644 --- a/benches/execution.rs +++ b/benches/execution.rs @@ -4,8 +4,8 @@ use criterion::{ }; use rustpython_compiler::Mode; use rustpython_parser::parser::parse_program; -use rustpython_vm::pyobject::PyResult; use rustpython_vm::Interpreter; +use rustpython_vm::PyResult; use std::collections::HashMap; use std::path::Path; diff --git a/benches/microbenchmarks.rs b/benches/microbenchmarks.rs index d0f23f1603..3933fd09f9 100644 --- a/benches/microbenchmarks.rs +++ b/benches/microbenchmarks.rs @@ -3,8 +3,8 @@ use criterion::{ criterion_group, criterion_main, BatchSize, BenchmarkGroup, BenchmarkId, Criterion, Throughput, }; use rustpython_compiler::Mode; -use rustpython_vm::pyobject::ItemProtocol; -use rustpython_vm::pyobject::PyResult; +use rustpython_vm::ItemProtocol; +use rustpython_vm::PyResult; use rustpython_vm::{InitParameter, Interpreter, PySettings}; use std::path::{Path, PathBuf}; use std::{ffi, fs, io}; diff --git a/derive/src/from_args.rs b/derive/src/from_args.rs index 8619f1c681..d396c20089 100644 --- a/derive/src/from_args.rs +++ b/derive/src/from_args.rs @@ -158,7 +158,7 @@ fn generate_field((i, field): (usize, &Field)) -> Result &'static ::rustpython_vm::builtins::PyTypeRef { - use rustpython_vm::pyobject::StaticType; + use rustpython_vm::StaticType; rustpython_vm::builtins::PyTuple::static_type() } } } else if let Some(base) = base { quote! { fn static_baseclass() -> &'static ::rustpython_vm::builtins::PyTypeRef { - use rustpython_vm::pyobject::StaticType; + use rustpython_vm::StaticType; #base::static_type() } } @@ -196,14 +196,14 @@ fn generate_class_def( }; let tokens = quote! { - impl ::rustpython_vm::pyobject::PyClassDef for #ident { + impl ::rustpython_vm::PyClassDef for #ident { const NAME: &'static str = #name; const MODULE_NAME: Option<&'static str> = #module_name; const TP_NAME: &'static str = #module_class_name; const DOC: Option<&'static str> = #doc; } - impl ::rustpython_vm::pyobject::StaticType for #ident { + impl ::rustpython_vm::StaticType for #ident { fn static_cell() -> &'static ::rustpython_common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> { ::rustpython_common::static_cell! { static CELL: ::rustpython_vm::builtins::PyTypeRef; @@ -555,7 +555,7 @@ impl ToTokens for GetSetNursery { #( #cfgs )* class.set_str_attr( #name, - ::rustpython_vm::pyobject::PyObject::new( + ::rustpython_vm::PyObject::new( ::rustpython_vm::builtins::PyGetSet::new(#name.into()) .with_get(&Self::#getter) #setter #deleter, diff --git a/derive/src/pymodule.rs b/derive/src/pymodule.rs index aab746ef1f..e3d33fdbb7 100644 --- a/derive/src/pymodule.rs +++ b/derive/src/pymodule.rs @@ -64,7 +64,7 @@ pub fn impl_pymodule( parse_quote! { pub(crate) fn extend_module( vm: &::rustpython_vm::VirtualMachine, - module: &::rustpython_vm::pyobject::PyObjectRef, + module: &::rustpython_vm::PyObjectRef, ) { #module_extend_items } @@ -73,7 +73,7 @@ pub fn impl_pymodule( #[allow(dead_code)] pub(crate) fn make_module( vm: &::rustpython_vm::VirtualMachine - ) -> ::rustpython_vm::pyobject::PyObjectRef { + ) -> ::rustpython_vm::PyObjectRef { let module = vm.new_module(MODULE_NAME, vm.ctx.new_dict()); extend_module(vm, &module); module @@ -318,7 +318,7 @@ impl ModuleItem for ClassItem { .optional_name() .unwrap_or_else(|| class_name.clone()); let new_class = quote_spanned!(ident.span() => - <#ident as ::rustpython_vm::pyobject::PyClassImpl>::make_class(&vm.ctx); + <#ident as ::rustpython_vm::PyClassImpl>::make_class(&vm.ctx); ); let item = quote! { let new_class = #new_class; diff --git a/derive/src/pystructseq.rs b/derive/src/pystructseq.rs index 4f3b4d2497..236f10efdd 100644 --- a/derive/src/pystructseq.rs +++ b/derive/src/pystructseq.rs @@ -29,19 +29,19 @@ pub(crate) fn impl_pystruct_sequence( let ty = &input.ident; let ret = quote! { - impl ::rustpython_vm::pyobject::PyStructSequence for #ty { + impl ::rustpython_vm::PyStructSequence for #ty { const FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#field_names)),*]; fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::tuple::PyTuple { - let items = vec![#(::rustpython_vm::pyobject::IntoPyObject::into_pyobject( + let items = vec![#(::rustpython_vm::IntoPyObject::into_pyobject( self.#field_names, vm, )),*]; ::rustpython_vm::builtins::tuple::PyTuple::_new(items.into_boxed_slice()) } } - impl ::rustpython_vm::pyobject::IntoPyObject for #ty { - fn into_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::pyobject::PyObjectRef { - ::rustpython_vm::pyobject::PyStructSequence::into_struct_sequence(self, vm).into_object() + impl ::rustpython_vm::IntoPyObject for #ty { + fn into_pyobject(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::PyObjectRef { + ::rustpython_vm::PyStructSequence::into_struct_sequence(self, vm).into_object() } } }; diff --git a/examples/freeze/main.rs b/examples/freeze/main.rs index b406296bac..c3f5e5f16f 100644 --- a/examples/freeze/main.rs +++ b/examples/freeze/main.rs @@ -1,10 +1,10 @@ use rustpython_vm as vm; -fn main() -> vm::pyobject::PyResult<()> { +fn main() -> vm::PyResult<()> { vm::Interpreter::default().enter(run) } -fn run(vm: &vm::VirtualMachine) -> vm::pyobject::PyResult<()> { +fn run(vm: &vm::VirtualMachine) -> vm::PyResult<()> { let scope = vm.new_scope_with_builtins(); // the file parameter is relevant to the directory where the crate's Cargo.toml is located, see $CARGO_MANIFEST_DIR: diff --git a/examples/hello_embed.rs b/examples/hello_embed.rs index acfd6305b9..9948a84b85 100644 --- a/examples/hello_embed.rs +++ b/examples/hello_embed.rs @@ -1,6 +1,6 @@ use rustpython_vm as vm; -fn main() -> vm::pyobject::PyResult<()> { +fn main() -> vm::PyResult<()> { vm::Interpreter::default().enter(|vm| { let scope = vm.new_scope_with_builtins(); diff --git a/examples/mini_repl.rs b/examples/mini_repl.rs index 7f20043fae..7e8e8817de 100644 --- a/examples/mini_repl.rs +++ b/examples/mini_repl.rs @@ -7,7 +7,7 @@ use rustpython_vm as vm; // these are needed for special memory shenanigans to let us share a variable with Python and Rust use std::sync::atomic::{AtomicBool, Ordering}; // this needs to be in scope in order to insert things into scope.globals -use vm::pyobject::ItemProtocol; +use vm::ItemProtocol; // This has to be a macro because it uses the py_compile macro, // which compiles python source to optimized bytecode at compile time, so that @@ -30,11 +30,11 @@ fn on(b: bool) { ON.store(b, Ordering::Relaxed); } -fn main() -> vm::pyobject::PyResult<()> { +fn main() -> vm::PyResult<()> { vm::Interpreter::default().enter(run) } -fn run(vm: &vm::VirtualMachine) -> vm::pyobject::PyResult<()> { +fn run(vm: &vm::VirtualMachine) -> vm::PyResult<()> { let mut input = String::with_capacity(50); let stdin = std::io::stdin(); diff --git a/src/lib.rs b/src/lib.rs index 904c43e7ff..c4f9d82564 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -46,13 +46,9 @@ extern crate log; use clap::{App, AppSettings, Arg, ArgMatches}; use rustpython_vm::{ - builtins::PyInt, - compile, - exceptions::print_exception, - match_class, - pyobject::{BorrowValue, ItemProtocol, PyResult, TypeProtocol}, - scope::Scope, - sysmodule, InitParameter, Interpreter, PySettings, VirtualMachine, + builtins::PyInt, compile, exceptions::print_exception, match_class, scope::Scope, sysmodule, + BorrowValue, InitParameter, Interpreter, ItemProtocol, PyResult, PySettings, TypeProtocol, + VirtualMachine, }; use std::convert::TryInto; diff --git a/src/shell.rs b/src/shell.rs index 7bab4b7dd7..a8c1869def 100644 --- a/src/shell.rs +++ b/src/shell.rs @@ -5,9 +5,8 @@ use rustpython_vm::readline::{Readline, ReadlineResult}; use rustpython_vm::{ compile::{self, CompileError, CompileErrorType}, exceptions::{print_exception, PyBaseExceptionRef}, - pyobject::{BorrowValue, PyResult, TypeProtocol}, scope::Scope, - VirtualMachine, + BorrowValue, PyResult, TypeProtocol, VirtualMachine, }; enum ShellExecResult { diff --git a/src/shell/helper.rs b/src/shell/helper.rs index 560441791a..eca026fc87 100644 --- a/src/shell/helper.rs +++ b/src/shell/helper.rs @@ -1,6 +1,6 @@ use rustpython_vm::builtins::{PyDictRef, PyStrRef}; -use rustpython_vm::pyobject::{BorrowValue, PyIterable, PyResult, TryFromObject}; use rustpython_vm::VirtualMachine; +use rustpython_vm::{BorrowValue, PyIterable, PyResult, TryFromObject}; pub struct ShellHelper<'vm> { vm: &'vm VirtualMachine, diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs index f44f2da2e7..a766018526 100644 --- a/vm/src/anystr.rs +++ b/vm/src/anystr.rs @@ -1,10 +1,8 @@ use crate::builtins::int::PyIntRef; use crate::cformat::CFormatString; use crate::function::{single_or_tuple_any, OptionalOption}; -use crate::pyobject::{ - BorrowValue, PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol, -}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use num_traits::{cast::ToPrimitive, sign::Signed}; use std::str::FromStr; diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs index d046d9bd44..be57effd08 100644 --- a/vm/src/builtins/asyncgenerator.rs +++ b/vm/src/builtins/asyncgenerator.rs @@ -5,11 +5,11 @@ use crate::coroutine::{Coro, Variant}; use crate::exceptions::PyBaseExceptionRef; use crate::frame::FrameRef; use crate::function::OptionalArg; -use crate::pyobject::{ - IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, -}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{ + IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, +}; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/builtins/builtinfunc.rs b/vm/src/builtins/builtinfunc.rs index e3eb8f79e2..1c3f557b4c 100644 --- a/vm/src/builtins/builtinfunc.rs +++ b/vm/src/builtins/builtinfunc.rs @@ -5,11 +5,11 @@ use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::common::borrow::BorrowValue; use crate::function::{FuncArgs, PyNativeFunc}; -use crate::pyobject::{ - PyClassImpl, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, -}; use crate::slots::{Callable, SlotDescriptor}; use crate::vm::VirtualMachine; +use crate::{ + PyClassImpl, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, +}; pub struct PyNativeFuncDef { pub func: PyNativeFunc, diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index d0b6a8c0c5..84b2df108b 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -16,15 +16,15 @@ use crate::byteslike::PyBytesLike; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ - BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, - PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, -}; use crate::sliceable::{PySliceableSequence, PySliceableSequenceMut, SequenceIndex}; use crate::slots::{ BufferProtocol, Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable, }; use crate::vm::VirtualMachine; +use crate::{ + BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, + PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, +}; use bstr::ByteSlice; use crossbeam_utils::atomic::AtomicCell; use std::mem::size_of; diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 6fb88de3ec..b0dd84f9de 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -15,16 +15,16 @@ use crate::bytesinner::{ }; use crate::common::hash::PyHash; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ - BorrowValue, Either, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, - PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, -}; use crate::slots::{BufferProtocol, Comparable, Hashable, Iterable, PyComparisonOp, PyIter}; use crate::vm::VirtualMachine; use crate::{ anystr::{self, AnyStr}, byteslike::PyBytesLike, }; +use crate::{ + BorrowValue, Either, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, + PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, +}; use crate::builtins::memory::{Buffer, BufferOptions}; diff --git a/vm/src/builtins/classmethod.rs b/vm/src/builtins/classmethod.rs index d84dc5f5a9..78a8941ae8 100644 --- a/vm/src/builtins/classmethod.rs +++ b/vm/src/builtins/classmethod.rs @@ -1,9 +1,7 @@ use super::pytype::PyTypeRef; -use crate::pyobject::{ - PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, -}; use crate::slots::SlotDescriptor; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol}; /// classmethod(function) -> method /// diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index 91f64d5f0e..ce752dbdfa 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -7,11 +7,11 @@ use std::ops::Deref; use super::{PyStrRef, PyTypeRef}; use crate::bytecode::{self, BorrowedConstant, Constant, ConstantBag}; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TypeProtocol, }; -use crate::VirtualMachine; use num_traits::Zero; #[derive(Clone)] diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs index c415aa1af1..6b2b4fdac3 100644 --- a/vm/src/builtins/complex.rs +++ b/vm/src/builtins/complex.rs @@ -5,13 +5,13 @@ use super::float; use super::pystr::PyStr; use super::pytype::PyTypeRef; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ +use crate::slots::{Comparable, Hashable, PyComparisonOp}; +use crate::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, Never, PyArithmaticValue::{self, *}, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; -use crate::slots::{Comparable, Hashable, PyComparisonOp}; -use crate::VirtualMachine; use rustpython_common::{float_ops, hash}; /// Create a complex number from a real part and an optional imaginary part. diff --git a/vm/src/builtins/coroutine.rs b/vm/src/builtins/coroutine.rs index fe99d7a86c..75e9cea181 100644 --- a/vm/src/builtins/coroutine.rs +++ b/vm/src/builtins/coroutine.rs @@ -4,9 +4,9 @@ use super::pytype::PyTypeRef; use crate::coroutine::{Coro, Variant}; use crate::frame::FrameRef; use crate::function::OptionalArg; -use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; type PyCoroutineRef = PyRef; diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index 9ea3132825..666c4fff7b 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -9,13 +9,13 @@ use crate::dictdatatype::{self, DictKey}; use crate::exceptions::PyBaseExceptionRef; use crate::function::{FuncArgs, KwArgs, OptionalArg}; use crate::iterator; -use crate::pyobject::{ +use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable}; +use crate::vm::{ReprGuard, VirtualMachine}; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue::*, PyAttributes, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable}; -use crate::vm::{ReprGuard, VirtualMachine}; pub type DictContentType = dictdatatype::Dict; diff --git a/vm/src/builtins/enumerate.rs b/vm/src/builtins/enumerate.rs index 77bbc8ae49..034aaaca1a 100644 --- a/vm/src/builtins/enumerate.rs +++ b/vm/src/builtins/enumerate.rs @@ -7,11 +7,11 @@ use super::int::PyIntRef; use super::pytype::PyTypeRef; use crate::function::OptionalArg; use crate::iterator; -use crate::pyobject::{ - BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, -}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{ + BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, +}; #[pyclass(module = false, name = "enumerate")] #[derive(Debug)] diff --git a/vm/src/builtins/filter.rs b/vm/src/builtins/filter.rs index d0460c2a86..0ba1f904b6 100644 --- a/vm/src/builtins/filter.rs +++ b/vm/src/builtins/filter.rs @@ -1,9 +1,9 @@ use super::pybool; use super::pytype::PyTypeRef; use crate::iterator; -use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; /// filter(function or None, iterable) --> filter object /// diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs index 017e1d1765..6f26852bbb 100644 --- a/vm/src/builtins/float.rs +++ b/vm/src/builtins/float.rs @@ -9,14 +9,14 @@ use super::pystr::{PyStr, PyStrRef}; use super::pytype::PyTypeRef; use crate::format::FormatSpec; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ +use crate::slots::{Comparable, Hashable, PyComparisonOp}; +use crate::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, PyArithmaticValue::{self, *}, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::{Comparable, Hashable, PyComparisonOp}; -use crate::VirtualMachine; use rustpython_common::{float_ops, hash}; /// Convert a string or number to a floating point number, if possible. diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs index 77bd5d843f..a9f288b493 100644 --- a/vm/src/builtins/frame.rs +++ b/vm/src/builtins/frame.rs @@ -6,8 +6,8 @@ use super::code::PyCodeRef; use super::dict::PyDictRef; use super::pystr::PyStrRef; use crate::frame::{Frame, FrameRef}; -use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult}; use crate::vm::VirtualMachine; +use crate::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult}; pub fn init(context: &PyContext) { FrameRef::extend_class(context, &context.types.frame_type); diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs index b83acbc4d3..acb8ecfb16 100644 --- a/vm/src/builtins/function.rs +++ b/vm/src/builtins/function.rs @@ -13,15 +13,15 @@ use crate::bytecode; use crate::common::lock::PyMutex; use crate::frame::Frame; use crate::function::{FuncArgs, OptionalArg}; +use crate::scope::Scope; +use crate::slots::{Callable, Comparable, PyComparisonOp, SlotDescriptor, SlotGetattro}; #[cfg(feature = "jit")] -use crate::pyobject::IntoPyObject; -use crate::pyobject::{ +use crate::IntoPyObject; +use crate::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, ItemProtocol, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; -use crate::scope::Scope; -use crate::slots::{Callable, Comparable, PyComparisonOp, SlotDescriptor, SlotGetattro}; -use crate::VirtualMachine; use itertools::Itertools; #[cfg(feature = "jit")] use rustpython_common::lock::OnceCell; diff --git a/vm/src/builtins/function/jitfunc.rs b/vm/src/builtins/function/jitfunc.rs index 3725d08ca5..dc50b0fe23 100644 --- a/vm/src/builtins/function/jitfunc.rs +++ b/vm/src/builtins/function/jitfunc.rs @@ -4,11 +4,11 @@ use crate::builtins::{float, int, pybool, PyStrRef}; use crate::bytecode::CodeFlags; use crate::exceptions::PyBaseExceptionRef; use crate::function::FuncArgs; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol, }; -use crate::VirtualMachine; use num_traits::ToPrimitive; use rustpython_jit::{AbiValue, Args, CompiledCode, JitArgumentError, JitType}; diff --git a/vm/src/builtins/generator.rs b/vm/src/builtins/generator.rs index 90cd897fc7..125ac9a590 100644 --- a/vm/src/builtins/generator.rs +++ b/vm/src/builtins/generator.rs @@ -8,9 +8,9 @@ use super::pytype::PyTypeRef; use crate::coroutine::{Coro, Variant}; use crate::frame::FrameRef; use crate::function::OptionalArg; -use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; #[pyclass(module = false, name = "generator")] #[derive(Debug)] diff --git a/vm/src/builtins/getset.rs b/vm/src/builtins/getset.rs index dffcbc116f..2f637dcd9b 100644 --- a/vm/src/builtins/getset.rs +++ b/vm/src/builtins/getset.rs @@ -3,12 +3,12 @@ */ use super::pytype::PyTypeRef; use crate::function::{OwnedParam, RefParam}; -use crate::pyobject::{ +use crate::slots::SlotDescriptor; +use crate::vm::VirtualMachine; +use crate::{ IntoPyResult, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::SlotDescriptor; -use crate::vm::VirtualMachine; pub type PyGetterFunc = Box PyResult)>; pub type PySetterFunc = diff --git a/vm/src/builtins/int.rs b/vm/src/builtins/int.rs index 5774ea7f07..b8a49953d6 100644 --- a/vm/src/builtins/int.rs +++ b/vm/src/builtins/int.rs @@ -15,14 +15,14 @@ use super::pystr::{PyStr, PyStrRef}; use super::pytype::PyTypeRef; use crate::format::FormatSpec; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ +use crate::slots::{Comparable, Hashable, PyComparisonOp}; +use crate::VirtualMachine; +use crate::{bytesinner::PyBytesInner, byteslike::try_bytes_like}; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, IntoPyResult, PyArithmaticValue, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::{Comparable, Hashable, PyComparisonOp}; -use crate::VirtualMachine; -use crate::{bytesinner::PyBytesInner, byteslike::try_bytes_like}; use rustpython_common::hash; /// int(x=0) -> integer diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs index 99ffe1f7d5..c4877c6b51 100644 --- a/vm/src/builtins/iter.rs +++ b/vm/src/builtins/iter.rs @@ -5,12 +5,12 @@ use crossbeam_utils::atomic::AtomicCell; use super::pytype::PyTypeRef; -use crate::pyobject::{ +use crate::slots::PyIter; +use crate::vm::VirtualMachine; +use crate::{ ItemProtocol, PyCallable, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; -use crate::slots::PyIter; -use crate::vm::VirtualMachine; #[pyclass(module = false, name = "iter")] #[derive(Debug)] diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs index a2ac441842..bea4063976 100644 --- a/vm/src/builtins/list.rs +++ b/vm/src/builtins/list.rs @@ -9,14 +9,14 @@ use super::pytype::PyTypeRef; use super::slice::PySliceRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::OptionalArg; -use crate::pyobject::{ - BorrowValue, Either, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, - PyResult, PyValue, TryFromObject, TypeProtocol, -}; use crate::sequence::{self, SimpleSeq}; use crate::sliceable::{PySliceableSequence, PySliceableSequenceMut, SequenceIndex}; use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable}; use crate::vm::{ReprGuard, VirtualMachine}; +use crate::{ + BorrowValue, Either, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, + PyResult, PyValue, TryFromObject, TypeProtocol, +}; /// Built-in mutable sequence. /// diff --git a/vm/src/builtins/make_module.rs b/vm/src/builtins/make_module.rs index 10cdf30790..8bd1375dca 100644 --- a/vm/src/builtins/make_module.rs +++ b/vm/src/builtins/make_module.rs @@ -1,8 +1,8 @@ //! Builtin function definitions. //! //! Implements functions listed here: https://docs.python.org/3/library/builtins.html -use crate::pyobject::PyObjectRef; use crate::vm::VirtualMachine; +use crate::PyObjectRef; /// Built-in functions, exceptions, and other objects. /// @@ -28,15 +28,15 @@ mod decl { single_or_tuple_any, Args, FuncArgs, KwArgs, OptionalArg, OptionalOption, }; use crate::iterator; - use crate::pyobject::{ - BorrowValue, Either, IdProtocol, ItemProtocol, PyArithmaticValue, PyCallable, PyClassImpl, - PyIterable, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, - }; use crate::readline::{Readline, ReadlineResult}; use crate::scope::Scope; use crate::slots::PyComparisonOp; use crate::vm::VirtualMachine; use crate::{py_io, sysmodule}; + use crate::{ + BorrowValue, Either, IdProtocol, ItemProtocol, PyArithmaticValue, PyCallable, PyClassImpl, + PyIterable, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, + }; use num_traits::{Signed, Zero}; #[pyfunction] diff --git a/vm/src/builtins/map.rs b/vm/src/builtins/map.rs index 21fcf237e8..248f2e14f4 100644 --- a/vm/src/builtins/map.rs +++ b/vm/src/builtins/map.rs @@ -1,9 +1,9 @@ use super::pytype::PyTypeRef; use crate::function::Args; use crate::iterator; -use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; /// map(func, *iterables) --> map object /// diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs index df88ee2a8c..22d6350ec7 100644 --- a/vm/src/builtins/mappingproxy.rs +++ b/vm/src/builtins/mappingproxy.rs @@ -3,12 +3,12 @@ use super::pystr::PyStrRef; use super::pytype::PyTypeRef; use crate::function::OptionalArg; use crate::iterator; -use crate::pyobject::{ +use crate::slots::Iterable; +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; -use crate::slots::Iterable; -use crate::vm::VirtualMachine; #[pyclass(module = false, name = "mappingproxy")] #[derive(Debug)] diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index 7e3dffd981..9034cf7057 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -11,14 +11,14 @@ use crate::common::hash::PyHash; use crate::common::lock::OnceCell; use crate::common::rc::PyRc; use crate::function::{FuncArgs, OptionalArg}; -use crate::pyobject::{ - Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, - PyRef, PyResult, PyThreadingConstraint, PyValue, TypeProtocol, -}; use crate::sliceable::{convert_slice, saturate_range, wrap_index, SequenceIndex}; use crate::slots::{BufferProtocol, Comparable, Hashable, PyComparisonOp}; use crate::stdlib::pystruct::_struct::FormatSpec; use crate::VirtualMachine; +use crate::{ + Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, + PyRef, PyResult, PyThreadingConstraint, PyValue, TypeProtocol, +}; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; use num_bigint::BigInt; diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs index 04b63d6950..6e340239d9 100644 --- a/vm/src/builtins/module.rs +++ b/vm/src/builtins/module.rs @@ -2,12 +2,12 @@ use super::dict::PyDictRef; use super::pystr::{PyStr, PyStrRef}; use super::pytype::PyTypeRef; use crate::function::FuncArgs; -use crate::pyobject::{ +use crate::slots::SlotGetattro; +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, }; -use crate::slots::SlotGetattro; -use crate::vm::VirtualMachine; #[pyclass(module = false, name = "module")] #[derive(Debug)] @@ -60,7 +60,7 @@ impl PyModule { #[pymethod(magic)] fn init(zelf: PyRef, args: ModuleInitArgs, vm: &VirtualMachine) { - debug_assert!(crate::pyobject::TypeProtocol::class(zelf.as_object()) + debug_assert!(crate::TypeProtocol::class(zelf.as_object()) .slots .flags .has_feature(crate::slots::PyTpFlags::HAS_DICT)); diff --git a/vm/src/builtins/namespace.rs b/vm/src/builtins/namespace.rs index 796dca3a2e..b86180357e 100644 --- a/vm/src/builtins/namespace.rs +++ b/vm/src/builtins/namespace.rs @@ -1,7 +1,7 @@ use super::pytype::PyTypeRef; use crate::function::KwArgs; -use crate::pyobject::{PyClassImpl, PyContext, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyRef, PyResult, PyValue}; /// A simple attribute-based namespace. /// diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs index d4362ae9e6..a08faadae6 100644 --- a/vm/src/builtins/object.rs +++ b/vm/src/builtins/object.rs @@ -6,13 +6,13 @@ use super::pytype::PyTypeRef; use crate::builtins::pytype::PyType; use crate::common::hash::PyHash; use crate::function::FuncArgs; -use crate::pyobject::{ +use crate::slots::PyComparisonOp; +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, Either, IdProtocol, ItemProtocol, PyArithmaticValue, PyAttributes, PyClassImpl, PyComparisonValue, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::PyComparisonOp; -use crate::vm::VirtualMachine; /// The most base type #[pyclass(module = false, name = "object")] diff --git a/vm/src/builtins/property.rs b/vm/src/builtins/property.rs index 1c44795b45..1113ad9580 100644 --- a/vm/src/builtins/property.rs +++ b/vm/src/builtins/property.rs @@ -5,11 +5,11 @@ use crate::common::lock::PyRwLock; use super::pytype::PyTypeRef; use crate::function::FuncArgs; -use crate::pyobject::{ - PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, -}; use crate::slots::SlotDescriptor; use crate::vm::VirtualMachine; +use crate::{ + PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, +}; /// Property attribute. /// diff --git a/vm/src/builtins/pybool.rs b/vm/src/builtins/pybool.rs index 39c7fb8987..0860024244 100644 --- a/vm/src/builtins/pybool.rs +++ b/vm/src/builtins/pybool.rs @@ -4,11 +4,11 @@ use num_traits::Zero; use super::int::PyInt; use super::pystr::PyStrRef; use crate::function::OptionalArg; -use crate::pyobject::{ +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyResult, TryFromObject, TypeProtocol, }; -use crate::vm::VirtualMachine; impl IntoPyObject for bool { fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef { diff --git a/vm/src/builtins/pystr.rs b/vm/src/builtins/pystr.rs index 628d3af654..6fa3454cd4 100644 --- a/vm/src/builtins/pystr.rs +++ b/vm/src/builtins/pystr.rs @@ -20,14 +20,14 @@ use crate::anystr::{self, adjust_indices, AnyStr, AnyStrContainer, AnyStrWrapper use crate::exceptions::IntoPyException; use crate::format::{FormatSpec, FormatString, FromTemplate}; use crate::function::{FuncArgs, OptionalArg, OptionalOption}; -use crate::pyobject::{ +use crate::sliceable::PySliceableSequence; +use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter}; +use crate::VirtualMachine; +use crate::{ BorrowValue, Either, IdProtocol, IntoPyObject, ItemProtocol, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TryIntoRef, TypeProtocol, }; -use crate::sliceable::PySliceableSequence; -use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter}; -use crate::VirtualMachine; use rustpython_common::hash; /// str(object='') -> str diff --git a/vm/src/builtins/pysuper.rs b/vm/src/builtins/pysuper.rs index a456ad8547..cc6ced3277 100644 --- a/vm/src/builtins/pysuper.rs +++ b/vm/src/builtins/pysuper.rs @@ -9,12 +9,12 @@ https://github.com/python/cpython/blob/50b48572d9a90c5bb36e2bef6179548ea927a35a/ use super::pystr::PyStrRef; use super::pytype::{PyType, PyTypeRef}; use crate::function::OptionalArg; -use crate::pyobject::{ +use crate::slots::{SlotDescriptor, SlotGetattro}; +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; -use crate::slots::{SlotDescriptor, SlotGetattro}; -use crate::vm::VirtualMachine; #[pyclass(module = false, name = "super")] #[derive(Debug)] diff --git a/vm/src/builtins/pytype.rs b/vm/src/builtins/pytype.rs index 29607e2b87..95857766bf 100644 --- a/vm/src/builtins/pytype.rs +++ b/vm/src/builtins/pytype.rs @@ -17,12 +17,12 @@ use super::tuple::PyTuple; use super::weakref::PyWeak; use crate::builtins::tuple::PyTupleTyped; use crate::function::{FuncArgs, KwArgs}; -use crate::pyobject::{ +use crate::slots::{self, Callable, PyTpFlags, PyTypeSlots, SlotGetattro, SlotSetattro}; +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, Either, IdProtocol, PyAttributes, PyClassImpl, PyContext, PyLease, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::slots::{self, Callable, PyTpFlags, PyTypeSlots, SlotGetattro, SlotSetattro}; -use crate::vm::VirtualMachine; use itertools::Itertools; use std::ops::Deref; diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs index 982e695829..293eb9e330 100644 --- a/vm/src/builtins/range.rs +++ b/vm/src/builtins/range.rs @@ -8,12 +8,12 @@ use super::pytype::PyTypeRef; use super::slice::{PySlice, PySliceRef}; use crate::common::hash::PyHash; use crate::function::{FuncArgs, OptionalArg}; -use crate::pyobject::{ - self, BorrowValue, IdProtocol, IntoPyRef, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, - PyValue, TryFromObject, TypeProtocol, -}; use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter}; use crate::vm::VirtualMachine; +use crate::{ + BorrowValue, IdProtocol, IntoPyRef, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, + PyValue, TryFromObject, TypeProtocol, +}; /// range(stop) -> range object /// range(start, stop[, step]) -> range object @@ -341,7 +341,7 @@ impl Hashable for PyRange { zelf.step().into_object(), ] }; - pyobject::hash_iter(elements.iter(), vm) + crate::hash_iter(elements.iter(), vm) } } @@ -351,7 +351,7 @@ impl Comparable for PyRange { other: &PyObjectRef, op: PyComparisonOp, _vm: &VirtualMachine, - ) -> PyResult { + ) -> PyResult { op.eq_only(|| { if zelf.is(other) { return Ok(true.into()); diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index be932a7720..3cdffd4a1e 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -7,12 +7,12 @@ use crate::common::rc::PyRc; use crate::dictdatatype; use crate::function::OptionalArg::{Missing, Present}; use crate::function::{Args, OptionalArg}; -use crate::pyobject::{ - self, BorrowValue, IdProtocol, PyClassImpl, PyComparisonValue, PyContext, PyIterable, - PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, -}; use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter, Unhashable}; use crate::vm::{ReprGuard, VirtualMachine}; +use crate::{ + BorrowValue, IdProtocol, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, + PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, +}; use crossbeam_utils::atomic::AtomicCell; use std::fmt; @@ -291,7 +291,7 @@ impl PySetInner { } fn hash(&self, vm: &VirtualMachine) -> PyResult { - pyobject::hash_iter_unordered(self.content.keys().iter(), vm) + crate::hash_iter_unordered(self.content.keys().iter(), vm) } } diff --git a/vm/src/builtins/singletons.rs b/vm/src/builtins/singletons.rs index a577bfcdd3..a77f520e61 100644 --- a/vm/src/builtins/singletons.rs +++ b/vm/src/builtins/singletons.rs @@ -1,8 +1,6 @@ use super::pytype::PyTypeRef; -use crate::pyobject::{ - IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyValue, TypeProtocol, -}; use crate::vm::VirtualMachine; +use crate::{IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyValue, TypeProtocol}; #[pyclass(module = false, name = "NoneType")] #[derive(Debug)] diff --git a/vm/src/builtins/slice.rs b/vm/src/builtins/slice.rs index 0f09b4a92e..766415bc9a 100644 --- a/vm/src/builtins/slice.rs +++ b/vm/src/builtins/slice.rs @@ -3,12 +3,12 @@ use super::int::{PyInt, PyIntRef}; use super::pytype::PyTypeRef; use crate::function::{FuncArgs, OptionalArg}; -use crate::pyobject::{ +use crate::slots::{Comparable, Hashable, PyComparisonOp, Unhashable}; +use crate::VirtualMachine; +use crate::{ BorrowValue, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryIntoRef, TypeProtocol, }; -use crate::slots::{Comparable, Hashable, PyComparisonOp, Unhashable}; -use crate::VirtualMachine; use num_bigint::{BigInt, ToBigInt}; use num_traits::{One, Signed, Zero}; diff --git a/vm/src/builtins/staticmethod.rs b/vm/src/builtins/staticmethod.rs index 78d2ddfe0f..c5a20c1fa9 100644 --- a/vm/src/builtins/staticmethod.rs +++ b/vm/src/builtins/staticmethod.rs @@ -1,7 +1,7 @@ use super::pytype::PyTypeRef; -use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::SlotDescriptor; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; #[pyclass(module = false, name = "staticmethod")] #[derive(Clone, Debug)] diff --git a/vm/src/builtins/traceback.rs b/vm/src/builtins/traceback.rs index fa7d4a8f18..c99db7c8b3 100644 --- a/vm/src/builtins/traceback.rs +++ b/vm/src/builtins/traceback.rs @@ -1,7 +1,7 @@ use crate::builtins::pytype::PyTypeRef; use crate::frame::FrameRef; -use crate::pyobject::{BorrowValue, PyClassImpl, PyContext, PyRef, PyValue}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, PyClassImpl, PyContext, PyRef, PyValue}; #[pyclass(module = false, name = "traceback")] #[derive(Debug)] diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index d9a0a5a3cc..8b679c9b3e 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -5,15 +5,15 @@ use std::marker::PhantomData; use super::pytype::PyTypeRef; use crate::common::hash::PyHash; use crate::function::OptionalArg; -use crate::pyobject::{ - self, BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl, - PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TransmuteFromObject, - TryFromObject, TypeProtocol, -}; use crate::sequence::{self, SimpleSeq}; use crate::sliceable::PySliceableSequence; use crate::slots::{Comparable, Hashable, Iterable, PyComparisonOp, PyIter}; use crate::vm::{ReprGuard, VirtualMachine}; +use crate::{ + BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl, + PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TransmuteFromObject, + TryFromObject, TypeProtocol, +}; /// tuple() -> empty tuple /// tuple(iterable) -> tuple initialized from iterable's items @@ -266,7 +266,7 @@ impl PyTuple { impl Hashable for PyTuple { fn hash(zelf: &PyRef, vm: &VirtualMachine) -> PyResult { - pyobject::hash_iter(zelf.elements.iter(), vm) + crate::hash_iter(zelf.elements.iter(), vm) } } diff --git a/vm/src/builtins/weakproxy.rs b/vm/src/builtins/weakproxy.rs index 45737efbdb..4aa8612f93 100644 --- a/vm/src/builtins/weakproxy.rs +++ b/vm/src/builtins/weakproxy.rs @@ -2,9 +2,9 @@ use super::pytype::PyTypeRef; use super::weakref::PyWeak; use super::PyStrRef; use crate::function::OptionalArg; -use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::SlotSetattro; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; #[pyclass(module = false, name = "weakproxy")] #[derive(Debug)] diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs index 4e5b4d0c84..17186b500d 100644 --- a/vm/src/builtins/weakref.rs +++ b/vm/src/builtins/weakref.rs @@ -1,12 +1,12 @@ use super::pytype::PyTypeRef; use crate::common::hash::PyHash; use crate::function::{FuncArgs, OptionalArg}; -use crate::pyobject::{ +use crate::slots::{Callable, Comparable, Hashable, PyComparisonOp}; +use crate::vm::VirtualMachine; +use crate::{ IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyObjectWeak, PyRef, PyResult, PyValue, TypeProtocol, }; -use crate::slots::{Callable, Comparable, Hashable, PyComparisonOp}; -use crate::vm::VirtualMachine; use crossbeam_utils::atomic::AtomicCell; @@ -94,7 +94,7 @@ impl Comparable for PyWeak { other: &PyObjectRef, op: PyComparisonOp, vm: &VirtualMachine, - ) -> PyResult { + ) -> PyResult { op.eq_only(|| { let other = class_or_notimplemented!(Self, other); let both = zelf.upgrade().and_then(|s| other.upgrade().map(|o| (s, o))); diff --git a/vm/src/builtins/zip.rs b/vm/src/builtins/zip.rs index e236c0c476..8a7795d692 100644 --- a/vm/src/builtins/zip.rs +++ b/vm/src/builtins/zip.rs @@ -1,9 +1,9 @@ use super::pytype::PyTypeRef; use crate::function::Args; use crate::iterator; -use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyIter; use crate::vm::VirtualMachine; +use crate::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; pub type PyZipRef = PyRef; diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs index a1d43558c1..e7438bb603 100644 --- a/vm/src/bytesinner.rs +++ b/vm/src/bytesinner.rs @@ -13,13 +13,13 @@ use crate::builtins::PyTypeRef; use crate::byteslike::try_bytes_like; use crate::cformat::CFormatBytes; use crate::function::{OptionalArg, OptionalOption}; -use crate::pyobject::{ - BorrowValue, Either, IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyResult, PyValue, - TryFromObject, -}; use crate::sliceable::PySliceableSequence; use crate::slots::PyComparisonOp; use crate::vm::VirtualMachine; +use crate::{ + BorrowValue, Either, IdProtocol, PyComparisonValue, PyIterable, PyObjectRef, PyResult, PyValue, + TryFromObject, +}; use rustpython_common::hash; #[derive(Debug, Default, Clone)] diff --git a/vm/src/byteslike.rs b/vm/src/byteslike.rs index ab76765635..7d8000d3e3 100644 --- a/vm/src/byteslike.rs +++ b/vm/src/byteslike.rs @@ -1,8 +1,8 @@ use crate::builtins::memory::{try_buffer_from_object, BufferRef}; use crate::builtins::PyStrRef; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, PyObjectRef, PyResult, TryFromObject}; #[derive(Debug)] pub struct PyBytesLike(BufferRef); diff --git a/vm/src/cformat.rs b/vm/src/cformat.rs index b3538e6433..cc29ebace5 100644 --- a/vm/src/cformat.rs +++ b/vm/src/cformat.rs @@ -5,10 +5,8 @@ use crate::builtins::int::{self, PyInt}; use crate::builtins::pystr::PyStr; use crate::builtins::{memory::try_buffer_from_object, tuple, PyBytes}; use crate::common::float_ops; -use crate::pyobject::{ - BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol, -}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use itertools::Itertools; use num_bigint::{BigInt, Sign}; use num_traits::cast::ToPrimitive; diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs index c19064e6c4..94d5da7425 100644 --- a/vm/src/coroutine.rs +++ b/vm/src/coroutine.rs @@ -1,8 +1,8 @@ use crate::builtins::{PyStrRef, PyTypeRef}; use crate::exceptions::{self, PyBaseExceptionRef}; use crate::frame::{ExecutionResult, FrameRef}; -use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol}; use crate::VirtualMachine; +use crate::{PyObjectRef, PyResult, TypeProtocol}; use crate::common::lock::PyMutex; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs index 7963b92895..9ea14b6b15 100644 --- a/vm/src/dictdatatype.rs +++ b/vm/src/dictdatatype.rs @@ -4,10 +4,10 @@ use crate::builtins::{PyStr, PyStrRef}; /// And: https://www.youtube.com/watch?v=p33CVV29OG8 /// And: http://code.activestate.com/recipes/578375/ use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; -use crate::pyobject::{ +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, IntoPyObject, PyObjectRef, PyRefExact, PyResult, TypeProtocol, }; -use crate::vm::VirtualMachine; use rustpython_common::hash; use std::fmt; use std::mem::size_of; diff --git a/vm/src/eval.rs b/vm/src/eval.rs index e8a00387b9..35751e02aa 100644 --- a/vm/src/eval.rs +++ b/vm/src/eval.rs @@ -1,6 +1,6 @@ use crate::compile; -use crate::pyobject::PyResult; use crate::scope::Scope; +use crate::PyResult; use crate::VirtualMachine; pub fn eval(vm: &VirtualMachine, source: &str, scope: Scope, source_path: &str) -> PyResult { diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index 56752aa824..f6136ef916 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -6,14 +6,14 @@ use crate::builtins::tuple::{PyTuple, PyTupleRef}; use crate::common::lock::PyRwLock; use crate::function::FuncArgs; use crate::py_io::{self, Write}; -use crate::pyobject::StaticType; -use crate::pyobject::{ +use crate::sysmodule; +use crate::types::create_type_with_slots; +use crate::StaticType; +use crate::VirtualMachine; +use crate::{ BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; -use crate::sysmodule; -use crate::types::create_type_with_slots; -use crate::VirtualMachine; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; diff --git a/vm/src/format.rs b/vm/src/format.rs index 779ddb6ad3..0bf079ae6b 100644 --- a/vm/src/format.rs +++ b/vm/src/format.rs @@ -2,8 +2,8 @@ use crate::builtins::{self, pystr}; use crate::common::float_ops; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::FuncArgs; -use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult, TypeProtocol}; use crate::vm::VirtualMachine; +use crate::{ItemProtocol, PyObjectRef, PyResult, TypeProtocol}; use itertools::{Itertools, PeekingNext}; use num_bigint::{BigInt, Sign}; use num_traits::cast::ToPrimitive; diff --git a/vm/src/frame.rs b/vm/src/frame.rs index e3bc4d5228..b523835a26 100644 --- a/vm/src/frame.rs +++ b/vm/src/frame.rs @@ -25,13 +25,13 @@ use crate::coroutine::Coro; use crate::exceptions::{self, ExceptionCtor, PyBaseExceptionRef}; use crate::function::FuncArgs; use crate::iterator; -use crate::pyobject::{ - BorrowValue, IdProtocol, ItemProtocol, PyMethod, PyObjectRef, PyRef, PyResult, PyValue, - TryFromObject, TypeProtocol, -}; use crate::scope::Scope; use crate::slots::PyComparisonOp; use crate::vm::VirtualMachine; +use crate::{ + BorrowValue, IdProtocol, ItemProtocol, PyMethod, PyObjectRef, PyRef, PyResult, PyValue, + TryFromObject, TypeProtocol, +}; #[derive(Clone, Debug)] struct Block { @@ -434,7 +434,7 @@ impl ExecutingFrame<'_> { exc_tb: PyObjectRef, ) -> PyResult { if let Some(coro) = self.yield_from_target() { - use crate::pyobject::Either; + use crate::Either; // borrow checker shenanigans - we only need to use exc_type/val/tb if the following // variable is Some let thrower = if let Some(coro) = self.builtin_coro(coro) { diff --git a/vm/src/function.rs b/vm/src/function.rs index 1c9f5f05ea..8a3cce325c 100644 --- a/vm/src/function.rs +++ b/vm/src/function.rs @@ -2,11 +2,11 @@ use self::OptionalArg::*; use crate::builtins::pytype::PyTypeRef; use crate::builtins::tuple::PyTupleRef; use crate::exceptions::PyBaseExceptionRef; -use crate::pyobject::{ +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IntoPyObject, IntoPyResult, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue, TryFromObject, TypeProtocol, }; -use crate::vm::VirtualMachine; use indexmap::IndexMap; use itertools::Itertools; use result_like::impl_option_like; diff --git a/vm/src/import.rs b/vm/src/import.rs index b211e6b73b..c2ae1758ad 100644 --- a/vm/src/import.rs +++ b/vm/src/import.rs @@ -9,10 +9,10 @@ use crate::builtins::{code, list}; #[cfg(feature = "rustpython-compiler")] use crate::compile; use crate::exceptions::PyBaseExceptionRef; -use crate::pyobject::{BorrowValue, ItemProtocol, PyResult, PyValue, TryFromObject, TypeProtocol}; use crate::scope::Scope; use crate::version::get_git_revision; use crate::vm::{InitParameter, VirtualMachine}; +use crate::{BorrowValue, ItemProtocol, PyResult, PyValue, TryFromObject, TypeProtocol}; pub(crate) fn init_importlib( vm: &mut VirtualMachine, diff --git a/vm/src/iterator.rs b/vm/src/iterator.rs index e6552a30cf..a603ad9877 100644 --- a/vm/src/iterator.rs +++ b/vm/src/iterator.rs @@ -5,8 +5,8 @@ use crate::builtins::int::{self, PyInt}; use crate::builtins::iter::PySequenceIterator; use crate::exceptions::PyBaseExceptionRef; -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol}; use num_traits::Signed; /* diff --git a/vm/src/lib.rs b/vm/src/lib.rs index 966ead6591..2770a4da70 100644 --- a/vm/src/lib.rs +++ b/vm/src/lib.rs @@ -67,7 +67,7 @@ pub mod import; pub mod iterator; pub mod py_io; pub mod py_serde; -pub mod pyobject; +mod pyobject; mod pyobjectrc; pub mod readline; pub mod scope; @@ -80,7 +80,8 @@ pub mod types; mod version; mod vm; -// pub use self::pyobject::Executor; +// pub use self::Executor; +pub use self::pyobject::*; pub use self::vm::{InitParameter, Interpreter, PySettings, VirtualMachine}; pub use rustpython_bytecode as bytecode; pub use rustpython_common as common; diff --git a/vm/src/macros.rs b/vm/src/macros.rs index 672f7811b3..b418d1daa1 100644 --- a/vm/src/macros.rs +++ b/vm/src/macros.rs @@ -11,7 +11,7 @@ macro_rules! py_module { macro_rules! extend_module { ( $vm:expr, $module:expr, { $($name:expr => $value:expr),* $(,)? }) => {{ #[allow(unused_variables)] - let module: &$crate::pyobject::PyObjectRef = &$module; + let module: &$crate::PyObjectRef = &$module; $( $vm.__module_set_attr(&module, $name, $value).unwrap(); )* @@ -86,7 +86,7 @@ macro_rules! py_namespace { /// use rustpython_vm::match_class; /// use rustpython_vm::builtins::PyFloat; /// use rustpython_vm::builtins::PyInt; -/// use rustpython_vm::pyobject::PyValue; +/// use rustpython_vm::PyValue; /// /// # rustpython_vm::Interpreter::default().enter(|vm| { /// let obj = PyInt::from(0).into_ref(&vm).into_object(); @@ -111,7 +111,7 @@ macro_rules! py_namespace { /// use rustpython_vm::match_class; /// use rustpython_vm::builtins::PyFloat; /// use rustpython_vm::builtins::PyInt; -/// use rustpython_vm::pyobject::{PyValue, BorrowValue}; +/// use rustpython_vm::{PyValue, BorrowValue}; /// /// # rustpython_vm::Interpreter::default().enter(|vm| { /// let obj = PyInt::from(0).into_ref(&vm).into_object(); @@ -215,9 +215,9 @@ macro_rules! flame_guard { #[macro_export] macro_rules! class_or_notimplemented { ($t:ty, $obj:expr) => { - match $crate::pyobject::PyObjectRef::downcast_ref::<$t>($obj) { + match $crate::PyObjectRef::downcast_ref::<$t>($obj) { Some(pyref) => pyref, - None => return Ok($crate::pyobject::PyArithmaticValue::NotImplemented), + None => return Ok($crate::PyArithmaticValue::NotImplemented), } }; } @@ -226,7 +226,7 @@ macro_rules! class_or_notimplemented { macro_rules! named_function { ($ctx:expr, $module:ident, $func:ident) => {{ #[allow(unused_variables)] // weird lint, something to do with paste probably - let ctx: &$crate::pyobject::PyContext = &$ctx; + let ctx: &$crate::PyContext = &$ctx; $crate::__exports::paste::expr! { ctx.make_funcdef( stringify!($module), diff --git a/vm/src/py_io.rs b/vm/src/py_io.rs index 0ab7dbef74..a747b14fb4 100644 --- a/vm/src/py_io.rs +++ b/vm/src/py_io.rs @@ -1,8 +1,8 @@ use crate::builtins::bytes::PyBytes; use crate::builtins::pystr::PyStr; use crate::exceptions::PyBaseExceptionRef; -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult}; use crate::VirtualMachine; +use crate::{BorrowValue, PyObjectRef, PyResult}; use std::{fmt, io, ops}; pub trait Write { diff --git a/vm/src/py_serde.rs b/vm/src/py_serde.rs index ae6c5b9a65..8d8fa4a1ff 100644 --- a/vm/src/py_serde.rs +++ b/vm/src/py_serde.rs @@ -4,8 +4,8 @@ use serde::de::{DeserializeSeed, Visitor}; use serde::ser::{Serialize, SerializeMap, SerializeSeq}; use crate::builtins::{dict::PyDictRef, float, int, list::PyList, pybool, pystr, tuple::PyTuple}; -use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, TypeProtocol}; use crate::VirtualMachine; +use crate::{BorrowValue, ItemProtocol, PyObjectRef, TypeProtocol}; #[inline] pub fn serialize( diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs index b1e7396845..3880c397d6 100644 --- a/vm/src/pyobject.rs +++ b/vm/src/pyobject.rs @@ -1000,7 +1000,7 @@ impl IntoPyObject for Either { /// ``` /// use rustpython_vm::VirtualMachine; /// use rustpython_vm::builtins::{PyStrRef, PyIntRef}; -/// use rustpython_vm::pyobject::Either; +/// use rustpython_vm::Either; /// /// fn do_something(arg: Either, vm: &VirtualMachine) { /// match arg { diff --git a/vm/src/pyobjectrc.rs b/vm/src/pyobjectrc.rs index 546fe1c56e..d7bf43457a 100644 --- a/vm/src/pyobjectrc.rs +++ b/vm/src/pyobjectrc.rs @@ -1,8 +1,8 @@ use crate::builtins::{PyDictRef, PyTypeRef}; use crate::common::lock::PyRwLock; use crate::common::rc::{PyRc, PyWeak}; -use crate::pyobject::{self, IdProtocol, PyObjectPayload, TypeProtocol}; use crate::VirtualMachine; +use crate::{IdProtocol, PyObjectPayload, TypeProtocol}; use std::any::TypeId; use std::fmt; use std::marker::PhantomData; @@ -226,7 +226,7 @@ impl PyObjectRef { /// /// If the downcast fails, the original ref is returned in as `Err` so /// another downcast can be attempted without unnecessary cloning. - pub fn downcast_exact( + pub fn downcast_exact( self, vm: &VirtualMachine, ) -> Result, Self> { @@ -244,7 +244,7 @@ impl PyObjectRef { } #[inline] - pub fn payload_if_exact( + pub fn payload_if_exact( &self, vm: &VirtualMachine, ) -> Option<&T> { @@ -271,10 +271,7 @@ impl PyObjectRef { } #[inline] - pub fn payload_if_subclass( - &self, - vm: &crate::VirtualMachine, - ) -> Option<&T> { + pub fn payload_if_subclass(&self, vm: &crate::VirtualMachine) -> Option<&T> { if self.class().issubclass(T::class(vm)) { self.payload() } else { @@ -297,7 +294,7 @@ impl PyObjectWeak { impl Drop for PyObjectRef { fn drop(&mut self) { - use crate::pyobject::BorrowValue; + use crate::BorrowValue; // PyObjectRef will drop the value when its count goes to 0 if PyRc::strong_count(&self.rc) != 1 { @@ -475,7 +472,7 @@ macro_rules! partially_init { pub(crate) fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef) { use crate::builtins::{object, PyType, PyWeak}; - use crate::pyobject::{PyAttributes, PyClassDef, PyClassImpl}; + use crate::{PyAttributes, PyClassDef, PyClassImpl}; use std::mem::MaybeUninit; use std::ptr; diff --git a/vm/src/scope.rs b/vm/src/scope.rs index 8a25dc3a55..9f1935007c 100644 --- a/vm/src/scope.rs +++ b/vm/src/scope.rs @@ -1,8 +1,8 @@ use std::fmt; use crate::builtins::{PyDictRef, PyStr, PyStrRef}; -use crate::pyobject::{IntoPyObject, ItemProtocol, TryIntoRef}; use crate::VirtualMachine; +use crate::{IntoPyObject, ItemProtocol, TryIntoRef}; #[derive(Clone)] pub struct Scope { diff --git a/vm/src/sequence.rs b/vm/src/sequence.rs index e9ec3ca48d..60bf245e19 100644 --- a/vm/src/sequence.rs +++ b/vm/src/sequence.rs @@ -1,6 +1,6 @@ -use crate::pyobject::{PyObjectRef, PyResult}; use crate::slots::PyComparisonOp; use crate::vm::VirtualMachine; +use crate::{PyObjectRef, PyResult}; use num_traits::cast::ToPrimitive; pub(super) type DynPyIter<'a> = Box + 'a>; diff --git a/vm/src/sliceable.rs b/vm/src/sliceable.rs index d6cf9a462b..ffb9120b4f 100644 --- a/vm/src/sliceable.rs +++ b/vm/src/sliceable.rs @@ -4,8 +4,8 @@ use std::ops::Range; use crate::builtins::int::PyInt; use crate::builtins::slice::{PySlice, PySliceRef}; -use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, Either, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; pub trait PySliceableSequenceMut { type Item: Clone; diff --git a/vm/src/slots.rs b/vm/src/slots.rs index 1a0a66a1f2..338d0038cc 100644 --- a/vm/src/slots.rs +++ b/vm/src/slots.rs @@ -5,10 +5,10 @@ use crate::builtins::pystr::PyStrRef; use crate::common::hash::PyHash; use crate::common::lock::PyRwLock; use crate::function::{FuncArgs, OptionalArg, PyNativeFunc}; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ Either, IdProtocol, PyComparisonValue, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; -use crate::VirtualMachine; use crossbeam_utils::atomic::AtomicCell; bitflags! { diff --git a/vm/src/stdlib/array.rs b/vm/src/stdlib/array.rs index d8a44a8af6..167855509b 100644 --- a/vm/src/stdlib/array.rs +++ b/vm/src/stdlib/array.rs @@ -12,13 +12,13 @@ use crate::common::lock::{ PyRwLockWriteGuard, }; use crate::function::OptionalArg; -use crate::pyobject::{ - BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyIterable, - PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, -}; use crate::sliceable::{saturate_index, PySliceableSequence, PySliceableSequenceMut}; use crate::slots::{BufferProtocol, Comparable, Iterable, PyComparisonOp, PyIter}; use crate::VirtualMachine; +use crate::{ + BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyIterable, + PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, +}; use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; use std::cmp::Ordering; diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs index 6bd1267336..8033538303 100644 --- a/vm/src/stdlib/ast.rs +++ b/vm/src/stdlib/ast.rs @@ -16,11 +16,11 @@ use rustpython_compiler as compile; use crate::builtins::{self, PyStrRef, PyTypeRef}; use crate::function::FuncArgs; -use crate::pyobject::{ +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, IdProtocol, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, }; -use crate::vm::VirtualMachine; #[rustfmt::skip] #[allow(clippy::all)] diff --git a/vm/src/stdlib/atexit.rs b/vm/src/stdlib/atexit.rs index 1e5d30cd54..f2cd53abbd 100644 --- a/vm/src/stdlib/atexit.rs +++ b/vm/src/stdlib/atexit.rs @@ -3,8 +3,8 @@ pub(crate) use atexit::make_module; #[pymodule] mod atexit { use crate::function::FuncArgs; - use crate::pyobject::{PyObjectRef, PyResult}; use crate::VirtualMachine; + use crate::{PyObjectRef, PyResult}; #[pyfunction] fn register(func: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyObjectRef { diff --git a/vm/src/stdlib/binascii.rs b/vm/src/stdlib/binascii.rs index a0f79a7cae..77d166875f 100644 --- a/vm/src/stdlib/binascii.rs +++ b/vm/src/stdlib/binascii.rs @@ -7,8 +7,8 @@ mod decl { use crate::builtins::pystr::{PyStr, PyStrRef}; use crate::byteslike::PyBytesLike; use crate::function::OptionalArg; - use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use crc::{crc32, Hasher32}; use itertools::Itertools; diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs index ddddc8e587..373bef6a64 100644 --- a/vm/src/stdlib/collections.rs +++ b/vm/src/stdlib/collections.rs @@ -5,13 +5,11 @@ mod _collections { use crate::builtins::pytype::PyTypeRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::OptionalArg; - use crate::pyobject::{ - PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, - }; use crate::slots::{Comparable, Iterable, PyComparisonOp, PyIter}; use crate::vm::ReprGuard; use crate::VirtualMachine; use crate::{sequence, sliceable}; + use crate::{PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType}; use itertools::Itertools; use std::collections::VecDeque; diff --git a/vm/src/stdlib/csv.rs b/vm/src/stdlib/csv.rs index fd297ab514..8aaf0715f5 100644 --- a/vm/src/stdlib/csv.rs +++ b/vm/src/stdlib/csv.rs @@ -6,13 +6,13 @@ use crate::builtins::pytype::PyTypeRef; use crate::common::lock::PyMutex; use crate::function::{ArgumentError, FromArgs, FuncArgs}; use crate::iterator; -use crate::pyobject::{ - BorrowValue, PyClassImpl, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, - TryFromObject, TypeProtocol, -}; use crate::slots::PyIter; use crate::types::create_simple_type; use crate::VirtualMachine; +use crate::{ + BorrowValue, PyClassImpl, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, + TryFromObject, TypeProtocol, +}; #[repr(i32)] pub enum QuoteStyle { diff --git a/vm/src/stdlib/dis.rs b/vm/src/stdlib/dis.rs index 1990261abe..5141bce876 100644 --- a/vm/src/stdlib/dis.rs +++ b/vm/src/stdlib/dis.rs @@ -7,8 +7,8 @@ mod decl { use crate::builtins::pystr::PyStrRef; use crate::bytecode::CodeFlags; use crate::compile; - use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject}; #[pyfunction] fn dis(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { diff --git a/vm/src/stdlib/errno.rs b/vm/src/stdlib/errno.rs index 8b464421e0..12e8593091 100644 --- a/vm/src/stdlib/errno.rs +++ b/vm/src/stdlib/errno.rs @@ -1,5 +1,5 @@ -use crate::pyobject::{ItemProtocol, PyObjectRef}; use crate::VirtualMachine; +use crate::{ItemProtocol, PyObjectRef}; pub fn make_module(vm: &VirtualMachine) -> PyObjectRef { let errorcode = vm.ctx.new_dict(); diff --git a/vm/src/stdlib/fcntl.rs b/vm/src/stdlib/fcntl.rs index bab4310ae5..a599afdb32 100644 --- a/vm/src/stdlib/fcntl.rs +++ b/vm/src/stdlib/fcntl.rs @@ -6,8 +6,8 @@ mod fcntl { use crate::builtins::int; use crate::byteslike::{BufOrStr, PyRwBytesLike}; use crate::function::OptionalArg; - use crate::pyobject::{BorrowValue, Either, PyResult}; use crate::VirtualMachine; + use crate::{BorrowValue, Either, PyResult}; #[pyattr] use libc::{FD_CLOEXEC, F_GETFD, F_GETFL, F_SETFD, F_SETFL}; diff --git a/vm/src/stdlib/functools.rs b/vm/src/stdlib/functools.rs index 2afe6da859..d7def1c153 100644 --- a/vm/src/stdlib/functools.rs +++ b/vm/src/stdlib/functools.rs @@ -4,8 +4,8 @@ pub(crate) use _functools::make_module; mod _functools { use crate::function::OptionalArg; use crate::iterator; - use crate::pyobject::{PyObjectRef, PyResult, TypeProtocol}; use crate::vm::VirtualMachine; + use crate::{PyObjectRef, PyResult, TypeProtocol}; #[pyfunction] fn reduce( diff --git a/vm/src/stdlib/hashlib.rs b/vm/src/stdlib/hashlib.rs index 31ad6cfa41..b0d60eace0 100644 --- a/vm/src/stdlib/hashlib.rs +++ b/vm/src/stdlib/hashlib.rs @@ -7,8 +7,8 @@ mod hashlib { use crate::builtins::pytype::PyTypeRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::{FuncArgs, OptionalArg}; - use crate::pyobject::{BorrowValue, PyResult, PyValue, StaticType}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, PyResult, PyValue, StaticType}; use blake2::{Blake2b, Blake2s}; use digest::DynDigest; use md5::Md5; diff --git a/vm/src/stdlib/imp.rs b/vm/src/stdlib/imp.rs index 61fda699d8..e6ad9369b1 100644 --- a/vm/src/stdlib/imp.rs +++ b/vm/src/stdlib/imp.rs @@ -3,14 +3,14 @@ use crate::builtins::code::PyCode; use crate::builtins::module::PyModuleRef; use crate::builtins::pystr::{self, PyStr, PyStrRef}; use crate::import; -use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, PyValue}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, PyValue}; #[cfg(feature = "threading")] mod lock { - use crate::pyobject::PyResult; use crate::stdlib::thread::RawRMutex; use crate::vm::VirtualMachine; + use crate::PyResult; pub(super) static IMP_LOCK: RawRMutex = RawRMutex::INIT; diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index 784a367a92..82cd0c3be4 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -8,8 +8,8 @@ cfg_if::cfg_if! { type Offset = i64; } } -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, TryFromObject}; use crate::VirtualMachine; +use crate::{BorrowValue, PyObjectRef, PyResult, TryFromObject}; pub(crate) use _io::io_open as open; pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef { @@ -88,11 +88,11 @@ mod _io { use crate::common::rc::PyRc; use crate::exceptions::{self, IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, OptionalArg, OptionalOption}; - use crate::pyobject::{ + use crate::vm::{ReprGuard, VirtualMachine}; + use crate::{ BorrowValue, Either, IdProtocol, IntoPyObject, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, }; - use crate::vm::{ReprGuard, VirtualMachine}; fn validate_whence(whence: i32) -> bool { let x = (0..=2).contains(&whence); @@ -3663,11 +3663,11 @@ mod fileio { use crate::exceptions::IntoPyException; use crate::function::OptionalOption; use crate::function::{FuncArgs, OptionalArg}; - use crate::pyobject::{ - BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, - }; use crate::stdlib::os; use crate::vm::VirtualMachine; + use crate::{ + BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, + }; use crossbeam_utils::atomic::AtomicCell; use std::io::{Read, Write}; diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs index 77a3762b52..1407943325 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -15,12 +15,12 @@ mod decl { use crate::common::rc::PyRc; use crate::function::{Args, FuncArgs, OptionalArg, OptionalOption}; use crate::iterator::{call_next, get_all, get_iter, get_next_object}; - use crate::pyobject::{ + use crate::slots::PyIter; + use crate::vm::VirtualMachine; + use crate::{ BorrowValue, IdProtocol, IntoPyObject, PyCallable, PyObjectRef, PyRef, PyResult, PyValue, PyWeakRef, StaticType, TypeProtocol, }; - use crate::slots::PyIter; - use crate::vm::VirtualMachine; #[pyattr] #[pyclass(name = "chain")] diff --git a/vm/src/stdlib/json.rs b/vm/src/stdlib/json.rs index 267d716c12..82c4a2c491 100644 --- a/vm/src/stdlib/json.rs +++ b/vm/src/stdlib/json.rs @@ -9,12 +9,12 @@ mod _json { use crate::exceptions::PyBaseExceptionRef; use crate::function::{FuncArgs, OptionalArg}; use crate::iterator; - use crate::pyobject::{ + use crate::slots::Callable; + use crate::VirtualMachine; + use crate::{ BorrowValue, IdProtocol, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, }; - use crate::slots::Callable; - use crate::VirtualMachine; use num_bigint::BigInt; use std::str::FromStr; diff --git a/vm/src/stdlib/keyword.rs b/vm/src/stdlib/keyword.rs index 9a30d717fe..aea2c92095 100644 --- a/vm/src/stdlib/keyword.rs +++ b/vm/src/stdlib/keyword.rs @@ -7,8 +7,8 @@ mod decl { use rustpython_parser::lexer; use crate::builtins::pystr::PyStrRef; - use crate::pyobject::{BorrowValue, PyObjectRef}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, PyObjectRef}; #[pyfunction] fn iskeyword(s: PyStrRef) -> bool { diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs index e5db599745..31d317150a 100644 --- a/vm/src/stdlib/marshal.rs +++ b/vm/src/stdlib/marshal.rs @@ -7,8 +7,8 @@ mod decl { use crate::bytecode; use crate::byteslike::PyBytesLike; use crate::common::borrow::BorrowValue; - use crate::pyobject::{PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; + use crate::{PyObjectRef, PyResult, TryFromObject}; #[pyfunction] fn dumps(co: PyCodeRef) -> PyBytes { diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs index a2cd36cf8c..ecffa3f9a4 100644 --- a/vm/src/stdlib/math.rs +++ b/vm/src/stdlib/math.rs @@ -10,8 +10,8 @@ use puruspe::{erf, erfc, gamma, ln_gamma}; use crate::builtins::float::{self, IntoPyFloat, PyFloatRef}; use crate::builtins::int::{self, PyInt, PyIntRef}; use crate::function::{Args, OptionalArg}; -use crate::pyobject::{BorrowValue, Either, PyIterable, PyObjectRef, PyResult, TypeProtocol}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, Either, PyIterable, PyObjectRef, PyResult, TypeProtocol}; use rustpython_common::float_ops; use std::cmp::Ordering; diff --git a/vm/src/stdlib/mod.rs b/vm/src/stdlib/mod.rs index c78e6946dd..90b62e010a 100644 --- a/vm/src/stdlib/mod.rs +++ b/vm/src/stdlib/mod.rs @@ -1,5 +1,5 @@ -use crate::pyobject::PyObjectRef; use crate::vm::VirtualMachine; +use crate::PyObjectRef; use std::borrow::Cow; use std::collections::HashMap; diff --git a/vm/src/stdlib/msvcrt.rs b/vm/src/stdlib/msvcrt.rs index db7a9498ce..0ff0673314 100644 --- a/vm/src/stdlib/msvcrt.rs +++ b/vm/src/stdlib/msvcrt.rs @@ -1,8 +1,8 @@ use super::os::errno_err; use crate::builtins::bytes::PyBytesRef; use crate::builtins::pystr::PyStrRef; -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult}; use crate::VirtualMachine; +use crate::{BorrowValue, PyObjectRef, PyResult}; use itertools::Itertools; use winapi::shared::minwindef::UINT; diff --git a/vm/src/stdlib/multiprocessing.rs b/vm/src/stdlib/multiprocessing.rs index 07280b8e85..09ac0c1c23 100644 --- a/vm/src/stdlib/multiprocessing.rs +++ b/vm/src/stdlib/multiprocessing.rs @@ -5,7 +5,7 @@ pub(crate) use _multiprocessing::make_module; mod _multiprocessing { use super::super::os; use crate::byteslike::PyBytesLike; - use crate::pyobject::PyResult; + use crate::PyResult; use crate::VirtualMachine; use winapi::um::winsock2::{self, SOCKET}; diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs index 12d0f62dab..f0bdc08911 100644 --- a/vm/src/stdlib/operator.rs +++ b/vm/src/stdlib/operator.rs @@ -4,8 +4,8 @@ use crate::byteslike::PyBytesLike; use crate::common::cmp; use crate::function::OptionalArg; use crate::iterator; -use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TypeProtocol}; use crate::VirtualMachine; +use crate::{BorrowValue, Either, PyObjectRef, PyResult, TypeProtocol}; fn _operator_length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMachine) -> PyResult { let default = default.unwrap_or_else(|| vm.ctx.new_int(0)); diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 8c32ff4005..fbcedea29b 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -23,12 +23,12 @@ use crate::byteslike::PyBytesLike; use crate::common::lock::PyRwLock; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{ArgumentError, FromArgs, FuncArgs, OptionalArg}; -use crate::pyobject::{ +use crate::slots::PyIter; +use crate::vm::{ReprGuard, VirtualMachine}; +use crate::{ BorrowValue, Either, IntoPyObject, ItemProtocol, PyObjectRef, PyRef, PyResult, PyStructSequence, PyValue, StaticType, TryFromObject, TypeProtocol, }; -use crate::slots::PyIter; -use crate::vm::{ReprGuard, VirtualMachine}; #[cfg(unix)] use std::os::unix::ffi as ffi_ext; @@ -1662,7 +1662,7 @@ mod posix { use crate::builtins::dict::PyMapping; use crate::builtins::list::PyListRef; - use crate::pyobject::PyIterable; + use crate::PyIterable; use bitflags::bitflags; use nix::errno::{errno, Errno}; use nix::unistd::{self, Gid, Pid, Uid}; diff --git a/vm/src/stdlib/posixsubprocess.rs b/vm/src/stdlib/posixsubprocess.rs index 5b4b3964ab..fdae869705 100644 --- a/vm/src/stdlib/posixsubprocess.rs +++ b/vm/src/stdlib/posixsubprocess.rs @@ -4,7 +4,7 @@ pub(crate) use _posixsubprocess::make_module; mod _posixsubprocess { use super::{exec, CStrPathLike, ForkExecArgs, ProcArgs}; use crate::exceptions::IntoPyException; - use crate::pyobject::PyResult; + use crate::PyResult; use crate::VirtualMachine; #[pyfunction] @@ -37,8 +37,8 @@ use std::io::{self, prelude::*}; use std::os::unix::io::AsRawFd; use super::os; -use crate::pyobject::{PyObjectRef, PyResult, PySequence, TryFromObject}; use crate::VirtualMachine; +use crate::{PyObjectRef, PyResult, PySequence, TryFromObject}; macro_rules! gen_args { ($($field:ident: $t:ty),*$(,)?) => { diff --git a/vm/src/stdlib/pwd.rs b/vm/src/stdlib/pwd.rs index cdcfd2d425..039d6e0aad 100644 --- a/vm/src/stdlib/pwd.rs +++ b/vm/src/stdlib/pwd.rs @@ -1,10 +1,8 @@ use crate::builtins::int::PyIntRef; use crate::builtins::pystr::PyStrRef; use crate::exceptions::IntoPyException; -use crate::pyobject::{ - BorrowValue, IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyStructSequence, -}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyStructSequence}; use std::convert::TryFrom; use std::ptr::NonNull; diff --git a/vm/src/stdlib/pystruct.rs b/vm/src/stdlib/pystruct.rs index eb2bd8fe7e..3bbc7867bd 100644 --- a/vm/src/stdlib/pystruct.rs +++ b/vm/src/stdlib/pystruct.rs @@ -9,7 +9,7 @@ * https://docs.rs/byteorder/1.2.6/byteorder/ */ -use crate::pyobject::PyObjectRef; +use crate::PyObjectRef; use crate::VirtualMachine; #[pymodule] @@ -29,12 +29,12 @@ pub(crate) mod _struct { use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::exceptions::PyBaseExceptionRef; use crate::function::Args; - use crate::pyobject::{ + use crate::slots::PyIter; + use crate::VirtualMachine; + use crate::{ BorrowValue, Either, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, }; - use crate::slots::PyIter; - use crate::VirtualMachine; use half::f16; #[derive(Debug, Copy, Clone, PartialEq)] diff --git a/vm/src/stdlib/random.rs b/vm/src/stdlib/random.rs index 9acc75ad7a..4f670a31e3 100644 --- a/vm/src/stdlib/random.rs +++ b/vm/src/stdlib/random.rs @@ -8,8 +8,8 @@ mod _random { use crate::builtins::pytype::PyTypeRef; use crate::common::lock::PyMutex; use crate::function::OptionalOption; - use crate::pyobject::{BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType}; use crate::VirtualMachine; + use crate::{BorrowValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType}; 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 1b80aa7071..142f349029 100644 --- a/vm/src/stdlib/re.rs +++ b/vm/src/stdlib/re.rs @@ -13,7 +13,7 @@ use crate::builtins::int::{PyInt, PyIntRef}; use crate::builtins::pystr::{PyStr, PyStrRef}; use crate::builtins::pytype::PyTypeRef; use crate::function::{Args, OptionalArg}; -use crate::pyobject::{ +use crate::{ BorrowValue, IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyValue, StaticType, TryFromObject, }; diff --git a/vm/src/stdlib/resource.rs b/vm/src/stdlib/resource.rs index 0c52c45a00..8a4628ccbe 100644 --- a/vm/src/stdlib/resource.rs +++ b/vm/src/stdlib/resource.rs @@ -4,8 +4,8 @@ pub(crate) use resource::make_module; mod resource { use super::super::os; use crate::exceptions::IntoPyException; - use crate::pyobject::{IntoPyObject, PyObjectRef, PyResult, PyStructSequence, TryFromObject}; use crate::VirtualMachine; + use crate::{IntoPyObject, PyObjectRef, PyResult, PyStructSequence, TryFromObject}; use std::{io, mem}; cfg_if::cfg_if! { diff --git a/vm/src/stdlib/scproxy.rs b/vm/src/stdlib/scproxy.rs index 660bc1cf32..b5c8867afe 100644 --- a/vm/src/stdlib/scproxy.rs +++ b/vm/src/stdlib/scproxy.rs @@ -5,8 +5,8 @@ mod _scproxy { // straight-forward port of Modules/_scproxy.c use crate::builtins::{PyDictRef, PyStr}; - use crate::pyobject::{IntoPyObject, ItemProtocol, PyResult}; use crate::VirtualMachine; + use crate::{IntoPyObject, ItemProtocol, PyResult}; 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 7dac27de64..95bf0a8b42 100644 --- a/vm/src/stdlib/select.rs +++ b/vm/src/stdlib/select.rs @@ -1,12 +1,12 @@ -use crate::pyobject::{PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; +use crate::{PyObjectRef, PyResult, TryFromObject}; use std::{io, mem}; pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef { super::socket::init_winsock(); #[cfg(unix)] { - use crate::pyobject::PyClassImpl; + use crate::PyClassImpl; decl::poll::PyPoll::make_class(&vm.ctx); } @@ -154,8 +154,8 @@ mod decl { use super::*; use crate::exceptions::IntoPyException; use crate::function::OptionalOption; - use crate::pyobject::{Either, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; + use crate::{Either, PyObjectRef, PyResult}; #[pyfunction] fn select( @@ -256,8 +256,8 @@ mod decl { use crate::builtins::{PyFloat, PyTypeRef}; use crate::common::lock::PyMutex; use crate::function::OptionalArg; - use crate::pyobject::{BorrowValue, IntoPyObject, PyValue, StaticType, TypeProtocol}; use crate::stdlib::io::Fildes; + use crate::{BorrowValue, IntoPyObject, PyValue, StaticType, TypeProtocol}; use libc::pollfd; use num_traits::ToPrimitive; use std::time; diff --git a/vm/src/stdlib/signal.rs b/vm/src/stdlib/signal.rs index 2dff0e749b..d1b8eb8c26 100644 --- a/vm/src/stdlib/signal.rs +++ b/vm/src/stdlib/signal.rs @@ -1,6 +1,6 @@ use crate::exceptions::IntoPyException; -use crate::pyobject::{PyObjectRef, PyResult, TryFromObject}; use crate::vm::{VirtualMachine, NSIG}; +use crate::{PyObjectRef, PyResult, TryFromObject}; use std::sync::atomic::{self, AtomicBool, Ordering}; diff --git a/vm/src/stdlib/socket.rs b/vm/src/stdlib/socket.rs index 5dcafc9158..3f88927340 100644 --- a/vm/src/stdlib/socket.rs +++ b/vm/src/stdlib/socket.rs @@ -18,11 +18,11 @@ use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, OptionalArg, OptionalOption}; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ BorrowValue, Either, IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, TypeProtocol, }; -use crate::VirtualMachine; #[cfg(unix)] type RawSocket = std::os::unix::io::RawFd; diff --git a/vm/src/stdlib/sre.rs b/vm/src/stdlib/sre.rs index cbdbb9e19e..578e106da2 100644 --- a/vm/src/stdlib/sre.rs +++ b/vm/src/stdlib/sre.rs @@ -15,12 +15,12 @@ mod _sre { PyCallableIterator, PyDictRef, PyInt, PyList, PyStr, PyStrRef, PyTypeRef, }; use crate::function::{Args, OptionalArg}; - use crate::pyobject::{ + use crate::slots::{Comparable, Hashable}; + use crate::VirtualMachine; + use crate::{ IntoPyObject, ItemProtocol, PyCallable, PyComparisonValue, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, }; - use crate::slots::{Comparable, Hashable}; - use crate::VirtualMachine; use core::str; use sre_engine::constants::SreFlag; use sre_engine::engine::{lower_ascii, lower_unicode, upper_unicode, State, StrDrive}; diff --git a/vm/src/stdlib/ssl.rs b/vm/src/stdlib/ssl.rs index 836a44c886..e82723c3e1 100644 --- a/vm/src/stdlib/ssl.rs +++ b/vm/src/stdlib/ssl.rs @@ -5,11 +5,11 @@ use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::common::lock::{PyRwLock, PyRwLockWriteGuard}; use crate::exceptions::{create_exception_type, IntoPyException, PyBaseExceptionRef}; use crate::function::OptionalArg; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ BorrowValue, Either, IntoPyObject, ItemProtocol, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, }; -use crate::VirtualMachine; use crossbeam_utils::atomic::AtomicCell; use foreign_types_shared::{ForeignType, ForeignTypeRef}; diff --git a/vm/src/stdlib/string.rs b/vm/src/stdlib/string.rs index 532ffeb054..9df99405f8 100644 --- a/vm/src/stdlib/string.rs +++ b/vm/src/stdlib/string.rs @@ -13,8 +13,8 @@ mod _string { use crate::format::{ FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate, }; - use crate::pyobject::{BorrowValue, IntoPyObject, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, IntoPyObject, PyObjectRef, PyResult}; fn create_format_part( literal: String, diff --git a/vm/src/stdlib/symtable.rs b/vm/src/stdlib/symtable.rs index ca79878895..18b89e85f8 100644 --- a/vm/src/stdlib/symtable.rs +++ b/vm/src/stdlib/symtable.rs @@ -7,8 +7,8 @@ mod decl { use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::compile::{self, Symbol, SymbolScope, SymbolTable, SymbolTableType}; - use crate::pyobject::{BorrowValue, PyRef, PyResult, PyValue, StaticType}; use crate::vm::VirtualMachine; + use crate::{BorrowValue, PyRef, PyResult, PyValue, StaticType}; /// symtable. Return top level SymbolTable. /// See docs: https://docs.python.org/3/library/symtable.html?highlight=symtable#symtable.symtable diff --git a/vm/src/stdlib/sysconfigdata.rs b/vm/src/stdlib/sysconfigdata.rs index cefc0dac75..6f9f8ce6b1 100644 --- a/vm/src/stdlib/sysconfigdata.rs +++ b/vm/src/stdlib/sysconfigdata.rs @@ -1,5 +1,5 @@ -use crate::pyobject::{IntoPyObject, ItemProtocol, PyObjectRef}; use crate::VirtualMachine; +use crate::{IntoPyObject, ItemProtocol, PyObjectRef}; use crate::sysmodule::MULTIARCH; diff --git a/vm/src/stdlib/termios.rs b/vm/src/stdlib/termios.rs index b671e46d0a..fb9e54f1fd 100644 --- a/vm/src/stdlib/termios.rs +++ b/vm/src/stdlib/termios.rs @@ -5,8 +5,8 @@ mod termios { use crate::builtins::{int, PyBytes, PyInt, PyListRef, PyTypeRef}; use crate::common::borrow::BorrowValue; use crate::exceptions::PyBaseExceptionRef; - use crate::pyobject::{IntoPyObject, PyObjectRef, PyResult, TryFromObject}; use crate::VirtualMachine; + use crate::{IntoPyObject, PyObjectRef, PyResult, TryFromObject}; use std::convert::TryFrom; use termios::Termios; diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs index 9d9b59cb87..5a3854a51b 100644 --- a/vm/src/stdlib/thread.rs +++ b/vm/src/stdlib/thread.rs @@ -6,12 +6,12 @@ use crate::builtins::tuple::PyTupleRef; use crate::exceptions::{self, IntoPyException}; use crate::function::{FuncArgs, KwArgs, OptionalArg}; use crate::py_io; -use crate::pyobject::{ +use crate::slots::{SlotGetattro, SlotSetattro}; +use crate::VirtualMachine; +use crate::{ BorrowValue, Either, IdProtocol, ItemProtocol, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TypeProtocol, }; -use crate::slots::{SlotGetattro, SlotSetattro}; -use crate::VirtualMachine; use parking_lot::{ lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex}, diff --git a/vm/src/stdlib/time_module.rs b/vm/src/stdlib/time_module.rs index e1876e9a64..181a036c37 100644 --- a/vm/src/stdlib/time_module.rs +++ b/vm/src/stdlib/time_module.rs @@ -10,10 +10,10 @@ use chrono::{Datelike, Timelike}; use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::function::OptionalArg; -use crate::pyobject::{ +use crate::vm::VirtualMachine; +use crate::{ BorrowValue, Either, PyClassImpl, PyObjectRef, PyResult, PyStructSequence, TryFromObject, }; -use crate::vm::VirtualMachine; #[cfg(unix)] fn time_sleep(dur: Duration, vm: &VirtualMachine) -> PyResult<()> { diff --git a/vm/src/stdlib/unicodedata.rs b/vm/src/stdlib/unicodedata.rs index 30628f7983..9fed3353ac 100644 --- a/vm/src/stdlib/unicodedata.rs +++ b/vm/src/stdlib/unicodedata.rs @@ -5,10 +5,8 @@ use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::function::OptionalArg; -use crate::pyobject::{ - BorrowValue, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType, -}; use crate::vm::VirtualMachine; +use crate::{BorrowValue, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType}; use itertools::Itertools; use unic_char_property::EnumeratedCharProperty; diff --git a/vm/src/stdlib/warnings.rs b/vm/src/stdlib/warnings.rs index 4a9059b8e3..f5855bc7fd 100644 --- a/vm/src/stdlib/warnings.rs +++ b/vm/src/stdlib/warnings.rs @@ -5,8 +5,8 @@ mod _warnings { use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::function::OptionalArg; - use crate::pyobject::{PyResult, TypeProtocol}; use crate::vm::VirtualMachine; + use crate::{PyResult, TypeProtocol}; #[derive(FromArgs)] struct WarnArgs { diff --git a/vm/src/stdlib/weakref.rs b/vm/src/stdlib/weakref.rs index f8a9e063d1..dbea81bbdf 100644 --- a/vm/src/stdlib/weakref.rs +++ b/vm/src/stdlib/weakref.rs @@ -5,8 +5,8 @@ //! - [rust weak struct](https://doc.rust-lang.org/std/rc/struct.Weak.html) //! -use crate::pyobject::PyObjectRef; use crate::vm::VirtualMachine; +use crate::PyObjectRef; 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 99c2d7ffe1..6f0374fc63 100644 --- a/vm/src/stdlib/winapi.rs +++ b/vm/src/stdlib/winapi.rs @@ -13,8 +13,8 @@ use super::os::errno_err; use crate::builtins::dict::{PyDictRef, PyMapping}; use crate::builtins::pystr::PyStrRef; use crate::function::OptionalArg; -use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, PySequence, TryFromObject}; use crate::VirtualMachine; +use crate::{BorrowValue, 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 d5520a5dd4..178f5740e5 100644 --- a/vm/src/stdlib/winreg.rs +++ b/vm/src/stdlib/winreg.rs @@ -3,10 +3,10 @@ use crate::builtins::pystr::PyStrRef; use crate::builtins::pytype::PyTypeRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::exceptions::IntoPyException; -use crate::pyobject::{ +use crate::VirtualMachine; +use crate::{ BorrowValue, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, StaticType, TryFromObject, }; -use crate::VirtualMachine; use std::convert::TryInto; use std::ffi::OsStr; diff --git a/vm/src/stdlib/zlib.rs b/vm/src/stdlib/zlib.rs index fd3637538f..b69618aa2b 100644 --- a/vm/src/stdlib/zlib.rs +++ b/vm/src/stdlib/zlib.rs @@ -9,9 +9,9 @@ mod decl { use crate::common::lock::PyMutex; use crate::exceptions::PyBaseExceptionRef; use crate::function::OptionalArg; - use crate::pyobject::{BorrowValue, IntoPyRef, PyResult, PyValue, StaticType}; use crate::types::create_simple_type; use crate::vm::VirtualMachine; + use crate::{BorrowValue, IntoPyRef, PyResult, PyValue, StaticType}; use adler32::RollingAdler32 as Adler32; use crc32fast::Hasher as Crc32; diff --git a/vm/src/sysmodule.rs b/vm/src/sysmodule.rs index 86f1271059..d374fc00c3 100644 --- a/vm/src/sysmodule.rs +++ b/vm/src/sysmodule.rs @@ -5,11 +5,11 @@ use crate::builtins::{PyStr, PyStrRef, PyTypeRef}; use crate::common::hash::{PyHash, PyUHash}; use crate::frame::FrameRef; use crate::function::{Args, FuncArgs, OptionalArg}; -use crate::pyobject::{ - ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRefExact, PyResult, PyStructSequence, -}; use crate::vm::{PySettings, VirtualMachine}; use crate::{builtins, exceptions, py_io, version}; +use crate::{ + ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRefExact, PyResult, PyStructSequence, +}; /* * The magic sys module. diff --git a/vm/src/types.rs b/vm/src/types.rs index c609f0f719..04adad206e 100644 --- a/vm/src/types.rs +++ b/vm/src/types.rs @@ -38,8 +38,8 @@ use crate::builtins::tuple; use crate::builtins::weakproxy; use crate::builtins::weakref; use crate::builtins::zip; -use crate::pyobject::{PyAttributes, PyContext, StaticType}; use crate::slots::PyTypeSlots; +use crate::{PyAttributes, PyContext, StaticType}; /// Holder of references to builtin types. #[derive(Debug, Clone)] diff --git a/vm/src/version.rs b/vm/src/version.rs index 75485fc095..d2935d1079 100644 --- a/vm/src/version.rs +++ b/vm/src/version.rs @@ -1,7 +1,7 @@ /* Several function to retrieve version information. */ -use crate::pyobject::PyStructSequence; +use crate::PyStructSequence; use chrono::prelude::DateTime; use chrono::Local; use std::time::{Duration, UNIX_EPOCH}; @@ -49,7 +49,7 @@ impl VersionInfo { _cls: crate::builtins::pytype::PyTypeRef, _args: crate::function::FuncArgs, vm: &crate::VirtualMachine, - ) -> crate::pyobject::PyResult { + ) -> crate::PyResult { Err(vm.new_type_error("cannot create 'sys.version_info' instances".to_owned())) } } diff --git a/vm/src/vm.rs b/vm/src/vm.rs index 3852588a8a..6448702b45 100644 --- a/vm/src/vm.rs +++ b/vm/src/vm.rs @@ -29,14 +29,14 @@ use crate::compile::{self, CompileError, CompileErrorType, CompileOpts}; use crate::exceptions::{self, PyBaseException, PyBaseExceptionRef}; use crate::frame::{ExecutionResult, Frame, FrameRef}; use crate::function::{FuncArgs, IntoFuncArgs}; -use crate::pyobject::{ +use crate::scope::Scope; +use crate::slots::PyComparisonOp; +use crate::{builtins, bytecode, frozen, import, iterator, stdlib, sysmodule}; +use crate::{ BorrowValue, Either, IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue, PyContext, PyLease, PyMethod, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult, PyValue, TryFromObject, TryIntoRef, TypeProtocol, }; -use crate::scope::Scope; -use crate::slots::PyComparisonOp; -use crate::{builtins, bytecode, frozen, import, iterator, stdlib, sysmodule}; // use objects::ects; diff --git a/wasm/lib/src/browser_module.rs b/wasm/lib/src/browser_module.rs index 64346ab933..f18d59a79d 100644 --- a/wasm/lib/src/browser_module.rs +++ b/wasm/lib/src/browser_module.rs @@ -6,11 +6,11 @@ use wasm_bindgen_futures::JsFuture; use rustpython_vm::builtins::{PyDictRef, PyStrRef, PyTypeRef}; use rustpython_vm::function::OptionalArg; use rustpython_vm::import::import_file; -use rustpython_vm::pyobject::{ +use rustpython_vm::VirtualMachine; +use rustpython_vm::{ BorrowValue, IntoPyObject, PyCallable, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue, StaticType, }; -use rustpython_vm::VirtualMachine; use crate::{convert, js_module::PyPromise, vm_class::weak_vm, wasm_builtins::window}; diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs index bdf78cc152..48942d09b7 100644 --- a/wasm/lib/src/convert.rs +++ b/wasm/lib/src/convert.rs @@ -6,11 +6,9 @@ use rustpython_vm::byteslike::PyBytesLike; use rustpython_vm::compile::{CompileError, CompileErrorType}; use rustpython_vm::exceptions::PyBaseExceptionRef; use rustpython_vm::function::FuncArgs; -use rustpython_vm::pyobject::{ - ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, -}; use rustpython_vm::VirtualMachine; use rustpython_vm::{exceptions, py_serde}; +use rustpython_vm::{ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol}; use crate::js_module; use crate::vm_class::{stored_vm_from_wasm, WASMVirtualMachine}; diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs index 629f796619..82e97b6b45 100644 --- a/wasm/lib/src/js_module.rs +++ b/wasm/lib/src/js_module.rs @@ -9,13 +9,13 @@ use wasm_bindgen_futures::{future_to_promise, JsFuture}; use rustpython_vm::builtins::{PyFloatRef, PyStrRef, PyTypeRef}; use rustpython_vm::exceptions::PyBaseExceptionRef; use rustpython_vm::function::{Args, OptionalArg, OptionalOption}; -use rustpython_vm::pyobject::{ - BorrowValue, IntoPyObject, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, - StaticType, TryFromObject, -}; use rustpython_vm::slots::PyIter; use rustpython_vm::types::create_simple_type; use rustpython_vm::VirtualMachine; +use rustpython_vm::{ + BorrowValue, IntoPyObject, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, + StaticType, TryFromObject, +}; #[wasm_bindgen(inline_js = " export function has_prop(target, prop) { return prop in Object(target); } diff --git a/wasm/lib/src/vm_class.rs b/wasm/lib/src/vm_class.rs index 0887f6b955..9cc69b1436 100644 --- a/wasm/lib/src/vm_class.rs +++ b/wasm/lib/src/vm_class.rs @@ -6,9 +6,9 @@ use js_sys::{Object, TypeError}; use wasm_bindgen::prelude::*; use rustpython_vm::compile::{self, Mode}; -use rustpython_vm::pyobject::{ItemProtocol, PyObjectRef, PyObjectWeak, PyValue}; use rustpython_vm::scope::Scope; use rustpython_vm::{InitParameter, Interpreter, PySettings, VirtualMachine}; +use rustpython_vm::{ItemProtocol, PyObjectRef, PyObjectWeak, PyValue}; use crate::browser_module::setup_browser_module; use crate::convert::{self, PyResultExt}; diff --git a/wasm/lib/src/wasm_builtins.rs b/wasm/lib/src/wasm_builtins.rs index 45be719b50..71e8c33269 100644 --- a/wasm/lib/src/wasm_builtins.rs +++ b/wasm/lib/src/wasm_builtins.rs @@ -7,8 +7,8 @@ use web_sys::{self, console}; use rustpython_vm::builtins::PyStrRef; -use rustpython_vm::pyobject::{BorrowValue, PyObjectRef, PyResult}; use rustpython_vm::VirtualMachine; +use rustpython_vm::{BorrowValue, PyObjectRef, PyResult}; pub(crate) fn window() -> web_sys::Window { web_sys::window().expect("Window to be available")