diff --git a/Cargo.lock b/Cargo.lock index b5f620599..0da0a83d4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1819,6 +1819,7 @@ version = "0.1.2" dependencies = [ "js-sys", "parking_lot", + "rustpython-common", "rustpython-compiler", "rustpython-parser", "rustpython-vm", diff --git a/common/src/lib.rs b/common/src/lib.rs index 5bbee0a85..34c011634 100644 --- a/common/src/lib.rs +++ b/common/src/lib.rs @@ -5,4 +5,5 @@ pub mod float_ops; pub mod hash; pub mod lock; pub mod rc; +pub mod static_cell; pub mod str; diff --git a/common/src/static_cell.rs b/common/src/static_cell.rs new file mode 100644 index 000000000..8e86e9aca --- /dev/null +++ b/common/src/static_cell.rs @@ -0,0 +1,76 @@ +#[cfg(not(feature = "threading"))] +mod non_threading { + use crate::lock::OnceCell; + pub type StaticCell = std::thread::LocalKey>; + + #[macro_export] + macro_rules! static_cells { + // process multiple declarations + ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty;) => ( + std::thread_local! { + $(#[$attr])* $vis static $name: $crate::lock::OnceCell<&'static $t> = $crate::lock::OnceCell::new(); + } + ); + } +} +#[cfg(not(feature = "threading"))] +pub use non_threading::*; + +#[cfg(feature = "threading")] +mod threading { + use crate::lock::OnceCell; + + pub struct StaticKey { + inner: T, + } + + impl StaticKey { + pub const fn new(inner: T) -> Self { + Self { inner } + } + + pub fn with(&self, f: F) -> R + where + F: FnOnce(&T) -> R, + { + f(&self.inner) + } + } + + pub type StaticCell = StaticKey>; + + #[macro_export] + macro_rules! static_cells { + // process multiple declarations + ($(#[$attr:meta])* $vis:vis static $name:ident: $t:ty;) => ( + $(#[$attr])* $vis static $name: $crate::static_cell::StaticKey<$crate::lock::OnceCell<&'static $t>> = $crate::static_cell::StaticKey::new($crate::lock::OnceCell::new()); + ); + } +} +#[cfg(feature = "threading")] +pub use threading::*; + +pub fn get(cell: &'static StaticCell) -> Option<&'static T> { + cell.with(|cell| cell.get().copied()) +} + +pub fn init_expect(cell: &'static StaticCell, value: T, msg: &'static str) -> &'static T { + cell.with(|cell| { + let static_ref = Box::leak(Box::new(value)) as &_; + cell.set(static_ref) + .unwrap_or_else(|_| panic!("double initializing '{}'", msg)); + static_ref + }) +} + +pub fn get_or_init(cell: &'static StaticCell, f: F) -> &'static T +where + F: FnOnce() -> T, +{ + cell.with(|cell| { + *cell.get_or_init(|| { + let value = f(); + Box::leak(Box::new(value)) + }) + }) +} diff --git a/derive/src/pyclass.rs b/derive/src/pyclass.rs index 882c8b779..99fe8c88f 100644 --- a/derive/src/pyclass.rs +++ b/derive/src/pyclass.rs @@ -133,6 +133,7 @@ fn generate_class_def( ident: &Ident, name: &str, module_name: Option<&str>, + base: Option, attrs: &[Attribute], ) -> std::result::Result { let doc = if let Some(doc) = attrs.doc() { @@ -159,11 +160,27 @@ fn generate_class_def( false } }); + if base.is_some() && is_pystruct { + return Err(syn::Error::new_spanned( + ident, + "PyStructSequence cannot have `base` class attr", + ) + .into()); + } + let base = base.map(|name| Ident::new(&name, ident.span())); let base_class = if is_pystruct { quote! { - fn base_class(ctx: &::rustpython_vm::pyobject::PyContext) -> ::rustpython_vm::builtins::PyTypeRef { - ctx.types.tuple_type.clone() + fn static_baseclass() -> &'static ::rustpython_vm::builtins::PyTypeRef { + use rustpython_vm::pyobject::StaticType; + rustpython_vm::builtins::PyTuple::static_type() + } + } + } else if let Some(base) = base { + quote! { + fn static_baseclass() -> &'static ::rustpython_vm::builtins::PyTypeRef { + use rustpython_vm::pyobject::StaticType; + #base::static_type() } } } else { @@ -176,6 +193,17 @@ fn generate_class_def( const MODULE_NAME: Option<&'static str> = #module_name; const TP_NAME: &'static str = #module_class_name; const DOC: Option<&'static str> = #doc; + } + + impl ::rustpython_vm::pyobject::StaticType for #ident { + fn static_cell() -> &'static ::rustpython_common::static_cell::StaticCell<::rustpython_vm::builtins::PyTypeRef> { + use ::rustpython_common::static_cells; + static_cells! { + static CELL: ::rustpython_vm::builtins::PyTypeRef; + } + &CELL + } + #base_class } }; @@ -191,7 +219,8 @@ pub(crate) fn impl_pyclass( let class_meta = ClassItemMeta::from_nested(ident.clone(), fake_ident, attr.into_iter())?; let class_name = class_meta.class_name()?; let module_name = class_meta.module()?; - let class_def = generate_class_def(&ident, &class_name, module_name.as_deref(), &attrs)?; + let base = class_meta.base()?; + let class_def = generate_class_def(&ident, &class_name, module_name.as_deref(), base, &attrs)?; let ret = quote! { #item diff --git a/derive/src/util.rs b/derive/src/util.rs index 86f7b31be..756478f20 100644 --- a/derive/src/util.rs +++ b/derive/src/util.rs @@ -233,7 +233,7 @@ impl ItemMeta for SimpleItemMeta { pub(crate) struct ClassItemMeta(ItemMetaInner); impl ItemMeta for ClassItemMeta { - const ALLOWED_NAMES: &'static [&'static str] = &["module", "name"]; + const ALLOWED_NAMES: &'static [&'static str] = &["module", "name", "base"]; fn from_inner(inner: ItemMetaInner) -> Self { Self(inner) @@ -268,6 +268,10 @@ impl ClassItemMeta { Ok(value) } + pub fn base(&self) -> Result> { + self.inner()._optional_str("base") + } + pub fn module(&self) -> Result> { const KEY: &str = "module"; let inner = self.inner(); diff --git a/vm/src/builtins/code.rs b/vm/src/builtins/code.rs index 173c87513..900713566 100644 --- a/vm/src/builtins/code.rs +++ b/vm/src/builtins/code.rs @@ -42,6 +42,9 @@ impl PyValue for PyCode { } } +#[pyimpl(with(PyRef))] +impl PyCode {} + #[pyimpl] impl PyCodeRef { #[pyslot] diff --git a/vm/src/builtins/frame.rs b/vm/src/builtins/frame.rs index 410772b44..947dd673a 100644 --- a/vm/src/builtins/frame.rs +++ b/vm/src/builtins/frame.rs @@ -5,14 +5,17 @@ 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::frame::{Frame, FrameRef}; +use crate::pyobject::{IdProtocol, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult}; use crate::vm::VirtualMachine; pub fn init(context: &PyContext) { FrameRef::extend_class(context, &context.types.frame_type); } +#[pyimpl(with(PyRef))] +impl Frame {} + #[pyimpl] impl FrameRef { #[pyslot] diff --git a/vm/src/builtins/pybool.rs b/vm/src/builtins/pybool.rs index 548612939..38b049c09 100644 --- a/vm/src/builtins/pybool.rs +++ b/vm/src/builtins/pybool.rs @@ -76,7 +76,7 @@ pub fn boolval(vm: &VirtualMachine, obj: PyObjectRef) -> PyResult { /// Returns True when the argument x is true, False otherwise. /// The builtins True and False are the only two instances of the class bool. /// The class bool is a subclass of the class int, and cannot be subclassed. -#[pyclass(name = "bool", module = false)] +#[pyclass(name = "bool", module = false, base = "PyInt")] pub struct PyBool; #[pyimpl] diff --git a/vm/src/exceptions.rs b/vm/src/exceptions.rs index d22c882a7..cfc91089a 100644 --- a/vm/src/exceptions.rs +++ b/vm/src/exceptions.rs @@ -6,21 +6,21 @@ use crate::builtins::tuple::{PyTuple, PyTupleRef}; use crate::common::lock::PyRwLock; use crate::function::FuncArgs; use crate::py_io::{self, Write}; +use crate::pyobject::StaticType; use crate::pyobject::{ - BorrowValue, IntoPyObject, PyClassDef, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, - PyResult, PyValue, TryFromObject, TypeProtocol, + BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyIterable, PyObjectRef, PyRef, PyResult, + PyValue, TryFromObject, TypeProtocol, }; use crate::types::create_type_with_slots; use crate::VirtualMachine; use crate::{py_serde, sysmodule}; +use crossbeam_utils::atomic::AtomicCell; use itertools::Itertools; use std::fmt; use std::fs::File; use std::io::{self, BufRead, BufReader}; -use crossbeam_utils::atomic::AtomicCell; - #[pyclass(module = false, name = "BaseException")] pub struct PyBaseException { traceback: PyRwLock>, @@ -394,7 +394,7 @@ pub fn normalize( Ok(exc) } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct ExceptionZoo { pub base_exception_type: PyTypeRef, pub system_exit: PyTypeRef, @@ -468,12 +468,17 @@ pub struct ExceptionZoo { } impl ExceptionZoo { - pub fn new(type_type: &PyTypeRef, object_type: &PyTypeRef) -> Self { + pub(crate) fn init() -> Self { + let base_exception_type = PyBaseException::init_bare_type().clone(); let create_exception_type = |name: &str, base: &PyTypeRef| { - create_type_with_slots(name, type_type, base.clone(), PyBaseException::make_slots()) + create_type_with_slots( + name, + PyType::static_type(), + base.clone(), + PyBaseException::make_slots(), + ) }; // Sorted By Hierarchy then alphabetized. - let base_exception_type = create_exception_type(PyBaseExceptionRef::NAME, &object_type); let system_exit = create_exception_type("SystemExit", &base_exception_type); let keyboard_interrupt = create_exception_type("KeyboardInterrupt", &base_exception_type); let generator_exit = create_exception_type("GeneratorExit", &base_exception_type); @@ -552,7 +557,7 @@ impl ExceptionZoo { let bytes_warning = create_exception_type("BytesWarning", &warning); let resource_warning = create_exception_type("ResourceWarning", &warning); - ExceptionZoo { + Self { base_exception_type, system_exit, keyboard_interrupt, @@ -624,6 +629,62 @@ impl ExceptionZoo { resource_warning, } } + + pub fn extend(ctx: &PyContext) { + let excs = &ctx.exceptions; + + PyBaseException::extend_class(ctx, &excs.base_exception_type); + + extend_class!(ctx, &excs.syntax_error, { + "msg" => ctx.new_readonly_getset("msg", make_arg_getter(0)), + // TODO: members + "filename" => ctx.none(), + "lineno" => ctx.none(), + "offset" => ctx.none(), + "text" => ctx.none(), + }); + + extend_class!(ctx, &excs.system_exit, { + "code" => ctx.new_readonly_getset("code", system_exit_code), + }); + + extend_class!(ctx, &excs.import_error, { + "__init__" => ctx.new_method(import_error_init), + "msg" => ctx.new_readonly_getset("msg", make_arg_getter(0)), + }); + + extend_class!(ctx, &excs.stop_iteration, { + "value" => ctx.new_readonly_getset("value", make_arg_getter(0)), + }); + + extend_class!(ctx, &excs.key_error, { + "__str__" => ctx.new_method(key_error_str), + }); + + extend_class!(ctx, &excs.unicode_decode_error, { + "encoding" => ctx.new_readonly_getset("encoding", make_arg_getter(0)), + "object" => ctx.new_readonly_getset("object", make_arg_getter(1)), + "start" => ctx.new_readonly_getset("start", make_arg_getter(2)), + "end" => ctx.new_readonly_getset("end", make_arg_getter(3)), + "reason" => ctx.new_readonly_getset("reason", make_arg_getter(4)), + }); + + extend_class!(ctx, &excs.unicode_encode_error, { + "encoding" => ctx.new_readonly_getset("encoding", make_arg_getter(0)), + "object" => ctx.new_readonly_getset("object", make_arg_getter(1)), + "start" => ctx.new_readonly_getset("start", make_arg_getter(2)), + "end" => ctx.new_readonly_getset("end", make_arg_getter(3)), + "reason" => ctx.new_readonly_getset("reason", make_arg_getter(4)), + }); + + extend_class!(ctx, &excs.unicode_translate_error, { + "encoding" => ctx.new_readonly_getset("encoding", none_getter), + "object" => ctx.new_readonly_getset("object", make_arg_getter(0)), + "start" => ctx.new_readonly_getset("start", make_arg_getter(1)), + "end" => ctx.new_readonly_getset("end", make_arg_getter(2)), + "reason" => ctx.new_readonly_getset("reason", make_arg_getter(3)), + }); + } } fn import_error_init(exc_self: PyObjectRef, args: FuncArgs, vm: &VirtualMachine) -> PyResult<()> { @@ -672,62 +733,6 @@ fn system_exit_code(exc: PyBaseExceptionRef) -> Option { }) } -pub fn init(ctx: &PyContext) { - let excs = &ctx.exceptions; - - PyBaseException::extend_class(ctx, &excs.base_exception_type); - - extend_class!(ctx, &excs.syntax_error, { - "msg" => ctx.new_readonly_getset("msg", make_arg_getter(0)), - // TODO: members - "filename" => ctx.none(), - "lineno" => ctx.none(), - "offset" => ctx.none(), - "text" => ctx.none(), - }); - - extend_class!(ctx, &excs.system_exit, { - "code" => ctx.new_readonly_getset("code", system_exit_code), - }); - - extend_class!(ctx, &excs.import_error, { - "__init__" => ctx.new_method(import_error_init), - "msg" => ctx.new_readonly_getset("msg", make_arg_getter(0)), - }); - - extend_class!(ctx, &excs.stop_iteration, { - "value" => ctx.new_readonly_getset("value", make_arg_getter(0)), - }); - - extend_class!(ctx, &excs.key_error, { - "__str__" => ctx.new_method(key_error_str), - }); - - extend_class!(ctx, &excs.unicode_decode_error, { - "encoding" => ctx.new_readonly_getset("encoding", make_arg_getter(0)), - "object" => ctx.new_readonly_getset("object", make_arg_getter(1)), - "start" => ctx.new_readonly_getset("start", make_arg_getter(2)), - "end" => ctx.new_readonly_getset("end", make_arg_getter(3)), - "reason" => ctx.new_readonly_getset("reason", make_arg_getter(4)), - }); - - extend_class!(ctx, &excs.unicode_encode_error, { - "encoding" => ctx.new_readonly_getset("encoding", make_arg_getter(0)), - "object" => ctx.new_readonly_getset("object", make_arg_getter(1)), - "start" => ctx.new_readonly_getset("start", make_arg_getter(2)), - "end" => ctx.new_readonly_getset("end", make_arg_getter(3)), - "reason" => ctx.new_readonly_getset("reason", make_arg_getter(4)), - }); - - extend_class!(ctx, &excs.unicode_translate_error, { - "encoding" => ctx.new_readonly_getset("encoding", none_getter), - "object" => ctx.new_readonly_getset("object", make_arg_getter(0)), - "start" => ctx.new_readonly_getset("start", make_arg_getter(1)), - "end" => ctx.new_readonly_getset("end", make_arg_getter(2)), - "reason" => ctx.new_readonly_getset("reason", make_arg_getter(3)), - }); -} - pub struct SerializeException<'s> { vm: &'s VirtualMachine, exc: &'s PyBaseExceptionRef, diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs index e41c04507..b1ac7092b 100644 --- a/vm/src/pyobject.rs +++ b/vm/src/pyobject.rs @@ -1,13 +1,12 @@ +use num_bigint::BigInt; +use num_complex::Complex64; +use num_traits::ToPrimitive; use std::any::Any; use std::collections::HashMap; use std::fmt; use std::marker::PhantomData; use std::ops::Deref; -use num_bigint::BigInt; -use num_complex::Complex64; -use num_traits::ToPrimitive; - use crate::builtins::builtinfunc::PyNativeFuncDef; use crate::builtins::bytearray; use crate::builtins::bytes; @@ -31,18 +30,18 @@ use crate::builtins::slice::PyEllipsis; use crate::builtins::staticmethod::PyStaticMethod; use crate::builtins::tuple::{PyTuple, PyTupleRef}; use crate::bytecode; +pub use crate::common::borrow::BorrowValue; +use crate::common::lock::{PyRwLock, PyRwLockReadGuard}; +use crate::common::rc::PyRc; +use crate::common::static_cell; use crate::exceptions::{self, PyBaseExceptionRef}; use crate::function::{IntoFuncArgs, IntoPyNativeFunc}; use crate::iterator; pub use crate::pyobjectrc::{PyObjectRc, PyObjectWeak}; use crate::scope::Scope; use crate::slots::{PyTpFlags, PyTypeSlots}; -use crate::types::{create_type_with_slots, initialize_types, TypeZoo}; +use crate::types::{create_type_with_slots, TypeZoo}; use crate::vm::VirtualMachine; -use rustpython_common::lock::{PyRwLock, PyRwLockReadGuard}; -use rustpython_common::rc::PyRc; - -pub use crate::common::borrow::BorrowValue; /* Python objects and references. @@ -92,7 +91,7 @@ impl fmt::Display for PyObject { } } -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct PyContext { pub true_value: PyIntRef, pub false_value: PyIntRef, @@ -113,60 +112,62 @@ impl PyContext { pub const INT_CACHE_POOL_MAX: i32 = 256; pub fn new() -> Self { - flame_guard!("init PyContext"); - let types = TypeZoo::new(); - let exceptions = exceptions::ExceptionZoo::new(&types.type_type, &types.object_type); - - fn create_object(payload: T, cls: &PyTypeRef) -> PyRef { - PyRef::new_ref(payload, cls.clone(), None) + use rustpython_common::static_cells; + static_cells! { + static CONTEXT: PyContext; } + static_cell::get_or_init(&CONTEXT, || { + flame_guard!("init PyContext"); + let types = TypeZoo::init(); + let exceptions = exceptions::ExceptionZoo::init(); - let none_type = PyNone::create_bare_type(&types.type_type, types.object_type.clone()); - let none = create_object(PyNone, &none_type); + fn create_object( + payload: T, + cls: &PyTypeRef, + ) -> PyRef { + PyRef::new_ref(payload, cls.clone(), None) + } - let ellipsis_type = - PyEllipsis::create_bare_type(&types.type_type, types.object_type.clone()); - let ellipsis = create_object(PyEllipsis, &ellipsis_type); + let none = create_object(PyNone, PyNone::static_type()); + let ellipsis = create_object(PyEllipsis, PyEllipsis::static_type()); + let not_implemented = create_object(PyNotImplemented, PyNotImplemented::static_type()); - let not_implemented_type = - PyNotImplemented::create_bare_type(&types.type_type, types.object_type.clone()); - let not_implemented = create_object(PyNotImplemented, ¬_implemented_type); + let int_cache_pool = (Self::INT_CACHE_POOL_MIN..=Self::INT_CACHE_POOL_MAX) + .map(|v| PyRef::new_ref(PyInt::from(BigInt::from(v)), types.int_type.clone(), None)) + .collect(); - let int_cache_pool = (Self::INT_CACHE_POOL_MIN..=Self::INT_CACHE_POOL_MAX) - .map(|v| PyRef::new_ref(PyInt::from(BigInt::from(v)), types.int_type.clone(), None)) - .collect(); + let true_value = create_object(PyInt::from(1), &types.bool_type); + let false_value = create_object(PyInt::from(0), &types.bool_type); - let true_value = create_object(PyInt::from(1), &types.bool_type); - let false_value = create_object(PyInt::from(0), &types.bool_type); + let empty_tuple = create_object( + PyTuple::_new(Vec::new().into_boxed_slice()), + &types.tuple_type, + ); - let empty_tuple = create_object( - PyTuple::_new(Vec::new().into_boxed_slice()), - &types.tuple_type, - ); + let tp_new_wrapper = create_object( + PyNativeFuncDef::from(pytype::tp_new_wrapper.into_func()).into_function(), + &types.builtin_function_or_method_type, + ) + .into_object(); - let tp_new_wrapper = create_object( - PyNativeFuncDef::from(pytype::tp_new_wrapper.into_func()).into_function(), - &types.builtin_function_or_method_type, - ) - .into_object(); + let context = PyContext { + true_value, + false_value, + not_implemented, + none, + empty_tuple, + ellipsis, - let context = PyContext { - true_value, - false_value, - not_implemented, - none, - empty_tuple, - ellipsis, - - types, - exceptions, - int_cache_pool, - tp_new_wrapper, - }; - initialize_types(&context); - - exceptions::init(&context); - context + types, + exceptions, + int_cache_pool, + tp_new_wrapper, + }; + TypeZoo::extend(&context); + exceptions::ExceptionZoo::extend(&context); + context + }) + .clone() } pub fn none(&self) -> PyObjectRef { @@ -1229,8 +1230,31 @@ pub trait PyClassDef { const MODULE_NAME: Option<&'static str>; const TP_NAME: &'static str; const DOC: Option<&'static str> = None; - fn base_class(ctx: &PyContext) -> PyTypeRef { - ctx.types.object_type.clone() +} + +pub trait StaticType { + // Ideally, saving PyType is better than PyTypeRef + fn static_cell() -> &'static static_cell::StaticCell; + fn static_metaclass() -> &'static PyTypeRef { + crate::builtins::pytype::PyType::static_type() + } + fn static_baseclass() -> &'static PyTypeRef { + crate::builtins::object::PyBaseObject::static_type() + } + fn static_type() -> &'static PyTypeRef { + static_cell::get(Self::static_cell()).unwrap() + } + + fn init_manually(typ: PyTypeRef) -> &'static PyTypeRef { + static_cell::init_expect(Self::static_cell(), typ, "init_manually") + } + fn init_bare_type() -> &'static PyTypeRef + where + Self: PyClassImpl, + { + let typ = + Self::create_bare_type(Self::static_metaclass(), Self::static_baseclass().clone()); + static_cell::init_expect(Self::static_cell(), typ, Self::NAME) } } @@ -1270,14 +1294,17 @@ pub trait PyClassImpl: PyClassDef { } } - fn make_class(ctx: &PyContext) -> PyTypeRef { - Self::make_class_with_base(ctx, Self::base_class(ctx)) - } - - fn make_class_with_base(ctx: &PyContext, base: PyTypeRef) -> PyTypeRef { - let py_class = ctx.new_class(Self::NAME, base, Self::make_slots()); - Self::extend_class(ctx, &py_class); - py_class + fn make_class(ctx: &PyContext) -> PyTypeRef + where + Self: StaticType, + { + static_cell::get_or_init(Self::static_cell(), || { + let typ = + Self::create_bare_type(Self::static_metaclass(), Self::static_baseclass().clone()); + Self::extend_class(ctx, &typ); + typ + }) + .clone() } fn create_bare_type(type_type: &PyTypeRef, base: PyTypeRef) -> PyTypeRef { diff --git a/vm/src/stdlib/io.rs b/vm/src/stdlib/io.rs index d9166f4f8..a5da79c9b 100644 --- a/vm/src/stdlib/io.rs +++ b/vm/src/stdlib/io.rs @@ -7,7 +7,8 @@ pub(crate) use _io::io_open as open; pub(crate) fn make_module(vm: &VirtualMachine) -> PyObjectRef { let module = _io::make_module(vm); - _io::extend_more(vm, &module); + #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] + fileio::extend_module(vm, &module); module } @@ -33,8 +34,8 @@ mod _io { use crate::exceptions::{IntoPyException, PyBaseExceptionRef}; use crate::function::{FuncArgs, OptionalArg, OptionalOption}; use crate::pyobject::{ - BorrowValue, IntoPyObject, PyClassImpl, PyContext, PyObjectRef, PyRef, PyResult, PyValue, - TryFromObject, TypeProtocol, + BorrowValue, IntoPyObject, PyContext, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, + TypeProtocol, }; use crate::vm::VirtualMachine; @@ -211,10 +212,10 @@ mod _io { #[pyattr] #[pyclass(name = "_IOBase")] - struct IOBase; + struct _IOBase; #[pyimpl(flags(BASETYPE))] - impl IOBase { + impl _IOBase { #[pyattr] fn __closed(ctx: &PyContext) -> PyObjectRef { ctx.new_bool(false) @@ -381,11 +382,12 @@ mod _io { } } - #[pyclass(name = "_RawIOBase", noattr)] - struct RawIOBase; + #[pyattr] + #[pyclass(name = "_RawIOBase", base = "_IOBase")] + pub(super) struct _RawIOBase; #[pyimpl(flags(BASETYPE))] - impl RawIOBase { + impl _RawIOBase { #[pymethod] fn read(instance: PyObjectRef, size: OptionalSize, vm: &VirtualMachine) -> PyResult { if let Some(size) = size.to_usize() { @@ -407,11 +409,12 @@ mod _io { } } - #[pyclass(name = "_BufferedIOBase", noattr)] - struct BufferedIOBase; + #[pyattr] + #[pyclass(name = "_BufferedIOBase", base = "_IOBase")] + struct _BufferedIOBase; #[pyimpl(flags(BASETYPE))] - impl BufferedIOBase { + impl _BufferedIOBase { // #[pymethod(magic)] fn init( instance: PyObjectRef, @@ -461,13 +464,15 @@ mod _io { } // TextIO Base has no public constructor - #[pyclass(name = "_TextIOBase", noattr)] - struct TextIOBase; + #[pyattr] + #[pyclass(name = "_TextIOBase", base = "_IOBase")] + struct _TextIOBase; #[pyimpl(flags(BASETYPE))] - impl TextIOBase {} + impl _TextIOBase {} - #[pyclass(name = "BufferedReader", noattr)] + #[pyattr] + #[pyclass(name = "BufferedReader", base = "_BufferedIOBase")] struct BufferedReader; #[pyimpl(flags(BASETYPE))] @@ -483,32 +488,32 @@ mod _io { buffer_size: OptionalArg, vm: &VirtualMachine, ) -> PyResult<()> { - BufferedIOBase::init(instance, raw, buffer_size, vm) + _BufferedIOBase::init(instance, raw, buffer_size, vm) } #[pymethod] fn fileno(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::fileno(instance, vm) + _BufferedIOBase::fileno(instance, vm) } #[pyproperty] fn mode(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::mode(instance, vm) + _BufferedIOBase::mode(instance, vm) } #[pyproperty] fn name(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::name(instance, vm) + _BufferedIOBase::name(instance, vm) } #[pymethod] fn tell(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::tell(instance, vm) + _BufferedIOBase::tell(instance, vm) } #[pymethod] fn close(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { - BufferedIOBase::close(instance, vm) + _BufferedIOBase::close(instance, vm) } #[pymethod] @@ -538,7 +543,8 @@ mod _io { } } - #[pyclass(name = "BufferedWriter", noattr)] + #[pyattr] + #[pyclass(name = "BufferedWriter", base = "_BufferedIOBase")] struct BufferedWriter; #[pyimpl(flags(BASETYPE))] @@ -554,32 +560,32 @@ mod _io { buffer_size: OptionalArg, vm: &VirtualMachine, ) -> PyResult<()> { - BufferedIOBase::init(instance, raw, buffer_size, vm) + _BufferedIOBase::init(instance, raw, buffer_size, vm) } #[pymethod] fn fileno(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::fileno(instance, vm) + _BufferedIOBase::fileno(instance, vm) } #[pyproperty] fn mode(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::mode(instance, vm) + _BufferedIOBase::mode(instance, vm) } #[pyproperty] fn name(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::name(instance, vm) + _BufferedIOBase::name(instance, vm) } #[pymethod] fn tell(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult { - BufferedIOBase::tell(instance, vm) + _BufferedIOBase::tell(instance, vm) } #[pymethod] fn close(instance: PyObjectRef, vm: &VirtualMachine) -> PyResult<()> { - BufferedIOBase::close(instance, vm) + _BufferedIOBase::close(instance, vm) } #[pymethod] @@ -635,7 +641,8 @@ mod _io { } } - #[pyclass(name = "TextIOWrapper", noattr)] + #[pyattr] + #[pyclass(name = "TextIOWrapper", base = "_TextIOBase")] struct TextIOWrapper; #[pyimpl] @@ -803,7 +810,8 @@ mod _io { newline: Option, } - #[pyclass(name = "StringIO", noattr)] + #[pyattr] + #[pyclass(name = "StringIO", base = "_TextIOBase")] #[derive(Debug)] struct StringIO { buffer: PyRwLock, @@ -936,7 +944,8 @@ mod _io { } } - #[pyclass(name = "BytesIO", noattr)] + #[pyattr] + #[pyclass(name = "BytesIO", base = "_BufferedIOBase")] #[derive(Debug)] struct BytesIO { buffer: PyRwLock, @@ -1305,55 +1314,6 @@ mod _io { } } - pub(crate) fn extend_more(vm: &VirtualMachine, module: &PyObjectRef) { - let ctx = &vm.ctx; - - // IOBase the abstract base class of the IO Module - let io_base = IOBase::make_class(&vm.ctx); - extend_class!(ctx, &io_base, {}); - - // IOBase Subclasses - let raw_io_base = RawIOBase::make_class_with_base(&vm.ctx, io_base.clone()); - let buffered_io_base = BufferedIOBase::make_class_with_base(&vm.ctx, io_base.clone()); - let text_io_base = TextIOBase::make_class_with_base(&vm.ctx, io_base.clone()); - - // BufferedIOBase Subclasses - let buffered_reader = - BufferedReader::make_class_with_base(&vm.ctx, buffered_io_base.clone()); - let buffered_writer = - BufferedWriter::make_class_with_base(&vm.ctx, buffered_io_base.clone()); - - //TextIOBase Subclass - let text_io_wrapper = TextIOWrapper::make_class_with_base(&vm.ctx, text_io_base.clone()); - - //StringIO: in-memory text - let string_io = StringIO::make_class_with_base(&vm.ctx, text_io_base.clone()); - extend_class!(ctx, &string_io, { - "__module__" => ctx.new_str("_io"), - }); - - //BytesIO: in-memory bytes - let bytes_io = BytesIO::make_class_with_base(&vm.ctx, buffered_io_base.clone()); - extend_class!(ctx, &bytes_io, {}); - - #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] - extend_module!(vm, module, { - "FileIO" => super::fileio::make_fileio(ctx, raw_io_base.clone()), - }); - - extend_module!(vm, module, { - "_IOBase" => io_base, - "_RawIOBase" => raw_io_base, - "_BufferedIOBase" => buffered_io_base, - "_TextIOBase" => text_io_base, - "BufferedReader" => buffered_reader, - "BufferedWriter" => buffered_writer, - "TextIOWrapper" => text_io_wrapper, - "StringIO" => string_io, - "BytesIO" => bytes_io, - }); - } - #[cfg(test)] mod tests { use super::*; @@ -1477,6 +1437,7 @@ mod _io { // disable FileIO on WASM #[cfg(any(not(target_arch = "wasm32"), target_os = "wasi"))] +#[pymodule] mod fileio { use super::_io::*; use crate::builtins::pystr::PyStrRef; @@ -1485,7 +1446,7 @@ mod fileio { use crate::exceptions::IntoPyException; use crate::function::{FuncArgs, OptionalArg}; use crate::pyobject::{ - BorrowValue, Either, PyClassImpl, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, + BorrowValue, Either, PyObjectRef, PyRef, PyResult, PyValue, TryFromObject, }; use crate::stdlib::os; use crate::vm::VirtualMachine; @@ -1506,9 +1467,10 @@ mod fileio { flag as u32 } - #[pyclass(module = "io", name)] + #[pyattr] + #[pyclass(module = "io", name, base = "_RawIOBase")] #[derive(Debug)] - struct FileIO { + pub(super) struct FileIO { fd: AtomicCell, closefd: AtomicCell, } @@ -1717,8 +1679,4 @@ mod fileio { Ok(pos) } } - - pub fn make_fileio(ctx: &crate::pyobject::PyContext, raw_io_base: PyTypeRef) -> PyTypeRef { - FileIO::make_class_with_base(ctx, raw_io_base) - } } diff --git a/vm/src/types.rs b/vm/src/types.rs index c4279b0de..22a62cdd9 100644 --- a/vm/src/types.rs +++ b/vm/src/types.rs @@ -39,7 +39,7 @@ use crate::builtins::weakproxy; use crate::builtins::weakref; use crate::builtins::zip; use crate::pyobject::{ - PyAttributes, PyClassDef, PyClassImpl, PyContext, PyObject, PyObjectRc, PyObjectRef, + PyAttributes, PyClassDef, PyClassImpl, PyContext, PyObject, PyObjectRc, PyObjectRef, StaticType, }; use crate::slots::PyTypeSlots; use rustpython_common::{lock::PyRwLock, rc::PyRc}; @@ -47,7 +47,7 @@ use std::mem::MaybeUninit; use std::ptr; /// Holder of references to builtin types. -#[derive(Debug)] +#[derive(Debug, Clone)] pub struct TypeZoo { pub async_generator: PyTypeRef, pub async_generator_asend: PyTypeRef, @@ -116,93 +116,133 @@ pub struct TypeZoo { pub object_type: PyTypeRef, } -impl Default for TypeZoo { - fn default() -> Self { - Self::new() - } -} - impl TypeZoo { - pub fn new() -> Self { + pub(crate) fn init() -> Self { let (type_type, object_type) = init_type_hierarchy(); + let new = Self { + // the order matters for type, object and int + type_type: pytype::PyType::init_manually(type_type).clone(), + object_type: object::PyBaseObject::init_manually(object_type).clone(), + int_type: int::PyInt::init_bare_type().clone(), - macro_rules! create_type { - ($class:ty) => { - <$class>::create_bare_type(&type_type, object_type.clone()) - }; - ($class:ty, $base:expr) => { - <$class>::create_bare_type(&type_type, $base.clone()) - }; - } + // types exposed as builtins + bool_type: pybool::PyBool::init_bare_type().clone(), + bytearray_type: bytearray::PyByteArray::init_bare_type().clone(), + bytes_type: bytes::PyBytes::init_bare_type().clone(), + classmethod_type: classmethod::PyClassMethod::init_bare_type().clone(), + complex_type: complex::PyComplex::init_bare_type().clone(), + dict_type: dict::PyDict::init_bare_type().clone(), + enumerate_type: enumerate::PyEnumerate::init_bare_type().clone(), + float_type: float::PyFloat::init_bare_type().clone(), + frozenset_type: set::PyFrozenSet::init_bare_type().clone(), + filter_type: filter::PyFilter::init_bare_type().clone(), + list_type: list::PyList::init_bare_type().clone(), + map_type: map::PyMap::init_bare_type().clone(), + memoryview_type: memory::PyMemoryView::init_bare_type().clone(), + property_type: property::PyProperty::init_bare_type().clone(), + range_type: range::PyRange::init_bare_type().clone(), + set_type: set::PySet::init_bare_type().clone(), + slice_type: slice::PySlice::init_bare_type().clone(), + staticmethod_type: staticmethod::PyStaticMethod::init_bare_type().clone(), + str_type: pystr::PyStr::init_bare_type().clone(), + super_type: pysuper::PySuper::init_bare_type().clone(), + tuple_type: tuple::PyTuple::init_bare_type().clone(), + zip_type: zip::PyZip::init_bare_type().clone(), - let int_type = create_type!(int::PyInt); - Self { - 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!(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!(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, - } + // hidden internal types. is this really need to be cached here? + async_generator: asyncgenerator::PyAsyncGen::init_bare_type().clone(), + async_generator_asend: asyncgenerator::PyAsyncGenASend::init_bare_type().clone(), + async_generator_athrow: asyncgenerator::PyAsyncGenAThrow::init_bare_type().clone(), + async_generator_wrapped_value: asyncgenerator::PyAsyncGenWrappedValue::init_bare_type() + .clone(), + bound_method_type: function::PyBoundMethod::init_bare_type().clone(), + builtin_function_or_method_type: builtinfunc::PyBuiltinFunction::init_bare_type() + .clone(), + bytearray_iterator_type: bytearray::PyByteArrayIterator::init_bare_type().clone(), + bytes_iterator_type: bytes::PyBytesIterator::init_bare_type().clone(), + callable_iterator: iter::PyCallableIterator::init_bare_type().clone(), + code_type: code::PyCode::init_bare_type().clone(), + coroutine_type: coroutine::PyCoroutine::init_bare_type().clone(), + coroutine_wrapper_type: coroutine::PyCoroutineWrapper::init_bare_type().clone(), + dict_keys_type: dict::PyDictKeys::init_bare_type().clone(), + dict_values_type: dict::PyDictValues::init_bare_type().clone(), + dict_items_type: dict::PyDictItems::init_bare_type().clone(), + dict_keyiterator_type: dict::PyDictKeyIterator::init_bare_type().clone(), + dict_reversekeyiterator_type: dict::PyDictReverseKeyIterator::init_bare_type().clone(), + dict_valueiterator_type: dict::PyDictValueIterator::init_bare_type().clone(), + dict_reversevalueiterator_type: dict::PyDictReverseValueIterator::init_bare_type() + .clone(), + dict_itemiterator_type: dict::PyDictItemIterator::init_bare_type().clone(), + dict_reverseitemiterator_type: dict::PyDictReverseItemIterator::init_bare_type() + .clone(), + frame_type: crate::frame::Frame::init_bare_type().clone(), + function_type: function::PyFunction::init_bare_type().clone(), + generator_type: generator::PyGenerator::init_bare_type().clone(), + getset_type: getset::PyGetSet::init_bare_type().clone(), + iter_type: iter::PySequenceIterator::init_bare_type().clone(), + list_iterator_type: list::PyListIterator::init_bare_type().clone(), + list_reverseiterator_type: list::PyListReverseIterator::init_bare_type().clone(), + mappingproxy_type: mappingproxy::PyMappingProxy::init_bare_type().clone(), + module_type: module::PyModule::init_bare_type().clone(), + namespace_type: namespace::PyNamespace::init_bare_type().clone(), + range_iterator_type: range::PyRangeIterator::init_bare_type().clone(), + set_iterator_type: set::PySetIterator::init_bare_type().clone(), + str_iterator_type: pystr::PyStrIterator::init_bare_type().clone(), + str_reverseiterator_type: pystr::PyStrReverseIterator::init_bare_type().clone(), + traceback_type: traceback::PyTraceback::init_bare_type().clone(), + tuple_iterator_type: tuple::PyTupleIterator::init_bare_type().clone(), + weakproxy_type: weakproxy::PyWeakProxy::init_bare_type().clone(), + weakref_type: weakref::PyWeak::init_bare_type().clone(), + method_descriptor_type: builtinfunc::PyBuiltinMethod::init_bare_type().clone(), + }; + singletons::PyNone::init_bare_type(); + singletons::PyNotImplemented::init_bare_type(); + slice::PyEllipsis::init_bare_type(); + new + } + + /// Fill attributes of builtin types. + pub(crate) fn extend(context: &PyContext) { + 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); } } @@ -328,47 +368,3 @@ fn init_type_hierarchy() -> (PyTypeRef, PyTypeRef) { (type_type, object_type) } - -/// Fill attributes of builtin types. -pub fn initialize_types(context: &PyContext) { - 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/wasm/lib/Cargo.toml b/wasm/lib/Cargo.toml index df4a21cb4..a5d7b5588 100644 --- a/wasm/lib/Cargo.toml +++ b/wasm/lib/Cargo.toml @@ -17,6 +17,7 @@ freeze-stdlib = ["rustpython-vm/freeze-stdlib"] [dependencies] rustpython-compiler = { path = "../../compiler" } rustpython-parser = { path = "../../parser" } +rustpython-common = { path = "../../common" } # no threading feature for rustpython-vm -- doesn't much matter anyway, but it might be more optimized rustpython-vm = { path = "../../vm", default-features = false, features = ["compile-parse"] } wasm-bindgen = "0.2"