clean up use statements

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<PyCode>
         let code = $vm.new_code_object(code);
 
         // run the python code in the scope to store the function

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<PyCode> },
 //     Tuple { elements: super::tuple::PyTupleRef },
 //     None(PyObjectRef),
 //     Ellipsis(PyObjectRef),
@@ -140,8 +140,6 @@ impl ConstantBag for PyObjBag<'_> {
     }
 }
 
-pub type PyCodeRef = PyRef<PyCode>;
-
 pub type CodeObject = bytecode::CodeObject<PyConstant>;
 pub type FrozenModule = bytecode::FrozenModule<PyConstant>;
 
@@ -193,7 +191,7 @@ impl PyValue for PyCode {
 impl PyCode {}
 
 #[pyimpl]
-impl PyCodeRef {
+impl PyRef<PyCode> {
     #[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::<PyCode>::extend_class(ctx, &ctx.types.code_type);
 }

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;

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<PyNotImplemented>;
 
 impl PyValue for PyNotImplemented {
     fn class(vm: &VirtualMachine) -> &PyTypeRef {

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;

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,
 };

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<u32>;
 
 #[pyclass(module = false, name = "frame")]
 pub struct Frame {
-    pub code: PyCodeRef,
+    pub code: PyRef<PyCode>,
 
     pub fastlocals: PyMutex<Box<[Option<PyObjectRef>]>>,
     pub(crate) cells_frees: Box<[PyCellRef]>,
@@ -174,7 +168,7 @@ pub type FrameResult = PyResult<Option<ExecutionResult>>;
 
 impl Frame {
     pub(crate) fn new(
-        code: PyCodeRef,
+        code: PyRef<PyCode>,
         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<PyCode>,
     fastlocals: &'a PyMutex<Box<[Option<PyObjectRef>]>>,
     cells_frees: &'a [PyCellRef],
     locals: &'a PyDictRef,
@@ -1550,7 +1544,7 @@ impl ExecutingFrame<'_> {
             .pop_value()
             .downcast::<PyStr>()
             .expect("qualified name to be a string");
-        let code_obj: PyCodeRef = self
+        let code_obj: PyRef<PyCode> = self
             .pop_value()
             .downcast()
             .expect("Second to top value on the stack must be a code object");

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<PyNone>,
     pub empty_tuple: PyTupleRef,
     pub empty_frozenset: PyRef<PyFrozenSet>,
     pub ellipsis: PyRef<PyEllipsis>,
-    pub not_implemented: PyNotImplementedRef,
+    pub not_implemented: PyRef<PyNotImplemented>,
 
     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<PyCode>` 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<PyCode> {
+        PyRef::new_ref(PyCode::new(code), self.types.code_type.clone(), None)
     }
 
     pub fn new_bound_method(&self, function: PyObjectRef, object: PyObjectRef) -> PyObjectRef {

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;

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};
 

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;

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,

vm/src/stdlib/time.rs

@@ -42,10 +42,12 @@ fn duration_since_system_now(vm: &VirtualMachine) -> PyResult<std::time::Duratio
 
 #[pymodule(name = "time")]
 mod time {
-    use crate::builtins::{PyStrRef, PyTypeRef};
-    use crate::function::{FuncArgs, OptionalArg};
-    use crate::utils::Either;
-    use crate::{PyObjectRef, PyResult, PyStructSequence, TryFromObject, VirtualMachine};
+    use crate::{
+        builtins::{PyStrRef, PyTypeRef},
+        function::{FuncArgs, OptionalArg},
+        utils::Either,
+        PyObjectRef, PyResult, PyStructSequence, TryFromObject, VirtualMachine,
+    };
     use chrono::{
         naive::{NaiveDate, NaiveDateTime, NaiveTime},
         Datelike, Timelike,
@@ -367,8 +369,7 @@ mod time {
 #[cfg(unix)]
 #[pymodule(name = "time")]
 mod unix {
-    use crate::vm::VirtualMachine;
-    use crate::PyResult;
+    use crate::{PyResult, VirtualMachine};
     use std::time::Duration;
 
     #[pyfunction]
@@ -474,8 +475,7 @@ mod unix {
 #[cfg(windows)]
 #[pymodule(name = "time")]
 mod windows {
-    use crate::vm::VirtualMachine;
-    use crate::PyResult;
+    use crate::{PyResult, VirtualMachine};
     use std::time::Duration;
     use winapi::shared::{minwindef::FILETIME, ntdef::ULARGE_INTEGER};
     use winapi::um::processthreadsapi::{

vm/src/types.rs

@@ -1,46 +1,11 @@
-use crate::builtins::asyncgenerator;
-use crate::builtins::builtinfunc;
-use crate::builtins::bytearray;
-use crate::builtins::bytes;
-use crate::builtins::classmethod;
-use crate::builtins::code;
-use crate::builtins::complex;
-use crate::builtins::coroutine;
-use crate::builtins::dict;
-use crate::builtins::enumerate;
-use crate::builtins::filter;
-use crate::builtins::float;
-use crate::builtins::frame;
-use crate::builtins::function;
-use crate::builtins::generator;
-use crate::builtins::genericalias;
-use crate::builtins::getset;
-use crate::builtins::int;
-use crate::builtins::iter;
-use crate::builtins::list;
-use crate::builtins::map;
-use crate::builtins::mappingproxy;
-use crate::builtins::memory;
-use crate::builtins::module;
-use crate::builtins::namespace;
-use crate::builtins::object;
-use crate::builtins::property;
-use crate::builtins::pybool;
-use crate::builtins::pystr;
-use crate::builtins::pysuper;
-use crate::builtins::pytype::{self, PyType, PyTypeRef};
-use crate::builtins::range;
-use crate::builtins::set;
-use crate::builtins::singletons;
-use crate::builtins::slice;
-use crate::builtins::staticmethod;
-use crate::builtins::traceback;
-use crate::builtins::tuple;
-use crate::builtins::weakproxy;
-use crate::builtins::weakref;
-use crate::builtins::zip;
-use crate::slots::PyTypeSlots;
-use crate::{PyAttributes, PyContext, StaticType};
+use crate::builtins::{
+    asyncgenerator, builtinfunc, bytearray, bytes, classmethod, code, complex, coroutine, dict,
+    enumerate, filter, float, frame, function, generator, genericalias, getset, int, iter, list,
+    map, mappingproxy, memory, module, namespace, object, property, pybool, pystr, pysuper,
+    pytype::{self, PyType, PyTypeRef},
+    range, set, singletons, slice, staticmethod, traceback, tuple, weakproxy, weakref, zip,
+};
+use crate::{slots::PyTypeSlots, PyAttributes, PyContext, StaticType};
 
 /// Holder of references to builtin types.
 #[derive(Debug, Clone)]

vm/src/vm.rs

@@ -4,39 +4,38 @@
 //!   https://github.com/ProgVal/pythonvm-rust/blob/master/src/processor/mod.rs
 //!
 
-use std::borrow::Cow;
-use std::cell::{Cell, Ref, RefCell};
-use std::collections::{HashMap, HashSet};
-use std::fmt;
-
-use crossbeam_utils::atomic::AtomicCell;
-use num_traits::{Signed, ToPrimitive};
-
-use crate::builtins::code::{self, PyCode, PyCodeRef};
-use crate::builtins::dict::PyDictRef;
-use crate::builtins::int::{PyInt, PyIntRef};
-use crate::builtins::list::PyList;
-use crate::builtins::module::{self, PyModule};
-use crate::builtins::object;
-use crate::builtins::pystr::{PyStr, PyStrRef};
-use crate::builtins::pytype::PyTypeRef;
-use crate::builtins::tuple::{PyTuple, PyTupleRef, PyTupleTyped};
-use crate::codecs::CodecsRegistry;
-use crate::common::{hash::HashSecret, lock::PyMutex, rc::PyRc};
 #[cfg(feature = "rustpython-compiler")]
 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::scope::Scope;
-use crate::slots::PyComparisonOp;
-use crate::utils::Either;
-use crate::{builtins, bytecode, frozen, import, iterator, stdlib, sysmodule};
 use crate::{
+    builtins::{
+        self,
+        code::{self, PyCode},
+        module, object,
+        tuple::{PyTuple, PyTupleRef, PyTupleTyped},
+        PyDictRef, PyInt, PyIntRef, PyList, PyModule, PyStr, PyStrRef, PyTypeRef,
+    },
+    bytecode,
+    codecs::CodecsRegistry,
+    common::{hash::HashSecret, lock::PyMutex, rc::PyRc},
+    exceptions::{self, PyBaseException, PyBaseExceptionRef},
+    frame::{ExecutionResult, Frame, FrameRef},
+    frozen,
+    function::{FuncArgs, IntoFuncArgs},
+    import, iterator,
+    scope::Scope,
+    slots::PyComparisonOp,
+    stdlib, sysmodule,
+    utils::Either,
     IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue, PyContext, PyLease, PyMethod,
     PyObject, PyObjectRef, PyRef, PyRefExact, PyResult, PyValue, TryFromObject, TryIntoRef,
     TypeProtocol,
 };
+use crossbeam_utils::atomic::AtomicCell;
+use num_traits::{Signed, ToPrimitive};
+use std::borrow::Cow;
+use std::cell::{Cell, Ref, RefCell};
+use std::collections::{HashMap, HashSet};
+use std::fmt;
 
 // use objects::ects;
 
@@ -487,7 +486,7 @@ impl VirtualMachine {
         }
     }
 
-    pub fn run_code_obj(&self, code: PyCodeRef, scope: Scope) -> PyResult {
+    pub fn run_code_obj(&self, code: PyRef<PyCode>, 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<PyCode> {
         self.ctx.new_code_object(code.into_codeobj(self))
     }
 
@@ -1573,7 +1572,7 @@ impl VirtualMachine {
         source: &str,
         mode: compile::Mode,
         source_path: String,
-    ) -> Result<PyCodeRef, CompileError> {
+    ) -> Result<PyRef<PyCode>, 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<PyCodeRef, CompileError> {
+    ) -> Result<PyRef<PyCode>, CompileError> {
         compile::compile(source, mode, source_path, opts)
             .map(|code| PyCode::new(self.map_codeobj(code)).into_ref(self))
     }