From cb9bfce007b20d81d612f3548643fcd5f0a04b52 Mon Sep 17 00:00:00 2001 From: Jeong YunWon Date: Sun, 26 Sep 2021 03:43:29 +0900 Subject: [PATCH] clean up use statements --- examples/mini_repl.rs | 2 +- vm/src/builtins/code.rs | 8 ++--- vm/src/builtins/mod.rs | 4 +-- vm/src/builtins/singletons.rs | 1 - vm/src/bytesinner.rs | 26 +++++++------- vm/src/cformat.rs | 4 +-- vm/src/frame.rs | 64 +++++++++++++++------------------ vm/src/pyobject.rs | 68 ++++++++++++++++------------------- vm/src/pyobjectrc.rs | 13 ++++--- vm/src/stdlib/io.rs | 64 ++++++++++++++++----------------- vm/src/stdlib/select.rs | 18 +++++----- vm/src/stdlib/syslog.rs | 2 +- vm/src/stdlib/time.rs | 16 ++++----- vm/src/types.rs | 51 +++++--------------------- vm/src/vm.rs | 59 +++++++++++++++--------------- 15 files changed, 173 insertions(+), 227 deletions(-) diff --git a/examples/mini_repl.rs b/examples/mini_repl.rs index 7e8e8817d..e3f23ed35 100644 --- a/examples/mini_repl.rs +++ b/examples/mini_repl.rs @@ -16,7 +16,7 @@ macro_rules! add_python_function { ( $scope:ident, $vm:ident, $src:literal $(,)? ) => {{ // compile the code to bytecode let code = vm::py_compile!(source = $src); - // convert the rustpython_bytecode::CodeObject to a PyCodeRef + // convert the rustpython_bytecode::CodeObject to a PyRef let code = $vm.new_code_object(code); // run the python code in the scope to store the function diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index ed37915c2..a6dc2bfa6 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -22,7 +22,7 @@ pub struct PyConstant(pub PyObjectRef); // Boolean { value: super::int::PyIntRef }, // Str { value: super::pystr::PyStrRef }, // Bytes { value: super::bytes::PyBytesRef }, -// Code { code: PyCodeRef }, +// Code { code: PyRef }, // Tuple { elements: super::tuple::PyTupleRef }, // None(PyObjectRef), // Ellipsis(PyObjectRef), @@ -140,8 +140,6 @@ impl ConstantBag for PyObjBag<'_> { } } -pub type PyCodeRef = PyRef; - pub type CodeObject = bytecode::CodeObject; pub type FrozenModule = bytecode::FrozenModule; @@ -193,7 +191,7 @@ impl PyValue for PyCode { impl PyCode {} #[pyimpl] -impl PyCodeRef { +impl PyRef { #[pyslot] fn tp_new(_cls: PyTypeRef, _args: FuncArgs, vm: &VirtualMachine) -> PyResult { Err(vm.new_type_error("Cannot directly create code object".to_owned())) @@ -271,5 +269,5 @@ impl fmt::Display for PyCode { } pub fn init(ctx: &PyContext) { - PyCodeRef::extend_class(ctx, &ctx.types.code_type); + PyRef::::extend_class(ctx, &ctx.types.code_type); } diff --git a/vm/src/builtins/mod.rs b/vm/src/builtins/mod.rs index d4e6ef88f..8f6f9f11f 100644 --- a/vm/src/builtins/mod.rs +++ b/vm/src/builtins/mod.rs @@ -25,7 +25,7 @@ pub(crate) mod float; pub use float::{IntoPyFloat, PyFloat, PyFloatRef}; pub(crate) mod frame; pub(crate) mod function; -pub use function::PyFunction; +pub use function::{PyBoundMethod, PyFunction}; pub(crate) mod generator; pub use generator::PyGenerator; pub(crate) mod genericalias; @@ -67,7 +67,7 @@ pub use set::PySet; pub(crate) mod singletons; pub use singletons::{PyNone, PyNotImplemented}; pub(crate) mod slice; -pub use slice::{PySlice, PySliceRef}; +pub use slice::{PyEllipsis, PySlice, PySliceRef}; pub(crate) mod staticmethod; pub use staticmethod::PyStaticMethod; pub(crate) mod traceback; diff --git a/vm/src/builtins/singletons.rs b/vm/src/builtins/singletons.rs index aa46d0905..6b79793fd 100644 --- a/vm/src/builtins/singletons.rs +++ b/vm/src/builtins/singletons.rs @@ -56,7 +56,6 @@ impl PyNone { #[pyclass(module = false, name = "NotImplementedType")] #[derive(Debug)] pub struct PyNotImplemented; -pub type PyNotImplementedRef = PyRef; impl PyValue for PyNotImplemented { fn class(vm: &VirtualMachine) -> &PyTypeRef { diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs index fb0fbdc44..f21c8ebdd 100644 --- a/vm/src/bytesinner.rs +++ b/vm/src/bytesinner.rs @@ -1,18 +1,16 @@ -use crate::anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper}; -use crate::builtins::bytearray::PyByteArray; -use crate::builtins::bytes::{PyBytes, PyBytesRef}; -use crate::builtins::int::{PyInt, PyIntRef}; -use crate::builtins::pystr::{self, PyStr, PyStrRef}; -use crate::builtins::PyTypeRef; -use crate::cformat::CFormatBytes; -use crate::function::{OptionalArg, OptionalOption}; -use crate::sliceable::PySliceableSequence; -use crate::slots::PyComparisonOp; -use crate::utils::Either; -use crate::vm::VirtualMachine; use crate::{ - function::ArgIterable, IdProtocol, PyComparisonValue, PyObjectRef, PyResult, PyValue, - TryFromBorrowedObject, + anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper}, + builtins::{ + pystr, PyByteArray, PyBytes, PyBytesRef, PyInt, PyIntRef, PyStr, PyStrRef, PyTypeRef, + }, + cformat::CFormatBytes, + function::ArgIterable, + function::{OptionalArg, OptionalOption}, + sliceable::PySliceableSequence, + slots::PyComparisonOp, + utils::Either, + IdProtocol, PyComparisonValue, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, + VirtualMachine, }; use bstr::ByteSlice; use itertools::Itertools; diff --git a/vm/src/cformat.rs b/vm/src/cformat.rs index 94a1fdcd2..1b0728025 100644 --- a/vm/src/cformat.rs +++ b/vm/src/cformat.rs @@ -1,10 +1,10 @@ //! Implementation of Printf-Style string formatting //! [https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting] -use crate::builtins::{int, try_f64_to_bigint, tuple, IntoPyFloat, PyBytes, PyFloat, PyInt, PyStr}; use crate::common::float_ops; -use crate::protocol::PyBuffer; use crate::{ + builtins::{int, try_f64_to_bigint, tuple, IntoPyFloat, PyBytes, PyFloat, PyInt, PyStr}, + protocol::PyBuffer, ItemProtocol, PyObjectRef, PyResult, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }; diff --git a/vm/src/frame.rs b/vm/src/frame.rs index 05f64bc71..411f32912 100644 --- a/vm/src/frame.rs +++ b/vm/src/frame.rs @@ -1,38 +1,32 @@ +use crate::common::{boxvec::BoxVec, lock::PyMutex}; +use crate::{ + builtins::{ + self, + asyncgenerator::PyAsyncGenWrappedValue, + coroutine::PyCoroutine, + function::{PyCell, PyCellRef, PyFunction}, + generator::PyGenerator, + list, pystr, set, + traceback::PyTraceback, + tuple::{PyTuple, PyTupleTyped}, + PyCode, PyDict, PyDictRef, PySlice, PyStr, PyStrRef, PyTypeRef, + }, + bytecode, + coroutine::Coro, + exceptions::{self, ExceptionCtor, PyBaseExceptionRef}, + function::FuncArgs, + iterator, + scope::Scope, + slots::PyComparisonOp, + IdProtocol, ItemProtocol, PyMethod, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, + TypeProtocol, VirtualMachine, +}; +use indexmap::IndexMap; +use itertools::Itertools; use std::fmt; #[cfg(feature = "threading")] use std::sync::atomic; -use indexmap::IndexMap; -use itertools::Itertools; - -use crate::builtins; -use crate::builtins::asyncgenerator::PyAsyncGenWrappedValue; -use crate::builtins::code::PyCodeRef; -use crate::builtins::coroutine::PyCoroutine; -use crate::builtins::dict::{PyDict, PyDictRef}; -use crate::builtins::function::{PyCell, PyCellRef, PyFunction}; -use crate::builtins::generator::PyGenerator; -use crate::builtins::pystr::{self, PyStr, PyStrRef}; -use crate::builtins::pytype::PyTypeRef; -use crate::builtins::slice::PySlice; -use crate::builtins::traceback::PyTraceback; -use crate::builtins::tuple::{PyTuple, PyTupleTyped}; -use crate::builtins::{list, set}; -use crate::bytecode; -use crate::common::boxvec::BoxVec; -use crate::common::lock::PyMutex; -use crate::coroutine::Coro; -use crate::exceptions::{self, ExceptionCtor, PyBaseExceptionRef}; -use crate::function::FuncArgs; -use crate::iterator; -use crate::scope::Scope; -use crate::slots::PyComparisonOp; -use crate::vm::VirtualMachine; -use crate::{ - IdProtocol, ItemProtocol, PyMethod, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, - TypeProtocol, -}; - #[derive(Clone, Debug)] struct Block { /// The type of block. @@ -104,7 +98,7 @@ type Lasti = std::cell::Cell; #[pyclass(module = false, name = "frame")] pub struct Frame { - pub code: PyCodeRef, + pub code: PyRef, pub fastlocals: PyMutex]>>, pub(crate) cells_frees: Box<[PyCellRef]>, @@ -174,7 +168,7 @@ pub type FrameResult = PyResult>; impl Frame { pub(crate) fn new( - code: PyCodeRef, + code: PyRef, scope: Scope, builtins: PyDictRef, closure: &[PyCellRef], @@ -317,7 +311,7 @@ impl FrameRef { /// An executing frame; essentially just a struct to combine the immutable data outside the mutex /// with the mutable data inside struct ExecutingFrame<'a> { - code: &'a PyCodeRef, + code: &'a PyRef, fastlocals: &'a PyMutex]>>, cells_frees: &'a [PyCellRef], locals: &'a PyDictRef, @@ -1550,7 +1544,7 @@ impl ExecutingFrame<'_> { .pop_value() .downcast::() .expect("qualified name to be a string"); - let code_obj: PyCodeRef = self + let code_obj: PyRef = self .pop_value() .downcast() .expect("Second to top value on the stack must be a code object"); diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs index 783e1f864..a6d6f6ab7 100644 --- a/vm/src/pyobject.rs +++ b/vm/src/pyobject.rs @@ -1,3 +1,28 @@ +use crate::common::{ + lock::{PyRwLock, PyRwLockReadGuard}, + rc::PyRc, + static_cell, +}; +pub use crate::pyobjectrc::{PyObject, PyObjectRef, PyObjectWeak, PyRef, PyWeakRef}; +use crate::{ + builtins::{ + builtinfunc::PyNativeFuncDef, + bytearray, bytes, + code::{self, PyCode}, + getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet}, + namespace::PyNamespace, + object, pystr, + set::{self, PyFrozenSet}, + PyBoundMethod, PyComplex, PyDict, PyDictRef, PyEllipsis, PyFloat, PyInt, PyIntRef, PyList, + PyNone, PyNotImplemented, PyStaticMethod, PyTuple, PyTupleRef, PyType, PyTypeRef, + }, + dictdatatype::Dict, + exceptions::{self, PyBaseExceptionRef}, + function::{IntoFuncArgs, IntoPyNativeFunc}, + slots::{PyTpFlags, PyTypeSlots}, + types::{create_type_with_slots, TypeZoo}, + VirtualMachine, +}; use num_bigint::BigInt; use num_complex::Complex64; use num_traits::ToPrimitive; @@ -5,39 +30,6 @@ use std::any::Any; use std::collections::HashMap; use std::fmt; use std::ops::Deref; - -use crate::builtins::builtinfunc::PyNativeFuncDef; -use crate::builtins::bytearray; -use crate::builtins::bytes; -use crate::builtins::code; -use crate::builtins::code::PyCodeRef; -use crate::builtins::complex::PyComplex; -use crate::builtins::dict::{PyDict, PyDictRef}; -use crate::builtins::float::PyFloat; -use crate::builtins::function::PyBoundMethod; -use crate::builtins::getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet}; -use crate::builtins::int::{PyInt, PyIntRef}; -use crate::builtins::list::PyList; -use crate::builtins::namespace::PyNamespace; -use crate::builtins::object; -use crate::builtins::pystr; -use crate::builtins::pytype::{PyType, PyTypeRef}; -use crate::builtins::set::{self, PyFrozenSet}; -use crate::builtins::singletons::{PyNone, PyNoneRef, PyNotImplemented, PyNotImplementedRef}; -use crate::builtins::slice::PyEllipsis; -use crate::builtins::staticmethod::PyStaticMethod; -use crate::builtins::tuple::{PyTuple, PyTupleRef}; -use crate::common::lock::{PyRwLock, PyRwLockReadGuard}; -use crate::common::rc::PyRc; -use crate::common::static_cell; -use crate::dictdatatype::Dict; -use crate::exceptions::{self, PyBaseExceptionRef}; -use crate::function::{IntoFuncArgs, IntoPyNativeFunc}; -pub use crate::pyobjectrc::{PyObject, PyObjectRef, PyObjectWeak, PyRef, PyWeakRef}; -use crate::slots::{PyTpFlags, PyTypeSlots}; -use crate::types::{create_type_with_slots, TypeZoo}; -use crate::vm::VirtualMachine; - /* Python objects and references. Okay, so each python object itself is an class itself (PyObject). Each @@ -73,11 +65,11 @@ impl fmt::Display for PyObjectRef { pub struct PyContext { pub true_value: PyIntRef, pub false_value: PyIntRef, - pub none: PyNoneRef, + pub none: PyRef, pub empty_tuple: PyTupleRef, pub empty_frozenset: PyRef, pub ellipsis: PyRef, - pub not_implemented: PyNotImplementedRef, + pub not_implemented: PyRef, pub types: TypeZoo, pub exceptions: exceptions::ExceptionZoo, @@ -366,11 +358,11 @@ impl PyContext { ) } - /// Create a new `PyCodeRef` from a `code::CodeObject`. If you have a non-mapped codeobject or + /// Create a new `PyRef` from a `code::CodeObject`. If you have a non-mapped codeobject or /// this is giving you a type error even though you've passed a `CodeObject`, try /// [`vm.new_code_object()`](VirtualMachine::new_code_object) instead. - pub fn new_code_object(&self, code: code::CodeObject) -> PyCodeRef { - PyRef::new_ref(code::PyCode::new(code), self.types.code_type.clone(), None) + pub fn new_code_object(&self, code: code::CodeObject) -> PyRef { + PyRef::new_ref(PyCode::new(code), self.types.code_type.clone(), None) } pub fn new_bound_method(&self, function: PyObjectRef, object: PyObjectRef) -> PyObjectRef { diff --git a/vm/src/pyobjectrc.rs b/vm/src/pyobjectrc.rs index 7c346b43d..1d85bf407 100644 --- a/vm/src/pyobjectrc.rs +++ b/vm/src/pyobjectrc.rs @@ -1,8 +1,11 @@ -use crate::builtins::{PyDictRef, PyTypeRef}; -use crate::common::lock::PyRwLock; -use crate::common::rc::{PyRc, PyWeak}; -use crate::VirtualMachine; -use crate::{IdProtocol, PyObjectPayload, TypeProtocol}; +use crate::common::{ + lock::PyRwLock, + rc::{PyRc, PyWeak}, +}; +use crate::{ + builtins::{PyDictRef, PyTypeRef}, + IdProtocol, PyObjectPayload, TypeProtocol, VirtualMachine, +}; use std::any::TypeId; use std::fmt; use std::marker::PhantomData; diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index c59800110..e7c565f78 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -68,35 +68,34 @@ impl TryFromObject for Fildes { mod _io { use super::*; + use crate::common::{ + borrow::{BorrowedValue, BorrowedValueMut}, + lock::{ + PyMappedThreadMutexGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard, + PyThreadMutex, PyThreadMutexGuard, + }, + rc::PyRc, + }; + use crate::{ + builtins::{ + pytype, PyByteArray, PyBytes, PyBytesRef, PyMemoryView, PyStr, PyStrRef, PyTypeRef, + }, + byteslike::{ArgBytesLike, ArgMemoryBuffer}, + exceptions::{self, PyBaseExceptionRef}, + function::{ArgIterable, FuncArgs, OptionalArg, OptionalOption}, + protocol::{BufferInternal, BufferOptions, PyBuffer, ResizeGuard}, + slots::{Iterable, PyIter, SlotConstructor}, + utils::Either, + vm::{ReprGuard, VirtualMachine}, + IdProtocol, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, StaticType, + TryFromObject, TypeProtocol, + }; use bstr::ByteSlice; use crossbeam_utils::atomic::AtomicCell; use num_traits::ToPrimitive; use std::io::{self, prelude::*, Cursor, SeekFrom}; use std::ops::Range; - use crate::builtins::memory::PyMemoryView; - use crate::builtins::{ - bytes::{PyBytes, PyBytesRef}, - pytype, PyByteArray, PyStr, PyStrRef, PyTypeRef, - }; - use crate::byteslike::{ArgBytesLike, ArgMemoryBuffer}; - use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; - use crate::common::lock::{ - PyMappedThreadMutexGuard, PyMutex, PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard, - PyThreadMutex, PyThreadMutexGuard, - }; - use crate::common::rc::PyRc; - use crate::exceptions::{self, PyBaseExceptionRef}; - use crate::function::{ArgIterable, FuncArgs, OptionalArg, OptionalOption}; - use crate::protocol::{BufferInternal, BufferOptions, PyBuffer, ResizeGuard}; - use crate::slots::{Iterable, PyIter, SlotConstructor}; - use crate::utils::Either; - use crate::vm::{ReprGuard, VirtualMachine}; - use crate::{ - IdProtocol, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, StaticType, - TryFromObject, TypeProtocol, - }; - #[allow(clippy::let_and_return)] fn validate_whence(whence: i32) -> bool { let x = (0..=2).contains(&whence); @@ -3681,15 +3680,16 @@ mod _io { mod fileio { use super::Offset; use super::_io::*; - use crate::builtins::{PyStr, PyStrRef, PyTypeRef}; - use crate::byteslike::{ArgBytesLike, ArgMemoryBuffer}; - use crate::crt_fd::Fd; - use crate::exceptions::IntoPyException; - use crate::function::OptionalOption; - use crate::function::{FuncArgs, OptionalArg}; - use crate::stdlib::os; - use crate::vm::VirtualMachine; - use crate::{PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol}; + use crate::{ + builtins::{PyStr, PyStrRef, PyTypeRef}, + byteslike::{ArgBytesLike, ArgMemoryBuffer}, + crt_fd::Fd, + exceptions::IntoPyException, + function::OptionalOption, + function::{FuncArgs, OptionalArg}, + stdlib::os, + PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, + }; use crossbeam_utils::atomic::AtomicCell; use std::io::{Read, Write}; diff --git a/vm/src/stdlib/select.rs b/vm/src/stdlib/select.rs index 7232c0510..1fcf7f906 100644 --- a/vm/src/stdlib/select.rs +++ b/vm/src/stdlib/select.rs @@ -150,11 +150,10 @@ fn sec_to_timeval(sec: f64) -> timeval { mod decl { use super::super::time; use super::*; - use crate::exceptions::IntoPyException; - use crate::function::OptionalOption; - use crate::utils::Either; - use crate::vm::VirtualMachine; - use crate::{PyObjectRef, PyResult}; + use crate::{ + exceptions::IntoPyException, function::OptionalOption, utils::Either, PyObjectRef, + PyResult, VirtualMachine, + }; #[pyfunction] fn select( @@ -252,11 +251,10 @@ mod decl { #[cfg(unix)] pub(super) mod poll { use super::*; - use crate::builtins::PyFloat; - use crate::common::lock::PyMutex; - use crate::function::OptionalArg; - use crate::stdlib::io::Fildes; - use crate::{IntoPyObject, PyValue, TypeProtocol}; + use crate::{ + builtins::PyFloat, common::lock::PyMutex, function::OptionalArg, stdlib::io::Fildes, + IntoPyObject, PyValue, TypeProtocol, + }; use libc::pollfd; use num_traits::ToPrimitive; use std::time; diff --git a/vm/src/stdlib/syslog.rs b/vm/src/stdlib/syslog.rs index 8e451a341..a8631f6ba 100644 --- a/vm/src/stdlib/syslog.rs +++ b/vm/src/stdlib/syslog.rs @@ -4,7 +4,7 @@ pub(crate) use syslog::make_module; mod syslog { use crate::common::lock::PyRwLock; use crate::{ - builtins::pystr::{PyStr, PyStrRef}, + builtins::{PyStr, PyStrRef}, function::{OptionalArg, OptionalOption}, utils::ToCString, PyObjectRef, PyResult, PyValue, TryFromObject, VirtualMachine, diff --git a/vm/src/stdlib/time.rs b/vm/src/stdlib/time.rs index df1a54079..3d90a9523 100644 --- a/vm/src/stdlib/time.rs +++ b/vm/src/stdlib/time.rs @@ -42,10 +42,12 @@ fn duration_since_system_now(vm: &VirtualMachine) -> PyResult PyResult { + pub fn run_code_obj(&self, code: PyRef, scope: Scope) -> PyResult { let frame = Frame::new(code, scope, self.builtins.dict().unwrap(), &[], self).into_ref(self); self.run_frame_full(frame) @@ -572,7 +571,7 @@ impl VirtualMachine { value.into_pyobject(self) } - pub fn new_code_object(&self, code: impl code::IntoCodeObject) -> PyCodeRef { + pub fn new_code_object(&self, code: impl code::IntoCodeObject) -> PyRef { self.ctx.new_code_object(code.into_codeobj(self)) } @@ -1573,7 +1572,7 @@ impl VirtualMachine { source: &str, mode: compile::Mode, source_path: String, - ) -> Result { + ) -> Result, CompileError> { self.compile_with_opts(source, mode, source_path, self.compile_opts()) } @@ -1584,7 +1583,7 @@ impl VirtualMachine { mode: compile::Mode, source_path: String, opts: CompileOpts, - ) -> Result { + ) -> Result, CompileError> { compile::compile(source, mode, source_path, opts) .map(|code| PyCode::new(self.map_codeobj(code)).into_ref(self)) }