diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs index 085738f53..16a283525 100644 --- a/derive/src/pyclass.rs +++ b/derive/src/pyclass.rs @@ -73,7 +73,7 @@ pub(crate) fn impl_pyimpl( fn impl_extend_class( ctx: &::rustpython_vm::pyobject::PyContext, - class: &::rustpython_vm::obj::objtype::PyTypeRef, + class: &::rustpython_vm::builtins::pytype::PyTypeRef, ) { #getset_impl #extend_impl @@ -100,7 +100,7 @@ pub(crate) fn impl_pyimpl( parse_quote! { fn __extend_py_class( ctx: &::rustpython_vm::pyobject::PyContext, - class: &::rustpython_vm::obj::objtype::PyTypeRef, + class: &::rustpython_vm::builtins::pytype::PyTypeRef, ) { #getset_impl #extend_impl @@ -162,7 +162,7 @@ fn generate_class_def( let base_class = if is_pystruct { quote! { - fn base_class(ctx: &::rustpython_vm::pyobject::PyContext) -> ::rustpython_vm::obj::objtype::PyTypeRef { + fn base_class(ctx: &::rustpython_vm::pyobject::PyContext) -> ::rustpython_vm::builtins::pytype::PyTypeRef { ctx.types.tuple_type.clone() } } @@ -502,7 +502,7 @@ impl ToTokens for GetSetNursery { class.set_str_attr( #name, ::rustpython_vm::pyobject::PyObject::new( - ::rustpython_vm::obj::objgetset::PyGetSet::#constructor(#name.into(), &Self::#getter #setter), + ::rustpython_vm::builtins::getset::PyGetSet::#constructor(#name.into(), &Self::#getter #setter), ctx.types.getset_type.clone(), None) ); } diff --git a/derive/src/pystructseq.rs b/derive/src/pystructseq.rs index f86ffc30b..4628e6153 100644 --- a/derive/src/pystructseq.rs +++ b/derive/src/pystructseq.rs @@ -31,12 +31,12 @@ pub(crate) fn impl_pystruct_sequence( let ret = quote! { impl ::rustpython_vm::pyobject::PyStructSequence for #ty { const FIELD_NAMES: &'static [&'static str] = &[#(stringify!(#field_names)),*]; - fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::obj::objtuple::PyTuple { + fn into_tuple(self, vm: &::rustpython_vm::VirtualMachine) -> ::rustpython_vm::builtins::tuple::PyTuple { let items = vec![#(::rustpython_vm::pyobject::IntoPyObject::into_pyobject( self.#field_names, vm, )),*]; - ::rustpython_vm::obj::objtuple::PyTuple::_new(items.into_boxed_slice()) + ::rustpython_vm::builtins::tuple::PyTuple::_new(items.into_boxed_slice()) } } }; diff --git a/examples/mini_repl.rs b/examples/mini_repl.rs index d1cb00c15..ff538cf3d 100644 --- a/examples/mini_repl.rs +++ b/examples/mini_repl.rs @@ -34,7 +34,7 @@ macro_rules! add_python_function { $scope.globals.set_item( def.obj_name.as_str(), $vm.ctx.new_pyfunction( - vm::obj::objcode::PyCode::new(*def.clone()).into_ref(&$vm), + vm::builtins::code::PyCode::new(*def.clone()).into_ref(&$vm), $scope.clone(), None, None, diff --git a/src/main.rs b/src/main.rs index 543799bf0..62c617533 100644 --- a/src/main.rs +++ b/src/main.rs @@ -7,9 +7,9 @@ extern crate log; use clap::{App, AppSettings, Arg, ArgMatches}; use rustpython_compiler::compile; use rustpython_vm::{ + builtins::{int::PyInt, pytype}, exceptions::print_exception, match_class, - obj::{objint::PyInt, objtype}, pyobject::{BorrowValue, ItemProtocol, PyResult}, scope::Scope, util, InitParameter, Interpreter, PySettings, VirtualMachine, @@ -67,7 +67,7 @@ fn main() { // See if any exception leaked out: let exitcode = match res { Ok(()) => 0, - Err(err) if objtype::isinstance(&err, &vm.ctx.exceptions.system_exit) => { + Err(err) if pytype::isinstance(&err, &vm.ctx.exceptions.system_exit) => { let args = err.args(); match args.borrow_value().len() { 0 => 0, diff --git a/src/shell.rs b/src/shell.rs index 06dcdf21f..6dd11eff3 100644 --- a/src/shell.rs +++ b/src/shell.rs @@ -4,8 +4,8 @@ use rustpython_compiler::{compile, error::CompileError, error::CompileErrorType} use rustpython_parser::error::{LexicalErrorType, ParseErrorType}; use rustpython_vm::readline::{Readline, ReadlineResult}; use rustpython_vm::{ + builtins::pytype, exceptions::{print_exception, PyBaseExceptionRef}, - obj::objtype, pyobject::{BorrowValue, PyResult}, scope::Scope, VirtualMachine, @@ -127,7 +127,7 @@ pub fn run_shell(vm: &VirtualMachine, scope: Scope) -> PyResult<()> { }; if let Err(exc) = result { - if objtype::isinstance(&exc, &vm.ctx.exceptions.system_exit) { + if pytype::isinstance(&exc, &vm.ctx.exceptions.system_exit) { repl.save_history(&repl_history_path).unwrap(); return Err(exc); } diff --git a/src/shell/helper.rs b/src/shell/helper.rs index 8a1103c5d..dfceccfc8 100644 --- a/src/shell/helper.rs +++ b/src/shell/helper.rs @@ -1,4 +1,4 @@ -use rustpython_vm::obj::objstr::PyStrRef; +use rustpython_vm::builtins::pystr::PyStrRef; use rustpython_vm::pyobject::{BorrowValue, PyIterable, PyResult, TryFromObject}; use rustpython_vm::scope::{NameProtocol, Scope}; use rustpython_vm::VirtualMachine; diff --git a/vm/src/anystr.rs b/vm/src/anystr.rs index bfce5e8bd..5316c5d27 100644 --- a/vm/src/anystr.rs +++ b/vm/src/anystr.rs @@ -1,6 +1,6 @@ +use crate::builtins::int::PyIntRef; use crate::cformat::CFormatString; use crate::function::{single_or_tuple_any, OptionalOption}; -use crate::obj::objint::PyIntRef; use crate::pyobject::{ BorrowValue, PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol, }; diff --git a/vm/src/builtins/asyncgenerator.rs b/vm/src/builtins/asyncgenerator.rs index 8c4a1798b..c59a46e29 100644 --- a/vm/src/builtins/asyncgenerator.rs +++ b/vm/src/builtins/asyncgenerator.rs @@ -1,5 +1,5 @@ -use super::objcode::PyCodeRef; -use super::objtype::{self, PyTypeRef}; +use super::code::PyCodeRef; +use super::pytype::{self, PyTypeRef}; use crate::coroutine::{Coro, Variant}; use crate::exceptions::PyBaseExceptionRef; use crate::frame::FrameRef; @@ -127,8 +127,8 @@ impl PyAsyncGenWrappedValue {} impl PyAsyncGenWrappedValue { fn unbox(ag: &PyAsyncGen, val: PyResult, vm: &VirtualMachine) -> PyResult { if let Err(ref e) = val { - if objtype::isinstance(&e, &vm.ctx.exceptions.stop_async_iteration) - || objtype::isinstance(&e, &vm.ctx.exceptions.generator_exit) + if pytype::isinstance(&e, &vm.ctx.exceptions.stop_async_iteration) + || pytype::isinstance(&e, &vm.ctx.exceptions.generator_exit) { ag.inner.closed.store(true); } @@ -385,8 +385,8 @@ impl PyAsyncGenAThrow { self.ag.running_async.store(false); self.state.store(AwaitableState::Closed); if self.aclose - && (objtype::isinstance(&exc, &vm.ctx.exceptions.stop_async_iteration) - || objtype::isinstance(&exc, &vm.ctx.exceptions.generator_exit)) + && (pytype::isinstance(&exc, &vm.ctx.exceptions.stop_async_iteration) + || pytype::isinstance(&exc, &vm.ctx.exceptions.generator_exit)) { vm.new_exception_empty(vm.ctx.exceptions.stop_iteration.clone()) } else { diff --git a/vm/src/builtins/builtinfunc.rs b/vm/src/builtins/builtinfunc.rs index cf7e7abb5..e660c6117 100644 --- a/vm/src/builtins/builtinfunc.rs +++ b/vm/src/builtins/builtinfunc.rs @@ -1,10 +1,10 @@ use std::fmt; -use super::objclassmethod::PyClassMethod; +use super::classmethod::PyClassMethod; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; use crate::common::borrow::BorrowValue; use crate::function::{FuncArgs, PyNativeFunc}; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ PyClassImpl, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; diff --git a/vm/src/builtins/bytearray.rs b/vm/src/builtins/bytearray.rs index 2e1c44d2a..2d7aba8ea 100644 --- a/vm/src/builtins/bytearray.rs +++ b/vm/src/builtins/bytearray.rs @@ -1,4 +1,11 @@ //! Implementation of the python bytearray object. +use super::bytes::{PyBytes, PyBytesRef}; +use super::int::PyIntRef; +use super::iter; +use super::memory::{Buffer, BufferOptions}; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; +use super::tuple::PyTupleRef; use crate::anystr::{self, AnyStr}; use crate::bytesinner::{ bytes_decode, ByteInnerFindOptions, ByteInnerNewOptions, ByteInnerPaddingOptions, @@ -10,13 +17,6 @@ use crate::common::lock::{ PyRwLock, PyRwLockReadGuard, PyRwLockUpgradableReadGuard, PyRwLockWriteGuard, }; use crate::function::{OptionalArg, OptionalOption}; -use crate::obj::objbytes::{PyBytes, PyBytesRef}; -use crate::obj::objint::PyIntRef; -use crate::obj::objiter; -use crate::obj::objmemory::{Buffer, BufferOptions}; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, @@ -656,7 +656,7 @@ impl PyByteArrayIterator { if let Some(&ret) = self.bytearray.borrow_value().elements.get(pos) { Ok(ret) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/builtins/bytes.rs b/vm/src/builtins/bytes.rs index 491116aa1..546de1fd8 100644 --- a/vm/src/builtins/bytes.rs +++ b/vm/src/builtins/bytes.rs @@ -7,17 +7,17 @@ use rustpython_common::{ use std::mem::size_of; use std::ops::Deref; -use super::objint::PyIntRef; -use super::objiter; -use super::objstr::PyStrRef; -use super::objtype::PyTypeRef; +use super::int::PyIntRef; +use super::iter; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; +use crate::builtins::tuple::PyTupleRef; use crate::bytesinner::{ bytes_decode, ByteInnerFindOptions, ByteInnerNewOptions, ByteInnerPaddingOptions, ByteInnerSplitOptions, ByteInnerTranslateOptions, DecodeArgs, PyBytesInner, }; use crate::common::hash::PyHash; use crate::function::{OptionalArg, OptionalOption}; -use crate::obj::objtuple::PyTupleRef; use crate::pyobject::{ BorrowValue, Either, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, @@ -29,7 +29,7 @@ use crate::{ byteslike::PyBytesLike, }; -use crate::obj::objmemory::{Buffer, BufferOptions}; +use crate::builtins::memory::{Buffer, BufferOptions}; /// "bytes(iterable_of_ints) -> bytes\n\ /// bytes(string, encoding[, errors]) -> bytes\n\ @@ -555,7 +555,7 @@ impl PyBytesIterator { if let Some(&ret) = self.bytes.borrow_value().get(pos) { Ok(ret) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/builtins/classmethod.rs b/vm/src/builtins/classmethod.rs index 65acc0074..5d3ea6f91 100644 --- a/vm/src/builtins/classmethod.rs +++ b/vm/src/builtins/classmethod.rs @@ -1,4 +1,4 @@ -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::pyobject::{ PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, }; diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index 1b304ecdd..173c87513 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -5,7 +5,7 @@ use std::fmt; use std::ops::Deref; -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::bytecode; use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/complex.rs b/vm/src/builtins/complex.rs index 6ad6cbb88..6905baf99 100644 --- a/vm/src/builtins/complex.rs +++ b/vm/src/builtins/complex.rs @@ -1,9 +1,9 @@ use num_complex::Complex64; use num_traits::Zero; -use super::objfloat; -use super::objstr::PyStr; -use super::objtype::{self, PyTypeRef}; +use super::float; +use super::pystr::PyStr; +use super::pytype::{self, PyTypeRef}; use crate::pyobject::{ BorrowValue, IntoPyObject, Never, PyArithmaticValue, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, @@ -48,7 +48,7 @@ pub fn init(context: &PyContext) { fn try_complex(value: &PyObjectRef, vm: &VirtualMachine) -> PyResult> { let r = if let Some(complex) = value.payload_if_subclass::(vm) { Some(complex.value) - } else if let Some(float) = objfloat::try_float(value, vm)? { + } else if let Some(float) = float::try_float(value, vm)? { Some(Complex64::new(float, 0.0)) } else { None @@ -253,7 +253,7 @@ impl PyComplex { Some(obj) => { if let Some(c) = try_complex(&obj, vm)? { c - } else if objtype::issubclass(obj.class(), &vm.ctx.types.str_type) { + } else if pytype::issubclass(obj.class(), &vm.ctx.types.str_type) { return Err( vm.new_type_error("complex() second arg can't be a string".to_owned()) ); @@ -289,7 +289,7 @@ impl Comparable for PyComplex { let result = if let Some(other) = other.payload_if_subclass::(vm) { zelf.value == other.value } else { - match objfloat::try_float(&other, vm) { + match float::try_float(&other, vm) { Ok(Some(other)) => zelf.value == other.into(), Err(_) => false, Ok(None) => return Ok(PyComparisonValue::NotImplemented), diff --git a/vm/src/builtins/coroutine.rs b/vm/src/builtins/coroutine.rs index 2e4ab03ff..ee939dfcb 100644 --- a/vm/src/builtins/coroutine.rs +++ b/vm/src/builtins/coroutine.rs @@ -1,6 +1,6 @@ -use super::objcode::PyCodeRef; -use super::objstr::PyStrRef; -use super::objtype::PyTypeRef; +use super::code::PyCodeRef; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; use crate::coroutine::{Coro, Variant}; use crate::frame::FrameRef; use crate::function::OptionalArg; diff --git a/vm/src/builtins/dict.rs b/vm/src/builtins/dict.rs index a01abe9d9..13a4cfebe 100644 --- a/vm/src/builtins/dict.rs +++ b/vm/src/builtins/dict.rs @@ -2,10 +2,10 @@ use crossbeam_utils::atomic::AtomicCell; use std::fmt; use std::mem::size_of; -use super::objiter; -use super::objset::PySet; -use super::objstr; -use super::objtype::{self, PyTypeRef}; +use super::iter; +use super::pystr; +use super::pytype::{self, PyTypeRef}; +use super::set::PySet; use crate::dictdatatype::{self, DictKey}; use crate::exceptions::PyBaseExceptionRef; use crate::function::{FuncArgs, KwArgs, OptionalArg}; @@ -83,25 +83,25 @@ impl PyDict { dict.insert(vm, key, value)?; } } else if let Some(keys) = vm.get_method(dict_obj.clone(), "keys") { - let keys = objiter::get_iter(vm, &vm.invoke(&keys?, ())?)?; - while let Some(key) = objiter::get_next_object(vm, &keys)? { + let keys = iter::get_iter(vm, &vm.invoke(&keys?, ())?)?; + while let Some(key) = iter::get_next_object(vm, &keys)? { let val = dict_obj.get_item(key.clone(), vm)?; dict.insert(vm, key, val)?; } } else { - let iter = objiter::get_iter(vm, &dict_obj)?; + let iter = iter::get_iter(vm, &dict_obj)?; loop { fn err(vm: &VirtualMachine) -> PyBaseExceptionRef { vm.new_value_error("Iterator must have exactly two elements".to_owned()) } - let element = match objiter::get_next_object(vm, &iter)? { + let element = match iter::get_next_object(vm, &iter)? { Some(obj) => obj, None => break, }; - let elem_iter = objiter::get_iter(vm, &element)?; - let key = objiter::get_next_object(vm, &elem_iter)?.ok_or_else(|| err(vm))?; - let value = objiter::get_next_object(vm, &elem_iter)?.ok_or_else(|| err(vm))?; - if objiter::get_next_object(vm, &elem_iter)?.is_some() { + let elem_iter = iter::get_iter(vm, &element)?; + let key = iter::get_next_object(vm, &elem_iter)?.ok_or_else(|| err(vm))?; + let value = iter::get_next_object(vm, &elem_iter)?.ok_or_else(|| err(vm))?; + if iter::get_next_object(vm, &elem_iter)?.is_some() { return Err(err(vm)); } dict.insert(vm, key, value)?; @@ -443,7 +443,7 @@ impl PyDictRef { pub fn to_attributes(self) -> PyAttributes { let mut attrs = PyAttributes::new(); for (key, value) in self { - let key = objstr::clone_value(&key); + let key = pystr::clone_value(&key); attrs.insert(key, value); } attrs @@ -468,7 +468,7 @@ impl PyDictRef { // We can take the short path here! match self.inner_getitem_option(key, vm) { Err(exc) => { - if objtype::isinstance(&exc, &vm.ctx.exceptions.key_error) { + if pytype::isinstance(&exc, &vm.ctx.exceptions.key_error) { Ok(None) } else { Err(exc) @@ -482,7 +482,7 @@ impl PyDictRef { match self.get_item(key, vm) { Ok(value) => Ok(Some(value)), Err(exc) => { - if objtype::isinstance(&exc, &vm.ctx.exceptions.key_error) { + if pytype::isinstance(&exc, &vm.ctx.exceptions.key_error) { Ok(None) } else { Err(exc) @@ -681,7 +681,7 @@ macro_rules! dict_iterator { self.position.store(position); Ok($result_fn(vm, key, value)) } - None => Err(objiter::new_stop_iteration(vm)), + None => Err(iter::new_stop_iteration(vm)), } } @@ -736,7 +736,7 @@ macro_rules! dict_iterator { } None => { self.position.store(std::isize::MAX as usize); - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } } diff --git a/vm/src/builtins/enumerate.rs b/vm/src/builtins/enumerate.rs index 04acb22c1..33d3f08b1 100644 --- a/vm/src/builtins/enumerate.rs +++ b/vm/src/builtins/enumerate.rs @@ -4,9 +4,9 @@ use std::ops::AddAssign; use num_bigint::BigInt; use num_traits::Zero; -use super::objint::PyIntRef; -use super::objiter; -use super::objtype::PyTypeRef; +use super::int::PyIntRef; +use super::iter; +use super::pytype::PyTypeRef; use crate::function::OptionalArg; use crate::pyobject::{BorrowValue, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; @@ -39,7 +39,7 @@ impl PyEnumerate { OptionalArg::Missing => BigInt::zero(), }; - let iterator = objiter::get_iter(vm, &iterable)?; + let iterator = iter::get_iter(vm, &iterable)?; PyEnumerate { counter: PyRwLock::new(counter), iterator, @@ -49,7 +49,7 @@ impl PyEnumerate { #[pymethod(name = "__next__")] fn next(&self, vm: &VirtualMachine) -> PyResult<(BigInt, PyObjectRef)> { - let next_obj = objiter::call_next(vm, &self.iterator)?; + let next_obj = iter::call_next(vm, &self.iterator)?; let mut counter = self.counter.write(); let position = counter.clone(); AddAssign::add_assign(&mut counter as &mut BigInt, 1); diff --git a/vm/src/builtins/filter.rs b/vm/src/builtins/filter.rs index bec8bce88..06e9d82e4 100644 --- a/vm/src/builtins/filter.rs +++ b/vm/src/builtins/filter.rs @@ -1,6 +1,6 @@ -use super::objbool; -use super::objiter; -use super::objtype::PyTypeRef; +use super::iter; +use super::pybool; +use super::pytype::PyTypeRef; use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; @@ -32,7 +32,7 @@ impl PyFilter { iterable: PyObjectRef, vm: &VirtualMachine, ) -> PyResult { - let iterator = objiter::get_iter(vm, &iterable)?; + let iterator = iter::get_iter(vm, &iterable)?; PyFilter { predicate: function, @@ -46,7 +46,7 @@ impl PyFilter { let predicate = &self.predicate; let iterator = &self.iterator; loop { - let next_obj = objiter::call_next(vm, iterator)?; + let next_obj = iter::call_next(vm, iterator)?; let predicate_value = if vm.is_none(predicate) { next_obj.clone() } else { @@ -54,7 +54,7 @@ impl PyFilter { // iteration vm.invoke(&predicate, vec![next_obj.clone()])? }; - if objbool::boolval(vm, predicate_value)? { + if pybool::boolval(vm, predicate_value)? { return Ok(next_obj); } } diff --git a/vm/src/builtins/float.rs b/vm/src/builtins/float.rs index 7bada74b8..d9c8ee1d3 100644 --- a/vm/src/builtins/float.rs +++ b/vm/src/builtins/float.rs @@ -3,10 +3,10 @@ use num_complex::Complex64; use num_rational::Ratio; use num_traits::{pow, ToPrimitive, Zero}; -use super::objbytes::PyBytes; -use super::objint::{self, PyInt, PyIntRef}; -use super::objstr::{PyStr, PyStrRef}; -use super::objtype::PyTypeRef; +use super::bytes::PyBytes; +use super::int::{self, PyInt, PyIntRef}; +use super::pystr::{PyStr, PyStrRef}; +use super::pytype::PyTypeRef; use crate::format::FormatSpec; use crate::function::{OptionalArg, OptionalOption}; use crate::pyobject::{ @@ -59,7 +59,7 @@ pub fn try_float(obj: &PyObjectRef, vm: &VirtualMachine) -> PyResult let v = if let Some(float) = obj.payload_if_subclass::(vm) { Some(float.value) } else if let Some(int) = obj.payload_if_subclass::(vm) { - Some(objint::try_float(int.borrow_value(), vm)?) + Some(int::try_float(int.borrow_value(), vm)?) } else { None }; @@ -495,7 +495,7 @@ fn to_float(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult { let value = if let Some(float) = obj.payload_if_subclass::(vm) { float.value } else if let Some(int) = obj.payload_if_subclass::(vm) { - objint::try_float(int.borrow_value(), vm)? + int::try_float(int.borrow_value(), vm)? } else if let Some(s) = obj.payload_if_subclass::(vm) { float_ops::parse_str(s.borrow_value().trim()).ok_or_else(|| { vm.new_value_error(format!("could not convert string to float: '{}'", s)) diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs index 014125d58..2ecb6c860 100644 --- a/vm/src/builtins/frame.rs +++ b/vm/src/builtins/frame.rs @@ -2,9 +2,9 @@ */ -use super::objcode::PyCodeRef; -use super::objdict::PyDictRef; -use super::objstr::PyStrRef; +use super::code::PyCodeRef; +use super::dict::PyDictRef; +use super::pystr::PyStrRef; use crate::frame::FrameRef; use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/function.rs b/vm/src/builtins/function.rs index 314b2c8f9..34afc0723 100644 --- a/vm/src/builtins/function.rs +++ b/vm/src/builtins/function.rs @@ -1,17 +1,17 @@ #[cfg(feature = "jit")] mod jitfunc; -use super::objcode::PyCodeRef; -use super::objdict::PyDictRef; -use super::objstr::PyStrRef; -use super::objtuple::PyTupleRef; -use super::objtype::PyTypeRef; +use super::code::PyCodeRef; +use super::dict::PyDictRef; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; +use super::tuple::PyTupleRef; +use crate::builtins::asyncgenerator::PyAsyncGen; +use crate::builtins::coroutine::PyCoroutine; +use crate::builtins::generator::PyGenerator; use crate::bytecode; use crate::frame::Frame; use crate::function::FuncArgs; -use crate::obj::objasyncgenerator::PyAsyncGen; -use crate::obj::objcoroutine::PyCoroutine; -use crate::obj::objgenerator::PyGenerator; #[cfg(feature = "jit")] use crate::pyobject::IntoPyObject; use crate::pyobject::{ diff --git a/vm/src/builtins/function/jitfunc.rs b/vm/src/builtins/function/jitfunc.rs index 758199b7f..5c315cb0b 100644 --- a/vm/src/builtins/function/jitfunc.rs +++ b/vm/src/builtins/function/jitfunc.rs @@ -1,8 +1,8 @@ +use crate::builtins::dict::PyDictRef; +use crate::builtins::function::{PyFunction, PyFunctionRef}; +use crate::builtins::{float, int}; use crate::exceptions::PyBaseExceptionRef; use crate::function::FuncArgs; -use crate::obj::objdict::PyDictRef; -use crate::obj::objfunction::{PyFunction, PyFunctionRef}; -use crate::obj::{objfloat, objint}; use crate::pyobject::{ BorrowValue, IdProtocol, IntoPyObject, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol, @@ -107,12 +107,12 @@ fn get_jit_value(vm: &VirtualMachine, obj: &PyObjectRef) -> Result PyResult { if int2.is_negative() { let v1 = try_float(int1, vm)?; let v2 = try_float(int2, vm)?; - objfloat::float_pow(v1, v2, vm).into_pyresult(vm) + float::float_pow(v1, v2, vm).into_pyresult(vm) } else { Ok(if let Some(v2) = int2.to_u64() { vm.ctx.new_int(Pow::pow(int1, v2)) diff --git a/vm/src/builtins/iter.rs b/vm/src/builtins/iter.rs index 4d8b71a97..f762e054c 100644 --- a/vm/src/builtins/iter.rs +++ b/vm/src/builtins/iter.rs @@ -5,8 +5,8 @@ use crossbeam_utils::atomic::AtomicCell; use num_traits::Signed; -use super::objint::{self, PyInt}; -use super::objtype::{self, PyTypeRef}; +use super::int::{self, PyInt}; +use super::pytype::{self, PyTypeRef}; use crate::exceptions::PyBaseExceptionRef; use crate::pyobject::{ BorrowValue, PyCallable, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, @@ -58,7 +58,7 @@ pub fn get_next_object( Ok(value) => Ok(Some(value)), Err(next_error) => { // Check if we have stopiteration, or something else: - if objtype::isinstance(&next_error, &vm.ctx.exceptions.stop_iteration) { + if pytype::isinstance(&next_error, &vm.ctx.exceptions.stop_iteration) { Ok(None) } else { Err(next_error) @@ -103,7 +103,7 @@ pub fn length_hint(vm: &VirtualMachine, iter: PyObjectRef) -> PyResult return Ok(Some(len)), Err(e) => { - if !objtype::isinstance(&e, &vm.ctx.exceptions.type_error) { + if !pytype::isinstance(&e, &vm.ctx.exceptions.type_error) { return Err(e); } } @@ -116,7 +116,7 @@ pub fn length_hint(vm: &VirtualMachine, iter: PyObjectRef) -> PyResult res, Err(e) => { - return if objtype::isinstance(&e, &vm.ctx.exceptions.type_error) { + return if pytype::isinstance(&e, &vm.ctx.exceptions.type_error) { Ok(None) } else { Err(e) @@ -135,7 +135,7 @@ pub fn length_hint(vm: &VirtualMachine, iter: PyObjectRef) -> PyResult= 0".to_owned())); } - let hint = objint::try_to_primitive(result, vm)?; + let hint = int::try_to_primitive(result, vm)?; Ok(Some(hint)) } @@ -177,7 +177,7 @@ impl PySequenceIterator { let pos = self.position.fetch_add(step); if pos >= 0 { match vm.call_method(&self.obj, "__getitem__", (pos,)) { - Err(ref e) if objtype::isinstance(&e, &vm.ctx.exceptions.index_error) => { + Err(ref e) if pytype::isinstance(&e, &vm.ctx.exceptions.index_error) => { Err(new_stop_iteration(vm)) } // also catches stop_iteration => stop_iteration diff --git a/vm/src/builtins/list.rs b/vm/src/builtins/list.rs index 2ee4b6348..41ed689b1 100644 --- a/vm/src/builtins/list.rs +++ b/vm/src/builtins/list.rs @@ -6,10 +6,10 @@ use std::ops::DerefMut; use crossbeam_utils::atomic::AtomicCell; use num_traits::ToPrimitive; -use super::objint::PyIntRef; -use super::objiter; -use super::objslice::PySliceRef; -use super::objtype::PyTypeRef; +use super::int::PyIntRef; +use super::iter; +use super::pytype::PyTypeRef; +use super::slice::PySliceRef; use crate::bytesinner; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::OptionalArg; @@ -474,7 +474,7 @@ impl PyListIterator { if let Some(obj) = list.get(pos) { Ok(obj.clone()) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } @@ -515,7 +515,7 @@ impl PyListReverseIterator { return Ok(ret.clone()); } } - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } #[pymethod(name = "__iter__")] diff --git a/vm/src/builtins.rs b/vm/src/builtins/make_module.rs similarity index 96% rename from vm/src/builtins.rs rename to vm/src/builtins/make_module.rs index 34b048225..6970a7878 100644 --- a/vm/src/builtins.rs +++ b/vm/src/builtins/make_module.rs @@ -17,19 +17,19 @@ mod decl { use rustpython_parser::parser; use super::to_ascii; + use crate::builtins::bytes::PyBytesRef; + use crate::builtins::code::PyCodeRef; + use crate::builtins::dict::PyDictRef; + use crate::builtins::function::PyFunctionRef; + use crate::builtins::int::{self, PyIntRef}; + use crate::builtins::iter; + use crate::builtins::list::{PyList, SortOptions}; + use crate::builtins::pybool::{self, IntoPyBool}; + use crate::builtins::pystr::{PyStr, PyStrRef}; + use crate::builtins::pytype::{self, PyTypeRef}; use crate::byteslike::PyBytesLike; use crate::exceptions::PyBaseExceptionRef; use crate::function::{single_or_tuple_any, Args, FuncArgs, KwArgs, OptionalArg}; - use crate::obj::objbool::{self, IntoPyBool}; - use crate::obj::objbytes::PyBytesRef; - use crate::obj::objcode::PyCodeRef; - use crate::obj::objdict::PyDictRef; - use crate::obj::objfunction::PyFunctionRef; - use crate::obj::objint::{self, PyIntRef}; - use crate::obj::objiter; - use crate::obj::objlist::{PyList, SortOptions}; - use crate::obj::objstr::{PyStr, PyStrRef}; - use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{ BorrowValue, Either, IdProtocol, ItemProtocol, PyCallable, PyIterable, PyObjectRef, PyResult, PyValue, TryFromObject, TypeProtocol, @@ -292,7 +292,7 @@ mod decl { default: T, vm: &VirtualMachine, ) -> PyResult { - if objtype::isinstance(&ex, &vm.ctx.exceptions.attribute_error) { + if pytype::isinstance(&ex, &vm.ctx.exceptions.attribute_error) { Ok(default) } else { Err(ex) @@ -432,11 +432,11 @@ mod decl { ) -> PyResult { if let OptionalArg::Present(sentinel) = sentinel { let callable = PyCallable::try_from_object(vm, iter_target)?; - Ok(objiter::PyCallableIterator::new(callable, sentinel) + Ok(iter::PyCallableIterator::new(callable, sentinel) .into_ref(vm) .into_object()) } else { - objiter::get_iter(vm, &iter_target) + iter::get_iter(vm, &iter_target) } } @@ -568,7 +568,7 @@ mod decl { match vm.call_method(&iterator, "__next__", ()) { Ok(value) => Ok(value), Err(value) => { - if objtype::isinstance(&value, &vm.ctx.exceptions.stop_iteration) { + if pytype::isinstance(&value, &vm.ctx.exceptions.stop_iteration) { match default_value { OptionalArg::Missing => Err(value), OptionalArg::Present(value) => Ok(value), @@ -639,15 +639,15 @@ mod decl { } OptionalArg::Present(m) => { // Check if the 3rd argument is defined and perform modulus on the result - if !(objtype::isinstance(&x, &vm.ctx.types.int_type) - && objtype::isinstance(&y, &vm.ctx.types.int_type)) + if !(pytype::isinstance(&x, &vm.ctx.types.int_type) + && pytype::isinstance(&y, &vm.ctx.types.int_type)) { return Err(vm.new_type_error( "pow() 3rd argument not allowed unless all arguments are integers" .to_owned(), )); } - let y = objint::get_value(&y); + let y = int::get_value(&y); if y.sign() == Sign::Minus { return Err(vm.new_value_error( "pow() 2nd argument cannot be negative when 3rd argument specified" @@ -658,7 +658,7 @@ mod decl { if m.is_zero() { return Err(vm.new_value_error("pow() 3rd argument cannot be 0".to_owned())); } - let x = objint::get_value(&x); + let x = int::get_value(&x); Ok(vm.ctx.new_int(x.modpow(&y, &m))) } } @@ -729,8 +729,8 @@ mod decl { "argument to reversed() must be a sequence".to_owned() })?; let len = vm.call_method(&obj, "__len__", ())?; - let len = objint::get_value(&len).to_isize().unwrap(); - let obj_iterator = objiter::PySequenceIterator::new_reversed(obj, len); + let len = int::get_value(&len).to_isize().unwrap(); + let obj_iterator = iter::PySequenceIterator::new_reversed(obj, len); Ok(obj_iterator.into_object(vm)) } } @@ -825,9 +825,9 @@ mod decl { for base in bases.clone() { let base_class = base.class(); - if objtype::issubclass(&base_class, &metaclass) { + if pytype::issubclass(&base_class, &metaclass) { metaclass = base.clone_class(); - } else if !objtype::issubclass(&metaclass, &base_class) { + } else if !pytype::issubclass(&metaclass, &base_class) { return Err(vm.new_type_error( "metaclass conflict: the metaclass of a derived class must be a (non-strict) \ subclass of the metaclasses of all its bases" diff --git a/vm/src/builtins/map.rs b/vm/src/builtins/map.rs index 0d974f37e..3f4be4eb2 100644 --- a/vm/src/builtins/map.rs +++ b/vm/src/builtins/map.rs @@ -1,5 +1,5 @@ -use super::objiter; -use super::objtype::PyTypeRef; +use super::iter; +use super::pytype::PyTypeRef; use crate::function::Args; use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; @@ -33,7 +33,7 @@ impl PyMap { ) -> PyResult { let iterators = iterables .into_iter() - .map(|iterable| objiter::get_iter(vm, &iterable)) + .map(|iterable| iter::get_iter(vm, &iterable)) .collect::, _>>()?; PyMap { mapper: function, @@ -47,7 +47,7 @@ impl PyMap { let next_objs = self .iterators .iter() - .map(|iterator| objiter::call_next(vm, iterator)) + .map(|iterator| iter::call_next(vm, iterator)) .collect::, _>>()?; // the mapper itself can raise StopIteration which does stop the map iteration @@ -62,7 +62,7 @@ impl PyMap { #[pymethod(name = "__length_hint__")] fn length_hint(&self, vm: &VirtualMachine) -> PyResult { self.iterators.iter().try_fold(0, |prev, cur| { - let cur = objiter::length_hint(vm, cur.clone())?.unwrap_or(0); + let cur = iter::length_hint(vm, cur.clone())?.unwrap_or(0); let max = std::cmp::max(prev, cur); Ok(max) }) diff --git a/vm/src/builtins/mappingproxy.rs b/vm/src/builtins/mappingproxy.rs index f5f6f3d4d..2da34eb9f 100644 --- a/vm/src/builtins/mappingproxy.rs +++ b/vm/src/builtins/mappingproxy.rs @@ -1,7 +1,7 @@ -use super::objdict::PyDict; -use super::objiter; -use super::objstr::PyStrRef; -use super::objtype::PyTypeRef; +use super::dict::PyDict; +use super::iter; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; use crate::function::OptionalArg; use crate::pyobject::{ BorrowValue, IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, @@ -94,7 +94,7 @@ impl PyMappingProxy { PyDict::from_attributes(c.attributes.read().clone(), vm)?.into_pyobject(vm) } }; - objiter::get_iter(vm, &obj) + iter::get_iter(vm, &obj) } #[pymethod] pub fn items(&self, vm: &VirtualMachine) -> PyResult { diff --git a/vm/src/builtins/memory.rs b/vm/src/builtins/memory.rs index c59a6ae73..0eae01707 100644 --- a/vm/src/builtins/memory.rs +++ b/vm/src/builtins/memory.rs @@ -1,14 +1,14 @@ use std::{fmt::Debug, ops::Deref}; +use crate::builtins::bytes::{PyBytes, PyBytesRef}; +use crate::builtins::list::{PyList, PyListRef}; +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::slice::PySliceRef; use crate::bytesinner::bytes_to_hex; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; use crate::common::hash::PyHash; use crate::function::OptionalArg; -use crate::obj::objbytes::{PyBytes, PyBytesRef}; -use crate::obj::objlist::{PyList, PyListRef}; -use crate::obj::objslice::PySliceRef; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue, TypeProtocol, diff --git a/vm/src/builtins/mod.rs b/vm/src/builtins/mod.rs index a5bab4445..5e90c5762 100644 --- a/vm/src/builtins/mod.rs +++ b/vm/src/builtins/mod.rs @@ -1,42 +1,45 @@ //! This package contains the python basic/builtin types -pub mod objasyncgenerator; -pub mod objbool; -pub mod objbuiltinfunc; -pub mod objbytearray; -pub mod objbytes; -pub mod objclassmethod; -pub mod objcode; -pub mod objcomplex; -pub mod objcoroutine; -pub mod objdict; -pub mod objenumerate; -pub mod objfilter; -pub mod objfloat; -pub mod objframe; -pub mod objfunction; -pub mod objgenerator; -pub mod objgetset; -pub mod objint; -pub mod objiter; -pub mod objlist; -pub mod objmap; -pub mod objmappingproxy; -pub mod objmemory; -pub mod objmodule; -pub mod objnamespace; -pub mod objobject; -pub mod objproperty; -pub mod objrange; -pub mod objset; -pub mod objsingletons; -pub mod objslice; -pub mod objstaticmethod; -pub mod objstr; -pub mod objsuper; -pub mod objtraceback; -pub mod objtuple; -pub mod objtype; -pub mod objweakproxy; -pub mod objweakref; -pub mod objzip; +pub mod asyncgenerator; +pub mod builtinfunc; +pub mod bytearray; +pub mod bytes; +pub mod classmethod; +pub mod code; +pub mod complex; +pub mod coroutine; +pub mod dict; +pub mod enumerate; +pub mod filter; +pub mod float; +pub mod frame; +pub mod function; +pub mod generator; +pub mod getset; +pub mod int; +pub mod iter; +pub mod list; +pub mod map; +pub mod mappingproxy; +pub mod memory; +pub mod module; +pub mod namespace; +pub mod object; +pub mod property; +pub mod pybool; +pub mod pystr; +pub mod pysuper; +pub mod pytype; +pub mod range; +pub mod set; +pub mod singletons; +pub mod slice; +pub mod staticmethod; +pub mod traceback; +pub mod tuple; +pub mod weakproxy; +pub mod weakref; +pub mod zip; + +mod make_module; +pub use make_module::*; diff --git a/vm/src/builtins/module.rs b/vm/src/builtins/module.rs index 25b62d7f1..6607831ac 100644 --- a/vm/src/builtins/module.rs +++ b/vm/src/builtins/module.rs @@ -1,6 +1,6 @@ -use super::objdict::PyDictRef; -use super::objstr::{PyStr, PyStrRef}; -use super::objtype::PyTypeRef; +use super::dict::PyDictRef; +use super::pystr::{PyStr, PyStrRef}; +use super::pytype::PyTypeRef; use crate::function::{FuncArgs, OptionalOption}; use crate::pyobject::{ BorrowValue, IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, diff --git a/vm/src/builtins/namespace.rs b/vm/src/builtins/namespace.rs index b5007ebb2..8548d6522 100644 --- a/vm/src/builtins/namespace.rs +++ b/vm/src/builtins/namespace.rs @@ -1,4 +1,4 @@ -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::function::KwArgs; use crate::pyobject::{PyClassImpl, PyContext, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/object.rs b/vm/src/builtins/object.rs index 747d80e74..d8e97daee 100644 --- a/vm/src/builtins/object.rs +++ b/vm/src/builtins/object.rs @@ -1,11 +1,11 @@ -use super::objbool; -use super::objdict::{PyDict, PyDictRef}; -use super::objlist::PyList; -use super::objstr::PyStrRef; -use super::objtype::PyTypeRef; +use super::dict::{PyDict, PyDictRef}; +use super::list::PyList; +use super::pybool; +use super::pystr::PyStrRef; +use super::pytype::PyTypeRef; +use crate::builtins::pytype::PyType; use crate::common::hash::PyHash; use crate::function::{FuncArgs, OptionalArg}; -use crate::obj::objtype::PyType; use crate::pyobject::{ BorrowValue, Either, IdProtocol, ItemProtocol, PyArithmaticValue, PyAttributes, PyClassImpl, PyComparisonValue, PyContext, PyObject, PyObjectRef, PyResult, PyValue, TryFromObject, @@ -71,7 +71,7 @@ impl PyBaseObject { .unwrap(); let value = match cmp(zelf, other, PyComparisonOp::Eq, vm)? { Either::A(obj) => PyArithmaticValue::from_object(vm, obj) - .map(|obj| objbool::boolval(vm, obj)) + .map(|obj| pybool::boolval(vm, obj)) .transpose()?, Either::B(value) => value, }; diff --git a/vm/src/builtins/property.rs b/vm/src/builtins/property.rs index ad34dff85..98da89658 100644 --- a/vm/src/builtins/property.rs +++ b/vm/src/builtins/property.rs @@ -3,7 +3,7 @@ */ use crate::common::lock::PyRwLock; -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::function::FuncArgs; use crate::pyobject::{ PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, diff --git a/vm/src/builtins/pybool.rs b/vm/src/builtins/pybool.rs index 1fb980402..1ab69afdc 100644 --- a/vm/src/builtins/pybool.rs +++ b/vm/src/builtins/pybool.rs @@ -8,9 +8,9 @@ use crate::pyobject::{ }; use crate::vm::VirtualMachine; -use super::objint::PyInt; -use super::objstr::PyStrRef; -use super::objtype; +use super::int::PyInt; +use super::pystr::PyStrRef; +use super::pytype; impl IntoPyObject for bool { fn into_pyobject(self, vm: &VirtualMachine) -> PyObjectRef { @@ -20,7 +20,7 @@ impl IntoPyObject for bool { impl TryFromObject for bool { fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { - if objtype::isinstance(&obj, &vm.ctx.types.int_type) { + if pytype::isinstance(&obj, &vm.ctx.types.int_type) { Ok(get_value(&obj)) } else { Err(vm.new_type_error(format!("Expected type bool, not {}", obj.class().name))) @@ -41,7 +41,7 @@ pub fn boolval(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { // If descriptor returns Error, propagate it further let method = method_or_err?; let bool_obj = vm.invoke(&method, ())?; - if !objtype::isinstance(&bool_obj, &vm.ctx.types.bool_type) { + if !pytype::isinstance(&bool_obj, &vm.ctx.types.bool_type) { return Err(vm.new_type_error(format!( "__bool__ should return bool, returned type {}", bool_obj.class().name @@ -100,8 +100,8 @@ impl PyBool { #[pymethod(name = "__ror__")] #[pymethod(magic)] fn or(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef { - if objtype::isinstance(&lhs, &vm.ctx.types.bool_type) - && objtype::isinstance(&rhs, &vm.ctx.types.bool_type) + if pytype::isinstance(&lhs, &vm.ctx.types.bool_type) + && pytype::isinstance(&rhs, &vm.ctx.types.bool_type) { let lhs = get_value(&lhs); let rhs = get_value(&rhs); @@ -114,8 +114,8 @@ impl PyBool { #[pymethod(name = "__rand__")] #[pymethod(magic)] fn and(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef { - if objtype::isinstance(&lhs, &vm.ctx.types.bool_type) - && objtype::isinstance(&rhs, &vm.ctx.types.bool_type) + if pytype::isinstance(&lhs, &vm.ctx.types.bool_type) + && pytype::isinstance(&rhs, &vm.ctx.types.bool_type) { let lhs = get_value(&lhs); let rhs = get_value(&rhs); @@ -128,8 +128,8 @@ impl PyBool { #[pymethod(name = "__rxor__")] #[pymethod(magic)] fn xor(lhs: PyObjectRef, rhs: PyObjectRef, vm: &VirtualMachine) -> PyObjectRef { - if objtype::isinstance(&lhs, &vm.ctx.types.bool_type) - && objtype::isinstance(&rhs, &vm.ctx.types.bool_type) + if pytype::isinstance(&lhs, &vm.ctx.types.bool_type) + && pytype::isinstance(&rhs, &vm.ctx.types.bool_type) { let lhs = get_value(&lhs); let rhs = get_value(&rhs); @@ -141,7 +141,7 @@ impl PyBool { #[pyslot] fn tp_new(zelf: PyObjectRef, x: OptionalArg, vm: &VirtualMachine) -> PyResult { - if !objtype::isinstance(&zelf, &vm.ctx.types.type_type) { + if !pytype::isinstance(&zelf, &vm.ctx.types.type_type) { let actual_type = &zelf.class().name; return Err(vm.new_type_error(format!( "requires a 'type' object but received a '{}'", @@ -161,7 +161,7 @@ pub(crate) fn init(context: &PyContext) { } pub fn not(vm: &VirtualMachine, obj: &PyObjectRef) -> PyResult { - if objtype::isinstance(obj, &vm.ctx.types.bool_type) { + if pytype::isinstance(obj, &vm.ctx.types.bool_type) { let value = get_value(obj); Ok(!value) } else { diff --git a/vm/src/builtins/pystr.rs b/vm/src/builtins/pystr.rs index 3d1514cc4..022bb6027 100644 --- a/vm/src/builtins/pystr.rs +++ b/vm/src/builtins/pystr.rs @@ -12,11 +12,11 @@ use unic_ucd_category::GeneralCategory; use unic_ucd_ident::{is_xid_continue, is_xid_start}; use unicode_casing::CharExt; -use super::objbytes::{PyBytes, PyBytesRef}; -use super::objdict::PyDict; -use super::objint::{PyInt, PyIntRef}; -use super::objiter; -use super::objtype::{self, PyTypeRef}; +use super::bytes::{PyBytes, PyBytesRef}; +use super::dict::PyDict; +use super::int::{PyInt, PyIntRef}; +use super::iter; +use super::pytype::{self, PyTypeRef}; use crate::anystr::{self, adjust_indices, AnyStr, AnyStrContainer, AnyStrWrapper}; use crate::exceptions::IntoPyException; use crate::format::{FormatSpec, FormatString, FromTemplate}; @@ -122,7 +122,7 @@ impl PyStrIterator { let value = &*self.string.value; let start = self.position.load(); if start == value.len() { - return Err(objiter::new_stop_iteration(vm)); + return Err(iter::new_stop_iteration(vm)); } let end = { let mut end = None; @@ -169,7 +169,7 @@ impl PyStrReverseIterator { let value = &*self.string.value; let end = self.position.load(); if end == 0 { - return Err(objiter::new_stop_iteration(vm)); + return Err(iter::new_stop_iteration(vm)); } let start = { let mut start = None; @@ -241,7 +241,7 @@ impl PyStr { #[pymethod(name = "__add__")] fn add(&self, other: PyObjectRef, vm: &VirtualMachine) -> PyResult { - if objtype::isinstance(&other, &vm.ctx.types.str_type) { + if pytype::isinstance(&other, &vm.ctx.types.str_type) { Ok(self.value.py_add(borrow_value(&other))) } else { Err(vm.new_type_error(format!("Cannot add {} and {}", self, other))) diff --git a/vm/src/builtins/pysuper.rs b/vm/src/builtins/pysuper.rs index b7802686c..b851e3717 100644 --- a/vm/src/builtins/pysuper.rs +++ b/vm/src/builtins/pysuper.rs @@ -6,8 +6,8 @@ https://github.com/python/cpython/blob/50b48572d9a90c5bb36e2bef6179548ea927a35a/ */ -use super::objstr::PyStrRef; -use super::objtype::{self, PyType, PyTypeRef}; +use super::pystr::PyStrRef; +use super::pytype::{self, PyType, PyTypeRef}; use crate::function::OptionalArg; use crate::pyobject::{ BorrowValue, IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, @@ -77,7 +77,7 @@ impl PySuper { }; // Check type argument: - if !objtype::isinstance(typ.as_object(), &vm.ctx.types.type_type) { + if !pytype::isinstance(typ.as_object(), &vm.ctx.types.type_type) { return Err(vm.new_type_error(format!( "super() argument 1 must be type, not {}", typ.class().name @@ -159,16 +159,16 @@ impl SlotDescriptor for PySuper { fn supercheck(ty: PyTypeRef, obj: PyObjectRef, vm: &VirtualMachine) -> PyResult { if let Ok(cls) = obj.clone().downcast::() { - if objtype::issubclass(&cls, &ty) { + if pytype::issubclass(&cls, &ty) { return Ok(cls); } } - if objtype::isinstance(&obj, &ty) { + if pytype::isinstance(&obj, &ty) { return Ok(obj.clone_class()); } let class_attr = vm.get_attribute(obj, "__class__")?; if let Ok(cls) = class_attr.downcast::() { - if !cls.is(&ty) && objtype::issubclass(&cls, &ty) { + if !cls.is(&ty) && pytype::issubclass(&cls, &ty) { return Ok(cls); } } diff --git a/vm/src/builtins/pytype.rs b/vm/src/builtins/pytype.rs index 651ad63be..440a2db04 100644 --- a/vm/src/builtins/pytype.rs +++ b/vm/src/builtins/pytype.rs @@ -2,16 +2,16 @@ use crate::common::lock::PyRwLock; use std::collections::{HashMap, HashSet}; use std::fmt; -use super::objclassmethod::PyClassMethod; -use super::objdict::PyDictRef; -use super::objint::PyInt; -use super::objlist::PyList; -use super::objmappingproxy::PyMappingProxy; -use super::objobject; -use super::objstaticmethod::PyStaticMethod; -use super::objstr::PyStrRef; -use super::objtuple::PyTuple; -use super::objweakref::PyWeak; +use super::classmethod::PyClassMethod; +use super::dict::PyDictRef; +use super::int::PyInt; +use super::list::PyList; +use super::mappingproxy::PyMappingProxy; +use super::object; +use super::pystr::PyStrRef; +use super::staticmethod::PyStaticMethod; +use super::tuple::PyTuple; +use super::weakref::PyWeak; use crate::function::{FuncArgs, KwArgs}; use crate::pyobject::{ BorrowValue, Either, IdProtocol, PyAttributes, PyClassImpl, PyContext, PyIterable, PyLease, @@ -584,7 +584,7 @@ fn subtype_get_dict(obj: PyObjectRef, vm: &VirtualMachine) -> PyResult { cls.name ))) })?, - None => objobject::object_get_dict(obj, vm)?.into_object(), + None => object::object_get_dict(obj, vm)?.into_object(), }; Ok(ret) } @@ -603,7 +603,7 @@ fn subtype_set_dict(obj: PyObjectRef, value: PyObjectRef, vm: &VirtualMachine) - ))) })?; } - None => objobject::object_set_dict(obj, PyDictRef::try_from_object(vm, value)?, vm)?, + None => object::object_set_dict(obj, PyDictRef::try_from_object(vm, value)?, vm)?, } Ok(()) } diff --git a/vm/src/builtins/range.rs b/vm/src/builtins/range.rs index 8c8bf4b05..345f331be 100644 --- a/vm/src/builtins/range.rs +++ b/vm/src/builtins/range.rs @@ -3,10 +3,10 @@ use num_bigint::{BigInt, Sign}; use num_integer::Integer; use num_traits::{One, Signed, Zero}; -use super::objint::{PyInt, PyIntRef}; -use super::objiter; -use super::objslice::{PySlice, PySliceRef}; -use super::objtype::PyTypeRef; +use super::int::{PyInt, PyIntRef}; +use super::iter; +use super::pytype::PyTypeRef; +use super::slice::{PySlice, PySliceRef}; use crate::common::hash::PyHash; use crate::function::{FuncArgs, OptionalArg}; @@ -393,7 +393,7 @@ impl PyRangeIterator { if let Some(int) = self.range.get(&position) { Ok(int) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/builtins/set.rs b/vm/src/builtins/set.rs index 7f6bdd7a1..430f820c0 100644 --- a/vm/src/builtins/set.rs +++ b/vm/src/builtins/set.rs @@ -4,8 +4,8 @@ use rustpython_common::rc::PyRc; use std::fmt; -use super::objiter; -use super::objtype::{self, PyTypeRef}; +use super::iter; +use super::pytype::{self, PyTypeRef}; use crate::dictdatatype; use crate::function::{Args, OptionalArg}; use crate::pyobject::{ @@ -723,8 +723,8 @@ struct SetIterable { impl TryFromObject for SetIterable { fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { let class = obj.class(); - if objtype::issubclass(&class, &vm.ctx.types.set_type) - || objtype::issubclass(&class, &vm.ctx.types.frozenset_type) + if pytype::issubclass(&class, &vm.ctx.types.set_type) + || pytype::issubclass(&class, &vm.ctx.types.frozenset_type) { // the class lease needs to be drop to be able to return the object drop(class); @@ -768,7 +768,7 @@ impl PySetIterator { let keys = self.dict.keys(); let item = keys .get(index) - .ok_or_else(|| objiter::new_stop_iteration(vm))?; + .ok_or_else(|| iter::new_stop_iteration(vm))?; size_info.position += 1; self.size_info.store(size_info); return Ok(item.clone()); diff --git a/vm/src/builtins/singletons.rs b/vm/src/builtins/singletons.rs index 5b2846588..ce10ff6cb 100644 --- a/vm/src/builtins/singletons.rs +++ b/vm/src/builtins/singletons.rs @@ -1,4 +1,4 @@ -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::pyobject::{ IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyValue, TypeProtocol, }; diff --git a/vm/src/builtins/slice.rs b/vm/src/builtins/slice.rs index 003bf7630..46664edea 100644 --- a/vm/src/builtins/slice.rs +++ b/vm/src/builtins/slice.rs @@ -1,7 +1,7 @@ // sliceobject.{h,c} in CPython -use super::objint::PyInt; -use super::objtype::PyTypeRef; +use super::int::PyInt; +use super::pytype::PyTypeRef; use crate::function::{FuncArgs, OptionalArg}; use crate::pyobject::{ BorrowValue, IntoPyObject, PyClassImpl, PyComparisonValue, PyContext, PyObjectRef, PyRef, diff --git a/vm/src/builtins/staticmethod.rs b/vm/src/builtins/staticmethod.rs index b3a26462e..2f060d724 100644 --- a/vm/src/builtins/staticmethod.rs +++ b/vm/src/builtins/staticmethod.rs @@ -1,4 +1,4 @@ -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::SlotDescriptor; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/traceback.rs b/vm/src/builtins/traceback.rs index 47d620376..ec3fd7fd2 100644 --- a/vm/src/builtins/traceback.rs +++ b/vm/src/builtins/traceback.rs @@ -1,5 +1,5 @@ +use crate::builtins::pytype::PyTypeRef; use crate::frame::FrameRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{PyClassImpl, PyContext, PyRef, PyValue}; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/tuple.rs b/vm/src/builtins/tuple.rs index 3a015d781..3a35262ba 100644 --- a/vm/src/builtins/tuple.rs +++ b/vm/src/builtins/tuple.rs @@ -2,9 +2,9 @@ use crossbeam_utils::atomic::AtomicCell; use num_traits::ToPrimitive; use std::fmt; -use super::objint::PyIntRef; -use super::objiter; -use super::objtype::PyTypeRef; +use super::int::PyIntRef; +use super::iter; +use super::pytype::PyTypeRef; use crate::common::hash::PyHash; use crate::pyobject::{ self, BorrowValue, Either, IdProtocol, IntoPyObject, PyArithmaticValue, PyClassImpl, @@ -302,7 +302,7 @@ impl PyTupleIterator { if let Some(obj) = self.tuple.borrow_value().get(pos) { Ok(obj.clone()) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/builtins/weakproxy.rs b/vm/src/builtins/weakproxy.rs index 0d0144a32..7cef00c2b 100644 --- a/vm/src/builtins/weakproxy.rs +++ b/vm/src/builtins/weakproxy.rs @@ -1,5 +1,5 @@ -use super::objtype::PyTypeRef; -use super::objweakref::PyWeak; +use super::pytype::PyTypeRef; +use super::weakref::PyWeak; use crate::function::OptionalArg; use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; diff --git a/vm/src/builtins/weakref.rs b/vm/src/builtins/weakref.rs index c71574707..6e63b195b 100644 --- a/vm/src/builtins/weakref.rs +++ b/vm/src/builtins/weakref.rs @@ -1,4 +1,4 @@ -use super::objtype::PyTypeRef; +use super::pytype::PyTypeRef; use crate::common::hash::PyHash; use crate::function::{FuncArgs, OptionalArg}; use crate::pyobject::{ diff --git a/vm/src/builtins/zip.rs b/vm/src/builtins/zip.rs index 8bb53a5cd..126635b58 100644 --- a/vm/src/builtins/zip.rs +++ b/vm/src/builtins/zip.rs @@ -1,5 +1,5 @@ -use super::objiter; -use super::objtype::PyTypeRef; +use super::iter; +use super::pytype::PyTypeRef; use crate::function::Args; use crate::pyobject::{PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; @@ -24,7 +24,7 @@ impl PyZip { fn tp_new(cls: PyTypeRef, iterables: Args, vm: &VirtualMachine) -> PyResult { let iterators = iterables .into_iter() - .map(|iterable| objiter::get_iter(vm, &iterable)) + .map(|iterable| iter::get_iter(vm, &iterable)) .collect::, _>>()?; PyZip { iterators }.into_ref_with_type(vm, cls) } @@ -32,12 +32,12 @@ impl PyZip { #[pymethod(name = "__next__")] fn next(&self, vm: &VirtualMachine) -> PyResult { if self.iterators.is_empty() { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } else { let next_objs = self .iterators .iter() - .map(|iterator| objiter::call_next(vm, iterator)) + .map(|iterator| iter::call_next(vm, iterator)) .collect::, _>>()?; Ok(vm.ctx.new_tuple(next_objs)) diff --git a/vm/src/bytesinner.rs b/vm/src/bytesinner.rs index 5658a45a5..c6875776f 100644 --- a/vm/src/bytesinner.rs +++ b/vm/src/bytesinner.rs @@ -4,17 +4,17 @@ use num_bigint::BigInt; use num_traits::ToPrimitive; use crate::anystr::{self, AnyStr, AnyStrContainer, AnyStrWrapper}; +use crate::builtins::bytearray::PyByteArray; +use crate::builtins::bytes::{PyBytes, PyBytesRef}; +use crate::builtins::int::{self, PyInt, PyIntRef}; +use crate::builtins::list::PyList; +use crate::builtins::memory::PyMemoryView; +use crate::builtins::pystr::{self, PyStr, PyStrRef}; +use crate::builtins::singletons::PyNoneRef; +use crate::builtins::slice::PySliceRef; +use crate::builtins::tuple::PyTuple; use crate::byteslike::try_bytes_like; use crate::function::{OptionalArg, OptionalOption}; -use crate::obj::objbytearray::PyByteArray; -use crate::obj::objbytes::{PyBytes, PyBytesRef}; -use crate::obj::objint::{self, PyInt, PyIntRef}; -use crate::obj::objlist::PyList; -use crate::obj::objmemory::PyMemoryView; -use crate::obj::objsingletons::PyNoneRef; -use crate::obj::objslice::PySliceRef; -use crate::obj::objstr::{self, PyStr, PyStrRef}; -use crate::obj::objtuple::PyTuple; use crate::pyobject::{ BorrowValue, Either, PyComparisonValue, PyIterable, PyIterator, PyObjectRef, PyResult, TryFromObject, TypeProtocol, @@ -91,7 +91,7 @@ impl ByteInnerNewOptions { // Handle bytes(string, encoding[, errors]) if let OptionalArg::Present(enc) = self.encoding { let bytes = - objstr::encode_string(s, Some(enc), self.errors.into_option(), vm)?; + pystr::encode_string(s, Some(enc), self.errors.into_option(), vm)?; Ok(PyBytesInner { elements: bytes.borrow_value().to_vec(), }) @@ -107,7 +107,7 @@ impl ByteInnerNewOptions { } else { let value = match_class!(match obj { i @ PyInt => { - let size = objint::get_value(&i.into_object()) + let size = int::get_value(&i.into_object()) .to_isize() .ok_or_else(|| { vm.new_overflow_error( diff --git a/vm/src/byteslike.rs b/vm/src/byteslike.rs index 7354c0f51..19b5887dd 100644 --- a/vm/src/byteslike.rs +++ b/vm/src/byteslike.rs @@ -1,5 +1,5 @@ +use crate::builtins::memory::{try_buffer_from_object, BufferRef}; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; -use crate::obj::objmemory::{try_buffer_from_object, BufferRef}; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; diff --git a/vm/src/cformat.rs b/vm/src/cformat.rs index 6a91240a4..80b588f5e 100644 --- a/vm/src/cformat.rs +++ b/vm/src/cformat.rs @@ -1,7 +1,7 @@ +use crate::builtins::{float, int, pystr, pytype, tuple}; /// Implementation of Printf-Style string formatting /// [https://docs.python.org/3/library/stdtypes.html#printf-style-string-formatting] use crate::format::get_num_digits; -use crate::obj::{objfloat, objint, objstr, objtuple, objtype}; use crate::pyobject::{ BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject, TypeProtocol, }; @@ -315,13 +315,13 @@ impl CFormatSpec { )) }; match_class!(match &obj { - ref i @ objint::PyInt => { + ref i @ int::PyInt => { self.format_number(i.borrow_value()) } // TODO: if guards for match_class - ref f @ objfloat::PyFloat => { + ref f @ float::PyFloat => { if let CNumberType::Decimal = number_type { - self.format_number(&objfloat::try_bigint(f.to_f64(), vm)?) + self.format_number(&float::try_bigint(f.to_f64(), vm)?) } else { return Err(err()); } @@ -330,7 +330,7 @@ impl CFormatSpec { }) } CFormatType::Float(_) => { - let value = objfloat::try_float(&obj, vm)?.ok_or_else(|| { + let value = float::try_float(&obj, vm)?.ok_or_else(|| { vm.new_type_error(format!( "%{} format: an floating point or integer is required, not {}", self.format_char, @@ -342,16 +342,16 @@ impl CFormatSpec { } CFormatType::Character => { let ch = { - if objtype::isinstance(&obj, &vm.ctx.types.int_type) { + if pytype::isinstance(&obj, &vm.ctx.types.int_type) { // BigInt truncation is fine in this case because only the unicode range is relevant - objint::get_value(&obj) + int::get_value(&obj) .to_u32() .and_then(std::char::from_u32) .ok_or_else(|| { vm.new_overflow_error("%c arg not in range(0x110000)".to_owned()) }) - } else if objtype::isinstance(&obj, &vm.ctx.types.str_type) { - let s = objstr::borrow_value(&obj); + } else if pytype::isinstance(&obj, &vm.ctx.types.str_type) { + let s = pystr::borrow_value(&obj); let num_chars = s.chars().count(); if num_chars != 1 { Err(vm.new_type_error("%c requires int or char".to_owned())) @@ -435,11 +435,11 @@ impl CFormatString { Some(CFormatQuantity::FromValuesTuple) => match elements.next() { Some(width_obj) => { tuple_index += 1; - if !objtype::isinstance(&width_obj, &vm.ctx.types.int_type) { + if !pytype::isinstance(&width_obj, &vm.ctx.types.int_type) { Err(vm.new_type_error("* wants int".to_owned())) } else { - let i = objint::get_value(&width_obj); - let i = objint::try_to_primitive::(i, vm)? as usize; + let i = int::get_value(&width_obj); + let i = int::try_to_primitive::(i, vm)? as usize; *q = Some(CFormatQuantity::Amount(i)); Ok(tuple_index) } @@ -469,16 +469,16 @@ impl CFormatString { .all(|(_, part)| CFormatPart::has_key(part)); let values = if mapping_required { - if !objtype::isinstance(&values_obj, &vm.ctx.types.dict_type) { + if !pytype::isinstance(&values_obj, &vm.ctx.types.dict_type) { return Err(vm.new_type_error("format requires a mapping".to_owned())); } values_obj.clone() } else { // check for only literal parts, in which case only dict or empty tuple is allowed if num_specifiers == 0 - && !(objtype::isinstance(&values_obj, &vm.ctx.types.tuple_type) - && objtuple::get_value(&values_obj).is_empty()) - && !objtype::isinstance(&values_obj, &vm.ctx.types.dict_type) + && !(pytype::isinstance(&values_obj, &vm.ctx.types.tuple_type) + && tuple::get_value(&values_obj).is_empty()) + && !pytype::isinstance(&values_obj, &vm.ctx.types.dict_type) { return Err(vm.new_type_error( "not all arguments converted during string formatting".to_owned(), @@ -486,7 +486,7 @@ impl CFormatString { } // convert `values_obj` to a new tuple if it's not a tuple - if !objtype::isinstance(&values_obj, &vm.ctx.types.tuple_type) { + if !pytype::isinstance(&values_obj, &vm.ctx.types.tuple_type) { vm.ctx.new_tuple(vec![values_obj.clone()]) } else { values_obj.clone() @@ -504,7 +504,7 @@ impl CFormatString { values.get_item(key, vm)? } None => { - let mut elements = objtuple::get_value(&values) + let mut elements = tuple::get_value(&values) .to_vec() .into_iter() .skip(tuple_index); @@ -541,8 +541,8 @@ impl CFormatString { } // check that all arguments were converted - if (!mapping_required && objtuple::get_value(&values).get(tuple_index).is_some()) - && !objtype::isinstance(&values_obj, &vm.ctx.types.dict_type) + if (!mapping_required && tuple::get_value(&values).get(tuple_index).is_some()) + && !pytype::isinstance(&values_obj, &vm.ctx.types.dict_type) { return Err(vm.new_type_error( "not all arguments converted during string formatting".to_owned(), diff --git a/vm/src/coroutine.rs b/vm/src/coroutine.rs index 00f11f265..c190544f6 100644 --- a/vm/src/coroutine.rs +++ b/vm/src/coroutine.rs @@ -1,6 +1,6 @@ +use crate::builtins::pytype::{self, PyTypeRef}; use crate::exceptions::{self, PyBaseExceptionRef}; use crate::frame::{ExecutionResult, FrameRef}; -use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{PyObjectRef, PyResult}; use crate::vm::VirtualMachine; @@ -98,13 +98,13 @@ impl Coro { match result { Ok(exec_res) => self.variant.exec_result(exec_res, vm), Err(e) => { - if objtype::isinstance(&e, &vm.ctx.exceptions.stop_iteration) { + if pytype::isinstance(&e, &vm.ctx.exceptions.stop_iteration) { let err = vm .new_runtime_error(format!("{} raised StopIteration", self.variant.name())); err.set_cause(Some(e)); Err(err) } else if self.variant == Variant::AsyncGen - && objtype::isinstance(&e, &vm.ctx.exceptions.stop_async_iteration) + && pytype::isinstance(&e, &vm.ctx.exceptions.stop_async_iteration) { let err = vm .new_runtime_error("async generator raised StopAsyncIteration".to_owned()); @@ -171,5 +171,5 @@ impl Coro { } pub fn is_gen_exit(exc: &PyBaseExceptionRef, vm: &VirtualMachine) -> bool { - objtype::isinstance(exc, &vm.ctx.exceptions.generator_exit) + pytype::isinstance(exc, &vm.ctx.exceptions.generator_exit) } diff --git a/vm/src/dictdatatype.rs b/vm/src/dictdatatype.rs index 0eddf35c5..7f66ebef8 100644 --- a/vm/src/dictdatatype.rs +++ b/vm/src/dictdatatype.rs @@ -1,9 +1,9 @@ +use crate::builtins::pystr::{PyStr, PyStrRef}; /// Ordered dictionary implementation. /// Inspired by: https://morepypy.blogspot.com/2015/01/faster-more-memory-efficient-and-more.html /// And: https://www.youtube.com/watch?v=p33CVV29OG8 /// And: http://code.activestate.com/recipes/578375/ use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; -use crate::obj::objstr::{PyStr, PyStrRef}; use crate::pyobject::{BorrowValue, IdProtocol, IntoPyObject, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; use rustpython_common::hash; diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index 0f86bded4..7ddb94c22 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -1,10 +1,10 @@ +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::{self, PyType, PyTypeRef}; +use crate::builtins::singletons::{PyNone, PyNoneRef}; +use crate::builtins::traceback::PyTracebackRef; +use crate::builtins::tuple::{PyTuple, PyTupleRef}; use crate::common::lock::PyRwLock; use crate::function::FuncArgs; -use crate::obj::objsingletons::{PyNone, PyNoneRef}; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtraceback::PyTracebackRef; -use crate::obj::objtuple::{PyTuple, PyTupleRef}; -use crate::obj::objtype::{self, PyType, PyTypeRef}; use crate::py_io::{self, Write}; use crate::pyobject::{ BorrowValue, IntoPyObject, PyClassDef, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, @@ -303,7 +303,7 @@ impl TryFromObject for ExceptionCtor { fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { obj.downcast::() .and_then(|cls| { - if objtype::issubclass(&cls, &vm.ctx.exceptions.base_exception_type) { + if pytype::issubclass(&cls, &vm.ctx.exceptions.base_exception_type) { Ok(Self::Class(cls)) } else { Err(cls.into_object()) @@ -352,7 +352,7 @@ impl ExceptionCtor { // if the "type" is an instance and the value isn't, use the "type" (Self::Instance(exc), None) => Ok(exc), // if the value is an instance of the type, use the instance value - (Self::Class(cls), Some(exc)) if objtype::isinstance(&exc, &cls) => Ok(exc), + (Self::Class(cls), Some(exc)) if pytype::isinstance(&exc, &cls) => Ok(exc), // otherwise; construct an exception of the type using the value as args (Self::Class(cls), _) => { let args = match_class!(match value { diff --git a/vm/src/format.rs b/vm/src/format.rs index f076973aa..5ee0516e6 100644 --- a/vm/src/format.rs +++ b/vm/src/format.rs @@ -1,6 +1,6 @@ +use crate::builtins::{pystr, pytype}; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::FuncArgs; -use crate::obj::{objstr, objtype}; use crate::pyobject::{ItemProtocol, PyObjectRef, PyResult, TypeProtocol}; use crate::vm::VirtualMachine; use itertools::{Itertools, PeekingNext}; @@ -830,7 +830,7 @@ impl FormatString { let value = call_object_format(vm, argument, *preconversion_spec, &format_spec)?; - objstr::clone_value(&value) + pystr::clone_value(&value) } FormatPart::Literal(literal) => literal.clone(), }; @@ -901,7 +901,7 @@ fn call_object_format( None => argument, }; let result = vm.call_method(&argument, "__format__", (format_spec,))?; - if !objtype::isinstance(&result, &vm.ctx.types.str_type) { + if !pytype::isinstance(&result, &vm.ctx.types.str_type) { return Err(vm.new_type_error(format!( "__format__ must return a str, not {}", &result.class().name diff --git a/vm/src/frame.rs b/vm/src/frame.rs index 3e477ec13..092540390 100644 --- a/vm/src/frame.rs +++ b/vm/src/frame.rs @@ -4,23 +4,23 @@ use std::sync::atomic::{AtomicUsize, Ordering}; use indexmap::IndexMap; use itertools::Itertools; +use crate::builtins::asyncgenerator::PyAsyncGenWrappedValue; use crate::builtins::builtin_isinstance; +use crate::builtins::code::PyCodeRef; +use crate::builtins::coroutine::PyCoroutine; +use crate::builtins::dict::{PyDict, PyDictRef}; +use crate::builtins::generator::PyGenerator; +use crate::builtins::pystr::{self, PyStr, PyStrRef}; +use crate::builtins::pytype::{self, PyTypeRef}; +use crate::builtins::slice::PySlice; +use crate::builtins::traceback::PyTraceback; +use crate::builtins::tuple::PyTuple; +use crate::builtins::{iter, list, pybool, set}; use crate::bytecode; use crate::common::lock::PyMutex; use crate::coroutine::Coro; use crate::exceptions::{self, ExceptionCtor, PyBaseExceptionRef}; use crate::function::FuncArgs; -use crate::obj::objasyncgenerator::PyAsyncGenWrappedValue; -use crate::obj::objcode::PyCodeRef; -use crate::obj::objcoroutine::PyCoroutine; -use crate::obj::objdict::{PyDict, PyDictRef}; -use crate::obj::objgenerator::PyGenerator; -use crate::obj::objslice::PySlice; -use crate::obj::objstr::{self, PyStr, PyStrRef}; -use crate::obj::objtraceback::PyTraceback; -use crate::obj::objtuple::PyTuple; -use crate::obj::objtype::{self, PyTypeRef}; -use crate::obj::{objbool, objiter, objlist, objset}; use crate::pyobject::{ BorrowValue, IdProtocol, ItemProtocol, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, @@ -116,8 +116,8 @@ impl ExecutionResult { match res { Ok(val) => Ok(ExecutionResult::Yield(val)), Err(err) => { - if objtype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { - objiter::stop_iter_value(vm, &err).map(ExecutionResult::Return) + if pytype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { + iter::stop_iter_value(vm, &err).map(ExecutionResult::Return) } else { Err(err) } @@ -313,7 +313,7 @@ impl ExecutingFrame<'_> { res.or_else(|err| { self.pop_value(); self.lasti.fetch_add(1, Ordering::Relaxed); - let val = objiter::stop_iter_value(vm, &err)?; + let val = iter::stop_iter_value(vm, &err)?; self._send(coro, val, vm) }) .map(ExecutionResult::Yield) @@ -386,7 +386,7 @@ impl ExecutingFrame<'_> { let s = self .pop_multiple(*size) .into_iter() - .map(|pyobj| objstr::clone_value(&pyobj)) + .map(|pyobj| pystr::clone_value(&pyobj)) .collect::(); let str_obj = vm.ctx.new_str(s); self.push_value(str_obj); @@ -422,13 +422,13 @@ impl ExecutingFrame<'_> { bytecode::Instruction::ListAppend { i } => { let list_obj = self.nth_value(*i); let item = self.pop_value(); - objlist::PyListRef::try_from_object(vm, list_obj)?.append(item); + list::PyListRef::try_from_object(vm, list_obj)?.append(item); Ok(None) } bytecode::Instruction::SetAdd { i } => { let set_obj = self.nth_value(*i); let item = self.pop_value(); - objset::PySetRef::try_from_object(vm, set_obj)?.add(item, vm)?; + set::PySetRef::try_from_object(vm, set_obj)?.add(item, vm)?; Ok(None) } bytecode::Instruction::MapAdd { i } => { @@ -564,7 +564,7 @@ impl ExecutingFrame<'_> { _ => panic!("WithCleanupFinish expects a FinallyHandler block on stack"), }; - let suppress_exception = objbool::boolval(vm, self.pop_value())?; + let suppress_exception = pybool::boolval(vm, self.pop_value())?; if suppress_exception { // suppress exception Ok(None) @@ -580,7 +580,7 @@ impl ExecutingFrame<'_> { } bytecode::Instruction::GetIter => { let iterated_obj = self.pop_value(); - let iter_obj = objiter::get_iter(vm, &iterated_obj)?; + let iter_obj = iter::get_iter(vm, &iterated_obj)?; self.push_value(iter_obj); Ok(None) } @@ -627,7 +627,7 @@ impl ExecutingFrame<'_> { } bytecode::Instruction::JumpIfTrue { target } => { let obj = self.pop_value(); - let value = objbool::boolval(vm, obj)?; + let value = pybool::boolval(vm, obj)?; if value { self.jump(*target); } @@ -636,7 +636,7 @@ impl ExecutingFrame<'_> { bytecode::Instruction::JumpIfFalse { target } => { let obj = self.pop_value(); - let value = objbool::boolval(vm, obj)?; + let value = pybool::boolval(vm, obj)?; if !value { self.jump(*target); } @@ -645,7 +645,7 @@ impl ExecutingFrame<'_> { bytecode::Instruction::JumpIfTrueOrPop { target } => { let obj = self.last_value(); - let value = objbool::boolval(vm, obj)?; + let value = pybool::boolval(vm, obj)?; if value { self.jump(*target); } else { @@ -656,7 +656,7 @@ impl ExecutingFrame<'_> { bytecode::Instruction::JumpIfFalseOrPop { target } => { let obj = self.last_value(); - let value = objbool::boolval(vm, obj)?; + let value = pybool::boolval(vm, obj)?; if !value { self.jump(*target); } else { @@ -1063,7 +1063,7 @@ impl ExecutingFrame<'_> { let kwarg_names = vm .extract_elements(&kwarg_names)? .iter() - .map(|pyobj| objstr::clone_value(pyobj)) + .map(|pyobj| pystr::clone_value(pyobj)) .collect(); FuncArgs::with_kwargs_names(args, kwarg_names) } @@ -1075,11 +1075,9 @@ impl ExecutingFrame<'_> { })?; let mut kwargs = IndexMap::new(); for (key, value) in kw_dict.into_iter() { - let key = - key.payload_if_subclass::(vm) - .ok_or_else(|| { - vm.new_type_error("keywords must be strings".to_owned()) - })?; + let key = key.payload_if_subclass::(vm).ok_or_else(|| { + vm.new_type_error("keywords must be strings".to_owned()) + })?; kwargs.insert(key.borrow_value().to_owned(), value); } kwargs @@ -1148,7 +1146,7 @@ impl ExecutingFrame<'_> { fn _send(&self, coro: PyObjectRef, val: PyObjectRef, vm: &VirtualMachine) -> PyResult { match self.builtin_coro(&coro) { Some(coro) => coro.send(val, vm), - None if vm.is_none(&val) => objiter::call_next(vm, &coro), + None if vm.is_none(&val) => iter::call_next(vm, &coro), None => vm.call_method(&coro, "send", (val,)), } } @@ -1222,7 +1220,7 @@ impl ExecutingFrame<'_> { /// The top of stack contains the iterator, lets push it forward fn execute_for_iter(&mut self, vm: &VirtualMachine, target: bytecode::Label) -> FrameResult { let top_of_stack = self.last_value(); - let next_obj = objiter::get_next_object(vm, &top_of_stack); + let next_obj = iter::get_next_object(vm, &top_of_stack); // Check the next object: match next_obj { @@ -1362,7 +1360,7 @@ impl ExecutingFrame<'_> { bytecode::UnaryOperator::Plus => vm.call_method(&a, "__pos__", ())?, bytecode::UnaryOperator::Invert => vm.call_method(&a, "__invert__", ())?, bytecode::UnaryOperator::Not => { - let value = objbool::boolval(vm, a)?; + let value = pybool::boolval(vm, a)?; vm.ctx.new_bool(!value) } }; @@ -1381,7 +1379,7 @@ impl ExecutingFrame<'_> { haystack: PyObjectRef, ) -> PyResult { let found = vm._membership(haystack, needle)?; - Ok(objbool::boolval(vm, found)?) + Ok(pybool::boolval(vm, found)?) } fn _not_in( @@ -1391,7 +1389,7 @@ impl ExecutingFrame<'_> { haystack: PyObjectRef, ) -> PyResult { let found = vm._membership(haystack, needle)?; - Ok(!objbool::boolval(vm, found)?) + Ok(!pybool::boolval(vm, found)?) } fn _is(&self, a: PyObjectRef, b: PyObjectRef) -> bool { diff --git a/vm/src/function.rs b/vm/src/function.rs index 8f8d3b194..5262940e6 100644 --- a/vm/src/function.rs +++ b/vm/src/function.rs @@ -1,7 +1,7 @@ use self::OptionalArg::*; +use crate::builtins::pytype::{isinstance, PyTypeRef}; +use crate::builtins::tuple::PyTupleRef; use crate::exceptions::PyBaseExceptionRef; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::{isinstance, PyTypeRef}; use crate::pyobject::{ BorrowValue, IntoPyObject, IntoPyResult, PyObjectRef, PyRef, PyResult, PyThreadingConstraint, PyValue, TryFromObject, TypeProtocol, diff --git a/vm/src/import.rs b/vm/src/import.rs index 5c1a39605..87fd0c3c0 100644 --- a/vm/src/import.rs +++ b/vm/src/import.rs @@ -3,10 +3,10 @@ */ use rand::Rng; +use crate::builtins::traceback::{PyTraceback, PyTracebackRef}; +use crate::builtins::{code, list, pytype}; use crate::bytecode::CodeObject; use crate::exceptions::PyBaseExceptionRef; -use crate::obj::objtraceback::{PyTraceback, PyTracebackRef}; -use crate::obj::{objcode, objlist, objtype}; use crate::pyobject::{ItemProtocol, PyResult, PyValue, TryFromObject}; use crate::scope::Scope; use crate::version::get_git_revision; @@ -47,7 +47,7 @@ pub(crate) fn init_importlib( let zipimport = vm.import("zipimport", &[], 0)?; let zipimporter = vm.get_attribute(zipimport, "zipimporter")?; let path_hooks = vm.get_attribute(vm.sys_module.clone(), "path_hooks")?; - let path_hooks = objlist::PyListRef::try_from_object(vm, path_hooks)?; + let path_hooks = list::PyListRef::try_from_object(vm, path_hooks)?; path_hooks.insert(0, zipimporter); Ok(()) })(); @@ -122,7 +122,7 @@ pub fn import_codeobj( // Execute main code in module: vm.run_code_obj( - objcode::PyCode::new(code_obj).into_ref(vm), + code::PyCode::new(code_obj).into_ref(vm), Scope::with_builtins(None, attrs, vm), )?; Ok(module) @@ -174,7 +174,7 @@ pub fn remove_importlib_frames( vm: &VirtualMachine, exc: &PyBaseExceptionRef, ) -> PyBaseExceptionRef { - let always_trim = objtype::isinstance(exc, &vm.ctx.exceptions.import_error); + let always_trim = pytype::isinstance(exc, &vm.ctx.exceptions.import_error); if let Some(tb) = exc.traceback() { let trimmed_tb = remove_importlib_frames_inner(vm, Some(tb), always_trim).0; diff --git a/vm/src/lib.rs b/vm/src/lib.rs index deea3f8fd..7089eb83c 100644 --- a/vm/src/lib.rs +++ b/vm/src/lib.rs @@ -44,7 +44,7 @@ pub use rustpython_derive::*; pub mod macros; mod anystr; -mod builtins; +pub mod builtins; mod bytesinner; pub mod byteslike; pub mod cformat; @@ -58,7 +58,6 @@ pub mod frame; mod frozen; pub mod function; pub mod import; -pub mod obj; mod py_io; pub mod py_serde; pub mod pyobject; diff --git a/vm/src/macros.rs b/vm/src/macros.rs index 04b839556..fb2a4eae5 100644 --- a/vm/src/macros.rs +++ b/vm/src/macros.rs @@ -97,8 +97,8 @@ macro_rules! py_namespace { /// use num_traits::Zero; /// /// use rustpython_vm::match_class; -/// use rustpython_vm::obj::objfloat::PyFloat; -/// use rustpython_vm::obj::objint::PyInt; +/// use rustpython_vm::builtins::float::PyFloat; +/// use rustpython_vm::builtins::int::PyInt; /// use rustpython_vm::pyobject::PyValue; /// /// # rustpython_vm::Interpreter::default().enter(|vm| { @@ -122,8 +122,8 @@ macro_rules! py_namespace { /// use num_traits::Zero; /// /// use rustpython_vm::match_class; -/// use rustpython_vm::obj::objfloat::PyFloat; -/// use rustpython_vm::obj::objint::PyInt; +/// use rustpython_vm::builtins::float::PyFloat; +/// use rustpython_vm::builtins::int::PyInt; /// use rustpython_vm::pyobject::{PyValue, BorrowValue}; /// /// # rustpython_vm::Interpreter::default().enter(|vm| { diff --git a/vm/src/py_io.rs b/vm/src/py_io.rs index 7967f500c..17c007772 100644 --- a/vm/src/py_io.rs +++ b/vm/src/py_io.rs @@ -1,6 +1,6 @@ +use crate::builtins::bytes::PyBytes; +use crate::builtins::pystr::PyStr; use crate::exceptions::PyBaseExceptionRef; -use crate::obj::objbytes::PyBytes; -use crate::obj::objstr::PyStr; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult}; use crate::VirtualMachine; use std::{fmt, io}; diff --git a/vm/src/py_serde.rs b/vm/src/py_serde.rs index 3d1a4f64f..c4feb6310 100644 --- a/vm/src/py_serde.rs +++ b/vm/src/py_serde.rs @@ -3,9 +3,8 @@ use num_traits::sign::Signed; use serde::de::{DeserializeSeed, Visitor}; use serde::ser::{Serialize, SerializeMap, SerializeSeq}; -use crate::obj::{ - objbool, objdict::PyDictRef, objfloat, objint, objlist::PyList, objstr, objtuple::PyTuple, - objtype, +use crate::builtins::{ + dict::PyDictRef, float, int, list::PyList, pybool, pystr, pytype, tuple::PyTuple, }; use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, TypeProtocol}; use crate::VirtualMachine; @@ -66,14 +65,14 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> { } seq.end() }; - if objtype::isinstance(self.pyobject, &self.vm.ctx.types.str_type) { - serializer.serialize_str(objstr::borrow_value(&self.pyobject)) - } else if objtype::isinstance(self.pyobject, &self.vm.ctx.types.float_type) { - serializer.serialize_f64(objfloat::get_value(self.pyobject)) - } else if objtype::isinstance(self.pyobject, &self.vm.ctx.types.bool_type) { - serializer.serialize_bool(objbool::get_value(self.pyobject)) - } else if objtype::isinstance(self.pyobject, &self.vm.ctx.types.int_type) { - let v = objint::get_value(self.pyobject); + if pytype::isinstance(self.pyobject, &self.vm.ctx.types.str_type) { + serializer.serialize_str(pystr::borrow_value(&self.pyobject)) + } else if pytype::isinstance(self.pyobject, &self.vm.ctx.types.float_type) { + serializer.serialize_f64(float::get_value(self.pyobject)) + } else if pytype::isinstance(self.pyobject, &self.vm.ctx.types.bool_type) { + serializer.serialize_bool(pybool::get_value(self.pyobject)) + } else if pytype::isinstance(self.pyobject, &self.vm.ctx.types.int_type) { + let v = int::get_value(self.pyobject); let int_too_large = || serde::ser::Error::custom("int too large to serialize"); // TODO: serialize BigInt when it does not fit into i64 // BigInt implements serialization to a tuple of sign and a list of u32s, @@ -88,7 +87,7 @@ impl<'s> serde::Serialize for PyObjectSerializer<'s> { serialize_seq_elements(serializer, &list.borrow_value()) } else if let Some(tuple) = self.pyobject.payload_if_subclass::(self.vm) { serialize_seq_elements(serializer, tuple.borrow_value()) - } else if objtype::isinstance(self.pyobject, &self.vm.ctx.types.dict_type) { + } else if pytype::isinstance(self.pyobject, &self.vm.ctx.types.dict_type) { let dict: PyDictRef = self.pyobject.clone().downcast().unwrap(); let pairs: Vec<_> = dict.into_iter().collect(); let mut map = serializer.serialize_map(Some(pairs.len()))?; diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs index a4b7710f8..695d42e58 100644 --- a/vm/src/pyobject.rs +++ b/vm/src/pyobject.rs @@ -8,31 +8,31 @@ use num_bigint::BigInt; use num_complex::Complex64; use num_traits::ToPrimitive; +use crate::builtins::builtinfunc::PyFuncDef; +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, PyFunction}; +use crate::builtins::getset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet}; +use crate::builtins::int::{PyInt, PyIntRef}; +use crate::builtins::iter; +use crate::builtins::list::PyList; +use crate::builtins::namespace::PyNamespace; +use crate::builtins::object; +use crate::builtins::pystr; +use crate::builtins::pytype::{self, PyType, PyTypeRef}; +use crate::builtins::set; +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::bytecode; use crate::exceptions::{self, PyBaseExceptionRef}; use crate::function::{IntoFuncArgs, IntoPyNativeFunc}; -use crate::obj::objbuiltinfunc::PyFuncDef; -use crate::obj::objbytearray; -use crate::obj::objbytes; -use crate::obj::objcode; -use crate::obj::objcode::PyCodeRef; -use crate::obj::objcomplex::PyComplex; -use crate::obj::objdict::{PyDict, PyDictRef}; -use crate::obj::objfloat::PyFloat; -use crate::obj::objfunction::{PyBoundMethod, PyFunction}; -use crate::obj::objgetset::{IntoPyGetterFunc, IntoPySetterFunc, PyGetSet}; -use crate::obj::objint::{PyInt, PyIntRef}; -use crate::obj::objiter; -use crate::obj::objlist::PyList; -use crate::obj::objnamespace::PyNamespace; -use crate::obj::objobject; -use crate::obj::objset; -use crate::obj::objsingletons::{PyNone, PyNoneRef, PyNotImplemented, PyNotImplementedRef}; -use crate::obj::objslice::PyEllipsis; -use crate::obj::objstaticmethod::PyStaticMethod; -use crate::obj::objstr; -use crate::obj::objtuple::{PyTuple, PyTupleRef}; -use crate::obj::objtype::{self, PyType, PyTypeRef}; pub use crate::pyobjectrc::{PyObjectRc, PyObjectWeak}; use crate::scope::Scope; use crate::slots::{PyTpFlags, PyTypeSlots}; @@ -144,7 +144,7 @@ impl PyContext { ); let tp_new_wrapper = create_object( - PyFuncDef::from(objtype::tp_new_wrapper.into_func()).into_function(), + PyFuncDef::from(pytype::tp_new_wrapper.into_func()).into_function(), &types.builtin_function_or_method_type, ) .into_object(); @@ -216,14 +216,14 @@ impl PyContext { pub fn new_str(&self, s: S) -> PyObjectRef where - S: Into, + S: Into, { PyObject::new(s.into(), self.types.str_type.clone(), None) } pub fn new_bytes(&self, data: Vec) -> PyObjectRef { PyObject::new( - objbytes::PyBytes::from(data), + bytes::PyBytes::from(data), self.types.bytes_type.clone(), None, ) @@ -231,7 +231,7 @@ impl PyContext { pub fn new_bytearray(&self, data: Vec) -> PyObjectRef { PyObject::new( - objbytearray::PyByteArray::from(data), + bytearray::PyByteArray::from(data), self.types.bytearray_type.clone(), None, ) @@ -255,10 +255,10 @@ impl PyContext { PyObject::new(PyList::from(elements), self.types.list_type.clone(), None) } - pub fn new_set(&self) -> objset::PySetRef { + pub fn new_set(&self) -> set::PySetRef { // Initialized empty, as calling __hash__ is required for adding each object to the set - // which requires a VM context - this is done in the objset code itself. - PyRef::new_ref(objset::PySet::default(), self.types.set_type.clone(), None) + // which requires a VM context - this is done in the set code itself. + PyRef::new_ref(set::PySet::default(), self.types.set_type.clone(), None) } pub fn new_dict(&self) -> PyDictRef { @@ -284,8 +284,8 @@ impl PyContext { PyFuncDef::from(f.into_func()).build_function(self) } - pub(crate) fn new_stringref(&self, s: String) -> objstr::PyStrRef { - PyRef::new_ref(objstr::PyStr::from(s), self.types.str_type.clone(), None) + pub(crate) fn new_stringref(&self, s: String) -> pystr::PyStrRef { + PyRef::new_ref(pystr::PyStr::from(s), self.types.str_type.clone(), None) } pub fn new_function_named(&self, f: F, name: String) -> PyFuncDef @@ -345,11 +345,7 @@ impl PyContext { } pub fn new_code_object(&self, code: bytecode::CodeObject) -> PyCodeRef { - PyRef::new_ref( - objcode::PyCode::new(code), - self.types.code_type.clone(), - None, - ) + PyRef::new_ref(code::PyCode::new(code), self.types.code_type.clone(), None) } pub fn new_pyfunction( @@ -378,7 +374,7 @@ impl PyContext { PyObject { typ: PyRwLock::new(class.into_typed_pyobj()), dict: dict.map(|d| PyRwLock::new(d.into_typed_pyobj())), - payload: objobject::PyBaseObject, + payload: object::PyBaseObject, } .into_ref() } @@ -584,7 +580,7 @@ where T: PyValue, { fn try_from_object(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { - if objtype::isinstance(&obj, &T::class(vm)) { + if pytype::isinstance(&obj, &T::class(vm)) { PyRef::from_obj(obj, vm) } else { let class = T::class(vm); @@ -833,7 +829,7 @@ impl PyIterable { let method = &self.method; let iter_obj = vm.invoke(method, ())?; - let length_hint = objiter::length_hint(vm, iter_obj.clone())?; + let length_hint = iter::length_hint(vm, iter_obj.clone())?; Ok(PyIterator { vm, @@ -861,7 +857,7 @@ where match self.vm.call_method(&self.obj, "__next__", ()) { Ok(value) => Some(T::try_from_object(self.vm, value)), Err(err) => { - if objtype::isinstance(&err, &self.vm.ctx.exceptions.stop_iteration) { + if pytype::isinstance(&err, &self.vm.ctx.exceptions.stop_iteration) { None } else { Some(Err(err)) @@ -892,7 +888,7 @@ where })?; Self::try_from_object( vm, - objiter::PySequenceIterator::new_forward(obj) + iter::PySequenceIterator::new_forward(obj) .into_ref(vm) .into_object(), ) @@ -1077,7 +1073,7 @@ impl PyObject { &self, vm: &VirtualMachine, ) -> Option<&T> { - if objtype::issubclass(self.class(), &T::class(vm)) { + if pytype::issubclass(self.class(), &T::class(vm)) { self.payload() } else { None @@ -1126,7 +1122,7 @@ pub trait PyValue: fmt::Debug + PyThreadingConstraint + Sized + 'static { fn into_ref_with_type(self, vm: &VirtualMachine, cls: PyTypeRef) -> PyResult> { let class = Self::class(vm); - if objtype::issubclass(&cls, &class) { + if pytype::issubclass(&cls, &class) { Ok(self.into_ref_with_type_unchecked(cls, vm)) } else { let subtype = vm.to_str(&cls.obj)?; @@ -1193,7 +1189,7 @@ impl IntoPyObject for Either { /// /// ``` /// use rustpython_vm::VirtualMachine; -/// use rustpython_vm::obj::{objstr::PyStrRef, objint::PyIntRef}; +/// use rustpython_vm::builtins::{pystr::PyStrRef, int::PyIntRef}; /// use rustpython_vm::pyobject::Either; /// /// fn do_something(arg: Either, vm: &VirtualMachine) { @@ -1253,11 +1249,7 @@ pub trait PyClassImpl: PyClassDef { if Self::TP_FLAGS.has_feature(PyTpFlags::HAS_DICT) { class.set_str_attr( "__dict__", - ctx.new_getset( - "__dict__", - objobject::object_get_dict, - objobject::object_set_dict, - ), + ctx.new_getset("__dict__", object::object_get_dict, object::object_set_dict), ); } Self::impl_extend_class(ctx, class); diff --git a/vm/src/scope.rs b/vm/src/scope.rs index e7f6811b5..f24f78d61 100644 --- a/vm/src/scope.rs +++ b/vm/src/scope.rs @@ -1,6 +1,6 @@ use std::fmt; -use crate::obj::objdict::PyDictRef; +use crate::builtins::dict::PyDictRef; use crate::pyobject::{ItemProtocol, PyContext, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; diff --git a/vm/src/sliceable.rs b/vm/src/sliceable.rs index 64a6c2059..f53917962 100644 --- a/vm/src/sliceable.rs +++ b/vm/src/sliceable.rs @@ -2,8 +2,8 @@ use num_bigint::BigInt; use num_traits::{One, Signed, ToPrimitive, Zero}; use std::ops::Range; -use crate::obj::objint::PyInt; -use crate::obj::objslice::{PySlice, PySliceRef}; +use crate::builtins::int::PyInt; +use crate::builtins::slice::{PySlice, PySliceRef}; use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use crate::vm::VirtualMachine; diff --git a/vm/src/slots.rs b/vm/src/slots.rs index afd4f4b77..711e9feaf 100644 --- a/vm/src/slots.rs +++ b/vm/src/slots.rs @@ -1,10 +1,10 @@ use std::cmp::Ordering; +use crate::builtins::memory::Buffer; +use crate::builtins::pystr::PyStrRef; use crate::common::hash::PyHash; use crate::common::lock::PyRwLock; use crate::function::{FuncArgs, OptionalArg, PyNativeFunc}; -use crate::obj::objmemory::Buffer; -use crate::obj::objstr::PyStrRef; use crate::pyobject::{ Either, IdProtocol, PyComparisonValue, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; diff --git a/vm/src/stdlib/array.rs b/vm/src/stdlib/array.rs index 0ee436d41..c45e45f30 100644 --- a/vm/src/stdlib/array.rs +++ b/vm/src/stdlib/array.rs @@ -1,17 +1,17 @@ +use crate::builtins::bytes::PyBytesRef; +use crate::builtins::float::try_float; +use crate::builtins::iter; +use crate::builtins::list::PyList; +use crate::builtins::memory::{Buffer, BufferOptions}; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::slice::PySliceRef; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; use crate::common::lock::{ PyMappedRwLockReadGuard, PyMappedRwLockWriteGuard, PyRwLock, PyRwLockReadGuard, PyRwLockUpgradableReadGuard, PyRwLockWriteGuard, }; use crate::function::OptionalArg; -use crate::obj::objbytes::PyBytesRef; -use crate::obj::objfloat::try_float; -use crate::obj::objiter; -use crate::obj::objlist::PyList; -use crate::obj::objmemory::{Buffer, BufferOptions}; -use crate::obj::objslice::PySliceRef; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, IdProtocol, IntoPyObject, PyClassImpl, PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, @@ -928,7 +928,7 @@ impl PyArrayIter { if let Some(item) = self.array.borrow_value().getitem_by_idx(pos, vm) { Ok(item) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/stdlib/ast.rs b/vm/src/stdlib/ast.rs index 611ac5a54..094244789 100644 --- a/vm/src/stdlib/ast.rs +++ b/vm/src/stdlib/ast.rs @@ -9,8 +9,8 @@ use num_complex::Complex64; use rustpython_parser::{ast, mode::Mode, parser}; -use crate::obj::objlist::PyListRef; -use crate::obj::objtype::PyTypeRef; +use crate::builtins::list::PyListRef; +use crate::builtins::pytype::PyTypeRef; use crate::pyobject::{IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::PyTpFlags; use crate::vm::VirtualMachine; diff --git a/vm/src/stdlib/binascii.rs b/vm/src/stdlib/binascii.rs index 3d028f137..d5dd2862f 100644 --- a/vm/src/stdlib/binascii.rs +++ b/vm/src/stdlib/binascii.rs @@ -2,11 +2,11 @@ pub(crate) use decl::make_module; #[pymodule(name = "binascii")] mod decl { + use crate::builtins::bytearray::{PyByteArray, PyByteArrayRef}; + use crate::builtins::bytes::{PyBytes, PyBytesRef}; + use crate::builtins::pystr::{PyStr, PyStrRef}; use crate::byteslike::PyBytesLike; use crate::function::OptionalArg; - use crate::obj::objbytearray::{PyByteArray, PyByteArrayRef}; - use crate::obj::objbytes::{PyBytes, PyBytesRef}; - use crate::obj::objstr::{PyStr, PyStrRef}; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, TryFromObject, TypeProtocol}; use crate::vm::VirtualMachine; use crc::{crc32, Hasher32}; diff --git a/vm/src/stdlib/collections.rs b/vm/src/stdlib/collections.rs index f75aafa2c..44529198a 100644 --- a/vm/src/stdlib/collections.rs +++ b/vm/src/stdlib/collections.rs @@ -2,9 +2,9 @@ pub(crate) use _collections::make_module; #[pymodule] mod _collections { + use crate::builtins::{iter, pytype::PyTypeRef}; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::OptionalArg; - use crate::obj::{objiter, objtype::PyTypeRef}; use crate::pyobject::{PyComparisonValue, PyIterable, PyObjectRef, PyRef, PyResult, PyValue}; use crate::slots::{Comparable, PyComparisonOp}; use crate::vm::ReprGuard; @@ -372,7 +372,7 @@ mod _collections { let ret = deque[pos].clone(); Ok(ret) } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } diff --git a/vm/src/stdlib/csv.rs b/vm/src/stdlib/csv.rs index 3bb340b7e..69b2a20f8 100644 --- a/vm/src/stdlib/csv.rs +++ b/vm/src/stdlib/csv.rs @@ -2,11 +2,11 @@ use csv as rust_csv; use itertools::{self, Itertools}; use std::fmt::{self, Debug, Formatter}; +use crate::builtins::iter; +use crate::builtins::pystr::{self, PyStr}; +use crate::builtins::pytype::PyTypeRef; use crate::common::lock::PyRwLock; use crate::function::FuncArgs; -use crate::obj::objiter; -use crate::obj::objstr::{self, PyStr}; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, IntoPyObject, PyClassImpl, PyIterable, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TypeProtocol, @@ -30,7 +30,7 @@ struct ReaderOption { impl ReaderOption { fn new(args: FuncArgs, vm: &VirtualMachine) -> PyResult { let delimiter = if let Some(delimiter) = args.get_optional_kwarg("delimiter") { - *objstr::borrow_value(&delimiter) + *pystr::borrow_value(&delimiter) .as_bytes() .iter() .exactly_one() @@ -43,7 +43,7 @@ impl ReaderOption { }; let quotechar = if let Some(quotechar) = args.get_optional_kwarg("quotechar") { - *objstr::borrow_value("echar) + *pystr::borrow_value("echar) .as_bytes() .iter() .exactly_one() @@ -178,7 +178,7 @@ impl Reader { } } } else { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } else { unreachable!() diff --git a/vm/src/stdlib/dis.rs b/vm/src/stdlib/dis.rs index 4ce8c2f68..5de03302e 100644 --- a/vm/src/stdlib/dis.rs +++ b/vm/src/stdlib/dis.rs @@ -2,10 +2,10 @@ pub(crate) use decl::make_module; #[pymodule(name = "dis")] mod decl { + use crate::builtins::code::PyCodeRef; + use crate::builtins::dict::PyDictRef; + use crate::builtins::pystr::PyStrRef; use crate::bytecode::CodeFlags; - use crate::obj::objcode::PyCodeRef; - use crate::obj::objdict::PyDictRef; - use crate::obj::objstr::PyStrRef; use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; use rustpython_compiler::compile; diff --git a/vm/src/stdlib/functools.rs b/vm/src/stdlib/functools.rs index 186c8e0a2..b9288512a 100644 --- a/vm/src/stdlib/functools.rs +++ b/vm/src/stdlib/functools.rs @@ -2,9 +2,9 @@ pub(crate) use _functools::make_module; #[pymodule] mod _functools { + use crate::builtins::iter; + use crate::builtins::pytype; use crate::function::OptionalArg; - use crate::obj::objiter; - use crate::obj::objtype; use crate::pyobject::{PyObjectRef, PyResult}; use crate::vm::VirtualMachine; @@ -15,13 +15,13 @@ mod _functools { start_value: OptionalArg, vm: &VirtualMachine, ) -> PyResult { - let iterator = objiter::get_iter(vm, &sequence)?; + let iterator = iter::get_iter(vm, &sequence)?; let start_value = if let OptionalArg::Present(val) = start_value { val } else { - objiter::call_next(vm, &iterator).map_err(|err| { - if objtype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { + iter::call_next(vm, &iterator).map_err(|err| { + if pytype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { let exc_type = vm.ctx.exceptions.type_error.clone(); vm.new_exception_msg( exc_type, @@ -35,7 +35,7 @@ mod _functools { let mut accumulator = start_value; - while let Ok(next_obj) = objiter::call_next(vm, &iterator) { + while let Ok(next_obj) = iter::call_next(vm, &iterator) { accumulator = vm.invoke(&function, vec![accumulator, next_obj])? } diff --git a/vm/src/stdlib/hashlib.rs b/vm/src/stdlib/hashlib.rs index 3d7353f7b..f6893b053 100644 --- a/vm/src/stdlib/hashlib.rs +++ b/vm/src/stdlib/hashlib.rs @@ -2,11 +2,11 @@ pub(crate) use hashlib::make_module; #[pymodule] mod hashlib { + use crate::builtins::bytes::{PyBytes, PyBytesRef}; + use crate::builtins::pystr::PyStrRef; + use crate::builtins::pytype::PyTypeRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::function::{FuncArgs, OptionalArg}; - use crate::obj::objbytes::{PyBytes, PyBytesRef}; - use crate::obj::objstr::PyStrRef; - use crate::obj::objtype::PyTypeRef; use crate::pyobject::{BorrowValue, PyResult, PyValue}; use crate::vm::VirtualMachine; use std::fmt; diff --git a/vm/src/stdlib/imp.rs b/vm/src/stdlib/imp.rs index 42d543536..f07a584a7 100644 --- a/vm/src/stdlib/imp.rs +++ b/vm/src/stdlib/imp.rs @@ -1,9 +1,9 @@ +use crate::builtins::bytes::PyBytesRef; +use crate::builtins::code::PyCode; +use crate::builtins::module::PyModuleRef; +use crate::builtins::pystr; +use crate::builtins::pystr::PyStrRef; use crate::import; -use crate::obj::objbytes::PyBytesRef; -use crate::obj::objcode::PyCode; -use crate::obj::objmodule::PyModuleRef; -use crate::obj::objstr; -use crate::obj::objstr::PyStrRef; use crate::pyobject::{BorrowValue, ItemProtocol, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; @@ -60,7 +60,7 @@ fn _imp_is_frozen(name: PyStrRef, vm: &VirtualMachine) -> bool { fn _imp_create_builtin(spec: PyObjectRef, vm: &VirtualMachine) -> PyResult { let sys_modules = vm.get_attribute(vm.sys_module.clone(), "modules").unwrap(); let spec = vm.get_attribute(spec, "name")?; - let name = objstr::borrow_value(&spec); + let name = pystr::borrow_value(&spec); if let Ok(module) = sys_modules.get_item(name, vm) { Ok(module) diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index e239e7db3..1e9eb436f 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -17,6 +17,16 @@ mod _io { use num_traits::ToPrimitive; use std::io::{self, prelude::*, Cursor, SeekFrom}; + use crate::builtins::bytearray::PyByteArray; + use crate::builtins::bytes::PyBytesRef; + use crate::builtins::int; + use crate::builtins::iter; + use crate::builtins::memory::{ + Buffer, BufferOptions, BufferRef, PyMemoryView, PyMemoryViewRef, + }; + use crate::builtins::pybool; + use crate::builtins::pystr::{self, PyStr, PyStrRef}; + use crate::builtins::pytype::{self, PyTypeRef}; use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::common::borrow::{BorrowedValue, BorrowedValueMut}; use crate::common::lock::{ @@ -24,14 +34,6 @@ mod _io { }; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, OptionalArg, OptionalOption}; - use crate::obj::objbool; - use crate::obj::objbytearray::PyByteArray; - use crate::obj::objbytes::PyBytesRef; - use crate::obj::objint; - use crate::obj::objiter; - use crate::obj::objmemory::{Buffer, BufferOptions, BufferRef, PyMemoryView, PyMemoryViewRef}; - use crate::obj::objstr::{self, PyStr, PyStrRef}; - use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{ BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, @@ -266,7 +268,7 @@ mod _io { #[pymethod] fn close(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { - let closed = objbool::boolval(vm, Self::closed(instance.clone(), vm)?)?; + let closed = pybool::boolval(vm, Self::closed(instance.clone(), vm)?)?; if !closed { let res = vm.call_method(&instance, "flush", ()); vm.set_attr(&instance, "__closed", vm.ctx.new_bool(true))?; @@ -308,7 +310,7 @@ mod _io { msg: OptionalOption, vm: &VirtualMachine, ) -> PyResult<()> { - if objbool::boolval(vm, vm.get_attribute(instance, "closed")?)? { + if pybool::boolval(vm, vm.get_attribute(instance, "closed")?)? { let msg = msg .flatten() .unwrap_or_else(|| vm.ctx.new_str("I/O operation on closed file")); @@ -324,7 +326,7 @@ mod _io { msg: OptionalOption, vm: &VirtualMachine, ) -> PyResult<()> { - if !objbool::boolval(vm, vm.call_method(&instance, "readable", ())?)? { + if !pybool::boolval(vm, vm.call_method(&instance, "readable", ())?)? { let msg = msg .flatten() .unwrap_or_else(|| vm.ctx.new_str("File or stream is not readable.")); @@ -340,7 +342,7 @@ mod _io { msg: OptionalOption, vm: &VirtualMachine, ) -> PyResult<()> { - if !objbool::boolval(vm, vm.call_method(&instance, "writable", ())?)? { + if !pybool::boolval(vm, vm.call_method(&instance, "writable", ())?)? { let msg = msg .flatten() .unwrap_or_else(|| vm.ctx.new_str("File or stream is not writable.")); @@ -356,7 +358,7 @@ mod _io { msg: OptionalOption, vm: &VirtualMachine, ) -> PyResult<()> { - if !objbool::boolval(vm, vm.call_method(&instance, "seekable", ())?)? { + if !pybool::boolval(vm, vm.call_method(&instance, "seekable", ())?)? { let msg = msg .flatten() .unwrap_or_else(|| vm.ctx.new_str("File or stream is not seekable.")); @@ -373,8 +375,8 @@ mod _io { #[pymethod(magic)] fn next(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { let line = vm.call_method(&instance, "readline", ())?; - if !objbool::boolval(vm, line.clone())? { - Err(objiter::new_stop_iteration(vm)) + if !pybool::boolval(vm, line.clone())? { + Err(iter::new_stop_iteration(vm)) } else { Ok(line) } @@ -726,7 +728,7 @@ mod _io { let buffered_reader_class = vm.try_class("_io", "BufferedReader")?; let raw = vm.get_attribute(instance, "buffer").unwrap(); - if !objtype::isinstance(&raw, &buffered_reader_class) { + if !pytype::isinstance(&raw, &buffered_reader_class) { // TODO: this should be io.UnsupportedOperation error which derives both from ValueError *and* OSError return Err(vm.new_value_error("not readable".to_owned())); } @@ -750,7 +752,7 @@ mod _io { let buffered_writer_class = vm.try_class("_io", "BufferedWriter")?; let raw = vm.get_attribute(instance, "buffer").unwrap(); - if !objtype::isinstance(&raw, &buffered_writer_class) { + if !pytype::isinstance(&raw, &buffered_writer_class) { // TODO: this should be io.UnsupportedOperation error which derives from ValueError and OSError return Err(vm.new_value_error("not writable".to_owned())); } @@ -758,7 +760,7 @@ mod _io { let bytes = obj.borrow_value().to_owned().into_bytes(); let len = vm.call_method(&raw, "write", (vm.ctx.new_bytes(bytes.clone()),))?; - let len = objint::try_to_primitive(objint::get_value(&len), vm)?; + let len = int::try_to_primitive(int::get_value(&len), vm)?; // returns the count of unicode code points written let len = from_utf8(&bytes[..len]) @@ -777,7 +779,7 @@ mod _io { let buffered_reader_class = vm.try_class("_io", "BufferedReader")?; let raw = vm.get_attribute(instance, "buffer").unwrap(); - if !objtype::isinstance(&raw, &buffered_reader_class) { + if !pytype::isinstance(&raw, &buffered_reader_class) { // TODO: this should be io.UnsupportedOperation error which derives both from ValueError *and* OSError return Err(vm.new_value_error("not readable".to_owned())); } @@ -837,7 +839,7 @@ mod _io { ) -> PyResult { let raw_bytes = object .flatten() - .map_or_else(Vec::new, |v| objstr::borrow_value(&v).as_bytes().to_vec()); + .map_or_else(Vec::new, |v| pystr::borrow_value(&v).as_bytes().to_vec()); StringIO { buffer: PyRwLock::new(BufferedIO::new(Cursor::new(raw_bytes))), @@ -1470,11 +1472,11 @@ mod _io { #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] mod fileio { use super::_io::*; + use crate::builtins::pystr::PyStrRef; + use crate::builtins::pytype::PyTypeRef; use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::exceptions::IntoPyException; use crate::function::{FuncArgs, OptionalArg}; - use crate::obj::objstr::PyStrRef; - use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; diff --git a/vm/src/stdlib/itertools.rs b/vm/src/stdlib/itertools.rs index b4088b693..d6115ba60 100644 --- a/vm/src/stdlib/itertools.rs +++ b/vm/src/stdlib/itertools.rs @@ -8,14 +8,16 @@ mod decl { use std::fmt; use std::iter; + use crate::builtins::int::{self, PyInt, PyIntRef}; + use crate::builtins::iter::{ + call_next, get_all, get_iter, get_next_object, new_stop_iteration, + }; + use crate::builtins::pybool; + use crate::builtins::pytype::{self, PyTypeRef}; + use crate::builtins::tuple::PyTupleRef; use crate::common::lock::{PyMutex, PyRwLock, PyRwLockWriteGuard}; use crate::common::rc::PyRc; use crate::function::{Args, FuncArgs, OptionalArg, OptionalOption}; - use crate::obj::objbool; - use crate::obj::objint::{self, PyInt, PyIntRef}; - use crate::obj::objiter::{call_next, get_all, get_iter, get_next_object, new_stop_iteration}; - use crate::obj::objtuple::PyTupleRef; - use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{ BorrowValue, IdProtocol, IntoPyRef, PyCallable, PyObjectRc, PyObjectRef, PyObjectWeak, PyRef, PyResult, PyValue, TypeProtocol, @@ -72,7 +74,7 @@ mod decl { match call_next(vm, &cur_iter) { Ok(ok) => return Ok(ok), Err(err) => { - if objtype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { + if pytype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { self.cur_idx.fetch_add(1); *self.cached_iter.write() = None; } else { @@ -145,7 +147,7 @@ mod decl { fn next(&self, vm: &VirtualMachine) -> PyResult { loop { let sel_obj = call_next(vm, &self.selector)?; - let verdict = objbool::boolval(vm, sel_obj.clone())?; + let verdict = pybool::boolval(vm, sel_obj.clone())?; let data_obj = call_next(vm, &self.data)?; if verdict { @@ -420,7 +422,7 @@ mod decl { let predicate = &self.predicate; let verdict = vm.invoke(predicate, (obj.clone(),))?; - let verdict = objbool::boolval(vm, verdict)?; + let verdict = pybool::boolval(vm, verdict)?; if verdict { Ok(obj) } else { @@ -479,7 +481,7 @@ mod decl { let obj = call_next(vm, iterable)?; let pred = predicate.clone(); let pred_value = vm.invoke(&pred.into_object(), (obj.clone(),))?; - if !objbool::boolval(vm, pred_value)? { + if !pybool::boolval(vm, pred_value)? { self.start_flag.store(true); return Ok(obj); } @@ -696,9 +698,9 @@ mod decl { } fn pyobject_to_opt_usize(obj: PyObjectRef, vm: &VirtualMachine) -> Option { - let is_int = objtype::isinstance(&obj, &vm.ctx.types.int_type); + let is_int = pytype::isinstance(&obj, &vm.ctx.types.int_type); if is_int { - objint::get_value(&obj).to_usize() + int::get_value(&obj).to_usize() } else { None } @@ -850,7 +852,7 @@ mod decl { vm.invoke(predicate, vec![obj.clone()])? }; - if !objbool::boolval(vm, pred_value)? { + if !pybool::boolval(vm, pred_value)? { return Ok(obj); } } @@ -1522,7 +1524,7 @@ mod decl { let next_obj = match call_next(vm, &self.iterators[idx]) { Ok(obj) => obj, Err(err) => { - if !objtype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { + if !pytype::isinstance(&err, &vm.ctx.exceptions.stop_iteration) { return Err(err); } numactive -= 1; diff --git a/vm/src/stdlib/json.rs b/vm/src/stdlib/json.rs index da77d5318..fd110c442 100644 --- a/vm/src/stdlib/json.rs +++ b/vm/src/stdlib/json.rs @@ -4,11 +4,11 @@ mod machinery; #[pymodule] mod _json { use super::*; + use crate::builtins::iter; + use crate::builtins::pystr::PyStrRef; + use crate::builtins::{pybool, pytype::PyTypeRef}; use crate::exceptions::PyBaseExceptionRef; use crate::function::{FuncArgs, OptionalArg}; - use crate::obj::objiter; - use crate::obj::objstr::PyStrRef; - use crate::obj::{objbool, objtype::PyTypeRef}; use crate::pyobject::{ BorrowValue, IdProtocol, IntoPyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; @@ -41,7 +41,7 @@ mod _json { impl JsonScanner { #[pyslot] fn tp_new(cls: PyTypeRef, ctx: PyObjectRef, vm: &VirtualMachine) -> PyResult> { - let strict = objbool::boolval(vm, vm.get_attribute(ctx.clone(), "strict")?)?; + let strict = pybool::boolval(vm, vm.get_attribute(ctx.clone(), "strict")?)?; let object_hook = vm.option_if_none(vm.get_attribute(ctx.clone(), "object_hook")?); let object_pairs_hook = vm.option_if_none(vm.get_attribute(ctx.clone(), "object_pairs_hook")?); @@ -83,7 +83,7 @@ mod _json { let c = s .chars() .next() - .ok_or_else(|| objiter::stop_iter_with_value(vm.ctx.new_int(idx), vm))?; + .ok_or_else(|| iter::stop_iter_with_value(vm.ctx.new_int(idx), vm))?; let next_idx = idx + c.len_utf8(); match c { '"' => { @@ -151,7 +151,7 @@ mod _json { parse_constant!("Infinity"); parse_constant!("-Infinity"); - Err(objiter::stop_iter_with_value(vm.ctx.new_int(idx), vm)) + Err(iter::stop_iter_with_value(vm.ctx.new_int(idx), vm)) } fn parse_number(&self, s: &str, vm: &VirtualMachine) -> Option<(PyResult, usize)> { @@ -199,7 +199,7 @@ mod _json { if idx > 0 { chars .nth(idx - 1) - .ok_or_else(|| objiter::stop_iter_with_value(vm.ctx.new_int(idx), vm))?; + .ok_or_else(|| iter::stop_iter_with_value(vm.ctx.new_int(idx), vm))?; } zelf.parse( chars.as_str(), diff --git a/vm/src/stdlib/keyword.rs b/vm/src/stdlib/keyword.rs index a57a640c2..50d795a9e 100644 --- a/vm/src/stdlib/keyword.rs +++ b/vm/src/stdlib/keyword.rs @@ -5,7 +5,7 @@ pub(crate) use decl::make_module; mod decl { use rustpython_parser::lexer; - use crate::obj::objstr::PyStrRef; + use crate::builtins::pystr::PyStrRef; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; diff --git a/vm/src/stdlib/marshal.rs b/vm/src/stdlib/marshal.rs index 8187995d2..76b4a0e22 100644 --- a/vm/src/stdlib/marshal.rs +++ b/vm/src/stdlib/marshal.rs @@ -2,11 +2,11 @@ pub(crate) use decl::make_module; #[pymodule(name = "marshal")] mod decl { + use crate::builtins::bytes::PyBytes; + use crate::builtins::code::{PyCode, PyCodeRef}; use crate::bytecode; use crate::byteslike::PyBytesLike; use crate::common::borrow::BorrowValue; - use crate::obj::objbytes::PyBytes; - use crate::obj::objcode::{PyCode, PyCodeRef}; use crate::pyobject::{PyObjectRef, PyResult, TryFromObject}; use crate::vm::VirtualMachine; diff --git a/vm/src/stdlib/math.rs b/vm/src/stdlib/math.rs index eb944c547..45fffe56c 100644 --- a/vm/src/stdlib/math.rs +++ b/vm/src/stdlib/math.rs @@ -9,10 +9,10 @@ use statrs::function::gamma::{gamma, ln_gamma}; use num_bigint::BigInt; use num_traits::{One, Signed, Zero}; +use crate::builtins::float::{self, IntoPyFloat, PyFloatRef}; +use crate::builtins::int::{self, PyInt, PyIntRef}; +use crate::builtins::pytype; use crate::function::{Args, OptionalArg}; -use crate::obj::objfloat::{self, IntoPyFloat, PyFloatRef}; -use crate::obj::objint::{self, PyInt, PyIntRef}; -use crate::obj::objtype; use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TypeProtocol}; use crate::vm::VirtualMachine; use rustpython_common::float_ops; @@ -265,9 +265,9 @@ fn math_trunc(value: PyObjectRef, vm: &VirtualMachine) -> PyResult { /// * `value` - Either a float or a python object which implements __ceil__ /// * `vm` - Represents the python state. fn math_ceil(value: PyObjectRef, vm: &VirtualMachine) -> PyResult { - if objtype::isinstance(&value, &vm.ctx.types.float_type) { - let v = objfloat::get_value(&value); - let v = objfloat::try_bigint(v.ceil(), vm)?; + if pytype::isinstance(&value, &vm.ctx.types.float_type) { + let v = float::get_value(&value); + let v = float::try_bigint(v.ceil(), vm)?; Ok(vm.ctx.new_int(v)) } else { try_magic_method("__ceil__", vm, &value) @@ -281,9 +281,9 @@ fn math_ceil(value: PyObjectRef, vm: &VirtualMachine) -> PyResult { /// * `value` - Either a float or a python object which implements __ceil__ /// * `vm` - Represents the python state. fn math_floor(value: PyObjectRef, vm: &VirtualMachine) -> PyResult { - if objtype::isinstance(&value, &vm.ctx.types.float_type) { - let v = objfloat::get_value(&value); - let v = objfloat::try_bigint(v.floor(), vm)?; + if pytype::isinstance(&value, &vm.ctx.types.float_type) { + let v = float::get_value(&value); + let v = float::try_bigint(v.floor(), vm)?; Ok(vm.ctx.new_int(v)) } else { try_magic_method("__floor__", vm, &value) @@ -307,9 +307,9 @@ fn math_ldexp( ) -> PyResult { let value = match value { Either::A(f) => f.to_f64(), - Either::B(z) => objint::try_float(z.borrow_value(), vm)?, + Either::B(z) => int::try_float(z.borrow_value(), vm)?, }; - Ok(value * (2_f64).powf(objint::try_float(i.borrow_value(), vm)?)) + Ok(value * (2_f64).powf(int::try_float(i.borrow_value(), vm)?)) } fn math_perf_arb_len_int_op(args: Args, op: F, default: BigInt) -> BigInt diff --git a/vm/src/stdlib/msvcrt.rs b/vm/src/stdlib/msvcrt.rs index ce449994a..8401a6160 100644 --- a/vm/src/stdlib/msvcrt.rs +++ b/vm/src/stdlib/msvcrt.rs @@ -1,6 +1,6 @@ use super::os::errno_err; -use crate::obj::objbytes::PyBytesRef; -use crate::obj::objstr::PyStrRef; +use crate::builtins::bytes::PyBytesRef; +use crate::builtins::pystr::PyStrRef; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult}; use crate::VirtualMachine; diff --git a/vm/src/stdlib/operator.rs b/vm/src/stdlib/operator.rs index d09172bd0..14dea746e 100644 --- a/vm/src/stdlib/operator.rs +++ b/vm/src/stdlib/operator.rs @@ -1,20 +1,20 @@ +use crate::builtins::pystr::PyStrRef; +use crate::builtins::{iter, pytype}; use crate::byteslike::PyBytesLike; use crate::function::OptionalArg; -use crate::obj::objstr::PyStrRef; -use crate::obj::{objiter, objtype}; use crate::pyobject::{BorrowValue, Either, PyObjectRef, PyResult, TypeProtocol}; use crate::VirtualMachine; use volatile::Volatile; fn _operator_length_hint(obj: PyObjectRef, default: OptionalArg, vm: &VirtualMachine) -> PyResult { let default = default.unwrap_or_else(|| vm.ctx.new_int(0)); - if !objtype::isinstance(&default, &vm.ctx.types.int_type) { + if !pytype::isinstance(&default, &vm.ctx.types.int_type) { return Err(vm.new_type_error(format!( "'{}' type cannot be interpreted as an integer", default.class().name ))); } - let hint = objiter::length_hint(vm, obj)? + let hint = iter::length_hint(vm, obj)? .map(|i| vm.ctx.new_int(i)) .unwrap_or(default); Ok(hint) diff --git a/vm/src/stdlib/os.rs b/vm/src/stdlib/os.rs index 6124969db..a486ea707 100644 --- a/vm/src/stdlib/os.rs +++ b/vm/src/stdlib/os.rs @@ -10,18 +10,18 @@ use crossbeam_utils::atomic::AtomicCell; use num_traits::ToPrimitive; use super::errno::errors; +use crate::builtins::bytes::{PyBytes, PyBytesRef}; +use crate::builtins::dict::PyDictRef; +use crate::builtins::int::{PyInt, PyIntRef}; +use crate::builtins::iter; +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::set::PySet; +use crate::builtins::tuple::PyTupleRef; use crate::byteslike::PyBytesLike; use crate::common::lock::PyRwLock; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, IntoPyNativeFunc, OptionalArg}; -use crate::obj::objbytes::{PyBytes, PyBytesRef}; -use crate::obj::objdict::PyDictRef; -use crate::obj::objint::{PyInt, PyIntRef}; -use crate::obj::objiter; -use crate::obj::objset::PySet; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, IntoPyObject, ItemProtocol, PyObjectRef, PyRef, PyResult, PyStructSequence, PyValue, TryFromObject, TypeProtocol, @@ -560,7 +560,7 @@ mod _os { #[pymethod(name = "__next__")] fn next(&self, vm: &VirtualMachine) -> PyResult { if self.exhausted.load() { - return Err(objiter::new_stop_iteration(vm)); + return Err(iter::new_stop_iteration(vm)); } match self.entries.write().next() { @@ -575,7 +575,7 @@ mod _os { }, None => { self.exhausted.store(true); - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } } } @@ -981,8 +981,8 @@ fn to_seconds_from_unix_epoch(sys_time: SystemTime) -> f64 { mod posix { use super::*; - use crate::obj::objdict::PyMapping; - use crate::obj::objlist::PyListRef; + use crate::builtins::dict::PyMapping; + use crate::builtins::list::PyListRef; use crate::pyobject::PyIterable; use bitflags::bitflags; use nix::errno::Errno; @@ -2202,7 +2202,7 @@ pub(crate) use posix::raw_set_inheritable; #[pymodule] mod nt { use super::*; - use crate::obj::objlist::PyListRef; + use crate::builtins::list::PyListRef; pub(super) use std::os::windows::fs::OpenOptionsExt; use std::os::windows::io::RawHandle; #[cfg(target_env = "msvc")] diff --git a/vm/src/stdlib/pwd.rs b/vm/src/stdlib/pwd.rs index 090f562f7..994d7561e 100644 --- a/vm/src/stdlib/pwd.rs +++ b/vm/src/stdlib/pwd.rs @@ -1,6 +1,6 @@ +use crate::builtins::int::PyIntRef; +use crate::builtins::pystr::PyStrRef; use crate::exceptions::IntoPyException; -use crate::obj::objint::PyIntRef; -use crate::obj::objstr::PyStrRef; use crate::pyobject::{BorrowValue, PyClassImpl, PyObjectRef, PyResult, PyStructSequence}; use crate::vm::VirtualMachine; use std::convert::TryFrom; diff --git a/vm/src/stdlib/pystruct.rs b/vm/src/stdlib/pystruct.rs index 1afee01a7..4d6832541 100644 --- a/vm/src/stdlib/pystruct.rs +++ b/vm/src/stdlib/pystruct.rs @@ -22,13 +22,13 @@ pub(crate) mod _struct { use std::io::{Cursor, Read, Write}; use std::iter::Peekable; + use crate::builtins::{ + bytes::PyBytesRef, iter, pybool::IntoPyBool, pystr::PyStr, pystr::PyStrRef, + pytype::PyTypeRef, tuple::PyTupleRef, + }; use crate::byteslike::{PyBytesLike, PyRwBytesLike}; use crate::exceptions::PyBaseExceptionRef; use crate::function::Args; - use crate::obj::{ - objbool::IntoPyBool, objbytes::PyBytesRef, objiter, objstr::PyStr, objstr::PyStrRef, - objtuple::PyTupleRef, objtype::PyTypeRef, - }; use crate::pyobject::{ BorrowValue, Either, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; @@ -853,7 +853,7 @@ pub(crate) mod _struct { let size = self.format_spec.size(); let offset = self.offset.fetch_add(size); if offset + size > self.buffer.len() { - Err(objiter::new_stop_iteration(vm)) + Err(iter::new_stop_iteration(vm)) } else { self.buffer .with_ref(|buf| self.format_spec.unpack(&buf[offset..offset + size], vm)) diff --git a/vm/src/stdlib/random.rs b/vm/src/stdlib/random.rs index 0bbe1583d..9da2a83fc 100644 --- a/vm/src/stdlib/random.rs +++ b/vm/src/stdlib/random.rs @@ -4,10 +4,10 @@ pub(crate) use _random::make_module; #[pymodule] mod _random { + use crate::builtins::int::PyIntRef; + use crate::builtins::pytype::PyTypeRef; use crate::common::lock::PyMutex; use crate::function::OptionalOption; - use crate::obj::objint::PyIntRef; - use crate::obj::objtype::PyTypeRef; use crate::pyobject::{BorrowValue, PyRef, PyResult, PyValue}; use crate::VirtualMachine; use num_bigint::{BigInt, Sign}; diff --git a/vm/src/stdlib/re.rs b/vm/src/stdlib/re.rs index bd6b65f30..747511b96 100644 --- a/vm/src/stdlib/re.rs +++ b/vm/src/stdlib/re.rs @@ -9,10 +9,10 @@ use regex::bytes::{Captures, Regex, RegexBuilder}; use std::fmt; use std::ops::Range; +use crate::builtins::int::{PyInt, PyIntRef}; +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::PyTypeRef; use crate::function::{Args, OptionalArg}; -use crate::obj::objint::{PyInt, PyIntRef}; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, IntoPyObject, PyClassImpl, PyObjectRef, PyResult, PyValue, TryFromObject, }; diff --git a/vm/src/stdlib/serde_json.rs b/vm/src/stdlib/serde_json.rs index 6b2d6f103..20d4af320 100644 --- a/vm/src/stdlib/serde_json.rs +++ b/vm/src/stdlib/serde_json.rs @@ -2,9 +2,9 @@ pub(crate) use _serde_json::make_module; #[pymodule] mod _serde_json { + use crate::builtins::pystr::PyStrRef; use crate::common::borrow::BorrowValue; use crate::exceptions::PyBaseExceptionRef; - use crate::obj::objstr::PyStrRef; use crate::py_serde; use crate::pyobject::{PyResult, TryFromObject}; use crate::VirtualMachine; diff --git a/vm/src/stdlib/socket.rs b/vm/src/stdlib/socket.rs index 2da826e96..fd2acf643 100644 --- a/vm/src/stdlib/socket.rs +++ b/vm/src/stdlib/socket.rs @@ -10,14 +10,14 @@ use gethostname::gethostname; use nix::unistd::sethostname; use socket2::{Domain, Protocol, Socket, Type as SocketType}; +use crate::builtins::bytearray::PyByteArrayRef; +use crate::builtins::bytes::PyBytesRef; +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::tuple::PyTupleRef; use crate::byteslike::PyBytesLike; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, OptionalArg}; -use crate::obj::objbytearray::PyByteArrayRef; -use crate::obj::objbytes::PyBytesRef; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, IntoPyObject, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, diff --git a/vm/src/stdlib/ssl.rs b/vm/src/stdlib/ssl.rs index 7fd8b6e41..09a877fd6 100644 --- a/vm/src/stdlib/ssl.rs +++ b/vm/src/stdlib/ssl.rs @@ -1,11 +1,11 @@ use super::socket::PySocketRef; +use crate::builtins::bytearray::PyByteArrayRef; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::{pytype::PyTypeRef, weakref::PyWeak}; use crate::byteslike::PyBytesLike; use crate::common::lock::{PyRwLock, PyRwLockWriteGuard}; use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::OptionalArg; -use crate::obj::objbytearray::PyByteArrayRef; -use crate::obj::objstr::PyStrRef; -use crate::obj::{objtype::PyTypeRef, objweakref::PyWeak}; use crate::pyobject::{ BorrowValue, Either, IntoPyObject, ItemProtocol, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, @@ -113,7 +113,7 @@ fn obj2py(obj: &Asn1ObjectRef) -> PyNid { #[cfg(windows)] fn ssl_enum_certificates(store_name: PyStrRef, vm: &VirtualMachine) -> PyResult { - use crate::obj::objset::PyFrozenSet; + use crate::builtins::set::PyFrozenSet; use schannel::{cert_context::ValidUses, cert_store::CertStore, RawPointer}; use winapi::um::wincrypt; // TODO: check every store for it, not just 2 of them: diff --git a/vm/src/stdlib/string.rs b/vm/src/stdlib/string.rs index 6a4db956b..532ffeb05 100644 --- a/vm/src/stdlib/string.rs +++ b/vm/src/stdlib/string.rs @@ -7,12 +7,12 @@ pub(crate) use _string::make_module; mod _string { use std::mem; + use crate::builtins::list::PyList; + use crate::builtins::pystr::PyStrRef; use crate::exceptions::IntoPyException; use crate::format::{ FieldName, FieldNamePart, FieldType, FormatPart, FormatString, FromTemplate, }; - use crate::obj::objlist::PyList; - use crate::obj::objstr::PyStrRef; use crate::pyobject::{BorrowValue, IntoPyObject, PyObjectRef, PyResult}; use crate::vm::VirtualMachine; diff --git a/vm/src/stdlib/symtable.rs b/vm/src/stdlib/symtable.rs index 0826603de..ebbec6720 100644 --- a/vm/src/stdlib/symtable.rs +++ b/vm/src/stdlib/symtable.rs @@ -4,8 +4,8 @@ pub(crate) use decl::make_module; mod decl { use std::fmt; - use crate::obj::objstr::PyStrRef; - use crate::obj::objtype::PyTypeRef; + use crate::builtins::pystr::PyStrRef; + use crate::builtins::pytype::PyTypeRef; use crate::pyobject::{BorrowValue, PyRef, PyResult, PyValue}; use crate::vm::VirtualMachine; use rustpython_compiler::{compile, error::CompileError, symboltable}; diff --git a/vm/src/stdlib/thread.rs b/vm/src/stdlib/thread.rs index 817c7e635..ac4c7cab5 100644 --- a/vm/src/stdlib/thread.rs +++ b/vm/src/stdlib/thread.rs @@ -1,10 +1,10 @@ +use crate::builtins::dict::PyDictRef; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::tuple::PyTupleRef; /// Implementation of the _thread module use crate::exceptions::{self, IntoPyException}; use crate::function::{FuncArgs, OptionalArg}; -use crate::obj::objdict::PyDictRef; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, IdProtocol, ItemProtocol, PyCallable, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TypeProtocol, diff --git a/vm/src/stdlib/time_module.rs b/vm/src/stdlib/time_module.rs index b5e41594d..15b005a27 100644 --- a/vm/src/stdlib/time_module.rs +++ b/vm/src/stdlib/time_module.rs @@ -7,10 +7,10 @@ use std::time::{Duration, SystemTime, UNIX_EPOCH}; use chrono::naive::{NaiveDate, NaiveDateTime, NaiveTime}; use chrono::{Datelike, Timelike}; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; +use crate::builtins::tuple::PyTupleRef; use crate::function::OptionalArg; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtuple::PyTupleRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, Either, PyClassImpl, PyObjectRef, PyResult, PyStructSequence, TryFromObject, }; diff --git a/vm/src/stdlib/tokenize.rs b/vm/src/stdlib/tokenize.rs index 674a71756..b6bdcf2be 100644 --- a/vm/src/stdlib/tokenize.rs +++ b/vm/src/stdlib/tokenize.rs @@ -8,7 +8,7 @@ pub(crate) use decl::make_module; mod decl { use std::iter::FromIterator; - use crate::obj::objstr::PyStrRef; + use crate::builtins::pystr::PyStrRef; use crate::pyobject::{BorrowValue, PyResult}; use crate::vm::VirtualMachine; use rustpython_parser::lexer; diff --git a/vm/src/stdlib/unicodedata.rs b/vm/src/stdlib/unicodedata.rs index a37f57e48..7b3e5ddd4 100644 --- a/vm/src/stdlib/unicodedata.rs +++ b/vm/src/stdlib/unicodedata.rs @@ -2,9 +2,9 @@ See also: https://docs.python.org/3/library/unicodedata.html */ +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; use crate::function::OptionalArg; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{BorrowValue, PyClassImpl, PyObject, PyObjectRef, PyResult, PyValue}; use crate::vm::VirtualMachine; diff --git a/vm/src/stdlib/warnings.rs b/vm/src/stdlib/warnings.rs index 4ae76b5ef..65324ecac 100644 --- a/vm/src/stdlib/warnings.rs +++ b/vm/src/stdlib/warnings.rs @@ -2,9 +2,9 @@ pub(crate) use _warnings::make_module; #[pymodule] mod _warnings { + use crate::builtins::pystr::PyStrRef; + use crate::builtins::pytype::{self, PyTypeRef}; use crate::function::OptionalArg; - use crate::obj::objstr::PyStrRef; - use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{PyResult, TypeProtocol}; use crate::vm::VirtualMachine; @@ -23,7 +23,7 @@ mod _warnings { // TODO: Implement correctly let level = args.stacklevel.unwrap_or(1); let category = if let OptionalArg::Present(category) = args.category { - if !objtype::issubclass(&category, &vm.ctx.exceptions.warning) { + if !pytype::issubclass(&category, &vm.ctx.exceptions.warning) { return Err(vm.new_type_error(format!( "category must be a Warning subclass, not '{}'", category.class().name diff --git a/vm/src/stdlib/winapi.rs b/vm/src/stdlib/winapi.rs index 053da7d86..99c2d7ffe 100644 --- a/vm/src/stdlib/winapi.rs +++ b/vm/src/stdlib/winapi.rs @@ -10,9 +10,9 @@ use winapi::um::{ }; use super::os::errno_err; +use crate::builtins::dict::{PyDictRef, PyMapping}; +use crate::builtins::pystr::PyStrRef; use crate::function::OptionalArg; -use crate::obj::objdict::{PyDictRef, PyMapping}; -use crate::obj::objstr::PyStrRef; use crate::pyobject::{BorrowValue, PyObjectRef, PyResult, PySequence, TryFromObject}; use crate::VirtualMachine; diff --git a/vm/src/stdlib/winreg.rs b/vm/src/stdlib/winreg.rs index 00fcf5948..29a86072b 100644 --- a/vm/src/stdlib/winreg.rs +++ b/vm/src/stdlib/winreg.rs @@ -1,9 +1,9 @@ #![allow(non_snake_case)] +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; use crate::common::lock::{PyRwLock, PyRwLockReadGuard, PyRwLockWriteGuard}; use crate::exceptions::IntoPyException; use crate::function::OptionalArg; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ BorrowValue, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; diff --git a/vm/src/stdlib/zlib.rs b/vm/src/stdlib/zlib.rs index 250db33ba..37e090a4c 100644 --- a/vm/src/stdlib/zlib.rs +++ b/vm/src/stdlib/zlib.rs @@ -2,12 +2,12 @@ pub(crate) use decl::make_module; #[pymodule(name = "zlib")] mod decl { + use crate::builtins::bytes::{PyBytes, PyBytesRef}; + use crate::builtins::pytype::PyTypeRef; use crate::byteslike::PyBytesLike; use crate::common::lock::PyMutex; use crate::exceptions::PyBaseExceptionRef; use crate::function::OptionalArg; - use crate::obj::objbytes::{PyBytes, PyBytesRef}; - use crate::obj::objtype::PyTypeRef; use crate::pyobject::{BorrowValue, IntoPyRef, PyResult, PyValue}; use crate::types::create_type; use crate::vm::VirtualMachine; diff --git a/vm/src/sysmodule.rs b/vm/src/sysmodule.rs index 44fc0f640..574f296ad 100644 --- a/vm/src/sysmodule.rs +++ b/vm/src/sysmodule.rs @@ -1,11 +1,11 @@ use num_traits::ToPrimitive; use std::{env, mem, path}; +use crate::builtins::pystr::PyStrRef; +use crate::builtins::pytype::PyTypeRef; use crate::common::hash::{PyHash, PyUHash}; use crate::frame::FrameRef; use crate::function::{Args, FuncArgs, OptionalArg}; -use crate::obj::objstr::PyStrRef; -use crate::obj::objtype::PyTypeRef; use crate::pyobject::{ IntoPyObject, ItemProtocol, PyClassImpl, PyContext, PyObjectRc, PyObjectRef, PyResult, PyStructSequence, @@ -275,7 +275,7 @@ struct WindowsVersion { impl WindowsVersion {} #[cfg(windows)] -fn sys_getwindowsversion(vm: &VirtualMachine) -> PyResult { +fn sys_getwindowsversion(vm: &VirtualMachine) -> PyResult { use std::ffi::OsString; use std::os::windows::ffi::OsStringExt; use winapi::um::{ diff --git a/vm/src/types.rs b/vm/src/types.rs index 80ccf7cf1..c83b88633 100644 --- a/vm/src/types.rs +++ b/vm/src/types.rs @@ -1,43 +1,43 @@ -use crate::obj::objasyncgenerator; -use crate::obj::objbool; -use crate::obj::objbuiltinfunc; -use crate::obj::objbytearray; -use crate::obj::objbytes; -use crate::obj::objclassmethod; -use crate::obj::objcode; -use crate::obj::objcomplex; -use crate::obj::objcoroutine; -use crate::obj::objdict; -use crate::obj::objenumerate; -use crate::obj::objfilter; -use crate::obj::objfloat; -use crate::obj::objframe; -use crate::obj::objfunction; -use crate::obj::objgenerator; -use crate::obj::objgetset; -use crate::obj::objint; -use crate::obj::objiter; -use crate::obj::objlist; -use crate::obj::objmap; -use crate::obj::objmappingproxy; -use crate::obj::objmemory; -use crate::obj::objmodule; -use crate::obj::objnamespace; -use crate::obj::objobject; -use crate::obj::objproperty; -use crate::obj::objrange; -use crate::obj::objset; -use crate::obj::objsingletons; -use crate::obj::objslice; -use crate::obj::objstaticmethod; -use crate::obj::objstr; -use crate::obj::objsuper; -use crate::obj::objtraceback; -use crate::obj::objtuple; -use crate::obj::objtype::{self, PyType, PyTypeRef}; -use crate::obj::objweakproxy; -use crate::obj::objweakref; -use crate::obj::objzip; +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::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::pyobject::{ PyAttributes, PyClassDef, PyClassImpl, PyContext, PyObject, PyObjectRc, PyObjectRef, }; @@ -135,71 +135,71 @@ impl TypeZoo { }; } - let int_type = create_type!(objint::PyInt); + let int_type = create_type!(int::PyInt); Self { - async_generator: create_type!(objasyncgenerator::PyAsyncGen), - async_generator_asend: create_type!(objasyncgenerator::PyAsyncGenASend), - async_generator_athrow: create_type!(objasyncgenerator::PyAsyncGenAThrow), - async_generator_wrapped_value: create_type!(objasyncgenerator::PyAsyncGenWrappedValue), - bool_type: create_type!(objbool::PyBool, int_type), - bound_method_type: create_type!(objfunction::PyBoundMethod), - builtin_function_or_method_type: create_type!(objbuiltinfunc::PyBuiltinFunction), - bytearray_type: create_type!(objbytearray::PyByteArray), - bytearray_iterator_type: create_type!(objbytearray::PyByteArrayIterator), - bytes_type: create_type!(objbytes::PyBytes), - bytes_iterator_type: create_type!(objbytes::PyBytesIterator), - callable_iterator: create_type!(objiter::PyCallableIterator), - classmethod_type: create_type!(objclassmethod::PyClassMethod), - code_type: create_type!(objcode::PyCodeRef), - complex_type: create_type!(objcomplex::PyComplex), - coroutine_type: create_type!(objcoroutine::PyCoroutine), - coroutine_wrapper_type: create_type!(objcoroutine::PyCoroutineWrapper), - dict_type: create_type!(objdict::PyDict), - dict_keys_type: create_type!(objdict::PyDictKeys), - dict_values_type: create_type!(objdict::PyDictValues), - dict_items_type: create_type!(objdict::PyDictItems), - dict_keyiterator_type: create_type!(objdict::PyDictKeyIterator), - dict_reversekeyiterator_type: create_type!(objdict::PyDictReverseKeyIterator), - dict_valueiterator_type: create_type!(objdict::PyDictValueIterator), - dict_reversevalueiterator_type: create_type!(objdict::PyDictReverseValueIterator), - dict_itemiterator_type: create_type!(objdict::PyDictItemIterator), - dict_reverseitemiterator_type: create_type!(objdict::PyDictReverseItemIterator), - enumerate_type: create_type!(objenumerate::PyEnumerate), - filter_type: create_type!(objfilter::PyFilter), - float_type: create_type!(objfloat::PyFloat), + async_generator: create_type!(asyncgenerator::PyAsyncGen), + async_generator_asend: create_type!(asyncgenerator::PyAsyncGenASend), + async_generator_athrow: create_type!(asyncgenerator::PyAsyncGenAThrow), + async_generator_wrapped_value: create_type!(asyncgenerator::PyAsyncGenWrappedValue), + bool_type: create_type!(pybool::PyBool, int_type), + bound_method_type: create_type!(function::PyBoundMethod), + builtin_function_or_method_type: create_type!(builtinfunc::PyBuiltinFunction), + bytearray_type: create_type!(bytearray::PyByteArray), + bytearray_iterator_type: create_type!(bytearray::PyByteArrayIterator), + bytes_type: create_type!(bytes::PyBytes), + bytes_iterator_type: create_type!(bytes::PyBytesIterator), + callable_iterator: create_type!(iter::PyCallableIterator), + classmethod_type: create_type!(classmethod::PyClassMethod), + code_type: create_type!(code::PyCodeRef), + complex_type: create_type!(complex::PyComplex), + coroutine_type: create_type!(coroutine::PyCoroutine), + coroutine_wrapper_type: create_type!(coroutine::PyCoroutineWrapper), + dict_type: create_type!(dict::PyDict), + dict_keys_type: create_type!(dict::PyDictKeys), + dict_values_type: create_type!(dict::PyDictValues), + dict_items_type: create_type!(dict::PyDictItems), + dict_keyiterator_type: create_type!(dict::PyDictKeyIterator), + dict_reversekeyiterator_type: create_type!(dict::PyDictReverseKeyIterator), + dict_valueiterator_type: create_type!(dict::PyDictValueIterator), + dict_reversevalueiterator_type: create_type!(dict::PyDictReverseValueIterator), + dict_itemiterator_type: create_type!(dict::PyDictItemIterator), + dict_reverseitemiterator_type: create_type!(dict::PyDictReverseItemIterator), + enumerate_type: create_type!(enumerate::PyEnumerate), + filter_type: create_type!(filter::PyFilter), + float_type: create_type!(float::PyFloat), frame_type: create_type!(crate::frame::FrameRef), - frozenset_type: create_type!(objset::PyFrozenSet), - function_type: create_type!(objfunction::PyFunction), - generator_type: create_type!(objgenerator::PyGenerator), - getset_type: create_type!(objgetset::PyGetSet), + frozenset_type: create_type!(set::PyFrozenSet), + function_type: create_type!(function::PyFunction), + generator_type: create_type!(generator::PyGenerator), + getset_type: create_type!(getset::PyGetSet), int_type, - iter_type: create_type!(objiter::PySequenceIterator), - list_type: create_type!(objlist::PyList), - list_iterator_type: create_type!(objlist::PyListIterator), - list_reverseiterator_type: create_type!(objlist::PyListReverseIterator), - map_type: create_type!(objmap::PyMap), - mappingproxy_type: create_type!(objmappingproxy::PyMappingProxy), - memoryview_type: create_type!(objmemory::PyMemoryView), - module_type: create_type!(objmodule::PyModule), - namespace_type: create_type!(objnamespace::PyNamespace), - property_type: create_type!(objproperty::PyProperty), - range_type: create_type!(objrange::PyRange), - range_iterator_type: create_type!(objrange::PyRangeIterator), - set_type: create_type!(objset::PySet), - set_iterator_type: create_type!(objset::PySetIterator), - slice_type: create_type!(objslice::PySlice), - staticmethod_type: create_type!(objstaticmethod::PyStaticMethod), - str_type: create_type!(objstr::PyStr), - str_iterator_type: create_type!(objstr::PyStrIterator), - str_reverseiterator_type: create_type!(objstr::PyStrReverseIterator), - super_type: create_type!(objsuper::PySuper), - traceback_type: create_type!(objtraceback::PyTraceback), - tuple_type: create_type!(objtuple::PyTuple), - tuple_iterator_type: create_type!(objtuple::PyTupleIterator), - weakproxy_type: create_type!(objweakproxy::PyWeakProxy), - weakref_type: create_type!(objweakref::PyWeak), - method_descriptor_type: create_type!(objbuiltinfunc::PyBuiltinMethod), - zip_type: create_type!(objzip::PyZip), + iter_type: create_type!(iter::PySequenceIterator), + list_type: create_type!(list::PyList), + list_iterator_type: create_type!(list::PyListIterator), + list_reverseiterator_type: create_type!(list::PyListReverseIterator), + map_type: create_type!(map::PyMap), + mappingproxy_type: create_type!(mappingproxy::PyMappingProxy), + memoryview_type: create_type!(memory::PyMemoryView), + module_type: create_type!(module::PyModule), + namespace_type: create_type!(namespace::PyNamespace), + property_type: create_type!(property::PyProperty), + range_type: create_type!(range::PyRange), + range_iterator_type: create_type!(range::PyRangeIterator), + set_type: create_type!(set::PySet), + set_iterator_type: create_type!(set::PySetIterator), + slice_type: create_type!(slice::PySlice), + staticmethod_type: create_type!(staticmethod::PyStaticMethod), + str_type: create_type!(pystr::PyStr), + str_iterator_type: create_type!(pystr::PyStrIterator), + str_reverseiterator_type: create_type!(pystr::PyStrReverseIterator), + super_type: create_type!(pysuper::PySuper), + traceback_type: create_type!(traceback::PyTraceback), + tuple_type: create_type!(tuple::PyTuple), + tuple_iterator_type: create_type!(tuple::PyTupleIterator), + weakproxy_type: create_type!(weakproxy::PyWeakProxy), + weakref_type: create_type!(weakref::PyWeak), + method_descriptor_type: create_type!(builtinfunc::PyBuiltinMethod), + zip_type: create_type!(zip::PyZip), type_type, object_type, } @@ -217,7 +217,7 @@ pub fn create_type_with_slots( slots: PyTypeSlots, ) -> PyTypeRef { let dict = PyAttributes::new(); - objtype::new( + pytype::new( type_type.clone(), name, base.clone(), @@ -267,16 +267,16 @@ fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef) { mro: vec![], subclasses: PyRwLock::default(), attributes: PyRwLock::new(PyAttributes::new()), - slots: objtype::PyType::make_slots(), + slots: pytype::PyType::make_slots(), }; let object_payload = PyType { - name: objobject::PyBaseObject::NAME.to_owned(), + name: object::PyBaseObject::NAME.to_owned(), base: None, bases: vec![], mro: vec![], subclasses: PyRwLock::default(), attributes: PyRwLock::new(PyAttributes::new()), - slots: objobject::PyBaseObject::make_slots(), + slots: object::PyBaseObject::make_slots(), }; let type_type: PyRc> = PyRc::new(partially_init!( PyObject:: { @@ -324,51 +324,51 @@ fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef) { object_type .subclasses .write() - .push(objweakref::PyWeak::downgrade(&type_type.as_object())); + .push(weakref::PyWeak::downgrade(&type_type.as_object())); (type_type, object_type) } /// Fill attributes of builtin types. pub fn initialize_types(context: &PyContext) { - objtype::init(&context); - objobject::init(&context); - objlist::init(&context); - objset::init(&context); - objtuple::init(&context); - objdict::init(&context); - objbuiltinfunc::init(&context); - objfunction::init(&context); - objstaticmethod::init(&context); - objclassmethod::init(&context); - objgenerator::init(&context); - objcoroutine::init(&context); - objasyncgenerator::init(&context); - objint::init(&context); - objfloat::init(&context); - objcomplex::init(&context); - objbytes::init(&context); - objbytearray::init(&context); - objproperty::init(&context); - objgetset::init(&context); - objmemory::init(&context); - objstr::init(&context); - objrange::init(&context); - objslice::init(&context); - objsuper::init(&context); - objiter::init(&context); - objenumerate::init(&context); - objfilter::init(&context); - objmap::init(&context); - objzip::init(&context); - objbool::init(&context); - objcode::init(&context); - objframe::init(&context); - objweakref::init(&context); - objweakproxy::init(&context); - objsingletons::init(&context); - objmodule::init(&context); - objnamespace::init(&context); - objmappingproxy::init(&context); - objtraceback::init(&context); + pytype::init(&context); + object::init(&context); + list::init(&context); + set::init(&context); + tuple::init(&context); + dict::init(&context); + builtinfunc::init(&context); + function::init(&context); + staticmethod::init(&context); + classmethod::init(&context); + generator::init(&context); + coroutine::init(&context); + asyncgenerator::init(&context); + int::init(&context); + float::init(&context); + complex::init(&context); + bytes::init(&context); + bytearray::init(&context); + property::init(&context); + getset::init(&context); + memory::init(&context); + pystr::init(&context); + range::init(&context); + slice::init(&context); + pysuper::init(&context); + iter::init(&context); + enumerate::init(&context); + filter::init(&context); + map::init(&context); + zip::init(&context); + pybool::init(&context); + code::init(&context); + frame::init(&context); + weakref::init(&context); + weakproxy::init(&context); + singletons::init(&context); + module::init(&context); + namespace::init(&context); + mappingproxy::init(&context); + traceback::init(&context); } diff --git a/vm/src/version.rs b/vm/src/version.rs index b98a0c061..9ff6ec7c2 100644 --- a/vm/src/version.rs +++ b/vm/src/version.rs @@ -46,7 +46,7 @@ impl VersionInfo { }; #[pyslot] fn tp_new( - _cls: crate::obj::objtype::PyTypeRef, + _cls: crate::builtins::pytype::PyTypeRef, _args: crate::function::FuncArgs, vm: &crate::VirtualMachine, ) -> crate::pyobject::PyResult { diff --git a/vm/src/vm.rs b/vm/src/vm.rs index 4fd10b230..29cb39da0 100644 --- a/vm/src/vm.rs +++ b/vm/src/vm.rs @@ -13,6 +13,17 @@ use arr_macro::arr; use crossbeam_utils::atomic::AtomicCell; use num_traits::{Signed, ToPrimitive}; +use crate::builtins::code::{PyCode, PyCodeRef}; +use crate::builtins::dict::PyDictRef; +use crate::builtins::int::{PyInt, PyIntRef}; +use crate::builtins::iter; +use crate::builtins::list::PyList; +use crate::builtins::module::{self, PyModule}; +use crate::builtins::object; +use crate::builtins::pybool; +use crate::builtins::pystr::{PyStr, PyStrRef}; +use crate::builtins::pytype::{self, PyTypeRef}; +use crate::builtins::tuple::PyTuple; use crate::builtins::{self, to_ascii}; use crate::bytecode; use crate::common::{hash::HashSecret, lock::PyMutex, rc::PyRc}; @@ -21,17 +32,6 @@ use crate::frame::{ExecutionResult, Frame, FrameRef}; use crate::frozen; use crate::function::{FuncArgs, IntoFuncArgs}; use crate::import; -use crate::obj::objbool; -use crate::obj::objcode::{PyCode, PyCodeRef}; -use crate::obj::objdict::PyDictRef; -use crate::obj::objint::{PyInt, PyIntRef}; -use crate::obj::objiter; -use crate::obj::objlist::PyList; -use crate::obj::objmodule::{self, PyModule}; -use crate::obj::objobject; -use crate::obj::objstr::{PyStr, PyStrRef}; -use crate::obj::objtuple::PyTuple; -use crate::obj::objtype::{self, PyTypeRef}; use crate::pyobject::{ BorrowValue, Either, IdProtocol, IntoPyObject, ItemProtocol, PyArithmaticValue, PyContext, PyObject, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, TryIntoRef, TypeProtocol, @@ -46,7 +46,7 @@ use rustpython_compiler::{ error::CompileError, }; -// use objects::objects; +// use objects::ects; // Objects are live when they are on stack, or referenced by a name (for now) @@ -97,7 +97,7 @@ pub(crate) mod thread { let vm_owns_obj = |intp: NonNull| { // SAFETY: all references in VM_STACK should be valid let vm = unsafe { intp.as_ref() }; - crate::obj::objtype::isinstance(obj, &vm.ctx.types.object_type) + crate::builtins::pytype::isinstance(obj, &vm.ctx.types.object_type) }; VM_STACK.with(|vms| { let intp = match vms.borrow().iter().copied().exactly_one() { @@ -290,13 +290,13 @@ impl VirtualMachine { initialized: false, }; - objmodule::init_module_dict( + module::init_module_dict( &vm, &builtins_dict, vm.ctx.new_str("builtins"), vm.ctx.none(), ); - objmodule::init_module_dict(&vm, &sysmod_dict, vm.ctx.new_str("sys"), vm.ctx.none()); + module::init_module_dict(&vm, &sysmod_dict, vm.ctx.new_str("sys"), vm.ctx.none()); vm } @@ -418,7 +418,7 @@ impl VirtualMachine { for (func, args) in self.state.atexit_funcs.lock().drain(..).rev() { if let Err(e) = self.invoke(&func, args) { last_exc = Some(e.clone()); - if !objtype::isinstance(&e, &self.ctx.exceptions.system_exit) { + if !pytype::isinstance(&e, &self.ctx.exceptions.system_exit) { writeln!(sysmodule::PyStderr(self), "Error in atexit._run_exitfuncs:"); exceptions::print_exception(self, e); } @@ -509,7 +509,7 @@ impl VirtualMachine { } pub fn new_module(&self, name: &str, dict: PyDictRef) -> PyObjectRef { - objmodule::init_module_dict( + module::init_module_dict( self, &dict, self.new_pyobj(name.to_owned()), @@ -854,7 +854,7 @@ impl VirtualMachine { Ok(true) } else { let ret = self.call_method(cls.as_object(), "__instancecheck__", (obj.clone(),))?; - objbool::boolval(self, ret) + pybool::boolval(self, ret) } } @@ -862,7 +862,7 @@ impl VirtualMachine { /// via the __subclasscheck__ magic method. pub fn issubclass(&self, subclass: &PyTypeRef, cls: &PyTypeRef) -> PyResult { let ret = self.call_method(cls.as_object(), "__subclasscheck__", (subclass.clone(),))?; - objbool::boolval(self, ret) + pybool::boolval(self, ret) } pub fn call_get_descriptor_specific( @@ -984,8 +984,8 @@ impl VirtualMachine { .map(|obj| T::try_from_object(self, obj.clone())) .collect() } else { - let iter = objiter::get_iter(self, value)?; - objiter::get_all(self, &iter) + let iter = iter::get_iter(self, value)?; + iter::get_all(self, &iter) } } @@ -1434,7 +1434,7 @@ impl VirtualMachine { let is_strict_subclass = { let v_class = v.class(); let w_class = w.class(); - !v_class.is(&w_class) && objtype::issubclass(&w_class, &v_class) + !v_class.is(&w_class) && pytype::issubclass(&w_class, &v_class) }; if is_strict_subclass { let res = call_cmp(w, v, swapped)?; @@ -1462,7 +1462,7 @@ impl VirtualMachine { pub fn bool_cmp(&self, a: &PyObjectRef, b: &PyObjectRef, op: PyComparisonOp) -> PyResult { match self._cmp(a, b, op)? { - Either::A(obj) => objbool::boolval(self, obj), + Either::A(obj) => pybool::boolval(self, obj), Either::B(b) => Ok(b), } } @@ -1503,9 +1503,9 @@ impl VirtualMachine { // https://docs.python.org/3/reference/expressions.html#membership-test-operations fn _membership_iter_search(&self, haystack: PyObjectRef, needle: PyObjectRef) -> PyResult { - let iter = objiter::get_iter(self, &haystack)?; + let iter = iter::get_iter(self, &haystack)?; loop { - if let Some(element) = objiter::get_next_object(self, &iter)? { + if let Some(element) = iter::get_next_object(self, &iter)? { if self.bool_eq(&needle, &element)? { return Ok(self.ctx.new_bool(true)); } else { @@ -1580,7 +1580,7 @@ impl VirtualMachine { attr_value: impl Into, ) -> PyResult<()> { let val = attr_value.into(); - objobject::setattr(module.clone(), attr_name.try_into_ref(self)?, val, self) + object::setattr(module.clone(), attr_name.try_into_ref(self)?, val, self) } } @@ -1700,7 +1700,7 @@ impl PyThread { #[cfg(test)] mod tests { use super::Interpreter; - use crate::obj::{objint, objstr}; + use crate::builtins::{int, pystr}; use num_bigint::ToBigInt; #[test] @@ -1709,7 +1709,7 @@ mod tests { let a = vm.ctx.new_int(33_i32); let b = vm.ctx.new_int(12_i32); let res = vm._add(&a, &b).unwrap(); - let value = objint::get_value(&res); + let value = int::get_value(&res); assert_eq!(*value, 45_i32.to_bigint().unwrap()); }) } @@ -1720,7 +1720,7 @@ mod tests { let a = vm.ctx.new_str(String::from("Hello ")); let b = vm.ctx.new_int(4_i32); let res = vm._mul(&a, &b).unwrap(); - let value = objstr::borrow_value(&res); + let value = pystr::borrow_value(&res); assert_eq!(value, String::from("Hello Hello Hello Hello ")) }) } diff --git a/wasm/lib/src/browser_module.rs b/wasm/lib/src/browser_module.rs index 0d3b457f5..4ed01294b 100644 --- a/wasm/lib/src/browser_module.rs +++ b/wasm/lib/src/browser_module.rs @@ -4,10 +4,10 @@ use wasm_bindgen::prelude::*; use wasm_bindgen::JsCast; use wasm_bindgen_futures::{future_to_promise, JsFuture}; +use rustpython_vm::builtins::{dict::PyDictRef, pystr::PyStrRef, pytype::PyTypeRef}; use rustpython_vm::common::rc::PyRc; use rustpython_vm::function::OptionalArg; use rustpython_vm::import::import_file; -use rustpython_vm::obj::{objdict::PyDictRef, objstr::PyStrRef, objtype::PyTypeRef}; use rustpython_vm::pyobject::{ BorrowValue, IntoPyObject, PyCallable, PyClassImpl, PyObject, PyObjectRef, PyRef, PyResult, PyValue, diff --git a/wasm/lib/src/convert.rs b/wasm/lib/src/convert.rs index 70aa0adb1..969f868b8 100644 --- a/wasm/lib/src/convert.rs +++ b/wasm/lib/src/convert.rs @@ -3,10 +3,10 @@ use wasm_bindgen::{closure::Closure, prelude::*, JsCast}; use rustpython_compiler::error::{CompileError, CompileErrorType}; use rustpython_parser::error::ParseErrorType; +use rustpython_vm::builtins::pytype; use rustpython_vm::byteslike::PyBytesLike; use rustpython_vm::exceptions::PyBaseExceptionRef; use rustpython_vm::function::FuncArgs; -use rustpython_vm::obj::objtype; use rustpython_vm::pyobject::{ItemProtocol, PyObjectRef, PyResult, PyValue, TryFromObject}; use rustpython_vm::VirtualMachine; use rustpython_vm::{exceptions, py_serde}; @@ -67,7 +67,7 @@ pub fn js_err_to_py_err(vm: &VirtualMachine, js_err: &JsValue) -> PyBaseExceptio pub fn py_to_js(vm: &VirtualMachine, py_obj: PyObjectRef) -> JsValue { if let Some(ref wasm_id) = vm.wasm_id { - if objtype::isinstance(&py_obj, &vm.ctx.types.function_type) { + if pytype::isinstance(&py_obj, &vm.ctx.types.function_type) { let wasm_vm = WASMVirtualMachine { id: wasm_id.clone(), }; diff --git a/wasm/lib/src/js_module.rs b/wasm/lib/src/js_module.rs index fb2ed7031..935825333 100644 --- a/wasm/lib/src/js_module.rs +++ b/wasm/lib/src/js_module.rs @@ -1,8 +1,8 @@ use js_sys::{Array, Object, Reflect}; +use rustpython_vm::builtins::{float::PyFloatRef, pystr::PyStrRef, pytype::PyTypeRef}; use rustpython_vm::common::rc::PyRc; use rustpython_vm::exceptions::PyBaseExceptionRef; use rustpython_vm::function::Args; -use rustpython_vm::obj::{objfloat::PyFloatRef, objstr::PyStrRef, objtype::PyTypeRef}; use rustpython_vm::pyobject::{ BorrowValue, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; diff --git a/wasm/lib/src/wasm_builtins.rs b/wasm/lib/src/wasm_builtins.rs index fffbb3efb..88451304f 100644 --- a/wasm/lib/src/wasm_builtins.rs +++ b/wasm/lib/src/wasm_builtins.rs @@ -6,7 +6,7 @@ use web_sys::{self, console}; -use rustpython_vm::obj::objstr::PyStrRef; +use rustpython_vm::builtins::pystr::PyStrRef; use rustpython_vm::pyobject::{BorrowValue, PyObjectRef, PyResult}; use rustpython_vm::VirtualMachine;