From 625f8675aefdc9a2de059cae242546bc418367a7 Mon Sep 17 00:00:00 2001 From: Jeong Yunwon Date: Sun, 17 Apr 2022 08:20:28 +0900 Subject: [PATCH] Introduce AsPyObject to replace IdProtocol --- src/lib.rs | 12 ++--- src/shell/helper.rs | 5 +- stdlib/src/array.rs | 7 ++- stdlib/src/json.rs | 2 +- vm/src/builtins/asyncgenerator.rs | 2 +- vm/src/builtins/bytearray.rs | 2 +- vm/src/builtins/bytes.rs | 2 +- vm/src/builtins/code.rs | 2 +- vm/src/builtins/complex.rs | 2 +- vm/src/builtins/coroutine.rs | 2 +- vm/src/builtins/dict.rs | 2 +- vm/src/builtins/float.rs | 2 +- vm/src/builtins/frame.rs | 2 +- vm/src/builtins/function.rs | 2 +- vm/src/builtins/function/jitfunc.rs | 2 +- vm/src/builtins/generator.rs | 2 +- vm/src/builtins/genericalias.rs | 2 +- vm/src/builtins/int.rs | 2 +- vm/src/builtins/list.rs | 4 +- vm/src/builtins/memory.rs | 2 +- vm/src/builtins/module.rs | 2 +- vm/src/builtins/namespace.rs | 2 +- vm/src/builtins/object.rs | 2 +- vm/src/builtins/pybool.rs | 2 +- vm/src/builtins/pystr.rs | 2 +- vm/src/builtins/pysuper.rs | 2 +- vm/src/builtins/pytype.rs | 2 +- vm/src/builtins/pyunion.rs | 2 +- vm/src/builtins/range.rs | 2 +- vm/src/builtins/set.rs | 2 +- vm/src/builtins/slice.rs | 3 +- vm/src/builtins/tuple.rs | 2 +- vm/src/builtins/weakref.rs | 4 +- vm/src/bytesinner.rs | 2 +- vm/src/codecs.rs | 2 +- vm/src/coroutine.rs | 2 +- vm/src/dictdatatype.rs | 2 +- vm/src/exceptions.rs | 2 +- vm/src/frame.rs | 2 +- vm/src/function/arithmetic.rs | 2 +- vm/src/import.rs | 2 +- vm/src/lib.rs | 4 +- vm/src/macros.rs | 2 +- vm/src/protocol/iter.rs | 4 +- vm/src/protocol/mapping.rs | 2 +- vm/src/protocol/object.rs | 2 +- vm/src/protocol/sequence.rs | 2 +- vm/src/pyobject.rs | 76 ++++++++++++++++------------- vm/src/pyobjectrc.rs | 58 ++++++---------------- vm/src/sequence.rs | 2 +- vm/src/stdlib/ast.rs | 2 +- vm/src/stdlib/builtins.rs | 2 +- vm/src/stdlib/codecs.rs | 2 +- vm/src/stdlib/collections.rs | 2 +- vm/src/stdlib/io.rs | 5 +- vm/src/stdlib/itertools.rs | 2 +- vm/src/stdlib/marshal.rs | 2 +- vm/src/stdlib/operator.rs | 2 +- vm/src/stdlib/os.rs | 4 +- vm/src/stdlib/pwd.rs | 2 +- vm/src/stdlib/thread.rs | 2 +- vm/src/stdlib/weakref.rs | 2 +- vm/src/suggestion.rs | 2 +- vm/src/types/slot.rs | 2 +- vm/src/vm.rs | 6 +-- vm/src/vm_new.rs | 2 +- vm/src/vm_object.rs | 2 +- vm/src/vm_ops.rs | 2 +- 68 files changed, 141 insertions(+), 161 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index 142f79615c..bf0ad6be3c 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -51,8 +51,8 @@ use rustpython_vm::{ compile, match_class, scope::Scope, stdlib::{atexit, sys}, - InitParameter, Interpreter, PyObjectRef, PyResult, PySettings, TryFromObject, TypeProtocol, - VirtualMachine, + AsPyObject, InitParameter, Interpreter, PyObjectRef, PyResult, PySettings, TryFromObject, + TypeProtocol, VirtualMachine, }; use std::{env, path::Path, process, str::FromStr}; @@ -536,12 +536,8 @@ fn setup_main_module(vm: &VirtualMachine) -> PyResult { main_module .dict() .and_then(|d| { - d.set_item( - "__annotations__", - vm.ctx.new_dict().as_object().to_owned(), - vm, - ) - .ok() + d.set_item("__annotations__", vm.ctx.new_dict().into(), vm) + .ok() }) .expect("Failed to initialize __main__.__annotations__"); diff --git a/src/shell/helper.rs b/src/shell/helper.rs index 171b7c274b..33b584a0df 100644 --- a/src/shell/helper.rs +++ b/src/shell/helper.rs @@ -85,9 +85,8 @@ impl<'vm> ShellHelper<'vm> { } else { // we need to get a variable based off of globals/builtins - let globals = str_iter_method(self.globals.as_object().to_owned(), "keys").ok()?; - let builtins = - str_iter_method(self.vm.builtins.as_object().to_owned(), "__dir__").ok()?; + let globals = str_iter_method(self.globals.clone().into(), "keys").ok()?; + let builtins = str_iter_method(self.vm.builtins.clone().into(), "__dir__").ok()?; (first, globals, Some(builtins)) }; Some((word_start, iter1.chain(iter2.into_iter().flatten()))) diff --git a/stdlib/src/array.rs b/stdlib/src/array.rs index 850ea73e61..137a1cd780 100644 --- a/stdlib/src/array.rs +++ b/stdlib/src/array.rs @@ -33,14 +33,13 @@ mod array { AsBuffer, AsMapping, Comparable, Constructor, IterNext, IterNextIterable, Iterable, PyComparisonOp, }, - IdProtocol, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, - PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }, }; use itertools::Itertools; use num_traits::ToPrimitive; - use std::cmp::Ordering; - use std::{fmt, os::raw}; + use std::{cmp::Ordering, fmt, os::raw}; macro_rules! def_array_enum { ($(($n:ident, $t:ty, $c:literal, $scode:literal)),*$(,)?) => { diff --git a/stdlib/src/json.rs b/stdlib/src/json.rs index 2da596efcf..ad28c6e4ca 100644 --- a/stdlib/src/json.rs +++ b/stdlib/src/json.rs @@ -9,7 +9,7 @@ mod _json { function::{IntoPyObject, IntoPyResult, OptionalArg}, protocol::PyIterReturn, types::{Callable, Constructor}, - IdProtocol, PyObjectRef, PyObjectView, PyResult, PyValue, VirtualMachine, + AsPyObject, PyObjectRef, PyObjectView, PyResult, PyValue, VirtualMachine, }; use num_bigint::BigInt; use std::str::FromStr; diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs index 39bb767f90..c6304cca5a 100644 --- a/vm/src/builtins/asyncgenerator.rs +++ b/vm/src/builtins/asyncgenerator.rs @@ -7,7 +7,7 @@ use crate::{ protocol::PyIterReturn, pyclass::PyClassImpl, types::{Constructor, IterNext, IterNextIterable, Unconstructible}, - IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index 08b7e7af29..2cd9358704 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -33,7 +33,7 @@ use crate::{ IterNextIterable, Iterable, PyComparisonOp, Unconstructible, Unhashable, }, utils::Either, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }; use bstr::ByteSlice; diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 9106461561..fbd459a83d 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -22,7 +22,7 @@ use crate::{ IterNextIterable, Iterable, PyComparisonOp, Unconstructible, }, utils::Either, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }; use bstr::ByteSlice; diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index 7b325c1868..3e10632a61 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -7,7 +7,7 @@ use crate::{ bytecode::{self, BorrowedConstant, Constant, ConstantBag}, function::FuncArgs, pyclass::{PyClassImpl, StaticType}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use num_traits::Zero; diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs index 21ad3d38fa..1aa41e0352 100644 --- a/vm/src/builtins/complex.rs +++ b/vm/src/builtins/complex.rs @@ -7,7 +7,7 @@ use crate::{ }, pyclass::PyClassImpl, types::{Comparable, Constructor, Hashable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use num_complex::Complex64; diff --git a/vm/src/builtins/coroutine.rs b/vm/src/builtins/coroutine.rs index 0eafde4fa0..c6859ba7d5 100644 --- a/vm/src/builtins/coroutine.rs +++ b/vm/src/builtins/coroutine.rs @@ -6,7 +6,7 @@ use crate::{ protocol::PyIterReturn, pyclass::PyClassImpl, types::{Constructor, IterNext, IterNextIterable, Unconstructible}, - IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, VirtualMachine, }; #[pyclass(module = false, name = "coroutine")] diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index 0f75607d55..299037110e 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -21,7 +21,7 @@ use crate::{ IterNextIterable, Iterable, PyComparisonOp, Unconstructible, Unhashable, }, vm::{ReprGuard, VirtualMachine}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; use rustpython_common::lock::PyMutex; diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs index 087643b5e8..de888f5946 100644 --- a/vm/src/builtins/float.rs +++ b/vm/src/builtins/float.rs @@ -9,7 +9,7 @@ use crate::{ }, pyclass::PyClassImpl, types::{Comparable, Constructor, Hashable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }; use num_bigint::{BigInt, ToBigInt}; diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs index 547c97f82c..c38b4c9b38 100644 --- a/vm/src/builtins/frame.rs +++ b/vm/src/builtins/frame.rs @@ -7,7 +7,7 @@ use crate::{ frame::{Frame, FrameRef}, pyclass::PyClassImpl, types::{Constructor, Unconstructible}, - IdProtocol, PyContext, PyObjectRef, PyObjectWrap, PyRef, PyResult, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyObjectWrap, PyRef, PyResult, VirtualMachine, }; pub fn init(context: &PyContext) { diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs index 2b2a6cac69..1e3f9c777c 100644 --- a/vm/src/builtins/function.rs +++ b/vm/src/builtins/function.rs @@ -14,7 +14,7 @@ use crate::{ pyclass::PyClassImpl, scope::Scope, types::{Callable, Comparable, Constructor, GetAttr, GetDescriptor, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; #[cfg(feature = "jit")] diff --git a/vm/src/builtins/function/jitfunc.rs b/vm/src/builtins/function/jitfunc.rs index cbc761847c..9ced316fdd 100644 --- a/vm/src/builtins/function/jitfunc.rs +++ b/vm/src/builtins/function/jitfunc.rs @@ -2,7 +2,7 @@ use crate::{ builtins::{float, int, pybool, PyBaseExceptionRef, PyDictRef, PyFunction, PyStrRef}, bytecode::CodeFlags, function::{FuncArgs, IntoPyObject}, - IdProtocol, PyObject, PyObjectRef, PyResult, TryFromObject, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, TryFromObject, TypeProtocol, 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 5cd5deffd1..7528981b79 100644 --- a/vm/src/builtins/generator.rs +++ b/vm/src/builtins/generator.rs @@ -10,7 +10,7 @@ use crate::{ protocol::PyIterReturn, pyclass::PyClassImpl, types::{Constructor, IterNext, IterNextIterable, Unconstructible}, - IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, VirtualMachine, }; #[pyclass(module = false, name = "generator")] diff --git a/vm/src/builtins/genericalias.rs b/vm/src/builtins/genericalias.rs index 2de0d451e2..d6d793360f 100644 --- a/vm/src/builtins/genericalias.rs +++ b/vm/src/builtins/genericalias.rs @@ -5,7 +5,7 @@ use crate::{ protocol::PyMappingMethods, pyclass::PyClassImpl, types::{AsMapping, Callable, Comparable, Constructor, GetAttr, Hashable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use std::fmt; diff --git a/vm/src/builtins/int.rs b/vm/src/builtins/int.rs index 2fb3b0d587..da837a099b 100644 --- a/vm/src/builtins/int.rs +++ b/vm/src/builtins/int.rs @@ -9,7 +9,7 @@ use crate::{ }, pyclass::PyClassImpl, types::{Comparable, Constructor, Hashable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol, VirtualMachine, }; use bstr::ByteSlice; diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs index 346504d586..622f56153e 100644 --- a/vm/src/builtins/list.rs +++ b/vm/src/builtins/list.rs @@ -15,8 +15,8 @@ use crate::{ }, utils::collection_repr, vm::{ReprGuard, VirtualMachine}, - PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, PyValue, - TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, + PyValue, TypeProtocol, }; use std::{borrow::Cow, fmt, ops::DerefMut}; diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index 5f8527bb82..6a12551c8c 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -18,7 +18,7 @@ use crate::{ sliceable::wrap_index, types::{AsBuffer, AsMapping, AsSequence, Comparable, Constructor, Hashable, PyComparisonOp}, utils::Either, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyObjectWrap, PyRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs index 90a43c45dd..1586c93716 100644 --- a/vm/src/builtins/module.rs +++ b/vm/src/builtins/module.rs @@ -4,7 +4,7 @@ use crate::{ function::{FuncArgs, IntoPyObject}, pyclass::PyClassImpl, types::GetAttr, - PyContext, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, VirtualMachine, }; #[pyclass(module = false, name = "module")] diff --git a/vm/src/builtins/namespace.rs b/vm/src/builtins/namespace.rs index 6668e367b3..aaebfdb3e1 100644 --- a/vm/src/builtins/namespace.rs +++ b/vm/src/builtins/namespace.rs @@ -5,7 +5,7 @@ use crate::{ pyclass::PyClassImpl, types::{Comparable, Constructor, PyComparisonOp}, vm::ReprGuard, - IdProtocol, PyContext, PyObject, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyContext, PyObject, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; /// A simple attribute-based namespace. diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs index 4498afa09e..a079cb3abe 100644 --- a/vm/src/builtins/object.rs +++ b/vm/src/builtins/object.rs @@ -5,7 +5,7 @@ use crate::{ pyclass::PyClassImpl, types::PyComparisonOp, utils::Either, - IdProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; /// object() diff --git a/vm/src/builtins/pybool.rs b/vm/src/builtins/pybool.rs index a44a4396b3..98315b9546 100644 --- a/vm/src/builtins/pybool.rs +++ b/vm/src/builtins/pybool.rs @@ -3,7 +3,7 @@ use crate::{ function::{IntoPyObject, OptionalArg}, pyclass::PyClassImpl, types::Constructor, - IdProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, + AsPyObject, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol, VirtualMachine, }; use num_bigint::Sign; diff --git a/vm/src/builtins/pystr.rs b/vm/src/builtins/pystr.rs index 55077213ca..9ee232a0bd 100644 --- a/vm/src/builtins/pystr.rs +++ b/vm/src/builtins/pystr.rs @@ -18,7 +18,7 @@ use crate::{ AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, IterNextIterable, Iterable, PyComparisonOp, Unconstructible, }, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TryFromBorrowedObject, TypeProtocol, VirtualMachine, }; use ascii::{AsciiStr, AsciiString}; diff --git a/vm/src/builtins/pysuper.rs b/vm/src/builtins/pysuper.rs index b86c0cc418..ea01de8bfb 100644 --- a/vm/src/builtins/pysuper.rs +++ b/vm/src/builtins/pysuper.rs @@ -8,7 +8,7 @@ use crate::{ function::OptionalArg, pyclass::PyClassImpl, types::{Constructor, GetAttr, GetDescriptor}, - IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; #[pyclass(module = false, name = "super")] diff --git a/vm/src/builtins/pytype.rs b/vm/src/builtins/pytype.rs index 3ea2561d76..8798bca74c 100644 --- a/vm/src/builtins/pytype.rs +++ b/vm/src/builtins/pytype.rs @@ -12,7 +12,7 @@ use crate::{ pyclass::{PyClassImpl, StaticType}, pyobject::PyLease, types::{Callable, GetAttr, PyTypeFlags, PyTypeSlots, SetAttr}, - IdProtocol, PyContext, PyObjectRef, PyObjectWeak, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyContext, PyObjectRef, PyObjectWeak, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use itertools::Itertools; diff --git a/vm/src/builtins/pyunion.rs b/vm/src/builtins/pyunion.rs index 7ea922cc91..42a1846665 100644 --- a/vm/src/builtins/pyunion.rs +++ b/vm/src/builtins/pyunion.rs @@ -6,7 +6,7 @@ use crate::{ protocol::PyMappingMethods, pyclass::PyClassImpl, types::{AsMapping, Comparable, GetAttr, Hashable, Iterable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use std::fmt; diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs index b48dd31d7c..dd22a4541a 100644 --- a/vm/src/builtins/range.rs +++ b/vm/src/builtins/range.rs @@ -9,7 +9,7 @@ use crate::{ AsMapping, AsSequence, Comparable, Constructor, Hashable, IterNext, IterNextIterable, Iterable, PyComparisonOp, Unconstructible, }, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index d04ff1315b..b3339e64a9 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -17,7 +17,7 @@ use crate::{ }, utils::collection_repr, vm::{ReprGuard, VirtualMachine}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; use std::borrow::Cow; diff --git a/vm/src/builtins/slice.rs b/vm/src/builtins/slice.rs index 60effa4cb7..3a3f998dda 100644 --- a/vm/src/builtins/slice.rs +++ b/vm/src/builtins/slice.rs @@ -4,7 +4,8 @@ use crate::{ function::{FuncArgs, IntoPyObject, OptionalArg, PyComparisonValue}, pyclass::PyClassImpl, types::{Comparable, Constructor, Hashable, PyComparisonOp, Unhashable}, - PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, + VirtualMachine, }; use num_bigint::{BigInt, ToBigInt}; use num_traits::{One, Signed, ToPrimitive, Zero}; diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index 7256c36e7e..7473e2a56a 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -14,7 +14,7 @@ use crate::{ }, utils::collection_repr, vm::{ReprGuard, VirtualMachine}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, + AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, }; use std::{borrow::Cow, fmt, marker::PhantomData}; diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs index 192818eccc..51e0e5dcc1 100644 --- a/vm/src/builtins/weakref.rs +++ b/vm/src/builtins/weakref.rs @@ -7,8 +7,8 @@ use crate::{ function::OptionalArg, pyclass::PyClassImpl, types::{Callable, Comparable, Constructor, Hashable, PyComparisonOp}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, - VirtualMachine, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, + TypeProtocol, VirtualMachine, }; pub use crate::pyobject::PyWeak; diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs index 83dc19df7c..ed50c56f4d 100644 --- a/vm/src/bytesinner.rs +++ b/vm/src/bytesinner.rs @@ -9,7 +9,7 @@ use crate::{ sequence::{SequenceMutOp, SequenceOp}, types::PyComparisonOp, utils::Either, - IdProtocol, PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, VirtualMachine, }; use bstr::ByteSlice; use itertools::Itertools; diff --git a/vm/src/codecs.rs b/vm/src/codecs.rs index af47a927d4..978374c54f 100644 --- a/vm/src/codecs.rs +++ b/vm/src/codecs.rs @@ -2,7 +2,7 @@ use crate::{ builtins::{PyBaseExceptionRef, PyBytesRef, PyStr, PyStrRef, PyTuple, PyTupleRef}, common::{ascii, lock::PyRwLock}, function::IntoPyObject, - IdProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use std::{borrow::Cow, collections::HashMap, fmt::Write, ops::Range}; diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs index 051614b74e..e3bbe45d08 100644 --- a/vm/src/coroutine.rs +++ b/vm/src/coroutine.rs @@ -3,7 +3,7 @@ use crate::{ common::lock::PyMutex, frame::{ExecutionResult, FrameRef}, protocol::PyIterReturn, - IdProtocol, PyObject, PyObjectRef, PyResult, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs index 5503b13e1d..ddbcca800e 100644 --- a/vm/src/dictdatatype.rs +++ b/vm/src/dictdatatype.rs @@ -10,7 +10,7 @@ use crate::common::{ use crate::{ builtins::{PyInt, PyStr, PyStrRef}, function::IntoPyObject, - IdProtocol, PyObject, PyObjectRef, PyObjectWrap, PyRefExact, PyResult, TypeProtocol, + AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyRefExact, PyResult, TypeProtocol, VirtualMachine, }; use num_traits::ToPrimitive; diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index 24b2b342b7..3674d8542b 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -9,7 +9,7 @@ use crate::{ pyclass::{PyClassImpl, StaticType}, stdlib::sys, suggestion::offer_suggestions, - IdProtocol, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, + AsPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/frame.rs b/vm/src/frame.rs index c6ab7b2c0e..fa0ba1386e 100644 --- a/vm/src/frame.rs +++ b/vm/src/frame.rs @@ -15,7 +15,7 @@ use crate::{ scope::Scope, stdlib::builtins, types::PyComparisonOp, - IdProtocol, PyMethod, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, + AsPyObject, PyMethod, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use indexmap::IndexMap; diff --git a/vm/src/function/arithmetic.rs b/vm/src/function/arithmetic.rs index d13397d04e..a4871e5964 100644 --- a/vm/src/function/arithmetic.rs +++ b/vm/src/function/arithmetic.rs @@ -1,7 +1,7 @@ use crate::{ convert::TryFromObject, function::IntoPyObject, - pyobject::{IdProtocol, PyObjectRef, PyResult}, + pyobject::{AsPyObject, PyObjectRef, PyResult}, VirtualMachine, }; diff --git a/vm/src/import.rs b/vm/src/import.rs index 215ab65cd7..2dc632bc17 100644 --- a/vm/src/import.rs +++ b/vm/src/import.rs @@ -127,7 +127,7 @@ pub fn import_codeobj( let attrs = vm.ctx.new_dict(); attrs.set_item("__name__", vm.ctx.new_str(module_name).into(), vm)?; if set_file_attr { - attrs.set_item("__file__", code_obj.source_path.as_object().to_owned(), vm)?; + attrs.set_item("__file__", code_obj.source_path.clone().into(), vm)?; } let module = vm.new_module(module_name, attrs.clone(), None); diff --git a/vm/src/lib.rs b/vm/src/lib.rs index 4fee1ee8b3..5a88bdd0a8 100644 --- a/vm/src/lib.rs +++ b/vm/src/lib.rs @@ -89,12 +89,12 @@ mod pyobject { pub use self::convert::{TryFromBorrowedObject, TryFromObject}; // pyobject items pub use self::pyobject::{ - IdProtocol, PyContext, PyMethod, PyObjectPayload, PyRefExact, PyResult, PyStructSequence, + PyContext, PyMethod, PyObjectPayload, PyObjectWrap, PyRefExact, PyResult, PyStructSequence, PyValue, TypeProtocol, }; // pyobjectrc items pub use self::pyobject::{ - PyObject, PyObjectRef, PyObjectView, PyObjectWeak, PyObjectWrap, PyRef, PyWeakRef, + AsPyObject, PyObject, PyObjectRef, PyObjectView, PyObjectWeak, PyRef, PyWeakRef, }; pub use self::vm::{InitParameter, Interpreter, PySettings, VirtualMachine}; pub use rustpython_bytecode as bytecode; diff --git a/vm/src/macros.rs b/vm/src/macros.rs index 6cd3ec5c6d..5945682730 100644 --- a/vm/src/macros.rs +++ b/vm/src/macros.rs @@ -49,7 +49,7 @@ macro_rules! py_namespace { { let namespace = $crate::builtins::PyNamespace::new_ref(&$vm.ctx); $( - $vm.__module_set_attr(namespace.as_object(), $name, $value).unwrap(); + $vm.__module_set_attr($crate::pyobject::AsPyObject::as_object(&namespace), $name, $value).unwrap(); )* namespace } diff --git a/vm/src/protocol/iter.rs b/vm/src/protocol/iter.rs index a79534694f..1ccfce00ff 100644 --- a/vm/src/protocol/iter.rs +++ b/vm/src/protocol/iter.rs @@ -1,8 +1,8 @@ use crate::{ builtins::iter::PySequenceIterator, function::{IntoPyObject, IntoPyResult}, - PyObject, PyObjectRef, PyObjectWrap, PyResult, PyValue, TryFromObject, TypeProtocol, - VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyResult, PyValue, TryFromObject, + TypeProtocol, VirtualMachine, }; use std::borrow::Borrow; use std::ops::Deref; diff --git a/vm/src/protocol/mapping.rs b/vm/src/protocol/mapping.rs index e844d42026..bd88ae1161 100644 --- a/vm/src/protocol/mapping.rs +++ b/vm/src/protocol/mapping.rs @@ -5,7 +5,7 @@ use crate::{ }, common::lock::OnceCell, function::IntoPyResult, - IdProtocol, PyObject, PyObjectRef, PyResult, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, TypeProtocol, VirtualMachine, }; // Mapping protocol diff --git a/vm/src/protocol/object.rs b/vm/src/protocol/object.rs index 1fd8565c1b..edc1ddde9e 100644 --- a/vm/src/protocol/object.rs +++ b/vm/src/protocol/object.rs @@ -13,7 +13,7 @@ use crate::{ protocol::{PyIter, PyMapping, PySequence}, types::{Constructor, PyComparisonOp}, utils::Either, - IdProtocol, PyObject, PyObjectRef, PyResult, TryFromObject, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, TryFromObject, TypeProtocol, VirtualMachine, }; // RustPython doesn't need these items diff --git a/vm/src/protocol/sequence.rs b/vm/src/protocol/sequence.rs index ffe3137aa7..684e6cd6e7 100644 --- a/vm/src/protocol/sequence.rs +++ b/vm/src/protocol/sequence.rs @@ -3,7 +3,7 @@ use crate::{ common::lock::OnceCell, function::{IntoPyObject, PyArithmeticValue}, protocol::PyMapping, - IdProtocol, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use itertools::Itertools; use std::{ diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs index df5f3cadb3..0054c190a5 100644 --- a/vm/src/pyobject.rs +++ b/vm/src/pyobject.rs @@ -1,6 +1,3 @@ -pub use crate::_pyobjectrc::{ - PyObject, PyObjectRef, PyObjectView, PyObjectWeak, PyObjectWrap, PyRef, PyWeakRef, -}; use crate::common::lock::PyRwLockReadGuard; use crate::{ builtins::{ @@ -20,6 +17,7 @@ use crate::{ pyclass::{PyClassImpl, StaticType}, types::{PyTypeFlags, PyTypeSlots, TypeZoo}, VirtualMachine, + _pyobjectrc::{PyObject, PyObjectRef, PyObjectView, PyRef}, }; use num_bigint::BigInt; use num_traits::ToPrimitive; @@ -389,46 +387,42 @@ impl IntoPyObject for PyRefExact { } } -pub trait IdProtocol { - fn get_id(&self) -> usize; +pub trait AsPyObject +where + Self: Borrow, +{ + #[inline(always)] + fn as_object(&self) -> &PyObject { + self.borrow() + } + #[inline(always)] + fn get_id(&self) -> usize { + self.as_object()._get_id() + } + #[inline(always)] fn is(&self, other: &T) -> bool where - T: IdProtocol, + T: AsPyObject, { self.get_id() == other.get_id() } } -// impl IdProtocol for PyRc { -// fn get_id(&self) -> usize { -// &**self as *const T as *const () as usize +impl AsPyObject for T where T: Borrow {} + +impl PyObject { + #[inline] + fn _get_id(&self) -> usize { + self as *const PyObject as usize + } +} + +// impl Borrow for PyRc { +// fn borrow(&self) -> &PyObject { +// unsafe { &*(&**self as *const T as *const PyObject) } // } // } -impl IdProtocol for PyRef { - fn get_id(&self) -> usize { - self.as_object().get_id() - } -} - -impl IdProtocol for PyObjectView { - fn get_id(&self) -> usize { - self.as_object().get_id() - } -} - -impl<'a, T: PyObjectPayload> IdProtocol for PyLease<'a, T> { - fn get_id(&self) -> usize { - self.inner.get_id() - } -} - -impl IdProtocol for &'_ T { - fn get_id(&self) -> usize { - (&**self).get_id() - } -} - /// A borrow of a reference to a Python object. This avoids having clone the `PyRef`/ /// `PyObjectRef`, which isn't that cheap as that increments the atomic reference counter. pub struct PyLease<'a, T: PyObjectPayload> { @@ -705,6 +699,22 @@ pub trait PyStructSequence: StaticType + PyClassImpl + Sized + 'static { } } +pub trait PyObjectWrap +where + Self: AsPyObject, +{ + fn into_object(self) -> PyObjectRef; +} + +impl From for PyObjectRef +where + T: PyObjectWrap, +{ + fn from(py_ref: T) -> Self { + py_ref.into_object() + } +} + #[derive(Debug)] pub enum PyMethod { Function { diff --git a/vm/src/pyobjectrc.rs b/vm/src/pyobjectrc.rs index 6c2ac805e3..0e1630c688 100644 --- a/vm/src/pyobjectrc.rs +++ b/vm/src/pyobjectrc.rs @@ -3,7 +3,7 @@ use crate::common::linked_list::{Link, LinkedList, Pointers}; use crate::common::lock::{PyMutex, PyMutexGuard, PyRwLock}; use crate::common::refcount::RefCount; use crate::{ - _pyobject::{IdProtocol, PyObjectPayload, PyResult, TypeProtocol}, + _pyobject::{AsPyObject, PyObjectPayload, PyObjectWrap, PyResult, TypeProtocol}, builtins::{PyBaseExceptionRef, PyDictRef, PyTypeRef}, vm::VirtualMachine, }; @@ -464,18 +464,6 @@ impl ToOwned for PyObject { } } -pub trait PyObjectWrap -where - Self: Borrow, -{ - #[inline(always)] - fn as_object(&self) -> &PyObject { - self.borrow() - } - - fn into_object(self) -> PyObjectRef; -} - impl PyObjectRef { pub fn into_raw(self) -> *const PyObject { let ptr = self.as_raw(); @@ -770,30 +758,22 @@ impl AsRef for PyObject { } } -impl IdProtocol for PyObjectRef { - fn get_id(&self) -> usize { - PyObject::get_id(self) - } -} - -impl IdProtocol for PyObject { - fn get_id(&self) -> usize { - self as *const PyObject as usize - } -} - impl<'a, T: PyObjectPayload> From<&'a PyObjectView> for &'a PyObject { fn from(py_ref: &'a PyObjectView) -> Self { py_ref.as_object() } } -impl From for PyObjectRef -where - T: PyObjectWrap, -{ - fn from(py_ref: T) -> Self { - py_ref.into_object() +impl Borrow for PyObjectWeak { + #[inline] + fn borrow(&self) -> &PyObject { + self.weak.as_object() + } +} + +impl PyObjectWrap for PyObjectWeak { + fn into_object(self) -> PyObjectRef { + self.weak.into_object() } } @@ -802,10 +782,6 @@ impl PyObjectWeak { pub fn upgrade(&self) -> Option { self.weak.upgrade() } - - pub fn into_object(self) -> PyObjectRef { - self.weak.into_object() - } } impl Drop for PyObjectRef { @@ -854,11 +830,6 @@ impl fmt::Debug for PyObjectWeak { pub struct PyObjectView(PyInner); impl PyObjectView { - #[inline(always)] - pub fn as_object(&self) -> &PyObject { - unsafe { &*(&self.0 as *const PyInner as *const PyObject) } - } - pub fn downgrade( &self, callback: Option, @@ -886,14 +857,16 @@ impl ToOwned for PyObjectView { impl Deref for PyObjectView { type Target = T; + #[inline(always)] fn deref(&self) -> &Self::Target { &self.0.payload } } impl Borrow for PyObjectView { + #[inline(always)] fn borrow(&self) -> &PyObject { - self.as_object() + unsafe { &*(&self.0 as *const PyInner as *const PyObject) } } } @@ -901,8 +874,9 @@ impl AsRef for PyObjectView where T: PyObjectPayload, { + #[inline(always)] fn as_ref(&self) -> &PyObject { - self.as_object() + self.borrow() } } diff --git a/vm/src/sequence.rs b/vm/src/sequence.rs index 14bf025787..2088156b22 100644 --- a/vm/src/sequence.rs +++ b/vm/src/sequence.rs @@ -3,7 +3,7 @@ use crate::{ types::{richcompare_wrapper, PyComparisonOp, RichCompareFunc}, utils::Either, vm::VirtualMachine, - IdProtocol, PyObject, PyObjectRef, PyResult, TypeProtocol, + AsPyObject, PyObject, PyObjectRef, PyResult, TypeProtocol, }; use itertools::Itertools; use optional::Optioned; diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs index b01e54e7c0..f58fcc5fb3 100644 --- a/vm/src/stdlib/ast.rs +++ b/vm/src/stdlib/ast.rs @@ -8,7 +8,7 @@ mod gen; use crate::{ builtins::{self, PyStrRef, PyTypeRef}, pyclass::{PyClassImpl, StaticType}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, + AsPyObject, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use num_complex::Complex64; diff --git a/vm/src/stdlib/builtins.rs b/vm/src/stdlib/builtins.rs index bf53b02251..102d98bda1 100644 --- a/vm/src/stdlib/builtins.rs +++ b/vm/src/stdlib/builtins.rs @@ -33,7 +33,7 @@ mod builtins { stdlib::sys, types::PyComparisonOp, utils::Either, - IdProtocol, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, TryFromObject, + AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, }; use num_traits::{Signed, ToPrimitive, Zero}; diff --git a/vm/src/stdlib/codecs.rs b/vm/src/stdlib/codecs.rs index 15ab8e60ea..484e1dda52 100644 --- a/vm/src/stdlib/codecs.rs +++ b/vm/src/stdlib/codecs.rs @@ -7,7 +7,7 @@ mod _codecs { builtins::{PyBaseExceptionRef, PyBytes, PyBytesRef, PyStr, PyStrRef, PyTuple}, codecs, function::{ArgBytesLike, FuncArgs}, - IdProtocol, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, TryFromBorrowedObject, VirtualMachine, }; use std::ops::Range; diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs index a59909ae0b..d99a279c7a 100644 --- a/vm/src/stdlib/collections.rs +++ b/vm/src/stdlib/collections.rs @@ -19,7 +19,7 @@ mod _collections { }, utils::collection_repr, vm::ReprGuard, - PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; use std::cmp::max; diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index 3e286b2942..6f9992ba98 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -88,7 +88,7 @@ mod _io { types::{Constructor, Destructor, IterNext, Iterable}, utils::Either, vm::{ReprGuard, VirtualMachine}, - IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, + AsPyObject, PyContext, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, }; use bstr::ByteSlice; @@ -3661,7 +3661,8 @@ mod fileio { ArgBytesLike, ArgMemoryBuffer, FuncArgs, IntoPyException, OptionalArg, OptionalOption, }, stdlib::os, - PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, VirtualMachine, + AsPyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, + VirtualMachine, }; 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 04f539027b..bd8264f3a6 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -12,7 +12,7 @@ mod decl { protocol::{PyIter, PyIterReturn}, stdlib::sys, types::{Constructor, IterNext, IterNextIterable}, - IdProtocol, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, PyWeakRef, TypeProtocol, + AsPyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, PyWeakRef, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs index d8791d0f0c..03cfc0cd24 100644 --- a/vm/src/stdlib/marshal.rs +++ b/vm/src/stdlib/marshal.rs @@ -10,7 +10,7 @@ mod decl { bytecode, function::{ArgBytesLike, IntoPyObject}, protocol::PyBuffer, - pyobject::{IdProtocol, TypeProtocol}, + pyobject::{AsPyObject, TypeProtocol}, PyObjectRef, PyResult, TryFromObject, VirtualMachine, }; /// TODO diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs index 4830ba87f4..5d46321a75 100644 --- a/vm/src/stdlib/operator.rs +++ b/vm/src/stdlib/operator.rs @@ -20,7 +20,7 @@ mod _operator { }, utils::Either, vm::ReprGuard, - IdProtocol, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 701ff8f396..d892d9d3f6 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -3,8 +3,8 @@ use crate::{ crt_fd::Fd, function::{ArgumentError, FromArgs, FuncArgs, IntoPyException, IntoPyObject}, protocol::PyBuffer, - PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, TypeProtocol, - VirtualMachine, + AsPyObject, PyObject, PyObjectRef, PyResult, PyValue, TryFromBorrowedObject, TryFromObject, + TypeProtocol, VirtualMachine, }; use std::{ ffi, fs, diff --git a/vm/src/stdlib/pwd.rs b/vm/src/stdlib/pwd.rs index 0ac569ef0d..be32213fda 100644 --- a/vm/src/stdlib/pwd.rs +++ b/vm/src/stdlib/pwd.rs @@ -5,7 +5,7 @@ mod pwd { use crate::{ builtins::{PyIntRef, PyStrRef}, function::{IntoPyException, IntoPyObject}, - PyObjectRef, PyResult, PyStructSequence, VirtualMachine, + AsPyObject, PyObjectRef, PyResult, PyStructSequence, VirtualMachine, }; use nix::unistd::{self, User}; use std::ptr::NonNull; diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs index abb67fe22a..deab60bd4d 100644 --- a/vm/src/stdlib/thread.rs +++ b/vm/src/stdlib/thread.rs @@ -10,7 +10,7 @@ pub(crate) mod _thread { py_io, types::{Constructor, GetAttr, SetAttr}, utils::Either, - IdProtocol, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, + AsPyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use parking_lot::{ lock_api::{RawMutex as RawMutexT, RawMutexTimed, RawReentrantMutex}, diff --git a/vm/src/stdlib/weakref.rs b/vm/src/stdlib/weakref.rs index ffeb036280..e5eefddef2 100644 --- a/vm/src/stdlib/weakref.rs +++ b/vm/src/stdlib/weakref.rs @@ -9,7 +9,7 @@ pub(crate) use _weakref::make_module; #[pymodule] mod _weakref { use crate::builtins::{PyDictRef, PyTypeRef, PyWeak}; - use crate::{PyObjectRef, PyResult, VirtualMachine}; + use crate::{PyObjectRef, PyObjectWrap, PyResult, VirtualMachine}; #[pyattr(name = "ref")] fn ref_(vm: &VirtualMachine) -> PyTypeRef { diff --git a/vm/src/suggestion.rs b/vm/src/suggestion.rs index 5ac4b95d65..e38713a321 100644 --- a/vm/src/suggestion.rs +++ b/vm/src/suggestion.rs @@ -2,7 +2,7 @@ use crate::{ builtins::{PyStr, PyStrRef}, exceptions::types::PyBaseExceptionRef, sliceable::SliceableSequenceOp, - IdProtocol, PyObjectRef, PyObjectView, TypeProtocol, VirtualMachine, + AsPyObject, PyObjectRef, PyObjectView, TypeProtocol, VirtualMachine, }; use rustpython_common::str::levenshtein::{levenshtein_distance, MOVE_COST}; use std::iter::ExactSizeIterator; diff --git a/vm/src/types/slot.rs b/vm/src/types/slot.rs index c002e84d39..713fd9e7ac 100644 --- a/vm/src/types/slot.rs +++ b/vm/src/types/slot.rs @@ -6,7 +6,7 @@ use crate::{ protocol::{PyBuffer, PyIterReturn, PyMapping, PyMappingMethods}, protocol::{PySequence, PySequenceMethods}, utils::Either, - IdProtocol, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TypeProtocol, + AsPyObject, PyObject, PyObjectRef, PyObjectView, PyRef, PyResult, PyValue, TypeProtocol, VirtualMachine, }; use crossbeam_utils::atomic::AtomicCell; diff --git a/vm/src/vm.rs b/vm/src/vm.rs index 59ab75d139..d61ec88ea1 100644 --- a/vm/src/vm.rs +++ b/vm/src/vm.rs @@ -24,8 +24,8 @@ use crate::{ protocol::PyIterIter, pyobject::PyLease, scope::Scope, - signal, stdlib, IdProtocol, PyContext, PyObject, PyObjectRef, PyObjectWrap, PyRef, PyRefExact, - PyResult, PyValue, TypeProtocol, + signal, stdlib, AsPyObject, PyContext, PyObject, PyObjectRef, PyRef, PyRefExact, PyResult, + PyValue, TypeProtocol, }; use crossbeam_utils::atomic::AtomicCell; use std::{ @@ -872,7 +872,7 @@ impl VirtualMachine { if !context_exc.is(exception) { let mut o = context_exc.clone(); while let Some(context) = o.context() { - if context.is(&exception) { + if context.is(exception) { o.set_context(None); break; } diff --git a/vm/src/vm_new.rs b/vm/src/vm_new.rs index 492ed91a86..e219535849 100644 --- a/vm/src/vm_new.rs +++ b/vm/src/vm_new.rs @@ -10,7 +10,7 @@ use crate::{ function::IntoPyObject, scope::Scope, vm::VirtualMachine, - PyObject, PyObjectRef, PyObjectWrap, PyRef, TypeProtocol, + AsPyObject, PyObject, PyObjectRef, PyObjectWrap, PyRef, TypeProtocol, }; /// Collection of object creation helpers diff --git a/vm/src/vm_object.rs b/vm/src/vm_object.rs index 3d2c3200c2..dc7cecf558 100644 --- a/vm/src/vm_object.rs +++ b/vm/src/vm_object.rs @@ -2,7 +2,7 @@ use crate::{ builtins::{PyBaseExceptionRef, PyList, PyStr}, function::{FuncArgs, IntoFuncArgs}, vm::VirtualMachine, - IdProtocol, PyMethod, PyObject, PyObjectRef, PyObjectWrap, PyResult, PyValue, TypeProtocol, + AsPyObject, PyMethod, PyObject, PyObjectRef, PyResult, PyValue, TypeProtocol, }; /// Trace events for sys.settrace and sys.setprofile. diff --git a/vm/src/vm_ops.rs b/vm/src/vm_ops.rs index 7766730afa..c783611ec7 100644 --- a/vm/src/vm_ops.rs +++ b/vm/src/vm_ops.rs @@ -4,7 +4,7 @@ use crate::{ protocol::PyIterReturn, types::PyComparisonOp, vm::VirtualMachine, - IdProtocol, PyMethod, PyObject, PyObjectRef, PyResult, TypeProtocol, + AsPyObject, PyMethod, PyObject, PyObjectRef, PyResult, TypeProtocol, }; /// Collection of operators